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 // If the constraints are not the same as those of the primary
859 // then, we can probably create a new specialization.
860 tree type_constr
= current_template_constraints ();
862 if (type
== TREE_TYPE (tmpl
))
863 if (tree main_constr
= get_constraints (tmpl
))
864 if (equivalent_constraints (type_constr
, main_constr
))
867 // Also, if there's a pre-existing specialization with matching
868 // constraints, then this also isn't new.
869 tree specs
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
872 tree spec_tmpl
= TREE_VALUE (specs
);
873 tree spec_args
= TREE_PURPOSE (specs
);
874 tree spec_constr
= get_constraints (spec_tmpl
);
875 if (comp_template_args (args
, spec_args
)
876 && equivalent_constraints (type_constr
, spec_constr
))
878 specs
= TREE_CHAIN (specs
);
881 // Create a new type node (and corresponding type decl)
882 // for the newly declared specialization.
883 tree t
= make_class_type (TREE_CODE (type
));
884 CLASSTYPE_DECLARED_CLASS (t
) = CLASSTYPE_DECLARED_CLASS (type
);
885 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (type
);
886 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (tmpl
, args
));
888 /* We only need a separate type node for storing the definition of this
889 partial specialization; uses of S<T*> are unconstrained, so all are
890 equivalent. So keep TYPE_CANONICAL the same. */
891 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
893 // Build the corresponding type decl.
894 tree d
= create_implicit_typedef (DECL_NAME (tmpl
), t
);
895 DECL_CONTEXT (d
) = TYPE_CONTEXT (t
);
896 DECL_SOURCE_LOCATION (d
) = input_location
;
904 /* The TYPE is being declared. If it is a template type, that means it
905 is a partial specialization. Do appropriate error-checking. */
908 maybe_process_partial_specialization (tree type
)
912 if (type
== error_mark_node
)
913 return error_mark_node
;
915 /* A lambda that appears in specialization context is not itself a
917 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
920 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
922 error ("name of class shadows template template parameter %qD",
924 return error_mark_node
;
927 context
= TYPE_CONTEXT (type
);
929 if (TYPE_ALIAS_P (type
))
931 if (TYPE_TEMPLATE_INFO (type
)
932 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type
)))
933 error ("specialization of alias template %qD",
934 TYPE_TI_TEMPLATE (type
));
936 error ("explicit specialization of non-template %qT", type
);
937 return error_mark_node
;
939 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
941 /* This is for ordinary explicit specialization and partial
942 specialization of a template class such as:
944 template <> class C<int>;
948 template <class T> class C<T*>;
950 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
952 if (tree t
= maybe_new_partial_specialization (type
))
954 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (t
))
955 && !at_namespace_scope_p ())
956 return error_mark_node
;
957 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t
);
958 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (t
)) = input_location
;
959 if (processing_template_decl
)
961 tree decl
= push_template_decl (TYPE_MAIN_DECL (t
));
962 if (decl
== error_mark_node
)
963 return error_mark_node
;
964 return TREE_TYPE (decl
);
967 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
968 error ("specialization of %qT after instantiation", type
);
969 else if (errorcount
&& !processing_specialization
970 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
971 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
972 /* Trying to define a specialization either without a template<> header
973 or in an inappropriate place. We've already given an error, so just
974 bail now so we don't actually define the specialization. */
975 return error_mark_node
;
977 else if (CLASS_TYPE_P (type
)
978 && !CLASSTYPE_USE_TEMPLATE (type
)
979 && CLASSTYPE_TEMPLATE_INFO (type
)
980 && context
&& CLASS_TYPE_P (context
)
981 && CLASSTYPE_TEMPLATE_INFO (context
))
983 /* This is for an explicit specialization of member class
984 template according to [temp.expl.spec/18]:
986 template <> template <class U> class C<int>::D;
988 The context `C<int>' must be an implicit instantiation.
989 Otherwise this is just a member class template declared
992 template <> class C<int> { template <class U> class D; };
993 template <> template <class U> class C<int>::D;
995 In the first case, `C<int>::D' is a specialization of `C<T>::D'
996 while in the second case, `C<int>::D' is a primary template
997 and `C<T>::D' may not exist. */
999 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
1000 && !COMPLETE_TYPE_P (type
))
1003 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1005 if (current_namespace
1006 != decl_namespace_context (tmpl
))
1008 permerror (input_location
,
1009 "specializing %q#T in different namespace", type
);
1010 permerror (DECL_SOURCE_LOCATION (tmpl
),
1011 " from definition of %q#D", tmpl
);
1014 /* Check for invalid specialization after instantiation:
1016 template <> template <> class C<int>::D<int>;
1017 template <> template <class U> class C<int>::D; */
1019 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1020 t
; t
= TREE_CHAIN (t
))
1022 tree inst
= TREE_VALUE (t
);
1023 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
1024 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
1026 /* We already have a full specialization of this partial
1027 instantiation, or a full specialization has been
1028 looked up but not instantiated. Reassign it to the
1029 new member specialization template. */
1033 elt
.tmpl
= most_general_template (tmpl
);
1034 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
1037 type_specializations
->remove_elt (&elt
);
1040 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
1043 = type_specializations
->find_slot (&elt
, INSERT
);
1044 entry
= ggc_alloc
<spec_entry
> ();
1049 /* But if we've had an implicit instantiation, that's a
1050 problem ([temp.expl.spec]/6). */
1051 error ("specialization %qT after instantiation %qT",
1055 /* Mark TYPE as a specialization. And as a result, we only
1056 have one level of template argument for the innermost
1058 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
1059 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
1060 CLASSTYPE_TI_ARGS (type
)
1061 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
1064 else if (processing_specialization
)
1066 /* Someday C++0x may allow for enum template specialization. */
1067 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
1068 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
1069 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
1070 "of %qD not allowed by ISO C++", type
);
1073 error ("explicit specialization of non-template %qT", type
);
1074 return error_mark_node
;
1081 /* Returns nonzero if we can optimize the retrieval of specializations
1082 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1083 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1086 optimize_specialization_lookup_p (tree tmpl
)
1088 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
1089 && DECL_CLASS_SCOPE_P (tmpl
)
1090 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1092 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1093 /* The optimized lookup depends on the fact that the
1094 template arguments for the member function template apply
1095 purely to the containing class, which is not true if the
1096 containing class is an explicit or partial
1098 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1099 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1100 && !DECL_CONV_FN_P (tmpl
)
1101 /* It is possible to have a template that is not a member
1102 template and is not a member of a template class:
1104 template <typename T>
1105 struct S { friend A::f(); };
1107 Here, the friend function is a template, but the context does
1108 not have template information. The optimized lookup relies
1109 on having ARGS be the template arguments for both the class
1110 and the function template. */
1111 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1114 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1115 gone through coerce_template_parms by now. */
1118 verify_unstripped_args (tree args
)
1120 ++processing_template_decl
;
1121 if (!any_dependent_template_arguments_p (args
))
1123 tree inner
= INNERMOST_TEMPLATE_ARGS (args
);
1124 for (int i
= 0; i
< TREE_VEC_LENGTH (inner
); ++i
)
1126 tree arg
= TREE_VEC_ELT (inner
, i
);
1127 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1129 else if (TYPE_P (arg
))
1130 gcc_assert (strip_typedefs (arg
, NULL
) == arg
);
1131 else if (strip_typedefs (TREE_TYPE (arg
), NULL
) != TREE_TYPE (arg
))
1132 /* Allow typedefs on the type of a non-type argument, since a
1133 parameter can have them. */;
1135 gcc_assert (strip_typedefs_expr (arg
, NULL
) == arg
);
1138 --processing_template_decl
;
1141 /* Retrieve the specialization (in the sense of [temp.spec] - a
1142 specialization is either an instantiation or an explicit
1143 specialization) of TMPL for the given template ARGS. If there is
1144 no such specialization, return NULL_TREE. The ARGS are a vector of
1145 arguments, or a vector of vectors of arguments, in the case of
1146 templates with more than one level of parameters.
1148 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1149 then we search for a partial specialization matching ARGS. This
1150 parameter is ignored if TMPL is not a class template.
1152 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1153 result is a NONTYPE_ARGUMENT_PACK. */
1156 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1158 if (tmpl
== NULL_TREE
)
1161 if (args
== error_mark_node
)
1164 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1165 || TREE_CODE (tmpl
) == FIELD_DECL
);
1167 /* There should be as many levels of arguments as there are
1168 levels of parameters. */
1169 gcc_assert (TMPL_ARGS_DEPTH (args
)
1170 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1171 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1172 : template_class_depth (DECL_CONTEXT (tmpl
))));
1175 verify_unstripped_args (args
);
1177 if (optimize_specialization_lookup_p (tmpl
))
1179 tree class_template
;
1180 tree class_specialization
;
1181 vec
<tree
, va_gc
> *methods
;
1185 /* The template arguments actually apply to the containing
1186 class. Find the class specialization with those
1188 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1189 class_specialization
1190 = retrieve_specialization (class_template
, args
, 0);
1191 if (!class_specialization
)
1193 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1194 for the specialization. */
1195 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
1198 /* Iterate through the methods with the indicated name, looking
1199 for the one that has an instance of TMPL. */
1200 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
1201 for (fns
= (*methods
)[idx
]; fns
; fns
= OVL_NEXT (fns
))
1203 tree fn
= OVL_CURRENT (fns
);
1204 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1205 /* using-declarations can add base methods to the method vec,
1206 and we don't want those here. */
1207 && DECL_CONTEXT (fn
) == class_specialization
)
1216 hash_table
<spec_hasher
> *specializations
;
1220 elt
.spec
= NULL_TREE
;
1222 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1223 specializations
= type_specializations
;
1225 specializations
= decl_specializations
;
1228 hash
= spec_hasher::hash (&elt
);
1229 found
= specializations
->find_with_hash (&elt
, hash
);
1237 /* Like retrieve_specialization, but for local declarations. */
1240 retrieve_local_specialization (tree tmpl
)
1242 if (local_specializations
== NULL
)
1245 tree
*slot
= local_specializations
->get (tmpl
);
1246 return slot
? *slot
: NULL_TREE
;
1249 /* Returns nonzero iff DECL is a specialization of TMPL. */
1252 is_specialization_of (tree decl
, tree tmpl
)
1256 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1260 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1266 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1268 for (t
= TREE_TYPE (decl
);
1270 t
= CLASSTYPE_USE_TEMPLATE (t
)
1271 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1272 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1279 /* Returns nonzero iff DECL is a specialization of friend declaration
1280 FRIEND_DECL according to [temp.friend]. */
1283 is_specialization_of_friend (tree decl
, tree friend_decl
)
1285 bool need_template
= true;
1288 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1289 || TREE_CODE (decl
) == TYPE_DECL
);
1291 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1292 of a template class, we want to check if DECL is a specialization
1294 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1295 && DECL_TEMPLATE_INFO (friend_decl
)
1296 && !DECL_USE_TEMPLATE (friend_decl
))
1298 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1299 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1300 need_template
= false;
1302 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1303 && !PRIMARY_TEMPLATE_P (friend_decl
))
1304 need_template
= false;
1306 /* There is nothing to do if this is not a template friend. */
1307 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1310 if (is_specialization_of (decl
, friend_decl
))
1314 A member of a class template may be declared to be a friend of a
1315 non-template class. In this case, the corresponding member of
1316 every specialization of the class template is a friend of the
1317 class granting friendship.
1319 For example, given a template friend declaration
1321 template <class T> friend void A<T>::f();
1323 the member function below is considered a friend
1325 template <> struct A<int> {
1329 For this type of template friend, TEMPLATE_DEPTH below will be
1330 nonzero. To determine if DECL is a friend of FRIEND, we first
1331 check if the enclosing class is a specialization of another. */
1333 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1335 && DECL_CLASS_SCOPE_P (decl
)
1336 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1337 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1339 /* Next, we check the members themselves. In order to handle
1340 a few tricky cases, such as when FRIEND_DECL's are
1342 template <class T> friend void A<T>::g(T t);
1343 template <class T> template <T t> friend void A<T>::h();
1347 void A<int>::g(int);
1348 template <int> void A<int>::h();
1350 we need to figure out ARGS, the template arguments from
1351 the context of DECL. This is required for template substitution
1352 of `T' in the function parameter of `g' and template parameter
1353 of `h' in the above examples. Here ARGS corresponds to `int'. */
1355 tree context
= DECL_CONTEXT (decl
);
1356 tree args
= NULL_TREE
;
1357 int current_depth
= 0;
1359 while (current_depth
< template_depth
)
1361 if (CLASSTYPE_TEMPLATE_INFO (context
))
1363 if (current_depth
== 0)
1364 args
= TYPE_TI_ARGS (context
);
1366 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1369 context
= TYPE_CONTEXT (context
);
1372 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1377 tree friend_args_type
;
1378 tree decl_args_type
;
1380 /* Make sure that both DECL and FRIEND_DECL are templates or
1382 is_template
= DECL_TEMPLATE_INFO (decl
)
1383 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1384 if (need_template
^ is_template
)
1386 else if (is_template
)
1388 /* If both are templates, check template parameter list. */
1390 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1392 if (!comp_template_parms
1393 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1397 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1400 decl_type
= TREE_TYPE (decl
);
1402 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1403 tf_none
, NULL_TREE
);
1404 if (friend_type
== error_mark_node
)
1407 /* Check if return types match. */
1408 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1411 /* Check if function parameter types match, ignoring the
1412 `this' parameter. */
1413 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1414 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1415 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1416 friend_args_type
= TREE_CHAIN (friend_args_type
);
1417 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1418 decl_args_type
= TREE_CHAIN (decl_args_type
);
1420 return compparms (decl_args_type
, friend_args_type
);
1424 /* DECL is a TYPE_DECL */
1426 tree decl_type
= TREE_TYPE (decl
);
1428 /* Make sure that both DECL and FRIEND_DECL are templates or
1431 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1432 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1434 if (need_template
^ is_template
)
1436 else if (is_template
)
1439 /* If both are templates, check the name of the two
1440 TEMPLATE_DECL's first because is_friend didn't. */
1441 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1442 != DECL_NAME (friend_decl
))
1445 /* Now check template parameter list. */
1447 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1449 return comp_template_parms
1450 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1454 return (DECL_NAME (decl
)
1455 == DECL_NAME (friend_decl
));
1461 /* Register the specialization SPEC as a specialization of TMPL with
1462 the indicated ARGS. IS_FRIEND indicates whether the specialization
1463 is actually just a friend declaration. Returns SPEC, or an
1464 equivalent prior declaration, if available.
1466 We also store instantiations of field packs in the hash table, even
1467 though they are not themselves templates, to make lookup easier. */
1470 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1474 spec_entry
**slot
= NULL
;
1477 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1478 || (TREE_CODE (tmpl
) == FIELD_DECL
1479 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1481 if (TREE_CODE (spec
) == FUNCTION_DECL
1482 && uses_template_parms (DECL_TI_ARGS (spec
)))
1483 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1484 register it; we want the corresponding TEMPLATE_DECL instead.
1485 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1486 the more obvious `uses_template_parms (spec)' to avoid problems
1487 with default function arguments. In particular, given
1488 something like this:
1490 template <class T> void f(T t1, T t = T())
1492 the default argument expression is not substituted for in an
1493 instantiation unless and until it is actually needed. */
1496 if (optimize_specialization_lookup_p (tmpl
))
1497 /* We don't put these specializations in the hash table, but we might
1498 want to give an error about a mismatch. */
1499 fn
= retrieve_specialization (tmpl
, args
, 0);
1507 hash
= spec_hasher::hash (&elt
);
1510 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1512 fn
= ((spec_entry
*) *slot
)->spec
;
1517 /* We can sometimes try to re-register a specialization that we've
1518 already got. In particular, regenerate_decl_from_template calls
1519 duplicate_decls which will update the specialization list. But,
1520 we'll still get called again here anyhow. It's more convenient
1521 to simply allow this than to try to prevent it. */
1524 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1526 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1528 if (DECL_ODR_USED (fn
)
1529 || DECL_EXPLICIT_INSTANTIATION (fn
))
1531 error ("specialization of %qD after instantiation",
1533 return error_mark_node
;
1538 /* This situation should occur only if the first
1539 specialization is an implicit instantiation, the
1540 second is an explicit specialization, and the
1541 implicit instantiation has not yet been used. That
1542 situation can occur if we have implicitly
1543 instantiated a member function and then specialized
1546 We can also wind up here if a friend declaration that
1547 looked like an instantiation turns out to be a
1550 template <class T> void foo(T);
1551 class S { friend void foo<>(int) };
1552 template <> void foo(int);
1554 We transform the existing DECL in place so that any
1555 pointers to it become pointers to the updated
1558 If there was a definition for the template, but not
1559 for the specialization, we want this to look as if
1560 there were no definition, and vice versa. */
1561 DECL_INITIAL (fn
) = NULL_TREE
;
1562 duplicate_decls (spec
, fn
, is_friend
);
1563 /* The call to duplicate_decls will have applied
1566 An explicit specialization of a function template
1567 is inline only if it is explicitly declared to be,
1568 and independently of whether its function template
1571 to the primary function; now copy the inline bits to
1572 the various clones. */
1573 FOR_EACH_CLONE (clone
, fn
)
1575 DECL_DECLARED_INLINE_P (clone
)
1576 = DECL_DECLARED_INLINE_P (fn
);
1577 DECL_SOURCE_LOCATION (clone
)
1578 = DECL_SOURCE_LOCATION (fn
);
1579 DECL_DELETED_FN (clone
)
1580 = DECL_DELETED_FN (fn
);
1582 check_specialization_namespace (tmpl
);
1587 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1589 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1590 /* Dup decl failed, but this is a new definition. Set the
1591 line number so any errors match this new
1593 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1599 return duplicate_decls (spec
, fn
, is_friend
);
1601 /* A specialization must be declared in the same namespace as the
1602 template it is specializing. */
1603 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1604 && !check_specialization_namespace (tmpl
))
1605 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1607 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1609 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1610 gcc_assert (tmpl
&& args
&& spec
);
1613 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1614 && PRIMARY_TEMPLATE_P (tmpl
)
1615 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1616 || variable_template_p (tmpl
))
1617 /* If TMPL is a forward declaration of a template function, keep a list
1618 of all specializations in case we need to reassign them to a friend
1619 template later in tsubst_friend_function.
1621 Also keep a list of all variable template instantiations so that
1622 process_partial_specialization can check whether a later partial
1623 specialization would have used it. */
1624 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1625 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1631 /* Returns true iff two spec_entry nodes are equivalent. */
1633 int comparing_specializations
;
1636 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1640 ++comparing_specializations
;
1641 equal
= (e1
->tmpl
== e2
->tmpl
1642 && comp_template_args (e1
->args
, e2
->args
));
1643 if (equal
&& flag_concepts
1644 /* tmpl could be a FIELD_DECL for a capture pack. */
1645 && TREE_CODE (e1
->tmpl
) == TEMPLATE_DECL
1646 && VAR_P (DECL_TEMPLATE_RESULT (e1
->tmpl
))
1647 && uses_template_parms (e1
->args
))
1649 /* Partial specializations of a variable template can be distinguished by
1651 tree c1
= e1
->spec
? get_constraints (e1
->spec
) : NULL_TREE
;
1652 tree c2
= e2
->spec
? get_constraints (e2
->spec
) : NULL_TREE
;
1653 equal
= equivalent_constraints (c1
, c2
);
1655 --comparing_specializations
;
1660 /* Returns a hash for a template TMPL and template arguments ARGS. */
1663 hash_tmpl_and_args (tree tmpl
, tree args
)
1665 hashval_t val
= iterative_hash_object (DECL_UID (tmpl
), 0);
1666 return iterative_hash_template_arg (args
, val
);
1669 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1673 spec_hasher::hash (spec_entry
*e
)
1675 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1678 /* Recursively calculate a hash value for a template argument ARG, for use
1679 in the hash tables of template specializations. */
1682 iterative_hash_template_arg (tree arg
, hashval_t val
)
1684 unsigned HOST_WIDE_INT i
;
1685 enum tree_code code
;
1688 if (arg
== NULL_TREE
)
1689 return iterative_hash_object (arg
, val
);
1694 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1695 /* We can get one of these when re-hashing a previous entry in the middle
1696 of substituting into a pack expansion. Just look through it. */
1697 arg
= ARGUMENT_PACK_SELECT_FROM_PACK (arg
);
1699 code
= TREE_CODE (arg
);
1700 tclass
= TREE_CODE_CLASS (code
);
1702 val
= iterative_hash_object (code
, val
);
1709 case IDENTIFIER_NODE
:
1710 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1714 int i
, len
= TREE_VEC_LENGTH (arg
);
1715 for (i
= 0; i
< len
; ++i
)
1716 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1720 case TYPE_PACK_EXPANSION
:
1721 case EXPR_PACK_EXPANSION
:
1722 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1723 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1725 case TYPE_ARGUMENT_PACK
:
1726 case NONTYPE_ARGUMENT_PACK
:
1727 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1730 for (; arg
; arg
= TREE_CHAIN (arg
))
1731 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1735 for (; arg
; arg
= OVL_NEXT (arg
))
1736 val
= iterative_hash_template_arg (OVL_CURRENT (arg
), val
);
1742 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1743 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1745 val
= iterative_hash_template_arg (field
, val
);
1746 val
= iterative_hash_template_arg (value
, val
);
1752 if (!DECL_ARTIFICIAL (arg
))
1754 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1755 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1757 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1760 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1763 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1764 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1766 case TEMPLATE_PARM_INDEX
:
1767 val
= iterative_hash_template_arg
1768 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1769 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1770 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1773 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1774 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1775 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1778 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1780 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1784 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1785 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1786 val
= iterative_hash_object (code
, val
);
1787 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1790 /* A lambda can't appear in a template arg, but don't crash on
1792 gcc_assert (seen_error ());
1796 case IMPLICIT_CONV_EXPR
:
1797 case STATIC_CAST_EXPR
:
1798 case REINTERPRET_CAST_EXPR
:
1799 case CONST_CAST_EXPR
:
1800 case DYNAMIC_CAST_EXPR
:
1802 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1803 /* Now hash operands as usual. */
1813 if (alias_template_specialization_p (arg
))
1815 // We want an alias specialization that survived strip_typedefs
1816 // to hash differently from its TYPE_CANONICAL, to avoid hash
1817 // collisions that compare as different in template_args_equal.
1818 // These could be dependent specializations that strip_typedefs
1819 // left alone, or untouched specializations because
1820 // coerce_template_parms returns the unconverted template
1821 // arguments if it sees incomplete argument packs.
1822 tree ti
= TYPE_TEMPLATE_INFO (arg
);
1823 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1825 if (TYPE_CANONICAL (arg
))
1826 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1828 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1829 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1830 /* Otherwise just compare the types during lookup. */
1833 case tcc_declaration
:
1835 return iterative_hash_expr (arg
, val
);
1838 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1840 unsigned n
= cp_tree_operand_length (arg
);
1841 for (i
= 0; i
< n
; ++i
)
1842 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1850 /* Unregister the specialization SPEC as a specialization of TMPL.
1851 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1852 if the SPEC was listed as a specialization of TMPL.
1854 Note that SPEC has been ggc_freed, so we can't look inside it. */
1857 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1862 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1863 elt
.args
= TI_ARGS (tinfo
);
1864 elt
.spec
= NULL_TREE
;
1866 entry
= decl_specializations
->find (&elt
);
1869 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1870 gcc_assert (new_spec
!= NULL_TREE
);
1871 entry
->spec
= new_spec
;
1878 /* Like register_specialization, but for local declarations. We are
1879 registering SPEC, an instantiation of TMPL. */
1882 register_local_specialization (tree spec
, tree tmpl
)
1884 local_specializations
->put (tmpl
, spec
);
1887 /* TYPE is a class type. Returns true if TYPE is an explicitly
1888 specialized class. */
1891 explicit_class_specialization_p (tree type
)
1893 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1895 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1898 /* Print the list of functions at FNS, going through all the overloads
1899 for each element of the list. Alternatively, FNS can not be a
1900 TREE_LIST, in which case it will be printed together with all the
1903 MORE and *STR should respectively be FALSE and NULL when the function
1904 is called from the outside. They are used internally on recursive
1905 calls. print_candidates manages the two parameters and leaves NULL
1906 in *STR when it ends. */
1909 print_candidates_1 (tree fns
, bool more
, const char **str
)
1912 char *spaces
= NULL
;
1914 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
1915 if (TREE_CODE (fn
) == TREE_LIST
)
1917 for (fn2
= fn
; fn2
!= NULL_TREE
; fn2
= TREE_CHAIN (fn2
))
1918 print_candidates_1 (TREE_VALUE (fn2
),
1919 TREE_CHAIN (fn2
) || more
, str
);
1923 tree cand
= OVL_CURRENT (fn
);
1926 /* Pick the prefix string. */
1927 if (!more
&& !OVL_NEXT (fns
))
1929 inform (DECL_SOURCE_LOCATION (cand
),
1930 "candidate is: %#D", cand
);
1934 *str
= _("candidates are:");
1935 spaces
= get_spaces (*str
);
1937 inform (DECL_SOURCE_LOCATION (cand
), "%s %#D", *str
, cand
);
1938 *str
= spaces
? spaces
: *str
;
1948 /* Print the list of candidate FNS in an error message. FNS can also
1949 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1952 print_candidates (tree fns
)
1954 const char *str
= NULL
;
1955 print_candidates_1 (fns
, false, &str
);
1956 gcc_assert (str
== NULL
);
1959 /* Get a (possibly) constrained template declaration for the
1960 purpose of ordering candidates. */
1962 get_template_for_ordering (tree list
)
1964 gcc_assert (TREE_CODE (list
) == TREE_LIST
);
1965 tree f
= TREE_VALUE (list
);
1966 if (tree ti
= DECL_TEMPLATE_INFO (f
))
1967 return TI_TEMPLATE (ti
);
1971 /* Among candidates having the same signature, return the
1972 most constrained or NULL_TREE if there is no best candidate.
1973 If the signatures of candidates vary (e.g., template
1974 specialization vs. member function), then there can be no
1977 Note that we don't compare constraints on the functions
1978 themselves, but rather those of their templates. */
1980 most_constrained_function (tree candidates
)
1982 // Try to find the best candidate in a first pass.
1983 tree champ
= candidates
;
1984 for (tree c
= TREE_CHAIN (champ
); c
; c
= TREE_CHAIN (c
))
1986 int winner
= more_constrained (get_template_for_ordering (champ
),
1987 get_template_for_ordering (c
));
1989 champ
= c
; // The candidate is more constrained
1990 else if (winner
== 0)
1991 return NULL_TREE
; // Neither is more constrained
1994 // Verify that the champ is better than previous candidates.
1995 for (tree c
= candidates
; c
!= champ
; c
= TREE_CHAIN (c
)) {
1996 if (!more_constrained (get_template_for_ordering (champ
),
1997 get_template_for_ordering (c
)))
2005 /* Returns the template (one of the functions given by TEMPLATE_ID)
2006 which can be specialized to match the indicated DECL with the
2007 explicit template args given in TEMPLATE_ID. The DECL may be
2008 NULL_TREE if none is available. In that case, the functions in
2009 TEMPLATE_ID are non-members.
2011 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2012 specialization of a member template.
2014 The TEMPLATE_COUNT is the number of references to qualifying
2015 template classes that appeared in the name of the function. See
2016 check_explicit_specialization for a more accurate description.
2018 TSK indicates what kind of template declaration (if any) is being
2019 declared. TSK_TEMPLATE indicates that the declaration given by
2020 DECL, though a FUNCTION_DECL, has template parameters, and is
2021 therefore a template function.
2023 The template args (those explicitly specified and those deduced)
2024 are output in a newly created vector *TARGS_OUT.
2026 If it is impossible to determine the result, an error message is
2027 issued. The error_mark_node is returned to indicate failure. */
2030 determine_specialization (tree template_id
,
2033 int need_member_template
,
2039 tree explicit_targs
;
2040 tree candidates
= NULL_TREE
;
2042 /* A TREE_LIST of templates of which DECL may be a specialization.
2043 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2044 corresponding TREE_PURPOSE is the set of template arguments that,
2045 when used to instantiate the template, would produce a function
2046 with the signature of DECL. */
2047 tree templates
= NULL_TREE
;
2049 cp_binding_level
*b
;
2051 *targs_out
= NULL_TREE
;
2053 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
2054 return error_mark_node
;
2056 /* We shouldn't be specializing a member template of an
2057 unspecialized class template; we already gave an error in
2058 check_specialization_scope, now avoid crashing. */
2059 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
2060 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
2062 gcc_assert (errorcount
);
2063 return error_mark_node
;
2066 fns
= TREE_OPERAND (template_id
, 0);
2067 explicit_targs
= TREE_OPERAND (template_id
, 1);
2069 if (fns
== error_mark_node
)
2070 return error_mark_node
;
2072 /* Check for baselinks. */
2073 if (BASELINK_P (fns
))
2074 fns
= BASELINK_FUNCTIONS (fns
);
2076 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
2078 error ("%qD is not a function template", fns
);
2079 return error_mark_node
;
2081 else if (VAR_P (decl
) && !variable_template_p (fns
))
2083 error ("%qD is not a variable template", fns
);
2084 return error_mark_node
;
2087 /* Count the number of template headers specified for this
2090 for (b
= current_binding_level
;
2091 b
->kind
== sk_template_parms
;
2095 tree orig_fns
= fns
;
2097 if (variable_template_p (fns
))
2099 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
2100 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
2101 tf_warning_or_error
,
2102 /*req_all*/true, /*use_defarg*/true);
2103 if (targs
!= error_mark_node
)
2104 templates
= tree_cons (targs
, fns
, templates
);
2106 else for (; fns
; fns
= OVL_NEXT (fns
))
2108 tree fn
= OVL_CURRENT (fns
);
2110 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2112 tree decl_arg_types
;
2116 /* In case of explicit specialization, we need to check if
2117 the number of template headers appearing in the specialization
2118 is correct. This is usually done in check_explicit_specialization,
2119 but the check done there cannot be exhaustive when specializing
2120 member functions. Consider the following code:
2122 template <> void A<int>::f(int);
2123 template <> template <> void A<int>::f(int);
2125 Assuming that A<int> is not itself an explicit specialization
2126 already, the first line specializes "f" which is a non-template
2127 member function, whilst the second line specializes "f" which
2128 is a template member function. So both lines are syntactically
2129 correct, and check_explicit_specialization does not reject
2132 Here, we can do better, as we are matching the specialization
2133 against the declarations. We count the number of template
2134 headers, and we check if they match TEMPLATE_COUNT + 1
2135 (TEMPLATE_COUNT is the number of qualifying template classes,
2136 plus there must be another header for the member template
2139 Notice that if header_count is zero, this is not a
2140 specialization but rather a template instantiation, so there
2141 is no check we can perform here. */
2142 if (header_count
&& header_count
!= template_count
+ 1)
2145 /* Check that the number of template arguments at the
2146 innermost level for DECL is the same as for FN. */
2147 if (current_binding_level
->kind
== sk_template_parms
2148 && !current_binding_level
->explicit_spec_p
2149 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
2150 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2151 (current_template_parms
))))
2154 /* DECL might be a specialization of FN. */
2155 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2156 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2158 /* For a non-static member function, we need to make sure
2159 that the const qualification is the same. Since
2160 get_bindings does not try to merge the "this" parameter,
2161 we must do the comparison explicitly. */
2162 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2163 && !same_type_p (TREE_VALUE (fn_arg_types
),
2164 TREE_VALUE (decl_arg_types
)))
2167 /* Skip the "this" parameter and, for constructors of
2168 classes with virtual bases, the VTT parameter. A
2169 full specialization of a constructor will have a VTT
2170 parameter, but a template never will. */
2172 = skip_artificial_parms_for (decl
, decl_arg_types
);
2174 = skip_artificial_parms_for (fn
, fn_arg_types
);
2176 /* Function templates cannot be specializations; there are
2177 no partial specializations of functions. Therefore, if
2178 the type of DECL does not match FN, there is no
2181 Note that it should never be the case that we have both
2182 candidates added here, and for regular member functions
2184 if (tsk
== tsk_template
)
2186 if (compparms (fn_arg_types
, decl_arg_types
))
2187 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2191 /* See whether this function might be a specialization of this
2192 template. Suppress access control because we might be trying
2193 to make this specialization a friend, and we have already done
2194 access control for the declaration of the specialization. */
2195 push_deferring_access_checks (dk_no_check
);
2196 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2197 pop_deferring_access_checks ();
2200 /* We cannot deduce template arguments that when used to
2201 specialize TMPL will produce DECL. */
2204 /* Remove, from the set of candidates, all those functions
2205 whose constraints are not satisfied. */
2206 if (flag_concepts
&& !constraints_satisfied_p (fn
, targs
))
2209 // Then, try to form the new function type.
2210 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
);
2211 if (insttype
== error_mark_node
)
2214 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2215 if (!compparms (fn_arg_types
, decl_arg_types
))
2218 /* Save this template, and the arguments deduced. */
2219 templates
= tree_cons (targs
, fn
, templates
);
2221 else if (need_member_template
)
2222 /* FN is an ordinary member function, and we need a
2223 specialization of a member template. */
2225 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2226 /* We can get IDENTIFIER_NODEs here in certain erroneous
2229 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2230 /* This is just an ordinary non-member function. Nothing can
2231 be a specialization of that. */
2233 else if (DECL_ARTIFICIAL (fn
))
2234 /* Cannot specialize functions that are created implicitly. */
2238 tree decl_arg_types
;
2240 /* This is an ordinary member function. However, since
2241 we're here, we can assume its enclosing class is a
2242 template class. For example,
2244 template <typename T> struct S { void f(); };
2245 template <> void S<int>::f() {}
2247 Here, S<int>::f is a non-template, but S<int> is a
2248 template class. If FN has the same type as DECL, we
2249 might be in business. */
2251 if (!DECL_TEMPLATE_INFO (fn
))
2252 /* Its enclosing class is an explicit specialization
2253 of a template class. This is not a candidate. */
2256 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2257 TREE_TYPE (TREE_TYPE (fn
))))
2258 /* The return types differ. */
2261 /* Adjust the type of DECL in case FN is a static member. */
2262 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2263 if (DECL_STATIC_FUNCTION_P (fn
)
2264 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2265 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2267 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2271 // If the deduced arguments do not satisfy the constraints,
2272 // this is not a candidate.
2273 if (flag_concepts
&& !constraints_satisfied_p (fn
))
2276 // Add the candidate.
2277 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2281 if (templates
&& TREE_CHAIN (templates
))
2287 It is possible for a specialization with a given function
2288 signature to be instantiated from more than one function
2289 template. In such cases, explicit specification of the
2290 template arguments must be used to uniquely identify the
2291 function template specialization being specialized.
2293 Note that here, there's no suggestion that we're supposed to
2294 determine which of the candidate templates is most
2295 specialized. However, we, also have:
2299 Partial ordering of overloaded function template
2300 declarations is used in the following contexts to select
2301 the function template to which a function template
2302 specialization refers:
2304 -- when an explicit specialization refers to a function
2307 So, we do use the partial ordering rules, at least for now.
2308 This extension can only serve to make invalid programs valid,
2309 so it's safe. And, there is strong anecdotal evidence that
2310 the committee intended the partial ordering rules to apply;
2311 the EDG front end has that behavior, and John Spicer claims
2312 that the committee simply forgot to delete the wording in
2313 [temp.expl.spec]. */
2314 tree tmpl
= most_specialized_instantiation (templates
);
2315 if (tmpl
!= error_mark_node
)
2318 TREE_CHAIN (templates
) = NULL_TREE
;
2322 // Concepts allows multiple declarations of member functions
2323 // with the same signature. Like above, we need to rely on
2324 // on the partial ordering of those candidates to determine which
2326 if (flag_concepts
&& candidates
&& TREE_CHAIN (candidates
))
2328 if (tree cand
= most_constrained_function (candidates
))
2331 TREE_CHAIN (cand
) = NULL_TREE
;
2335 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2337 error ("template-id %qD for %q+D does not match any template "
2338 "declaration", template_id
, decl
);
2339 if (header_count
&& header_count
!= template_count
+ 1)
2340 inform (input_location
, "saw %d %<template<>%>, need %d for "
2341 "specializing a member function template",
2342 header_count
, template_count
+ 1);
2344 print_candidates (orig_fns
);
2345 return error_mark_node
;
2347 else if ((templates
&& TREE_CHAIN (templates
))
2348 || (candidates
&& TREE_CHAIN (candidates
))
2349 || (templates
&& candidates
))
2351 error ("ambiguous template specialization %qD for %q+D",
2353 candidates
= chainon (candidates
, templates
);
2354 print_candidates (candidates
);
2355 return error_mark_node
;
2358 /* We have one, and exactly one, match. */
2361 tree fn
= TREE_VALUE (candidates
);
2362 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2364 // Propagate the candidate's constraints to the declaration.
2365 set_constraints (decl
, get_constraints (fn
));
2367 /* DECL is a re-declaration or partial instantiation of a template
2369 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2371 /* It was a specialization of an ordinary member function in a
2373 return DECL_TI_TEMPLATE (fn
);
2376 /* It was a specialization of a template. */
2377 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2378 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2380 *targs_out
= copy_node (targs
);
2381 SET_TMPL_ARGS_LEVEL (*targs_out
,
2382 TMPL_ARGS_DEPTH (*targs_out
),
2383 TREE_PURPOSE (templates
));
2386 *targs_out
= TREE_PURPOSE (templates
);
2387 return TREE_VALUE (templates
);
2390 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2391 but with the default argument values filled in from those in the
2395 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2398 tree new_spec_types
;
2403 if (spec_types
== void_list_node
)
2404 return void_list_node
;
2406 /* Substitute into the rest of the list. */
2408 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2409 TREE_CHAIN (tmpl_types
));
2411 /* Add the default argument for this parameter. */
2412 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2413 TREE_VALUE (spec_types
),
2417 /* DECL is an explicit specialization. Replicate default arguments
2418 from the template it specializes. (That way, code like:
2420 template <class T> void f(T = 3);
2421 template <> void f(double);
2424 works, as required.) An alternative approach would be to look up
2425 the correct default arguments at the call-site, but this approach
2426 is consistent with how implicit instantiations are handled. */
2429 copy_default_args_to_explicit_spec (tree decl
)
2434 tree new_spec_types
;
2438 tree object_type
= NULL_TREE
;
2439 tree in_charge
= NULL_TREE
;
2440 tree vtt
= NULL_TREE
;
2442 /* See if there's anything we need to do. */
2443 tmpl
= DECL_TI_TEMPLATE (decl
);
2444 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2445 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2446 if (TREE_PURPOSE (t
))
2451 old_type
= TREE_TYPE (decl
);
2452 spec_types
= TYPE_ARG_TYPES (old_type
);
2454 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2456 /* Remove the this pointer, but remember the object's type for
2458 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2459 spec_types
= TREE_CHAIN (spec_types
);
2460 tmpl_types
= TREE_CHAIN (tmpl_types
);
2462 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2464 /* DECL may contain more parameters than TMPL due to the extra
2465 in-charge parameter in constructors and destructors. */
2466 in_charge
= spec_types
;
2467 spec_types
= TREE_CHAIN (spec_types
);
2469 if (DECL_HAS_VTT_PARM_P (decl
))
2472 spec_types
= TREE_CHAIN (spec_types
);
2476 /* Compute the merged default arguments. */
2478 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2480 /* Compute the new FUNCTION_TYPE. */
2484 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2489 /* Put the in-charge parameter back. */
2490 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2491 TREE_VALUE (in_charge
),
2494 new_type
= build_method_type_directly (object_type
,
2495 TREE_TYPE (old_type
),
2499 new_type
= build_function_type (TREE_TYPE (old_type
),
2501 new_type
= cp_build_type_attribute_variant (new_type
,
2502 TYPE_ATTRIBUTES (old_type
));
2503 new_type
= build_exception_variant (new_type
,
2504 TYPE_RAISES_EXCEPTIONS (old_type
));
2506 if (TYPE_HAS_LATE_RETURN_TYPE (old_type
))
2507 TYPE_HAS_LATE_RETURN_TYPE (new_type
) = 1;
2509 TREE_TYPE (decl
) = new_type
;
2512 /* Return the number of template headers we expect to see for a definition
2513 or specialization of CTYPE or one of its non-template members. */
2516 num_template_headers_for_class (tree ctype
)
2518 int num_templates
= 0;
2520 while (ctype
&& CLASS_TYPE_P (ctype
))
2522 /* You're supposed to have one `template <...>' for every
2523 template class, but you don't need one for a full
2524 specialization. For example:
2526 template <class T> struct S{};
2527 template <> struct S<int> { void f(); };
2528 void S<int>::f () {}
2530 is correct; there shouldn't be a `template <>' for the
2531 definition of `S<int>::f'. */
2532 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2533 /* If CTYPE does not have template information of any
2534 kind, then it is not a template, nor is it nested
2535 within a template. */
2537 if (explicit_class_specialization_p (ctype
))
2539 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2542 ctype
= TYPE_CONTEXT (ctype
);
2545 return num_templates
;
2548 /* Do a simple sanity check on the template headers that precede the
2549 variable declaration DECL. */
2552 check_template_variable (tree decl
)
2554 tree ctx
= CP_DECL_CONTEXT (decl
);
2555 int wanted
= num_template_headers_for_class (ctx
);
2556 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2557 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2559 if (cxx_dialect
< cxx14
)
2560 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2561 "variable templates only available with "
2562 "-std=c++14 or -std=gnu++14");
2564 // Namespace-scope variable templates should have a template header.
2567 if (template_header_count
> wanted
)
2569 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2570 "too many template headers for %D (should be %d)",
2572 if (warned
&& CLASS_TYPE_P (ctx
)
2573 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2574 inform (DECL_SOURCE_LOCATION (decl
),
2575 "members of an explicitly specialized class are defined "
2576 "without a template header");
2580 /* Check to see if the function just declared, as indicated in
2581 DECLARATOR, and in DECL, is a specialization of a function
2582 template. We may also discover that the declaration is an explicit
2583 instantiation at this point.
2585 Returns DECL, or an equivalent declaration that should be used
2586 instead if all goes well. Issues an error message if something is
2587 amiss. Returns error_mark_node if the error is not easily
2590 FLAGS is a bitmask consisting of the following flags:
2592 2: The function has a definition.
2593 4: The function is a friend.
2595 The TEMPLATE_COUNT is the number of references to qualifying
2596 template classes that appeared in the name of the function. For
2599 template <class T> struct S { void f(); };
2602 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2603 classes are not counted in the TEMPLATE_COUNT, so that in
2605 template <class T> struct S {};
2606 template <> struct S<int> { void f(); }
2607 template <> void S<int>::f();
2609 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2610 invalid; there should be no template <>.)
2612 If the function is a specialization, it is marked as such via
2613 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2614 is set up correctly, and it is added to the list of specializations
2615 for that template. */
2618 check_explicit_specialization (tree declarator
,
2623 int have_def
= flags
& 2;
2624 int is_friend
= flags
& 4;
2625 bool is_concept
= flags
& 8;
2626 int specialization
= 0;
2627 int explicit_instantiation
= 0;
2628 int member_specialization
= 0;
2629 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2630 tree dname
= DECL_NAME (decl
);
2635 if (!processing_specialization
)
2638 tsk
= tsk_excessive_parms
;
2641 tsk
= current_tmpl_spec_kind (template_count
);
2646 if (processing_specialization
&& !VAR_P (decl
))
2649 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2651 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2654 /* This could be something like:
2656 template <class T> void f(T);
2657 class S { friend void f<>(int); } */
2661 /* This case handles bogus declarations like template <>
2662 template <class T> void f<int>(); */
2664 error ("template-id %qD in declaration of primary template",
2671 case tsk_invalid_member_spec
:
2672 /* The error has already been reported in
2673 check_specialization_scope. */
2674 return error_mark_node
;
2676 case tsk_invalid_expl_inst
:
2677 error ("template parameter list used in explicit instantiation");
2683 error ("definition provided for explicit instantiation");
2685 explicit_instantiation
= 1;
2688 case tsk_excessive_parms
:
2689 case tsk_insufficient_parms
:
2690 if (tsk
== tsk_excessive_parms
)
2691 error ("too many template parameter lists in declaration of %qD",
2693 else if (template_header_count
)
2694 error("too few template parameter lists in declaration of %qD", decl
);
2696 error("explicit specialization of %qD must be introduced by "
2697 "%<template <>%>", decl
);
2702 error ("explicit specialization declared %<concept%>");
2704 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2705 /* In cases like template<> constexpr bool v = true;
2706 We'll give an error in check_template_variable. */
2709 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2711 member_specialization
= 1;
2717 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2719 /* This case handles bogus declarations like template <>
2720 template <class T> void f<int>(); */
2722 if (!uses_template_parms (declarator
))
2723 error ("template-id %qD in declaration of primary template",
2725 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2727 /* Partial specialization of variable template. */
2728 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2732 else if (cxx_dialect
< cxx14
)
2733 error ("non-type partial specialization %qD "
2734 "is not allowed", declarator
);
2736 error ("non-class, non-variable partial specialization %qD "
2737 "is not allowed", declarator
);
2742 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2743 /* This is a specialization of a member template, without
2744 specialization the containing class. Something like:
2746 template <class T> struct S {
2747 template <class U> void f (U);
2749 template <> template <class U> void S<int>::f(U) {}
2751 That's a specialization -- but of the entire template. */
2759 if ((specialization
|| member_specialization
)
2760 /* This doesn't apply to variable templates. */
2761 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2762 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
2764 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2765 for (; t
; t
= TREE_CHAIN (t
))
2766 if (TREE_PURPOSE (t
))
2768 permerror (input_location
,
2769 "default argument specified in explicit specialization");
2774 if (specialization
|| member_specialization
|| explicit_instantiation
)
2776 tree tmpl
= NULL_TREE
;
2777 tree targs
= NULL_TREE
;
2778 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2780 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2781 if (!was_template_id
)
2785 gcc_assert (identifier_p (declarator
));
2790 /* If there is no class context, the explicit instantiation
2791 must be at namespace scope. */
2792 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2794 /* Find the namespace binding, using the declaration
2796 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2798 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2800 error ("%qD is not a template function", dname
);
2801 fns
= error_mark_node
;
2805 declarator
= lookup_template_function (fns
, NULL_TREE
);
2808 if (declarator
== error_mark_node
)
2809 return error_mark_node
;
2811 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2813 if (!explicit_instantiation
)
2814 /* A specialization in class scope. This is invalid,
2815 but the error will already have been flagged by
2816 check_specialization_scope. */
2817 return error_mark_node
;
2820 /* It's not valid to write an explicit instantiation in
2823 class C { template void f(); }
2825 This case is caught by the parser. However, on
2828 template class C { void f(); };
2830 (which is invalid) we can get here. The error will be
2837 else if (ctype
!= NULL_TREE
2838 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2840 // We'll match variable templates in start_decl.
2844 /* Find the list of functions in ctype that have the same
2845 name as the declared function. */
2846 tree name
= TREE_OPERAND (declarator
, 0);
2847 tree fns
= NULL_TREE
;
2850 if (constructor_name_p (name
, ctype
))
2852 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2854 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2855 : !CLASSTYPE_DESTRUCTORS (ctype
))
2857 /* From [temp.expl.spec]:
2859 If such an explicit specialization for the member
2860 of a class template names an implicitly-declared
2861 special member function (clause _special_), the
2862 program is ill-formed.
2864 Similar language is found in [temp.explicit]. */
2865 error ("specialization of implicitly-declared special member function");
2866 return error_mark_node
;
2869 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2872 if (!DECL_CONV_FN_P (decl
))
2874 idx
= lookup_fnfields_1 (ctype
, name
);
2876 fns
= (*CLASSTYPE_METHOD_VEC (ctype
))[idx
];
2880 vec
<tree
, va_gc
> *methods
;
2883 /* For a type-conversion operator, we cannot do a
2884 name-based lookup. We might be looking for `operator
2885 int' which will be a specialization of `operator T'.
2886 So, we find *all* the conversion operators, and then
2887 select from them. */
2890 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2892 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2893 methods
->iterate (idx
, &ovl
);
2896 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2897 /* There are no more conversion functions. */
2900 /* Glue all these conversion functions together
2901 with those we already have. */
2902 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2903 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2907 if (fns
== NULL_TREE
)
2909 error ("no member function %qD declared in %qT", name
, ctype
);
2910 return error_mark_node
;
2913 TREE_OPERAND (declarator
, 0) = fns
;
2916 /* Figure out what exactly is being specialized at this point.
2917 Note that for an explicit instantiation, even one for a
2918 member function, we cannot tell apriori whether the
2919 instantiation is for a member template, or just a member
2920 function of a template class. Even if a member template is
2921 being instantiated, the member template arguments may be
2922 elided if they can be deduced from the rest of the
2924 tmpl
= determine_specialization (declarator
, decl
,
2926 member_specialization
,
2930 if (!tmpl
|| tmpl
== error_mark_node
)
2931 /* We couldn't figure out what this declaration was
2933 return error_mark_node
;
2936 if (!ctype
&& !was_template_id
2937 && (specialization
|| member_specialization
2938 || explicit_instantiation
)
2939 && !is_associated_namespace (CP_DECL_CONTEXT (decl
),
2940 CP_DECL_CONTEXT (tmpl
)))
2941 error ("%qD is not declared in %qD",
2942 tmpl
, current_namespace
);
2944 tree gen_tmpl
= most_general_template (tmpl
);
2946 if (explicit_instantiation
)
2948 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2949 is done by do_decl_instantiation later. */
2951 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2952 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2954 if (arg_depth
> parm_depth
)
2956 /* If TMPL is not the most general template (for
2957 example, if TMPL is a friend template that is
2958 injected into namespace scope), then there will
2959 be too many levels of TARGS. Remove some of them
2964 new_targs
= make_tree_vec (parm_depth
);
2965 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2966 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2967 = TREE_VEC_ELT (targs
, i
);
2971 return instantiate_template (tmpl
, targs
, tf_error
);
2974 /* If we thought that the DECL was a member function, but it
2975 turns out to be specializing a static member function,
2976 make DECL a static member function as well. */
2977 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
2978 && DECL_STATIC_FUNCTION_P (tmpl
)
2979 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2980 revert_static_member_fn (decl
);
2982 /* If this is a specialization of a member template of a
2983 template class, we want to return the TEMPLATE_DECL, not
2984 the specialization of it. */
2985 if (tsk
== tsk_template
&& !was_template_id
)
2987 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
2988 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2989 DECL_INITIAL (result
) = NULL_TREE
;
2993 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2994 DECL_SOURCE_LOCATION (result
)
2995 = DECL_SOURCE_LOCATION (decl
);
2996 /* We want to use the argument list specified in the
2997 definition, not in the original declaration. */
2998 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
2999 for (parm
= DECL_ARGUMENTS (result
); parm
;
3000 parm
= DECL_CHAIN (parm
))
3001 DECL_CONTEXT (parm
) = result
;
3003 return register_specialization (tmpl
, gen_tmpl
, targs
,
3007 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3008 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
3010 if (was_template_id
)
3011 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
)) = true;
3013 /* Inherit default function arguments from the template
3014 DECL is specializing. */
3015 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
3016 copy_default_args_to_explicit_spec (decl
);
3018 /* This specialization has the same protection as the
3019 template it specializes. */
3020 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
3021 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
3023 /* 7.1.1-1 [dcl.stc]
3025 A storage-class-specifier shall not be specified in an
3026 explicit specialization...
3028 The parser rejects these, so unless action is taken here,
3029 explicit function specializations will always appear with
3032 The action recommended by the C++ CWG in response to C++
3033 defect report 605 is to make the storage class and linkage
3034 of the explicit specialization match the templated function:
3036 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3038 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
3040 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
3041 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
3043 /* A concept cannot be specialized. */
3044 if (DECL_DECLARED_CONCEPT_P (tmpl_func
))
3046 error ("explicit specialization of function concept %qD",
3048 return error_mark_node
;
3051 /* This specialization has the same linkage and visibility as
3052 the function template it specializes. */
3053 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
3054 if (! TREE_PUBLIC (decl
))
3056 DECL_INTERFACE_KNOWN (decl
) = 1;
3057 DECL_NOT_REALLY_EXTERN (decl
) = 1;
3059 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
3060 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
3062 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3063 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
3067 /* If DECL is a friend declaration, declared using an
3068 unqualified name, the namespace associated with DECL may
3069 have been set incorrectly. For example, in:
3071 template <typename T> void f(T);
3073 struct S { friend void f<int>(int); }
3076 we will have set the DECL_CONTEXT for the friend
3077 declaration to N, rather than to the global namespace. */
3078 if (DECL_NAMESPACE_SCOPE_P (decl
))
3079 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
3081 if (is_friend
&& !have_def
)
3082 /* This is not really a declaration of a specialization.
3083 It's just the name of an instantiation. But, it's not
3084 a request for an instantiation, either. */
3085 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
3086 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3087 /* A specialization is not necessarily COMDAT. */
3088 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
3089 && DECL_DECLARED_INLINE_P (decl
));
3090 else if (VAR_P (decl
))
3091 DECL_COMDAT (decl
) = false;
3093 /* If this is a full specialization, register it so that we can find
3094 it again. Partial specializations will be registered in
3095 process_partial_specialization. */
3096 if (!processing_template_decl
)
3097 decl
= register_specialization (decl
, gen_tmpl
, targs
,
3100 /* A 'structor should already have clones. */
3101 gcc_assert (decl
== error_mark_node
3102 || variable_template_p (tmpl
)
3103 || !(DECL_CONSTRUCTOR_P (decl
)
3104 || DECL_DESTRUCTOR_P (decl
))
3105 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
3112 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3113 parameters. These are represented in the same format used for
3114 DECL_TEMPLATE_PARMS. */
3117 comp_template_parms (const_tree parms1
, const_tree parms2
)
3122 if (parms1
== parms2
)
3125 for (p1
= parms1
, p2
= parms2
;
3126 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
3127 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
3129 tree t1
= TREE_VALUE (p1
);
3130 tree t2
= TREE_VALUE (p2
);
3133 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
3134 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
3136 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3139 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
3141 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
3142 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
3144 /* If either of the template parameters are invalid, assume
3145 they match for the sake of error recovery. */
3146 if (error_operand_p (parm1
) || error_operand_p (parm2
))
3149 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
3152 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
3153 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
3154 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
3156 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
3161 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
3162 /* One set of parameters has more parameters lists than the
3169 /* Determine whether PARM is a parameter pack. */
3172 template_parameter_pack_p (const_tree parm
)
3174 /* Determine if we have a non-type template parameter pack. */
3175 if (TREE_CODE (parm
) == PARM_DECL
)
3176 return (DECL_TEMPLATE_PARM_P (parm
)
3177 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
3178 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
3179 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
3181 /* If this is a list of template parameters, we could get a
3182 TYPE_DECL or a TEMPLATE_DECL. */
3183 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
3184 parm
= TREE_TYPE (parm
);
3186 /* Otherwise it must be a type template parameter. */
3187 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
3188 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
3189 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
3192 /* Determine if T is a function parameter pack. */
3195 function_parameter_pack_p (const_tree t
)
3197 if (t
&& TREE_CODE (t
) == PARM_DECL
)
3198 return DECL_PACK_P (t
);
3202 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3203 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3206 get_function_template_decl (const_tree primary_func_tmpl_inst
)
3208 if (! primary_func_tmpl_inst
3209 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
3210 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
3213 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
3216 /* Return true iff the function parameter PARAM_DECL was expanded
3217 from the function parameter pack PACK. */
3220 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
3222 if (DECL_ARTIFICIAL (param_decl
)
3223 || !function_parameter_pack_p (pack
))
3226 /* The parameter pack and its pack arguments have the same
3228 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
3231 /* Determine whether ARGS describes a variadic template args list,
3232 i.e., one that is terminated by a template argument pack. */
3235 template_args_variadic_p (tree args
)
3240 if (args
== NULL_TREE
)
3243 args
= INNERMOST_TEMPLATE_ARGS (args
);
3244 nargs
= TREE_VEC_LENGTH (args
);
3249 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
3251 return ARGUMENT_PACK_P (last_parm
);
3254 /* Generate a new name for the parameter pack name NAME (an
3255 IDENTIFIER_NODE) that incorporates its */
3258 make_ith_pack_parameter_name (tree name
, int i
)
3260 /* Munge the name to include the parameter index. */
3261 #define NUMBUF_LEN 128
3262 char numbuf
[NUMBUF_LEN
];
3266 if (name
== NULL_TREE
)
3268 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
3269 newname_len
= IDENTIFIER_LENGTH (name
)
3270 + strlen (numbuf
) + 2;
3271 newname
= (char*)alloca (newname_len
);
3272 snprintf (newname
, newname_len
,
3273 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3274 return get_identifier (newname
);
3277 /* Return true if T is a primary function, class or alias template
3281 primary_template_instantiation_p (const_tree t
)
3286 if (TREE_CODE (t
) == FUNCTION_DECL
)
3287 return DECL_LANG_SPECIFIC (t
)
3288 && DECL_TEMPLATE_INSTANTIATION (t
)
3289 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
3290 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3291 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
3292 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
3293 else if (alias_template_specialization_p (t
))
3298 /* Return true if PARM is a template template parameter. */
3301 template_template_parameter_p (const_tree parm
)
3303 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3306 /* Return true iff PARM is a DECL representing a type template
3310 template_type_parameter_p (const_tree parm
)
3313 && (TREE_CODE (parm
) == TYPE_DECL
3314 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3315 && DECL_TEMPLATE_PARM_P (parm
));
3318 /* Return the template parameters of T if T is a
3319 primary template instantiation, NULL otherwise. */
3322 get_primary_template_innermost_parameters (const_tree t
)
3324 tree parms
= NULL
, template_info
= NULL
;
3326 if ((template_info
= get_template_info (t
))
3327 && primary_template_instantiation_p (t
))
3328 parms
= INNERMOST_TEMPLATE_PARMS
3329 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3334 /* Return the template parameters of the LEVELth level from the full list
3335 of template parameters PARMS. */
3338 get_template_parms_at_level (tree parms
, int level
)
3342 || TREE_CODE (parms
) != TREE_LIST
3343 || level
> TMPL_PARMS_DEPTH (parms
))
3346 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3347 if (TMPL_PARMS_DEPTH (p
) == level
)
3353 /* Returns the template arguments of T if T is a template instantiation,
3357 get_template_innermost_arguments (const_tree t
)
3359 tree args
= NULL
, template_info
= NULL
;
3361 if ((template_info
= get_template_info (t
))
3362 && TI_ARGS (template_info
))
3363 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3368 /* Return the argument pack elements of T if T is a template argument pack,
3372 get_template_argument_pack_elems (const_tree t
)
3374 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3375 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3378 return ARGUMENT_PACK_ARGS (t
);
3381 /* Structure used to track the progress of find_parameter_packs_r. */
3382 struct find_parameter_pack_data
3384 /* TREE_LIST that will contain all of the parameter packs found by
3386 tree
* parameter_packs
;
3388 /* Set of AST nodes that have been visited by the traversal. */
3389 hash_set
<tree
> *visited
;
3391 /* True iff we're making a type pack expansion. */
3392 bool type_pack_expansion_p
;
3395 /* Identifies all of the argument packs that occur in a template
3396 argument and appends them to the TREE_LIST inside DATA, which is a
3397 find_parameter_pack_data structure. This is a subroutine of
3398 make_pack_expansion and uses_parameter_packs. */
3400 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3403 struct find_parameter_pack_data
* ppd
=
3404 (struct find_parameter_pack_data
*)data
;
3405 bool parameter_pack_p
= false;
3407 /* Handle type aliases/typedefs. */
3408 if (TYPE_ALIAS_P (t
))
3410 if (TYPE_TEMPLATE_INFO (t
))
3411 cp_walk_tree (&TYPE_TI_ARGS (t
),
3412 &find_parameter_packs_r
,
3418 /* Identify whether this is a parameter pack or not. */
3419 switch (TREE_CODE (t
))
3421 case TEMPLATE_PARM_INDEX
:
3422 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3423 parameter_pack_p
= true;
3426 case TEMPLATE_TYPE_PARM
:
3427 t
= TYPE_MAIN_VARIANT (t
);
3428 case TEMPLATE_TEMPLATE_PARM
:
3429 /* If the placeholder appears in the decl-specifier-seq of a function
3430 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3431 is a pack expansion, the invented template parameter is a template
3433 if (ppd
->type_pack_expansion_p
&& is_auto_or_concept (t
))
3434 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
3435 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3436 parameter_pack_p
= true;
3441 if (DECL_PACK_P (t
))
3443 /* We don't want to walk into the type of a PARM_DECL,
3444 because we don't want to see the type parameter pack. */
3446 parameter_pack_p
= true;
3450 /* Look through a lambda capture proxy to the field pack. */
3452 if (DECL_HAS_VALUE_EXPR_P (t
))
3454 tree v
= DECL_VALUE_EXPR (t
);
3456 &find_parameter_packs_r
,
3460 else if (variable_template_specialization_p (t
))
3462 cp_walk_tree (&DECL_TI_ARGS (t
),
3463 find_parameter_packs_r
,
3470 parameter_pack_p
= true;
3473 /* Not a parameter pack. */
3477 if (parameter_pack_p
)
3479 /* Add this parameter pack to the list. */
3480 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3484 cp_walk_tree (&TYPE_CONTEXT (t
),
3485 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3487 /* This switch statement will return immediately if we don't find a
3489 switch (TREE_CODE (t
))
3491 case TEMPLATE_PARM_INDEX
:
3494 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3495 /* Check the template itself. */
3496 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3497 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3498 /* Check the template arguments. */
3499 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3504 case TEMPLATE_TYPE_PARM
:
3505 case TEMPLATE_TEMPLATE_PARM
:
3512 if (TYPE_PTRMEMFUNC_P (t
))
3518 if (TYPE_TEMPLATE_INFO (t
))
3519 cp_walk_tree (&TYPE_TI_ARGS (t
),
3520 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3527 cp_walk_tree (&TREE_TYPE (t
),
3528 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3532 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3537 case TYPE_PACK_EXPANSION
:
3538 case EXPR_PACK_EXPANSION
:
3543 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3548 case IDENTIFIER_NODE
:
3549 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3556 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3557 type_pack_expansion_p to false so that any placeholders
3558 within the expression don't get marked as parameter packs. */
3559 bool type_pack_expansion_p
= ppd
->type_pack_expansion_p
;
3560 ppd
->type_pack_expansion_p
= false;
3561 cp_walk_tree (&DECLTYPE_TYPE_EXPR (t
), &find_parameter_packs_r
,
3563 ppd
->type_pack_expansion_p
= type_pack_expansion_p
;
3575 /* Determines if the expression or type T uses any parameter packs. */
3577 uses_parameter_packs (tree t
)
3579 tree parameter_packs
= NULL_TREE
;
3580 struct find_parameter_pack_data ppd
;
3581 ppd
.parameter_packs
= ¶meter_packs
;
3582 ppd
.visited
= new hash_set
<tree
>;
3583 ppd
.type_pack_expansion_p
= false;
3584 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3586 return parameter_packs
!= NULL_TREE
;
3589 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3590 representation a base-class initializer into a parameter pack
3591 expansion. If all goes well, the resulting node will be an
3592 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3595 make_pack_expansion (tree arg
)
3598 tree parameter_packs
= NULL_TREE
;
3599 bool for_types
= false;
3600 struct find_parameter_pack_data ppd
;
3602 if (!arg
|| arg
== error_mark_node
)
3605 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
3607 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3608 class initializer. In this case, the TREE_PURPOSE will be a
3609 _TYPE node (representing the base class expansion we're
3610 initializing) and the TREE_VALUE will be a TREE_LIST
3611 containing the initialization arguments.
3613 The resulting expansion looks somewhat different from most
3614 expansions. Rather than returning just one _EXPANSION, we
3615 return a TREE_LIST whose TREE_PURPOSE is a
3616 TYPE_PACK_EXPANSION containing the bases that will be
3617 initialized. The TREE_VALUE will be identical to the
3618 original TREE_VALUE, which is a list of arguments that will
3619 be passed to each base. We do not introduce any new pack
3620 expansion nodes into the TREE_VALUE (although it is possible
3621 that some already exist), because the TREE_PURPOSE and
3622 TREE_VALUE all need to be expanded together with the same
3623 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3624 resulting TREE_PURPOSE will mention the parameter packs in
3625 both the bases and the arguments to the bases. */
3628 tree parameter_packs
= NULL_TREE
;
3630 /* Determine which parameter packs will be used by the base
3632 ppd
.visited
= new hash_set
<tree
>;
3633 ppd
.parameter_packs
= ¶meter_packs
;
3634 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3637 if (parameter_packs
== NULL_TREE
)
3639 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3641 return error_mark_node
;
3644 if (TREE_VALUE (arg
) != void_type_node
)
3646 /* Collect the sets of parameter packs used in each of the
3647 initialization arguments. */
3648 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3650 /* Determine which parameter packs will be expanded in this
3652 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3659 /* Create the pack expansion type for the base type. */
3660 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3661 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3662 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3664 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3665 they will rarely be compared to anything. */
3666 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3668 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3671 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3674 /* Build the PACK_EXPANSION_* node. */
3676 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3677 : make_node (EXPR_PACK_EXPANSION
);
3678 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3679 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3681 /* Propagate type and const-expression information. */
3682 TREE_TYPE (result
) = TREE_TYPE (arg
);
3683 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3686 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3687 they will rarely be compared to anything. */
3688 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3690 /* Determine which parameter packs will be expanded. */
3691 ppd
.parameter_packs
= ¶meter_packs
;
3692 ppd
.visited
= new hash_set
<tree
>;
3693 ppd
.type_pack_expansion_p
= TYPE_P (arg
);
3694 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3697 /* Make sure we found some parameter packs. */
3698 if (parameter_packs
== NULL_TREE
)
3701 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3703 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3704 return error_mark_node
;
3706 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3708 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3713 /* Checks T for any "bare" parameter packs, which have not yet been
3714 expanded, and issues an error if any are found. This operation can
3715 only be done on full expressions or types (e.g., an expression
3716 statement, "if" condition, etc.), because we could have expressions like:
3718 foo(f(g(h(args)))...)
3720 where "args" is a parameter pack. check_for_bare_parameter_packs
3721 should not be called for the subexpressions args, h(args),
3722 g(h(args)), or f(g(h(args))), because we would produce erroneous
3725 Returns TRUE and emits an error if there were bare parameter packs,
3726 returns FALSE otherwise. */
3728 check_for_bare_parameter_packs (tree t
)
3730 tree parameter_packs
= NULL_TREE
;
3731 struct find_parameter_pack_data ppd
;
3733 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3736 if (TREE_CODE (t
) == TYPE_DECL
)
3739 ppd
.parameter_packs
= ¶meter_packs
;
3740 ppd
.visited
= new hash_set
<tree
>;
3741 ppd
.type_pack_expansion_p
= false;
3742 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3745 if (parameter_packs
)
3747 error ("parameter packs not expanded with %<...%>:");
3748 while (parameter_packs
)
3750 tree pack
= TREE_VALUE (parameter_packs
);
3751 tree name
= NULL_TREE
;
3753 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3754 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3755 name
= TYPE_NAME (pack
);
3756 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3757 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3759 name
= DECL_NAME (pack
);
3762 inform (input_location
, " %qD", name
);
3764 inform (input_location
, " <anonymous>");
3766 parameter_packs
= TREE_CHAIN (parameter_packs
);
3775 /* Expand any parameter packs that occur in the template arguments in
3778 expand_template_argument_pack (tree args
)
3780 tree result_args
= NULL_TREE
;
3781 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3782 int num_result_args
= -1;
3783 int non_default_args_count
= -1;
3785 /* First, determine if we need to expand anything, and the number of
3786 slots we'll need. */
3787 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3789 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3790 if (arg
== NULL_TREE
)
3792 if (ARGUMENT_PACK_P (arg
))
3794 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3795 if (num_result_args
< 0)
3796 num_result_args
= in_arg
+ num_packed
;
3798 num_result_args
+= num_packed
;
3802 if (num_result_args
>= 0)
3807 /* If no expansion is necessary, we're done. */
3808 if (num_result_args
< 0)
3811 /* Expand arguments. */
3812 result_args
= make_tree_vec (num_result_args
);
3813 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3814 non_default_args_count
=
3815 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3816 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3818 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3819 if (ARGUMENT_PACK_P (arg
))
3821 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3822 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3823 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3824 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3825 if (non_default_args_count
> 0)
3826 non_default_args_count
+= num_packed
- 1;
3830 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3834 if (non_default_args_count
>= 0)
3835 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3839 /* Checks if DECL shadows a template parameter.
3841 [temp.local]: A template-parameter shall not be redeclared within its
3842 scope (including nested scopes).
3844 Emits an error and returns TRUE if the DECL shadows a parameter,
3845 returns FALSE otherwise. */
3848 check_template_shadow (tree decl
)
3852 /* If we're not in a template, we can't possibly shadow a template
3854 if (!current_template_parms
)
3857 /* Figure out what we're shadowing. */
3858 if (TREE_CODE (decl
) == OVERLOAD
)
3859 decl
= OVL_CURRENT (decl
);
3860 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3862 /* If there's no previous binding for this name, we're not shadowing
3863 anything, let alone a template parameter. */
3867 /* If we're not shadowing a template parameter, we're done. Note
3868 that OLDDECL might be an OVERLOAD (or perhaps even an
3869 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3871 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3874 /* We check for decl != olddecl to avoid bogus errors for using a
3875 name inside a class. We check TPFI to avoid duplicate errors for
3876 inline member templates. */
3878 || (DECL_TEMPLATE_PARM_P (decl
)
3879 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
3882 /* Don't complain about the injected class name, as we've already
3883 complained about the class itself. */
3884 if (DECL_SELF_REFERENCE_P (decl
))
3887 if (DECL_TEMPLATE_PARM_P (decl
))
3888 error ("declaration of template parameter %q+D shadows "
3889 "template parameter", decl
);
3891 error ("declaration of %q+#D shadows template parameter", decl
);
3892 inform (DECL_SOURCE_LOCATION (olddecl
),
3893 "template parameter %qD declared here", olddecl
);
3897 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3898 ORIG_LEVEL, DECL, and TYPE. */
3901 build_template_parm_index (int index
,
3907 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3908 TEMPLATE_PARM_IDX (t
) = index
;
3909 TEMPLATE_PARM_LEVEL (t
) = level
;
3910 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3911 TEMPLATE_PARM_DECL (t
) = decl
;
3912 TREE_TYPE (t
) = type
;
3913 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3914 TREE_READONLY (t
) = TREE_READONLY (decl
);
3919 /* Find the canonical type parameter for the given template type
3920 parameter. Returns the canonical type parameter, which may be TYPE
3921 if no such parameter existed. */
3924 canonical_type_parameter (tree type
)
3927 int idx
= TEMPLATE_TYPE_IDX (type
);
3928 if (!canonical_template_parms
)
3929 vec_alloc (canonical_template_parms
, idx
+1);
3931 while (canonical_template_parms
->length () <= (unsigned)idx
)
3932 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3934 list
= (*canonical_template_parms
)[idx
];
3935 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3936 list
= TREE_CHAIN (list
);
3939 return TREE_VALUE (list
);
3942 (*canonical_template_parms
)[idx
]
3943 = tree_cons (NULL_TREE
, type
,
3944 (*canonical_template_parms
)[idx
]);
3949 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3950 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3951 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3952 new one is created. */
3955 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3956 tsubst_flags_t complain
)
3958 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3959 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3960 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3961 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3963 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3966 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3967 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3968 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3969 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3970 DECL_ARTIFICIAL (decl
) = 1;
3971 SET_DECL_TEMPLATE_PARM_P (decl
);
3973 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3974 TEMPLATE_PARM_LEVEL (index
) - levels
,
3975 TEMPLATE_PARM_ORIG_LEVEL (index
),
3977 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3978 TEMPLATE_PARM_PARAMETER_PACK (t
)
3979 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3981 /* Template template parameters need this. */
3982 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3984 DECL_TEMPLATE_RESULT (decl
)
3985 = build_decl (DECL_SOURCE_LOCATION (decl
),
3986 TYPE_DECL
, DECL_NAME (decl
), type
);
3987 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (decl
)) = true;
3988 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3989 (DECL_TEMPLATE_PARMS (orig_decl
), args
, complain
);
3993 return TEMPLATE_PARM_DESCENDANTS (index
);
3996 /* Process information from new template parameter PARM and append it
3997 to the LIST being built. This new parameter is a non-type
3998 parameter iff IS_NON_TYPE is true. This new parameter is a
3999 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4003 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
4004 bool is_non_type
, bool is_parameter_pack
)
4009 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
4010 tree defval
= TREE_PURPOSE (parm
);
4011 tree constr
= TREE_TYPE (parm
);
4015 tree p
= tree_last (list
);
4017 if (p
&& TREE_VALUE (p
) != error_mark_node
)
4020 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
4021 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
4023 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
4031 parm
= TREE_VALUE (parm
);
4033 SET_DECL_TEMPLATE_PARM_P (parm
);
4035 if (TREE_TYPE (parm
) != error_mark_node
)
4039 The top-level cv-qualifiers on the template-parameter are
4040 ignored when determining its type. */
4041 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
4042 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
4043 TREE_TYPE (parm
) = error_mark_node
;
4044 else if (uses_parameter_packs (TREE_TYPE (parm
))
4045 && !is_parameter_pack
4046 /* If we're in a nested template parameter list, the template
4047 template parameter could be a parameter pack. */
4048 && processing_template_parmlist
== 1)
4050 /* This template parameter is not a parameter pack, but it
4051 should be. Complain about "bare" parameter packs. */
4052 check_for_bare_parameter_packs (TREE_TYPE (parm
));
4054 /* Recover by calling this a parameter pack. */
4055 is_parameter_pack
= true;
4059 /* A template parameter is not modifiable. */
4060 TREE_CONSTANT (parm
) = 1;
4061 TREE_READONLY (parm
) = 1;
4062 decl
= build_decl (parm_loc
,
4063 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
4064 TREE_CONSTANT (decl
) = 1;
4065 TREE_READONLY (decl
) = 1;
4066 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
4067 = build_template_parm_index (idx
, processing_template_decl
,
4068 processing_template_decl
,
4069 decl
, TREE_TYPE (parm
));
4071 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4072 = is_parameter_pack
;
4077 parm
= TREE_VALUE (TREE_VALUE (parm
));
4079 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
4081 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
4082 /* This is for distinguishing between real templates and template
4083 template parameters */
4084 TREE_TYPE (parm
) = t
;
4085 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
4090 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
4091 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4092 decl
= build_decl (parm_loc
,
4093 TYPE_DECL
, parm
, t
);
4096 TYPE_NAME (t
) = decl
;
4097 TYPE_STUB_DECL (t
) = decl
;
4099 TEMPLATE_TYPE_PARM_INDEX (t
)
4100 = build_template_parm_index (idx
, processing_template_decl
,
4101 processing_template_decl
,
4102 decl
, TREE_TYPE (parm
));
4103 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
4104 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
4106 DECL_ARTIFICIAL (decl
) = 1;
4107 SET_DECL_TEMPLATE_PARM_P (decl
);
4109 /* Build requirements for the type/template parameter.
4110 This must be done after SET_DECL_TEMPLATE_PARM_P or
4111 process_template_parm could fail. */
4112 tree reqs
= finish_shorthand_constraint (parm
, constr
);
4116 /* Build the parameter node linking the parameter declaration,
4117 its default argument (if any), and its constraints (if any). */
4118 parm
= build_tree_list (defval
, parm
);
4119 TEMPLATE_PARM_CONSTRAINTS (parm
) = reqs
;
4121 return chainon (list
, parm
);
4124 /* The end of a template parameter list has been reached. Process the
4125 tree list into a parameter vector, converting each parameter into a more
4126 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4130 end_template_parm_list (tree parms
)
4134 tree saved_parmlist
= make_tree_vec (list_length (parms
));
4136 /* Pop the dummy parameter level and add the real one. */
4137 current_template_parms
= TREE_CHAIN (current_template_parms
);
4139 current_template_parms
4140 = tree_cons (size_int (processing_template_decl
),
4141 saved_parmlist
, current_template_parms
);
4143 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
4145 next
= TREE_CHAIN (parm
);
4146 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
4147 TREE_CHAIN (parm
) = NULL_TREE
;
4150 --processing_template_parmlist
;
4152 return saved_parmlist
;
4155 // Explicitly indicate the end of the template parameter list. We assume
4156 // that the current template parameters have been constructed and/or
4157 // managed explicitly, as when creating new template template parameters
4158 // from a shorthand constraint.
4160 end_template_parm_list ()
4162 --processing_template_parmlist
;
4165 /* end_template_decl is called after a template declaration is seen. */
4168 end_template_decl (void)
4170 reset_specialization ();
4172 if (! processing_template_decl
)
4175 /* This matches the pushlevel in begin_template_parm_list. */
4178 --processing_template_decl
;
4179 current_template_parms
= TREE_CHAIN (current_template_parms
);
4182 /* Takes a TREE_LIST representing a template parameter and convert it
4183 into an argument suitable to be passed to the type substitution
4184 functions. Note that If the TREE_LIST contains an error_mark
4185 node, the returned argument is error_mark_node. */
4188 template_parm_to_arg (tree t
)
4192 || TREE_CODE (t
) != TREE_LIST
)
4195 if (error_operand_p (TREE_VALUE (t
)))
4196 return error_mark_node
;
4200 if (TREE_CODE (t
) == TYPE_DECL
4201 || TREE_CODE (t
) == TEMPLATE_DECL
)
4205 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
4207 /* Turn this argument into a TYPE_ARGUMENT_PACK
4208 with a single element, which expands T. */
4209 tree vec
= make_tree_vec (1);
4211 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4213 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4215 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
4216 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4221 t
= DECL_INITIAL (t
);
4223 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
4225 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4226 with a single element, which expands T. */
4227 tree vec
= make_tree_vec (1);
4228 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
4230 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4232 t
= convert_from_reference (t
);
4233 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4235 t
= make_node (NONTYPE_ARGUMENT_PACK
);
4236 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4237 TREE_TYPE (t
) = type
;
4240 t
= convert_from_reference (t
);
4245 /* Given a set of template parameters, return them as a set of template
4246 arguments. The template parameters are represented as a TREE_VEC, in
4247 the form documented in cp-tree.h for template arguments. */
4250 template_parms_to_args (tree parms
)
4253 tree args
= NULL_TREE
;
4254 int length
= TMPL_PARMS_DEPTH (parms
);
4257 /* If there is only one level of template parameters, we do not
4258 create a TREE_VEC of TREE_VECs. Instead, we return a single
4259 TREE_VEC containing the arguments. */
4261 args
= make_tree_vec (length
);
4263 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
4265 tree a
= copy_node (TREE_VALUE (header
));
4268 TREE_TYPE (a
) = NULL_TREE
;
4269 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
4270 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
4273 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
4276 TREE_VEC_ELT (args
, --l
) = a
;
4284 /* Within the declaration of a template, return the currently active
4285 template parameters as an argument TREE_VEC. */
4288 current_template_args (void)
4290 return template_parms_to_args (current_template_parms
);
4293 /* Update the declared TYPE by doing any lookups which were thought to be
4294 dependent, but are not now that we know the SCOPE of the declarator. */
4297 maybe_update_decl_type (tree orig_type
, tree scope
)
4299 tree type
= orig_type
;
4301 if (type
== NULL_TREE
)
4304 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4305 type
= TREE_TYPE (type
);
4307 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4308 && dependent_type_p (type
)
4309 /* Don't bother building up the args in this case. */
4310 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4312 /* tsubst in the args corresponding to the template parameters,
4313 including auto if present. Most things will be unchanged, but
4314 make_typename_type and tsubst_qualified_id will resolve
4315 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4316 tree args
= current_template_args ();
4317 tree auto_node
= type_uses_auto (type
);
4321 tree auto_vec
= make_tree_vec (1);
4322 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4323 args
= add_to_template_args (args
, auto_vec
);
4325 pushed
= push_scope (scope
);
4326 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4331 if (type
== error_mark_node
)
4334 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4336 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4339 type
= TYPE_NAME (type
);
4344 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4345 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4346 the new template is a member template. */
4349 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4351 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4352 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4353 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4354 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4355 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4360 struct template_parm_data
4362 /* The level of the template parameters we are currently
4366 /* The index of the specialization argument we are currently
4370 /* An array whose size is the number of template parameters. The
4371 elements are nonzero if the parameter has been used in any one
4372 of the arguments processed so far. */
4375 /* An array whose size is the number of template arguments. The
4376 elements are nonzero if the argument makes use of template
4377 parameters of this level. */
4378 int* arg_uses_template_parms
;
4381 /* Subroutine of push_template_decl used to see if each template
4382 parameter in a partial specialization is used in the explicit
4383 argument list. If T is of the LEVEL given in DATA (which is
4384 treated as a template_parm_data*), then DATA->PARMS is marked
4388 mark_template_parm (tree t
, void* data
)
4392 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4394 template_parm_level_and_index (t
, &level
, &idx
);
4396 if (level
== tpd
->level
)
4398 tpd
->parms
[idx
] = 1;
4399 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4402 /* Return zero so that for_each_template_parm will continue the
4403 traversal of the tree; we want to mark *every* template parm. */
4407 /* Process the partial specialization DECL. */
4410 process_partial_specialization (tree decl
)
4412 tree type
= TREE_TYPE (decl
);
4413 tree tinfo
= get_template_info (decl
);
4414 tree maintmpl
= TI_TEMPLATE (tinfo
);
4415 tree specargs
= TI_ARGS (tinfo
);
4416 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4417 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4420 int nargs
= TREE_VEC_LENGTH (inner_args
);
4423 bool did_error_intro
= false;
4424 struct template_parm_data tpd
;
4425 struct template_parm_data tpd2
;
4427 gcc_assert (current_template_parms
);
4429 /* A concept cannot be specialized. */
4430 if (flag_concepts
&& variable_concept_p (maintmpl
))
4432 error ("specialization of variable concept %q#D", maintmpl
);
4433 return error_mark_node
;
4436 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4437 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4439 /* We check that each of the template parameters given in the
4440 partial specialization is used in the argument list to the
4441 specialization. For example:
4443 template <class T> struct S;
4444 template <class T> struct S<T*>;
4446 The second declaration is OK because `T*' uses the template
4447 parameter T, whereas
4449 template <class T> struct S<int>;
4451 is no good. Even trickier is:
4462 The S2<T> declaration is actually invalid; it is a
4463 full-specialization. Of course,
4466 struct S2<T (*)(U)>;
4468 or some such would have been OK. */
4469 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4470 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4471 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4473 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4474 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4475 for (i
= 0; i
< nargs
; ++i
)
4477 tpd
.current_arg
= i
;
4478 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4479 &mark_template_parm
,
4482 /*include_nondeduced_p=*/false);
4484 for (i
= 0; i
< ntparms
; ++i
)
4485 if (tpd
.parms
[i
] == 0)
4487 /* One of the template parms was not used in a deduced context in the
4489 if (!did_error_intro
)
4491 error ("template parameters not deducible in "
4492 "partial specialization:");
4493 did_error_intro
= true;
4496 inform (input_location
, " %qD",
4497 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4500 if (did_error_intro
)
4501 return error_mark_node
;
4503 /* [temp.class.spec]
4505 The argument list of the specialization shall not be identical to
4506 the implicit argument list of the primary template. */
4508 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4509 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
))
4511 || !subsumes_constraints (current_template_constraints (),
4512 get_constraints (maintmpl
))))
4515 error ("partial specialization %q+D does not specialize "
4516 "any template arguments", decl
);
4518 error ("partial specialization %q+D does not specialize any "
4519 "template arguments and is not more constrained than", decl
);
4520 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4523 /* A partial specialization that replaces multiple parameters of the
4524 primary template with a pack expansion is less specialized for those
4526 if (nargs
< DECL_NTPARMS (maintmpl
))
4528 error ("partial specialization is not more specialized than the "
4529 "primary template because it replaces multiple parameters "
4530 "with a pack expansion");
4531 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4535 /* [temp.class.spec]
4537 A partially specialized non-type argument expression shall not
4538 involve template parameters of the partial specialization except
4539 when the argument expression is a simple identifier.
4541 The type of a template parameter corresponding to a specialized
4542 non-type argument shall not be dependent on a parameter of the
4545 Also, we verify that pack expansions only occur at the
4546 end of the argument list. */
4547 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4549 for (i
= 0; i
< nargs
; ++i
)
4551 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4552 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4553 tree packed_args
= NULL_TREE
;
4556 if (ARGUMENT_PACK_P (arg
))
4558 /* Extract the arguments from the argument pack. We'll be
4559 iterating over these in the following loop. */
4560 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4561 len
= TREE_VEC_LENGTH (packed_args
);
4564 for (j
= 0; j
< len
; j
++)
4567 /* Get the Jth argument in the parameter pack. */
4568 arg
= TREE_VEC_ELT (packed_args
, j
);
4570 if (PACK_EXPANSION_P (arg
))
4572 /* Pack expansions must come at the end of the
4574 if ((packed_args
&& j
< len
- 1)
4575 || (!packed_args
&& i
< nargs
- 1))
4577 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4578 error ("parameter pack argument %qE must be at the "
4579 "end of the template argument list", arg
);
4581 error ("parameter pack argument %qT must be at the "
4582 "end of the template argument list", arg
);
4586 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4587 /* We only care about the pattern. */
4588 arg
= PACK_EXPANSION_PATTERN (arg
);
4590 if (/* These first two lines are the `non-type' bit. */
4592 && TREE_CODE (arg
) != TEMPLATE_DECL
4593 /* This next two lines are the `argument expression is not just a
4594 simple identifier' condition and also the `specialized
4595 non-type argument' bit. */
4596 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4597 && !(REFERENCE_REF_P (arg
)
4598 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4600 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4601 || (packed_args
&& uses_template_parms (arg
)))
4602 error ("template argument %qE involves template parameter(s)",
4606 /* Look at the corresponding template parameter,
4607 marking which template parameters its type depends
4609 tree type
= TREE_TYPE (parm
);
4613 /* We haven't yet initialized TPD2. Do so now. */
4614 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4615 /* The number of parameters here is the number in the
4616 main template, which, as checked in the assertion
4618 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4620 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4623 /* Mark the template parameters. But this time, we're
4624 looking for the template parameters of the main
4625 template, not in the specialization. */
4626 tpd2
.current_arg
= i
;
4627 tpd2
.arg_uses_template_parms
[i
] = 0;
4628 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4629 for_each_template_parm (type
,
4630 &mark_template_parm
,
4633 /*include_nondeduced_p=*/false);
4635 if (tpd2
.arg_uses_template_parms
[i
])
4637 /* The type depended on some template parameters.
4638 If they are fully specialized in the
4639 specialization, that's OK. */
4642 for (j
= 0; j
< nargs
; ++j
)
4643 if (tpd2
.parms
[j
] != 0
4644 && tpd
.arg_uses_template_parms
[j
])
4647 error_n (input_location
, count
,
4648 "type %qT of template argument %qE depends "
4649 "on a template parameter",
4650 "type %qT of template argument %qE depends "
4651 "on template parameters",
4660 /* We should only get here once. */
4661 if (TREE_CODE (decl
) == TYPE_DECL
)
4662 gcc_assert (!COMPLETE_TYPE_P (type
));
4664 // Build the template decl.
4665 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4666 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4667 TREE_TYPE (tmpl
) = type
;
4668 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4669 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4670 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4671 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4674 /* We didn't register this in check_explicit_specialization so we could
4675 wait until the constraints were set. */
4676 decl
= register_specialization (decl
, maintmpl
, specargs
, false, 0);
4678 associate_classtype_constraints (type
);
4680 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4681 = tree_cons (specargs
, tmpl
,
4682 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4683 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4685 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4686 inst
= TREE_CHAIN (inst
))
4688 tree instance
= TREE_VALUE (inst
);
4689 if (TYPE_P (instance
)
4690 ? (COMPLETE_TYPE_P (instance
)
4691 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
4692 : DECL_TEMPLATE_INSTANTIATION (instance
))
4694 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
4695 tree inst_decl
= (DECL_P (instance
)
4696 ? instance
: TYPE_NAME (instance
));
4699 else if (spec
== error_mark_node
)
4700 permerror (input_location
,
4701 "declaration of %qD ambiguates earlier template "
4702 "instantiation for %qD", decl
, inst_decl
);
4703 else if (TREE_VALUE (spec
) == tmpl
)
4704 permerror (input_location
,
4705 "partial specialization of %qD after instantiation "
4706 "of %qD", decl
, inst_decl
);
4713 /* PARM is a template parameter of some form; return the corresponding
4714 TEMPLATE_PARM_INDEX. */
4717 get_template_parm_index (tree parm
)
4719 if (TREE_CODE (parm
) == PARM_DECL
4720 || TREE_CODE (parm
) == CONST_DECL
)
4721 parm
= DECL_INITIAL (parm
);
4722 else if (TREE_CODE (parm
) == TYPE_DECL
4723 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4724 parm
= TREE_TYPE (parm
);
4725 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4726 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
4727 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4728 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4729 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4733 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4734 parameter packs used by the template parameter PARM. */
4737 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4739 /* A type parm can't refer to another parm. */
4740 if (TREE_CODE (parm
) == TYPE_DECL
)
4742 else if (TREE_CODE (parm
) == PARM_DECL
)
4744 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4749 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4751 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4752 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4753 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4756 /* PARM is a template parameter pack. Return any parameter packs used in
4757 its type or the type of any of its template parameters. If there are
4758 any such packs, it will be instantiated into a fixed template parameter
4759 list by partial instantiation rather than be fully deduced. */
4762 fixed_parameter_pack_p (tree parm
)
4764 /* This can only be true in a member template. */
4765 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4767 /* This can only be true for a parameter pack. */
4768 if (!template_parameter_pack_p (parm
))
4770 /* A type parm can't refer to another parm. */
4771 if (TREE_CODE (parm
) == TYPE_DECL
)
4774 tree parameter_packs
= NULL_TREE
;
4775 struct find_parameter_pack_data ppd
;
4776 ppd
.parameter_packs
= ¶meter_packs
;
4777 ppd
.visited
= new hash_set
<tree
>;
4778 ppd
.type_pack_expansion_p
= false;
4780 fixed_parameter_pack_p_1 (parm
, &ppd
);
4783 return parameter_packs
;
4786 /* Check that a template declaration's use of default arguments and
4787 parameter packs is not invalid. Here, PARMS are the template
4788 parameters. IS_PRIMARY is true if DECL is the thing declared by
4789 a primary template. IS_PARTIAL is true if DECL is a partial
4792 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4793 declaration (but not a definition); 1 indicates a declaration, 2
4794 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4795 emitted for extraneous default arguments.
4797 Returns TRUE if there were no errors found, FALSE otherwise. */
4800 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4801 bool is_partial
, int is_friend_decl
)
4804 int last_level_to_check
;
4806 bool no_errors
= true;
4810 A default template-argument shall not be specified in a
4811 function template declaration or a function template definition, nor
4812 in the template-parameter-list of the definition of a member of a
4815 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
4816 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
4817 /* You can't have a function template declaration in a local
4818 scope, nor you can you define a member of a class template in a
4822 if ((TREE_CODE (decl
) == TYPE_DECL
4824 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4825 || (TREE_CODE (decl
) == FUNCTION_DECL
4826 && LAMBDA_FUNCTION_P (decl
)))
4827 /* A lambda doesn't have an explicit declaration; don't complain
4828 about the parms of the enclosing class. */
4831 if (current_class_type
4832 && !TYPE_BEING_DEFINED (current_class_type
)
4833 && DECL_LANG_SPECIFIC (decl
)
4834 && DECL_DECLARES_FUNCTION_P (decl
)
4835 /* If this is either a friend defined in the scope of the class
4836 or a member function. */
4837 && (DECL_FUNCTION_MEMBER_P (decl
)
4838 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4839 : DECL_FRIEND_CONTEXT (decl
)
4840 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4842 /* And, if it was a member function, it really was defined in
4843 the scope of the class. */
4844 && (!DECL_FUNCTION_MEMBER_P (decl
)
4845 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4846 /* We already checked these parameters when the template was
4847 declared, so there's no need to do it again now. This function
4848 was defined in class scope, but we're processing its body now
4849 that the class is complete. */
4852 /* Core issue 226 (C++0x only): the following only applies to class
4855 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4859 If a template-parameter has a default template-argument, all
4860 subsequent template-parameters shall have a default
4861 template-argument supplied. */
4862 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4864 tree inner_parms
= TREE_VALUE (parm_level
);
4865 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4866 int seen_def_arg_p
= 0;
4869 for (i
= 0; i
< ntparms
; ++i
)
4871 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4873 if (parm
== error_mark_node
)
4876 if (TREE_PURPOSE (parm
))
4878 else if (seen_def_arg_p
4879 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4881 error ("no default argument for %qD", TREE_VALUE (parm
));
4882 /* For better subsequent error-recovery, we indicate that
4883 there should have been a default argument. */
4884 TREE_PURPOSE (parm
) = error_mark_node
;
4887 else if (!is_partial
4889 /* Don't complain about an enclosing partial
4891 && parm_level
== parms
4892 && TREE_CODE (decl
) == TYPE_DECL
4894 && template_parameter_pack_p (TREE_VALUE (parm
))
4895 /* A fixed parameter pack will be partially
4896 instantiated into a fixed length list. */
4897 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4899 /* A primary class template can only have one
4900 parameter pack, at the end of the template
4903 error ("parameter pack %q+D must be at the end of the"
4904 " template parameter list", TREE_VALUE (parm
));
4906 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4914 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4918 /* For an ordinary class template, default template arguments are
4919 allowed at the innermost level, e.g.:
4920 template <class T = int>
4922 but, in a partial specialization, they're not allowed even
4923 there, as we have in [temp.class.spec]:
4925 The template parameter list of a specialization shall not
4926 contain default template argument values.
4928 So, for a partial specialization, or for a function template
4929 (in C++98/C++03), we look at all of them. */
4932 /* But, for a primary class template that is not a partial
4933 specialization we look at all template parameters except the
4935 parms
= TREE_CHAIN (parms
);
4937 /* Figure out what error message to issue. */
4938 if (is_friend_decl
== 2)
4939 msg
= G_("default template arguments may not be used in function template "
4940 "friend re-declaration");
4941 else if (is_friend_decl
)
4942 msg
= G_("default template arguments may not be used in function template "
4943 "friend declarations");
4944 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4945 msg
= G_("default template arguments may not be used in function templates "
4946 "without -std=c++11 or -std=gnu++11");
4947 else if (is_partial
)
4948 msg
= G_("default template arguments may not be used in "
4949 "partial specializations");
4950 else if (current_class_type
&& CLASSTYPE_IS_TEMPLATE (current_class_type
))
4951 msg
= G_("default argument for template parameter for class enclosing %qD");
4953 /* Per [temp.param]/9, "A default template-argument shall not be
4954 specified in the template-parameter-lists of the definition of
4955 a member of a class template that appears outside of the member's
4956 class.", thus if we aren't handling a member of a class template
4957 there is no need to examine the parameters. */
4960 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4961 /* If we're inside a class definition, there's no need to
4962 examine the parameters to the class itself. On the one
4963 hand, they will be checked when the class is defined, and,
4964 on the other, default arguments are valid in things like:
4965 template <class T = double>
4966 struct S { template <class U> void f(U); };
4967 Here the default argument for `S' has no bearing on the
4968 declaration of `f'. */
4969 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4971 /* Check everything. */
4972 last_level_to_check
= 0;
4974 for (parm_level
= parms
;
4975 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4976 parm_level
= TREE_CHAIN (parm_level
))
4978 tree inner_parms
= TREE_VALUE (parm_level
);
4982 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4983 for (i
= 0; i
< ntparms
; ++i
)
4985 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4988 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4993 if (is_friend_decl
== 2)
5000 /* Clear out the default argument so that we are not
5002 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
5006 /* At this point, if we're still interested in issuing messages,
5007 they must apply to classes surrounding the object declared. */
5009 msg
= G_("default argument for template parameter for class "
5016 /* Worker for push_template_decl_real, called via
5017 for_each_template_parm. DATA is really an int, indicating the
5018 level of the parameters we are interested in. If T is a template
5019 parameter of that level, return nonzero. */
5022 template_parm_this_level_p (tree t
, void* data
)
5024 int this_level
= *(int *)data
;
5027 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5028 level
= TEMPLATE_PARM_LEVEL (t
);
5030 level
= TEMPLATE_TYPE_LEVEL (t
);
5031 return level
== this_level
;
5034 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5035 parameters given by current_template_args, or reuses a
5036 previously existing one, if appropriate. Returns the DECL, or an
5037 equivalent one, if it is replaced via a call to duplicate_decls.
5039 If IS_FRIEND is true, DECL is a friend declaration. */
5042 push_template_decl_real (tree decl
, bool is_friend
)
5050 int new_template_p
= 0;
5051 /* True if the template is a member template, in the sense of
5053 bool member_template_p
= false;
5055 if (decl
== error_mark_node
|| !current_template_parms
)
5056 return error_mark_node
;
5058 /* See if this is a partial specialization. */
5059 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
5060 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
5061 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
5063 && DECL_LANG_SPECIFIC (decl
)
5064 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5065 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
5067 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
5071 /* For a friend, we want the context of the friend function, not
5072 the type of which it is a friend. */
5073 ctx
= CP_DECL_CONTEXT (decl
);
5074 else if (CP_DECL_CONTEXT (decl
)
5075 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
5076 /* In the case of a virtual function, we want the class in which
5078 ctx
= CP_DECL_CONTEXT (decl
);
5080 /* Otherwise, if we're currently defining some class, the DECL
5081 is assumed to be a member of the class. */
5082 ctx
= current_scope ();
5084 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5087 if (!DECL_CONTEXT (decl
))
5088 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5090 /* See if this is a primary template. */
5091 if (is_friend
&& ctx
5092 && uses_template_parms_level (ctx
, processing_template_decl
))
5093 /* A friend template that specifies a class context, i.e.
5094 template <typename T> friend void A<T>::f();
5097 else if (TREE_CODE (decl
) == TYPE_DECL
5098 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5101 is_primary
= template_parm_scope_p ();
5105 warning (OPT_Wtemplates
, "template %qD declared", decl
);
5107 if (DECL_CLASS_SCOPE_P (decl
))
5108 member_template_p
= true;
5109 if (TREE_CODE (decl
) == TYPE_DECL
5110 && anon_aggrname_p (DECL_NAME (decl
)))
5112 error ("template class without a name");
5113 return error_mark_node
;
5115 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5117 if (member_template_p
)
5119 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
5120 error ("member template %qD may not have virt-specifiers", decl
);
5122 if (DECL_DESTRUCTOR_P (decl
))
5126 A destructor shall not be a member template. */
5127 error ("destructor %qD declared as member template", decl
);
5128 return error_mark_node
;
5130 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
5131 && (!prototype_p (TREE_TYPE (decl
))
5132 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
5133 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5134 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
5135 == void_list_node
)))
5137 /* [basic.stc.dynamic.allocation]
5139 An allocation function can be a function
5140 template. ... Template allocation functions shall
5141 have two or more parameters. */
5142 error ("invalid template declaration of %qD", decl
);
5143 return error_mark_node
;
5146 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5147 && CLASS_TYPE_P (TREE_TYPE (decl
)))
5149 else if (TREE_CODE (decl
) == TYPE_DECL
5150 && TYPE_DECL_ALIAS_P (decl
))
5151 /* alias-declaration */
5152 gcc_assert (!DECL_ARTIFICIAL (decl
));
5153 else if (VAR_P (decl
))
5154 /* C++14 variable template. */;
5157 error ("template declaration of %q#D", decl
);
5158 return error_mark_node
;
5162 /* Check to see that the rules regarding the use of default
5163 arguments are not being violated. */
5164 check_default_tmpl_args (decl
, current_template_parms
,
5165 is_primary
, is_partial
, /*is_friend_decl=*/0);
5167 /* Ensure that there are no parameter packs in the type of this
5168 declaration that have not been expanded. */
5169 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5171 /* Check each of the arguments individually to see if there are
5172 any bare parameter packs. */
5173 tree type
= TREE_TYPE (decl
);
5174 tree arg
= DECL_ARGUMENTS (decl
);
5175 tree argtype
= TYPE_ARG_TYPES (type
);
5177 while (arg
&& argtype
)
5179 if (!DECL_PACK_P (arg
)
5180 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
5182 /* This is a PARM_DECL that contains unexpanded parameter
5183 packs. We have already complained about this in the
5184 check_for_bare_parameter_packs call, so just replace
5185 these types with ERROR_MARK_NODE. */
5186 TREE_TYPE (arg
) = error_mark_node
;
5187 TREE_VALUE (argtype
) = error_mark_node
;
5190 arg
= DECL_CHAIN (arg
);
5191 argtype
= TREE_CHAIN (argtype
);
5194 /* Check for bare parameter packs in the return type and the
5195 exception specifiers. */
5196 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
5197 /* Errors were already issued, set return type to int
5198 as the frontend doesn't expect error_mark_node as
5200 TREE_TYPE (type
) = integer_type_node
;
5201 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
5202 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
5204 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
5205 && TYPE_DECL_ALIAS_P (decl
))
5206 ? DECL_ORIGINAL_TYPE (decl
)
5207 : TREE_TYPE (decl
)))
5209 TREE_TYPE (decl
) = error_mark_node
;
5210 return error_mark_node
;
5214 return process_partial_specialization (decl
);
5216 args
= current_template_args ();
5219 || TREE_CODE (ctx
) == FUNCTION_DECL
5220 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
5221 || (TREE_CODE (decl
) == TYPE_DECL
5222 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5223 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
5225 if (DECL_LANG_SPECIFIC (decl
)
5226 && DECL_TEMPLATE_INFO (decl
)
5227 && DECL_TI_TEMPLATE (decl
))
5228 tmpl
= DECL_TI_TEMPLATE (decl
);
5229 /* If DECL is a TYPE_DECL for a class-template, then there won't
5230 be DECL_LANG_SPECIFIC. The information equivalent to
5231 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5232 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5233 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
5234 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
5236 /* Since a template declaration already existed for this
5237 class-type, we must be redeclaring it here. Make sure
5238 that the redeclaration is valid. */
5239 redeclare_class_template (TREE_TYPE (decl
),
5240 current_template_parms
,
5241 current_template_constraints ());
5242 /* We don't need to create a new TEMPLATE_DECL; just use the
5243 one we already had. */
5244 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
5248 tmpl
= build_template_decl (decl
, current_template_parms
,
5252 if (DECL_LANG_SPECIFIC (decl
)
5253 && DECL_TEMPLATE_SPECIALIZATION (decl
))
5255 /* A specialization of a member template of a template
5257 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5258 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
5259 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
5265 tree a
, t
, current
, parms
;
5267 tree tinfo
= get_template_info (decl
);
5271 error ("template definition of non-template %q#D", decl
);
5272 return error_mark_node
;
5275 tmpl
= TI_TEMPLATE (tinfo
);
5277 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
5278 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
5279 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5280 && DECL_MEMBER_TEMPLATE_P (tmpl
))
5284 /* The declaration is a specialization of a member
5285 template, declared outside the class. Therefore, the
5286 innermost template arguments will be NULL, so we
5287 replace them with the arguments determined by the
5288 earlier call to check_explicit_specialization. */
5289 args
= DECL_TI_ARGS (decl
);
5292 = build_template_decl (decl
, current_template_parms
,
5294 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
5295 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
5296 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
5297 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
5298 DECL_TEMPLATE_INFO (new_tmpl
)
5299 = build_template_info (tmpl
, args
);
5301 register_specialization (new_tmpl
,
5302 most_general_template (tmpl
),
5308 /* Make sure the template headers we got make sense. */
5310 parms
= DECL_TEMPLATE_PARMS (tmpl
);
5311 i
= TMPL_PARMS_DEPTH (parms
);
5312 if (TMPL_ARGS_DEPTH (args
) != i
)
5314 error ("expected %d levels of template parms for %q#D, got %d",
5315 i
, decl
, TMPL_ARGS_DEPTH (args
));
5316 DECL_INTERFACE_KNOWN (decl
) = 1;
5317 return error_mark_node
;
5320 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5322 a
= TMPL_ARGS_LEVEL (args
, i
);
5323 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5325 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5327 if (current
== decl
)
5328 error ("got %d template parameters for %q#D",
5329 TREE_VEC_LENGTH (a
), decl
);
5331 error ("got %d template parameters for %q#T",
5332 TREE_VEC_LENGTH (a
), current
);
5333 error (" but %d required", TREE_VEC_LENGTH (t
));
5334 /* Avoid crash in import_export_decl. */
5335 DECL_INTERFACE_KNOWN (decl
) = 1;
5336 return error_mark_node
;
5339 if (current
== decl
)
5341 else if (current
== NULL_TREE
)
5342 /* Can happen in erroneous input. */
5345 current
= get_containing_scope (current
);
5348 /* Check that the parms are used in the appropriate qualifying scopes
5349 in the declarator. */
5350 if (!comp_template_args
5352 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5355 template arguments to %qD do not match original template %qD",
5356 decl
, DECL_TEMPLATE_RESULT (tmpl
));
5357 if (!uses_template_parms (TI_ARGS (tinfo
)))
5358 inform (input_location
, "use template<> for an explicit specialization");
5359 /* Avoid crash in import_export_decl. */
5360 DECL_INTERFACE_KNOWN (decl
) = 1;
5361 return error_mark_node
;
5365 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5366 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5368 /* Push template declarations for global functions and types. Note
5369 that we do not try to push a global template friend declared in a
5370 template class; such a thing may well depend on the template
5371 parameters of the class. */
5372 if (new_template_p
&& !ctx
5373 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5375 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5376 if (tmpl
== error_mark_node
)
5377 return error_mark_node
;
5379 /* Hide template friend classes that haven't been declared yet. */
5380 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5382 DECL_ANTICIPATED (tmpl
) = 1;
5383 DECL_FRIEND_P (tmpl
) = 1;
5389 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5392 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5393 if (DECL_CONV_FN_P (tmpl
))
5395 int depth
= TMPL_PARMS_DEPTH (parms
);
5397 /* It is a conversion operator. See if the type converted to
5398 depends on innermost template operands. */
5400 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
5402 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
5405 /* Give template template parms a DECL_CONTEXT of the template
5406 for which they are a parameter. */
5407 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5408 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5410 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5411 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5412 DECL_CONTEXT (parm
) = tmpl
;
5415 if (TREE_CODE (decl
) == TYPE_DECL
5416 && TYPE_DECL_ALIAS_P (decl
)
5417 && complex_alias_template_p (tmpl
))
5418 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
5421 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5422 back to its most general template. If TMPL is a specialization,
5423 ARGS may only have the innermost set of arguments. Add the missing
5424 argument levels if necessary. */
5425 if (DECL_TEMPLATE_INFO (tmpl
))
5426 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5428 info
= build_template_info (tmpl
, args
);
5430 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5431 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5434 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5435 retrofit_lang_decl (decl
);
5436 if (DECL_LANG_SPECIFIC (decl
))
5437 DECL_TEMPLATE_INFO (decl
) = info
;
5440 if (flag_implicit_templates
5442 && TREE_PUBLIC (decl
)
5443 && VAR_OR_FUNCTION_DECL_P (decl
))
5444 /* Set DECL_COMDAT on template instantiations; if we force
5445 them to be emitted by explicit instantiation or -frepo,
5446 mark_needed will tell cgraph to do the right thing. */
5447 DECL_COMDAT (decl
) = true;
5449 return DECL_TEMPLATE_RESULT (tmpl
);
5453 push_template_decl (tree decl
)
5455 return push_template_decl_real (decl
, false);
5458 /* FN is an inheriting constructor that inherits from the constructor
5459 template INHERITED; turn FN into a constructor template with a matching
5463 add_inherited_template_parms (tree fn
, tree inherited
)
5466 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5467 inner_parms
= copy_node (inner_parms
);
5469 = tree_cons (size_int (processing_template_decl
+ 1),
5470 inner_parms
, current_template_parms
);
5471 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5472 tree args
= template_parms_to_args (parms
);
5473 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5474 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5475 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5476 DECL_ARTIFICIAL (tmpl
) = true;
5477 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5481 /* Called when a class template TYPE is redeclared with the indicated
5482 template PARMS, e.g.:
5484 template <class T> struct S;
5485 template <class T> struct S {}; */
5488 redeclare_class_template (tree type
, tree parms
, tree cons
)
5494 if (!TYPE_TEMPLATE_INFO (type
))
5496 error ("%qT is not a template type", type
);
5500 tmpl
= TYPE_TI_TEMPLATE (type
);
5501 if (!PRIMARY_TEMPLATE_P (tmpl
))
5502 /* The type is nested in some template class. Nothing to worry
5503 about here; there are no new template parameters for the nested
5509 error ("template specifiers not specified in declaration of %qD",
5514 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5515 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5517 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5519 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5520 "redeclared with %d template parameter",
5521 "redeclared with %d template parameters",
5522 TREE_VEC_LENGTH (parms
));
5523 inform_n (DECL_SOURCE_LOCATION (tmpl
), TREE_VEC_LENGTH (tmpl_parms
),
5524 "previous declaration %qD used %d template parameter",
5525 "previous declaration %qD used %d template parameters",
5526 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5530 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5537 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5538 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5541 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5542 if (error_operand_p (tmpl_parm
))
5545 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5546 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5547 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5549 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5551 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5552 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5553 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5554 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5555 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5556 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5557 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5558 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5559 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5561 error ("template parameter %q+#D", tmpl_parm
);
5562 error ("redeclared here as %q#D", parm
);
5566 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5568 /* We have in [temp.param]:
5570 A template-parameter may not be given default arguments
5571 by two different declarations in the same scope. */
5572 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5573 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5574 "original definition appeared here");
5578 if (parm_default
!= NULL_TREE
)
5579 /* Update the previous template parameters (which are the ones
5580 that will really count) with the new default value. */
5581 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5582 else if (tmpl_default
!= NULL_TREE
)
5583 /* Update the new parameters, too; they'll be used as the
5584 parameters for any members. */
5585 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5587 /* Give each template template parm in this redeclaration a
5588 DECL_CONTEXT of the template for which they are a parameter. */
5589 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5591 gcc_assert (DECL_CONTEXT (parm
) == NULL_TREE
);
5592 DECL_CONTEXT (parm
) = tmpl
;
5596 // Cannot redeclare a class template with a different set of constraints.
5597 if (!equivalent_constraints (get_constraints (tmpl
), cons
))
5599 error_at (input_location
, "redeclaration %q#D with different "
5600 "constraints", tmpl
);
5601 inform (DECL_SOURCE_LOCATION (tmpl
),
5602 "original declaration appeared here");
5608 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5609 to be used when the caller has already checked
5610 (processing_template_decl
5611 && !instantiation_dependent_expression_p (expr)
5612 && potential_constant_expression (expr))
5613 and cleared processing_template_decl. */
5616 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
5618 return tsubst_copy_and_build (expr
,
5621 /*in_decl=*/NULL_TREE
,
5622 /*function_p=*/false,
5623 /*integral_constant_expression_p=*/true);
5626 /* Simplify EXPR if it is a non-dependent expression. Returns the
5627 (possibly simplified) expression. */
5630 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5632 if (expr
== NULL_TREE
)
5635 /* If we're in a template, but EXPR isn't value dependent, simplify
5636 it. We're supposed to treat:
5638 template <typename T> void f(T[1 + 1]);
5639 template <typename T> void f(T[2]);
5641 as two declarations of the same function, for example. */
5642 if (processing_template_decl
5643 && !instantiation_dependent_expression_p (expr
)
5644 && potential_constant_expression (expr
))
5646 processing_template_decl_sentinel s
;
5647 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
5653 instantiate_non_dependent_expr (tree expr
)
5655 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
5658 /* True iff T is a specialization of a variable template. */
5661 variable_template_specialization_p (tree t
)
5663 if (!VAR_P (t
) || !DECL_LANG_SPECIFIC (t
) || !DECL_TEMPLATE_INFO (t
))
5665 tree tmpl
= DECL_TI_TEMPLATE (t
);
5666 return variable_template_p (tmpl
);
5669 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5670 template declaration, or a TYPE_DECL for an alias declaration. */
5673 alias_type_or_template_p (tree t
)
5677 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5680 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5681 || DECL_ALIAS_TEMPLATE_P (t
));
5684 /* Return TRUE iff T is a specialization of an alias template. */
5687 alias_template_specialization_p (const_tree t
)
5689 /* It's an alias template specialization if it's an alias and its
5690 TYPE_NAME is a specialization of a primary template. */
5691 if (TYPE_ALIAS_P (t
))
5693 tree name
= TYPE_NAME (t
);
5694 if (DECL_LANG_SPECIFIC (name
))
5695 if (tree ti
= DECL_TEMPLATE_INFO (name
))
5697 tree tmpl
= TI_TEMPLATE (ti
);
5698 return PRIMARY_TEMPLATE_P (tmpl
);
5704 /* An alias template is complex from a SFINAE perspective if a template-id
5705 using that alias can be ill-formed when the expansion is not, as with
5706 the void_t template. We determine this by checking whether the
5707 expansion for the alias template uses all its template parameters. */
5709 struct uses_all_template_parms_data
5716 uses_all_template_parms_r (tree t
, void *data_
)
5718 struct uses_all_template_parms_data
&data
5719 = *(struct uses_all_template_parms_data
*)data_
;
5720 tree idx
= get_template_parm_index (t
);
5722 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
5723 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
5728 complex_alias_template_p (const_tree tmpl
)
5730 struct uses_all_template_parms_data data
;
5731 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5732 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5733 data
.level
= TMPL_PARMS_DEPTH (parms
);
5734 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
5735 data
.seen
= XALLOCAVEC (bool, len
);
5736 for (int i
= 0; i
< len
; ++i
)
5737 data
.seen
[i
] = false;
5739 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
5740 for (int i
= 0; i
< len
; ++i
)
5746 /* Return TRUE iff T is a specialization of a complex alias template with
5747 dependent template-arguments. */
5750 dependent_alias_template_spec_p (const_tree t
)
5752 return (alias_template_specialization_p (t
)
5753 && TEMPLATE_DECL_COMPLEX_ALIAS_P (DECL_TI_TEMPLATE (TYPE_NAME (t
)))
5754 && (any_dependent_template_arguments_p
5755 (INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (t
)))));
5758 /* Return the number of innermost template parameters in TMPL. */
5761 num_innermost_template_parms (tree tmpl
)
5763 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5764 return TREE_VEC_LENGTH (parms
);
5767 /* Return either TMPL or another template that it is equivalent to under DR
5768 1286: An alias that just changes the name of a template is equivalent to
5769 the other template. */
5772 get_underlying_template (tree tmpl
)
5774 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5775 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5777 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5778 if (TYPE_TEMPLATE_INFO (result
))
5780 tree sub
= TYPE_TI_TEMPLATE (result
);
5781 if (PRIMARY_TEMPLATE_P (sub
)
5782 && (num_innermost_template_parms (tmpl
)
5783 == num_innermost_template_parms (sub
)))
5785 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5786 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5787 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5789 /* The alias type is equivalent to the pattern of the
5790 underlying template, so strip the alias. */
5800 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5801 must be a function or a pointer-to-function type, as specified
5802 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5803 and check that the resulting function has external linkage. */
5806 convert_nontype_argument_function (tree type
, tree expr
,
5807 tsubst_flags_t complain
)
5811 linkage_kind linkage
;
5813 fn
= instantiate_type (type
, fns
, tf_none
);
5814 if (fn
== error_mark_node
)
5815 return error_mark_node
;
5818 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5819 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5820 if (BASELINK_P (fn_no_ptr
))
5821 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5823 /* [temp.arg.nontype]/1
5825 A template-argument for a non-type, non-template template-parameter
5828 -- the address of an object or function with external [C++11: or
5829 internal] linkage. */
5831 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5833 if (complain
& tf_error
)
5835 error ("%qE is not a valid template argument for type %qT",
5837 if (TYPE_PTR_P (type
))
5838 error ("it must be the address of a function with "
5839 "external linkage");
5841 error ("it must be the name of a function with "
5842 "external linkage");
5847 linkage
= decl_linkage (fn_no_ptr
);
5848 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5850 if (complain
& tf_error
)
5852 if (cxx_dialect
>= cxx11
)
5853 error ("%qE is not a valid template argument for type %qT "
5854 "because %qD has no linkage",
5855 expr
, type
, fn_no_ptr
);
5857 error ("%qE is not a valid template argument for type %qT "
5858 "because %qD does not have external linkage",
5859 expr
, type
, fn_no_ptr
);
5867 /* Subroutine of convert_nontype_argument.
5868 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5869 Emit an error otherwise. */
5872 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5873 tsubst_flags_t complain
)
5876 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5878 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5880 if (processing_template_decl
5881 && TREE_CODE (expr
) == ADDR_EXPR
5882 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
5884 if (complain
& tf_error
)
5886 error ("%qE is not a valid template argument for type %qT",
5888 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5893 /* Returns TRUE iff the address of OP is value-dependent.
5895 14.6.2.4 [temp.dep.temp]:
5896 A non-integral non-type template-argument is dependent if its type is
5897 dependent or it has either of the following forms
5900 and contains a nested-name-specifier which specifies a class-name that
5901 names a dependent type.
5903 We generalize this to just say that the address of a member of a
5904 dependent class is value-dependent; the above doesn't cover the
5905 address of a static data member named with an unqualified-id. */
5908 has_value_dependent_address (tree op
)
5910 /* We could use get_inner_reference here, but there's no need;
5911 this is only relevant for template non-type arguments, which
5912 can only be expressed as &id-expression. */
5915 tree ctx
= CP_DECL_CONTEXT (op
);
5916 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5923 /* The next set of functions are used for providing helpful explanatory
5924 diagnostics for failed overload resolution. Their messages should be
5925 indented by two spaces for consistency with the messages in
5929 unify_success (bool /*explain_p*/)
5935 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5938 inform (input_location
,
5939 " couldn't deduce template parameter %qD", parm
);
5944 unify_invalid (bool /*explain_p*/)
5950 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5953 inform (input_location
,
5954 " types %qT and %qT have incompatible cv-qualifiers",
5960 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5963 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5968 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5971 inform (input_location
,
5972 " template parameter %qD is not a parameter pack, but "
5979 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5982 inform (input_location
,
5983 " template argument %qE does not match "
5984 "pointer-to-member constant %qE",
5990 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5993 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5998 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
6001 inform (input_location
,
6002 " inconsistent parameter pack deduction with %qT and %qT",
6008 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
6013 inform (input_location
,
6014 " deduced conflicting types for parameter %qT (%qT and %qT)",
6015 parm
, first
, second
);
6017 inform (input_location
,
6018 " deduced conflicting values for non-type parameter "
6019 "%qE (%qE and %qE)", parm
, first
, second
);
6025 unify_vla_arg (bool explain_p
, tree arg
)
6028 inform (input_location
,
6029 " variable-sized array type %qT is not "
6030 "a valid template argument",
6036 unify_method_type_error (bool explain_p
, tree arg
)
6039 inform (input_location
,
6040 " member function type %qT is not a valid template argument",
6046 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
6051 inform_n (input_location
, wanted
,
6052 " candidate expects at least %d argument, %d provided",
6053 " candidate expects at least %d arguments, %d provided",
6056 inform_n (input_location
, wanted
,
6057 " candidate expects %d argument, %d provided",
6058 " candidate expects %d arguments, %d provided",
6065 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
6067 return unify_arity (explain_p
, have
, wanted
);
6071 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
6072 bool least_p
= false)
6074 return unify_arity (explain_p
, have
, wanted
, least_p
);
6078 unify_arg_conversion (bool explain_p
, tree to_type
,
6079 tree from_type
, tree arg
)
6082 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
6083 " cannot convert %qE (type %qT) to type %qT",
6084 arg
, from_type
, to_type
);
6089 unify_no_common_base (bool explain_p
, enum template_base_result r
,
6090 tree parm
, tree arg
)
6095 case tbr_ambiguous_baseclass
:
6096 inform (input_location
, " %qT is an ambiguous base class of %qT",
6100 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
6107 unify_inconsistent_template_template_parameters (bool explain_p
)
6110 inform (input_location
,
6111 " template parameters of a template template argument are "
6112 "inconsistent with other deduced template arguments");
6117 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
6120 inform (input_location
,
6121 " can't deduce a template for %qT from non-template type %qT",
6127 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
6130 inform (input_location
,
6131 " template argument %qE does not match %qD", arg
, parm
);
6136 unify_overload_resolution_failure (bool explain_p
, tree arg
)
6139 inform (input_location
,
6140 " could not resolve address from overloaded function %qE",
6145 /* Attempt to convert the non-type template parameter EXPR to the
6146 indicated TYPE. If the conversion is successful, return the
6147 converted value. If the conversion is unsuccessful, return
6148 NULL_TREE if we issued an error message, or error_mark_node if we
6149 did not. We issue error messages for out-and-out bad template
6150 parameters, but not simply because the conversion failed, since we
6151 might be just trying to do argument deduction. Both TYPE and EXPR
6152 must be non-dependent.
6154 The conversion follows the special rules described in
6155 [temp.arg.nontype], and it is much more strict than an implicit
6158 This function is called twice for each template argument (see
6159 lookup_template_class for a more accurate description of this
6160 problem). This means that we need to handle expressions which
6161 are not valid in a C++ source, but can be created from the
6162 first call (for instance, casts to perform conversions). These
6163 hacks can go away after we fix the double coercion problem. */
6166 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
6170 /* Detect immediately string literals as invalid non-type argument.
6171 This special-case is not needed for correctness (we would easily
6172 catch this later), but only to provide better diagnostic for this
6173 common user mistake. As suggested by DR 100, we do not mention
6174 linkage issues in the diagnostic as this is not the point. */
6175 /* FIXME we're making this OK. */
6176 if (TREE_CODE (expr
) == STRING_CST
)
6178 if (complain
& tf_error
)
6179 error ("%qE is not a valid template argument for type %qT "
6180 "because string literals can never be used in this context",
6185 /* Add the ADDR_EXPR now for the benefit of
6186 value_dependent_expression_p. */
6187 if (TYPE_PTROBV_P (type
)
6188 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
6190 expr
= decay_conversion (expr
, complain
);
6191 if (expr
== error_mark_node
)
6192 return error_mark_node
;
6195 /* If we are in a template, EXPR may be non-dependent, but still
6196 have a syntactic, rather than semantic, form. For example, EXPR
6197 might be a SCOPE_REF, rather than the VAR_DECL to which the
6198 SCOPE_REF refers. Preserving the qualifying scope is necessary
6199 so that access checking can be performed when the template is
6200 instantiated -- but here we need the resolved form so that we can
6201 convert the argument. */
6202 bool non_dep
= false;
6203 if (TYPE_REF_OBJ_P (type
)
6204 && has_value_dependent_address (expr
))
6205 /* If we want the address and it's value-dependent, don't fold. */;
6206 else if (!type_unknown_p (expr
)
6207 && processing_template_decl
6208 && !instantiation_dependent_expression_p (expr
)
6209 && potential_constant_expression (expr
))
6211 if (error_operand_p (expr
))
6212 return error_mark_node
;
6213 expr_type
= TREE_TYPE (expr
);
6214 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6215 expr
= mark_lvalue_use (expr
);
6217 expr
= mark_rvalue_use (expr
);
6219 /* If the argument is non-dependent, perform any conversions in
6220 non-dependent context as well. */
6221 processing_template_decl_sentinel
s (non_dep
);
6223 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6225 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6226 to a non-type argument of "nullptr". */
6227 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
6228 expr
= fold_simple (convert (type
, expr
));
6230 /* In C++11, integral or enumeration non-type template arguments can be
6231 arbitrary constant expressions. Pointer and pointer to
6232 member arguments can be general constant expressions that evaluate
6233 to a null value, but otherwise still need to be of a specific form. */
6234 if (cxx_dialect
>= cxx11
)
6236 if (TREE_CODE (expr
) == PTRMEM_CST
)
6237 /* A PTRMEM_CST is already constant, and a valid template
6238 argument for a parameter of pointer to member type, we just want
6239 to leave it in that form rather than lower it to a
6241 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6242 expr
= maybe_constant_value (expr
);
6243 else if (cxx_dialect
>= cxx1z
)
6245 if (TREE_CODE (type
) != REFERENCE_TYPE
)
6246 expr
= maybe_constant_value (expr
);
6247 else if (REFERENCE_REF_P (expr
))
6249 expr
= TREE_OPERAND (expr
, 0);
6250 expr
= maybe_constant_value (expr
);
6251 expr
= convert_from_reference (expr
);
6254 else if (TYPE_PTR_OR_PTRMEM_P (type
))
6256 tree folded
= maybe_constant_value (expr
);
6257 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
6258 : null_member_pointer_value_p (folded
))
6263 /* HACK: Due to double coercion, we can get a
6264 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6265 which is the tree that we built on the first call (see
6266 below when coercing to reference to object or to reference to
6267 function). We just strip everything and get to the arg.
6268 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6270 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
6272 tree probe_type
, probe
= expr
;
6273 if (REFERENCE_REF_P (probe
))
6274 probe
= TREE_OPERAND (probe
, 0);
6275 probe_type
= TREE_TYPE (probe
);
6276 if (TREE_CODE (probe
) == NOP_EXPR
)
6278 /* ??? Maybe we could use convert_from_reference here, but we
6279 would need to relax its constraints because the NOP_EXPR
6280 could actually change the type to something more cv-qualified,
6281 and this is not folded by convert_from_reference. */
6282 tree addr
= TREE_OPERAND (probe
, 0);
6283 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
6284 && TREE_CODE (addr
) == ADDR_EXPR
6285 && TYPE_PTR_P (TREE_TYPE (addr
))
6286 && (same_type_ignoring_top_level_qualifiers_p
6287 (TREE_TYPE (probe_type
),
6288 TREE_TYPE (TREE_TYPE (addr
)))))
6290 expr
= TREE_OPERAND (addr
, 0);
6291 expr_type
= TREE_TYPE (probe_type
);
6296 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
6297 parameter is a pointer to object, through decay and
6298 qualification conversion. Let's strip everything. */
6299 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
6303 if (TREE_CODE (probe
) == ADDR_EXPR
6304 && TYPE_PTR_P (TREE_TYPE (probe
)))
6306 /* Skip the ADDR_EXPR only if it is part of the decay for
6307 an array. Otherwise, it is part of the original argument
6308 in the source code. */
6309 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
6310 probe
= TREE_OPERAND (probe
, 0);
6312 expr_type
= TREE_TYPE (expr
);
6316 /* [temp.arg.nontype]/5, bullet 1
6318 For a non-type template-parameter of integral or enumeration type,
6319 integral promotions (_conv.prom_) and integral conversions
6320 (_conv.integral_) are applied. */
6321 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6323 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
6324 t
= maybe_constant_value (t
);
6325 if (t
!= error_mark_node
)
6328 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
6329 return error_mark_node
;
6331 /* Notice that there are constant expressions like '4 % 0' which
6332 do not fold into integer constants. */
6333 if (TREE_CODE (expr
) != INTEGER_CST
)
6335 if (complain
& tf_error
)
6337 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
6338 if (processing_template_decl
6339 && !require_potential_constant_expression (expr
))
6341 expr
= cxx_constant_value (expr
);
6342 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
6343 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
6344 "in template argument for type %qT ", type
);
6345 if (expr
== error_mark_node
)
6347 /* else cxx_constant_value complained but gave us
6348 a real constant, so go ahead. */
6349 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
6355 /* Avoid typedef problems. */
6356 if (TREE_TYPE (expr
) != type
)
6357 expr
= fold_convert (type
, expr
);
6359 /* [temp.arg.nontype]/5, bullet 2
6361 For a non-type template-parameter of type pointer to object,
6362 qualification conversions (_conv.qual_) and the array-to-pointer
6363 conversion (_conv.array_) are applied. */
6364 else if (TYPE_PTROBV_P (type
))
6366 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6368 A template-argument for a non-type, non-template template-parameter
6369 shall be one of: [...]
6371 -- the name of a non-type template-parameter;
6372 -- the address of an object or function with external linkage, [...]
6373 expressed as "& id-expression" where the & is optional if the name
6374 refers to a function or array, or if the corresponding
6375 template-parameter is a reference.
6377 Here, we do not care about functions, as they are invalid anyway
6378 for a parameter of type pointer-to-object. */
6380 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
6381 /* Non-type template parameters are OK. */
6383 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6384 /* Null pointer values are OK in C++11. */;
6385 else if (TREE_CODE (expr
) != ADDR_EXPR
6386 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
6390 if (complain
& tf_error
)
6391 error ("%qD is not a valid template argument "
6392 "because %qD is a variable, not the address of "
6393 "a variable", expr
, expr
);
6396 if (POINTER_TYPE_P (expr_type
))
6398 if (complain
& tf_error
)
6399 error ("%qE is not a valid template argument for %qT "
6400 "because it is not the address of a variable",
6404 /* Other values, like integer constants, might be valid
6405 non-type arguments of some other type. */
6406 return error_mark_node
;
6412 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
6413 ? TREE_OPERAND (expr
, 0) : expr
);
6416 if (complain
& tf_error
)
6417 error ("%qE is not a valid template argument of type %qT "
6418 "because %qE is not a variable", expr
, type
, decl
);
6421 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6423 if (complain
& tf_error
)
6424 error ("%qE is not a valid template argument of type %qT "
6425 "because %qD does not have external linkage",
6429 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
6431 if (complain
& tf_error
)
6432 error ("%qE is not a valid template argument of type %qT "
6433 "because %qD has no linkage", expr
, type
, decl
);
6438 expr
= decay_conversion (expr
, complain
);
6439 if (expr
== error_mark_node
)
6440 return error_mark_node
;
6442 expr
= perform_qualification_conversions (type
, expr
);
6443 if (expr
== error_mark_node
)
6444 return error_mark_node
;
6446 /* [temp.arg.nontype]/5, bullet 3
6448 For a non-type template-parameter of type reference to object, no
6449 conversions apply. The type referred to by the reference may be more
6450 cv-qualified than the (otherwise identical) type of the
6451 template-argument. The template-parameter is bound directly to the
6452 template-argument, which must be an lvalue. */
6453 else if (TYPE_REF_OBJ_P (type
))
6455 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
6457 return error_mark_node
;
6459 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
6461 if (complain
& tf_error
)
6462 error ("%qE is not a valid template argument for type %qT "
6463 "because of conflicts in cv-qualification", expr
, type
);
6467 if (!real_lvalue_p (expr
))
6469 if (complain
& tf_error
)
6470 error ("%qE is not a valid template argument for type %qT "
6471 "because it is not an lvalue", expr
, type
);
6475 /* [temp.arg.nontype]/1
6477 A template-argument for a non-type, non-template template-parameter
6478 shall be one of: [...]
6480 -- the address of an object or function with external linkage. */
6481 if (INDIRECT_REF_P (expr
)
6482 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
6484 expr
= TREE_OPERAND (expr
, 0);
6487 if (complain
& tf_error
)
6488 error ("%q#D is not a valid template argument for type %qT "
6489 "because a reference variable does not have a constant "
6490 "address", expr
, type
);
6497 if (complain
& tf_error
)
6498 error ("%qE is not a valid template argument for type %qT "
6499 "because it is not an object with linkage",
6504 /* DR 1155 allows internal linkage in C++11 and up. */
6505 linkage_kind linkage
= decl_linkage (expr
);
6506 if (linkage
< (cxx_dialect
>= cxx11
? lk_internal
: lk_external
))
6508 if (complain
& tf_error
)
6509 error ("%qE is not a valid template argument for type %qT "
6510 "because object %qD does not have linkage",
6515 expr
= build_nop (type
, build_address (expr
));
6517 /* [temp.arg.nontype]/5, bullet 4
6519 For a non-type template-parameter of type pointer to function, only
6520 the function-to-pointer conversion (_conv.func_) is applied. If the
6521 template-argument represents a set of overloaded functions (or a
6522 pointer to such), the matching function is selected from the set
6524 else if (TYPE_PTRFN_P (type
))
6526 /* If the argument is a template-id, we might not have enough
6527 context information to decay the pointer. */
6528 if (!type_unknown_p (expr_type
))
6530 expr
= decay_conversion (expr
, complain
);
6531 if (expr
== error_mark_node
)
6532 return error_mark_node
;
6535 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6536 /* Null pointer values are OK in C++11. */
6537 return perform_qualification_conversions (type
, expr
);
6539 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6540 if (!expr
|| expr
== error_mark_node
)
6543 /* [temp.arg.nontype]/5, bullet 5
6545 For a non-type template-parameter of type reference to function, no
6546 conversions apply. If the template-argument represents a set of
6547 overloaded functions, the matching function is selected from the set
6549 else if (TYPE_REFFN_P (type
))
6551 if (TREE_CODE (expr
) == ADDR_EXPR
)
6553 if (complain
& tf_error
)
6555 error ("%qE is not a valid template argument for type %qT "
6556 "because it is a pointer", expr
, type
);
6557 inform (input_location
, "try using %qE instead",
6558 TREE_OPERAND (expr
, 0));
6563 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6564 if (!expr
|| expr
== error_mark_node
)
6567 expr
= build_nop (type
, build_address (expr
));
6569 /* [temp.arg.nontype]/5, bullet 6
6571 For a non-type template-parameter of type pointer to member function,
6572 no conversions apply. If the template-argument represents a set of
6573 overloaded member functions, the matching member function is selected
6574 from the set (_over.over_). */
6575 else if (TYPE_PTRMEMFUNC_P (type
))
6577 expr
= instantiate_type (type
, expr
, tf_none
);
6578 if (expr
== error_mark_node
)
6579 return error_mark_node
;
6581 /* [temp.arg.nontype] bullet 1 says the pointer to member
6582 expression must be a pointer-to-member constant. */
6583 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6584 return error_mark_node
;
6586 /* There is no way to disable standard conversions in
6587 resolve_address_of_overloaded_function (called by
6588 instantiate_type). It is possible that the call succeeded by
6589 converting &B::I to &D::I (where B is a base of D), so we need
6590 to reject this conversion here.
6592 Actually, even if there was a way to disable standard conversions,
6593 it would still be better to reject them here so that we can
6594 provide a superior diagnostic. */
6595 if (!same_type_p (TREE_TYPE (expr
), type
))
6597 if (complain
& tf_error
)
6599 error ("%qE is not a valid template argument for type %qT "
6600 "because it is of type %qT", expr
, type
,
6602 /* If we are just one standard conversion off, explain. */
6603 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6604 inform (input_location
,
6605 "standard conversions are not allowed in this context");
6610 /* [temp.arg.nontype]/5, bullet 7
6612 For a non-type template-parameter of type pointer to data member,
6613 qualification conversions (_conv.qual_) are applied. */
6614 else if (TYPE_PTRDATAMEM_P (type
))
6616 /* [temp.arg.nontype] bullet 1 says the pointer to member
6617 expression must be a pointer-to-member constant. */
6618 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6619 return error_mark_node
;
6621 expr
= perform_qualification_conversions (type
, expr
);
6622 if (expr
== error_mark_node
)
6625 else if (NULLPTR_TYPE_P (type
))
6627 if (expr
!= nullptr_node
)
6629 if (complain
& tf_error
)
6630 error ("%qE is not a valid template argument for type %qT "
6631 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6636 /* A template non-type parameter must be one of the above. */
6640 /* Sanity check: did we actually convert the argument to the
6642 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6643 (type
, TREE_TYPE (expr
)));
6644 return convert_from_reference (expr
);
6647 /* Subroutine of coerce_template_template_parms, which returns 1 if
6648 PARM_PARM and ARG_PARM match using the rule for the template
6649 parameters of template template parameters. Both PARM and ARG are
6650 template parameters; the rest of the arguments are the same as for
6651 coerce_template_template_parms.
6654 coerce_template_template_parm (tree parm
,
6656 tsubst_flags_t complain
,
6660 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6661 || parm
== NULL_TREE
|| error_operand_p (parm
))
6664 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6667 switch (TREE_CODE (parm
))
6670 /* We encounter instantiations of templates like
6671 template <template <template <class> class> class TT>
6674 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6675 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6677 if (!coerce_template_template_parms
6678 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6684 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6685 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6686 /* Argument is a parameter pack but parameter is not. */
6691 /* The tsubst call is used to handle cases such as
6693 template <int> class C {};
6694 template <class T, template <T> class TT> class D {};
6697 i.e. the parameter list of TT depends on earlier parameters. */
6698 if (!uses_template_parms (TREE_TYPE (arg
)))
6700 tree t
= tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
);
6701 if (!uses_template_parms (t
)
6702 && !same_type_p (t
, TREE_TYPE (arg
)))
6706 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6707 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6708 /* Argument is a parameter pack but parameter is not. */
6721 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6722 template template parameters. Both PARM_PARMS and ARG_PARMS are
6723 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6726 Consider the example:
6727 template <class T> class A;
6728 template<template <class U> class TT> class B;
6730 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6731 the parameters to A, and OUTER_ARGS contains A. */
6734 coerce_template_template_parms (tree parm_parms
,
6736 tsubst_flags_t complain
,
6740 int nparms
, nargs
, i
;
6744 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6745 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6747 nparms
= TREE_VEC_LENGTH (parm_parms
);
6748 nargs
= TREE_VEC_LENGTH (arg_parms
);
6750 /* Determine whether we have a parameter pack at the end of the
6751 template template parameter's template parameter list. */
6752 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6754 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6756 if (error_operand_p (parm
))
6759 switch (TREE_CODE (parm
))
6763 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6768 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6778 && !(variadic_p
&& nargs
>= nparms
- 1))
6781 /* Check all of the template parameters except the parameter pack at
6782 the end (if any). */
6783 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6785 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6786 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6789 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6790 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6792 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6800 /* Check each of the template parameters in the template
6801 argument against the template parameter pack at the end of
6802 the template template parameter. */
6803 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6806 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6808 for (; i
< nargs
; ++i
)
6810 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6813 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6815 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6824 /* Verifies that the deduced template arguments (in TARGS) for the
6825 template template parameters (in TPARMS) represent valid bindings,
6826 by comparing the template parameter list of each template argument
6827 to the template parameter list of its corresponding template
6828 template parameter, in accordance with DR150. This
6829 routine can only be called after all template arguments have been
6830 deduced. It will return TRUE if all of the template template
6831 parameter bindings are okay, FALSE otherwise. */
6833 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6835 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6838 /* We're dealing with template parms in this process. */
6839 ++processing_template_decl
;
6841 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6843 for (i
= 0; i
< ntparms
; ++i
)
6845 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6846 tree targ
= TREE_VEC_ELT (targs
, i
);
6848 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6850 tree packed_args
= NULL_TREE
;
6853 if (ARGUMENT_PACK_P (targ
))
6855 /* Look inside the argument pack. */
6856 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6857 len
= TREE_VEC_LENGTH (packed_args
);
6860 for (idx
= 0; idx
< len
; ++idx
)
6862 tree targ_parms
= NULL_TREE
;
6865 /* Extract the next argument from the argument
6867 targ
= TREE_VEC_ELT (packed_args
, idx
);
6869 if (PACK_EXPANSION_P (targ
))
6870 /* Look at the pattern of the pack expansion. */
6871 targ
= PACK_EXPANSION_PATTERN (targ
);
6873 /* Extract the template parameters from the template
6875 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6876 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6877 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6878 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6880 /* Verify that we can coerce the template template
6881 parameters from the template argument to the template
6882 parameter. This requires an exact match. */
6884 && !coerce_template_template_parms
6885 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6900 --processing_template_decl
;
6904 /* Since type attributes aren't mangled, we need to strip them from
6905 template type arguments. */
6908 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6910 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6912 bool removed_attributes
= false;
6913 tree canon
= strip_typedefs (arg
, &removed_attributes
);
6914 if (removed_attributes
6915 && (complain
& tf_warning
))
6916 warning (0, "ignoring attributes on template argument %qT", arg
);
6920 // A template declaration can be substituted for a constrained
6921 // template template parameter only when the argument is more
6922 // constrained than the parameter.
6924 is_compatible_template_arg (tree parm
, tree arg
)
6926 tree parm_cons
= get_constraints (parm
);
6928 /* For now, allow constrained template template arguments
6929 and unconstrained template template parameters. */
6930 if (parm_cons
== NULL_TREE
)
6933 tree arg_cons
= get_constraints (arg
);
6935 // If the template parameter is constrained, we need to rewrite its
6936 // constraints in terms of the ARG's template parameters. This ensures
6937 // that all of the template parameter types will have the same depth.
6939 // Note that this is only valid when coerce_template_template_parm is
6940 // true for the innermost template parameters of PARM and ARG. In other
6941 // words, because coercion is successful, this conversion will be valid.
6944 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (arg
));
6945 parm_cons
= tsubst_constraint_info (parm_cons
,
6946 INNERMOST_TEMPLATE_ARGS (args
),
6947 tf_none
, NULL_TREE
);
6948 if (parm_cons
== error_mark_node
)
6952 return subsumes (parm_cons
, arg_cons
);
6955 // Convert a placeholder argument into a binding to the original
6956 // parameter. The original parameter is saved as the TREE_TYPE of
6959 convert_wildcard_argument (tree parm
, tree arg
)
6961 TREE_TYPE (arg
) = parm
;
6965 /* Convert the indicated template ARG as necessary to match the
6966 indicated template PARM. Returns the converted ARG, or
6967 error_mark_node if the conversion was unsuccessful. Error and
6968 warning messages are issued under control of COMPLAIN. This
6969 conversion is for the Ith parameter in the parameter list. ARGS is
6970 the full set of template arguments deduced so far. */
6973 convert_template_argument (tree parm
,
6976 tsubst_flags_t complain
,
6982 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6984 if (parm
== error_mark_node
)
6985 return error_mark_node
;
6987 /* Trivially convert placeholders. */
6988 if (TREE_CODE (arg
) == WILDCARD_DECL
)
6989 return convert_wildcard_argument (parm
, arg
);
6991 if (TREE_CODE (arg
) == TREE_LIST
6992 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6994 /* The template argument was the name of some
6995 member function. That's usually
6996 invalid, but static members are OK. In any
6997 case, grab the underlying fields/functions
6998 and issue an error later if required. */
6999 orig_arg
= TREE_VALUE (arg
);
7000 TREE_TYPE (arg
) = unknown_type_node
;
7005 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
7006 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
7007 || requires_tmpl_type
);
7009 /* When determining whether an argument pack expansion is a template,
7010 look at the pattern. */
7011 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
7012 arg
= PACK_EXPANSION_PATTERN (arg
);
7014 /* Deal with an injected-class-name used as a template template arg. */
7015 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
7017 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
7018 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7020 if (cxx_dialect
>= cxx11
)
7021 /* OK under DR 1004. */;
7022 else if (complain
& tf_warning_or_error
)
7023 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
7024 " used as template template argument", TYPE_NAME (arg
));
7025 else if (flag_pedantic_errors
)
7033 ((TREE_CODE (arg
) == TEMPLATE_DECL
7034 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
7035 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
7036 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7037 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
7040 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7041 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
7042 arg
= TYPE_STUB_DECL (arg
);
7044 is_type
= TYPE_P (arg
) || is_tmpl_type
;
7046 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
7047 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
7049 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
7051 if (complain
& tf_error
)
7052 error ("invalid use of destructor %qE as a type", orig_arg
);
7053 return error_mark_node
;
7056 permerror (input_location
,
7057 "to refer to a type member of a template parameter, "
7058 "use %<typename %E%>", orig_arg
);
7060 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
7061 TREE_OPERAND (arg
, 1),
7067 if (is_type
!= requires_type
)
7071 if (complain
& tf_error
)
7073 error ("type/value mismatch at argument %d in template "
7074 "parameter list for %qD",
7077 inform (input_location
,
7078 " expected a constant of type %qT, got %qT",
7080 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
7081 else if (requires_tmpl_type
)
7082 inform (input_location
,
7083 " expected a class template, got %qE", orig_arg
);
7085 inform (input_location
,
7086 " expected a type, got %qE", orig_arg
);
7089 return error_mark_node
;
7091 if (is_tmpl_type
^ requires_tmpl_type
)
7093 if (in_decl
&& (complain
& tf_error
))
7095 error ("type/value mismatch at argument %d in template "
7096 "parameter list for %qD",
7099 inform (input_location
,
7100 " expected a type, got %qT", DECL_NAME (arg
));
7102 inform (input_location
,
7103 " expected a class template, got %qT", orig_arg
);
7105 return error_mark_node
;
7110 if (requires_tmpl_type
)
7112 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
7114 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
7115 /* The number of argument required is not known yet.
7116 Just accept it for now. */
7117 val
= TREE_TYPE (arg
);
7120 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
7123 /* Strip alias templates that are equivalent to another
7125 arg
= get_underlying_template (arg
);
7126 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
7128 if (coerce_template_template_parms (parmparm
, argparm
,
7134 /* TEMPLATE_TEMPLATE_PARM node is preferred over
7136 if (val
!= error_mark_node
)
7138 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
7139 val
= TREE_TYPE (val
);
7140 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
7141 val
= make_pack_expansion (val
);
7146 if (in_decl
&& (complain
& tf_error
))
7148 error ("type/value mismatch at argument %d in "
7149 "template parameter list for %qD",
7151 inform (input_location
,
7152 " expected a template of type %qD, got %qT",
7156 val
= error_mark_node
;
7159 // Check that the constraints are compatible before allowing the
7161 if (val
!= error_mark_node
)
7162 if (!is_compatible_template_arg (parm
, arg
))
7164 if (in_decl
&& (complain
& tf_error
))
7166 error ("constraint mismatch at argument %d in "
7167 "template parameter list for %qD",
7169 inform (input_location
, " expected %qD but got %qD",
7172 val
= error_mark_node
;
7178 /* We only form one instance of each template specialization.
7179 Therefore, if we use a non-canonical variant (i.e., a
7180 typedef), any future messages referring to the type will use
7181 the typedef, which is confusing if those future uses do not
7182 themselves also use the typedef. */
7184 val
= canonicalize_type_argument (val
, complain
);
7188 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
7190 if (invalid_nontype_parm_type_p (t
, complain
))
7191 return error_mark_node
;
7193 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
7195 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
7199 /* Not sure if this is reachable, but it doesn't hurt
7201 error ("type mismatch in nontype parameter pack");
7202 val
= error_mark_node
;
7205 else if (!dependent_template_arg_p (orig_arg
)
7206 && !uses_template_parms (t
))
7207 /* We used to call digest_init here. However, digest_init
7208 will report errors, which we don't want when complain
7209 is zero. More importantly, digest_init will try too
7210 hard to convert things: for example, `0' should not be
7211 converted to pointer type at this point according to
7212 the standard. Accepting this is not merely an
7213 extension, since deciding whether or not these
7214 conversions can occur is part of determining which
7215 function template to call, or whether a given explicit
7216 argument specification is valid. */
7217 val
= convert_nontype_argument (t
, orig_arg
, complain
);
7220 bool removed_attr
= false;
7221 val
= strip_typedefs_expr (orig_arg
, &removed_attr
);
7224 if (val
== NULL_TREE
)
7225 val
= error_mark_node
;
7226 else if (val
== error_mark_node
&& (complain
& tf_error
))
7227 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
7229 if (INDIRECT_REF_P (val
))
7231 /* Reject template arguments that are references to built-in
7232 functions with no library fallbacks. */
7233 const_tree inner
= TREE_OPERAND (val
, 0);
7234 if (TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
7235 && TREE_CODE (TREE_TYPE (TREE_TYPE (inner
))) == FUNCTION_TYPE
7236 && TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
7237 && 0 < TREE_OPERAND_LENGTH (inner
)
7238 && reject_gcc_builtin (TREE_OPERAND (inner
, 0)))
7239 return error_mark_node
;
7242 if (TREE_CODE (val
) == SCOPE_REF
)
7244 /* Strip typedefs from the SCOPE_REF. */
7245 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
7246 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
7248 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
7249 QUALIFIED_NAME_IS_TEMPLATE (val
));
7256 /* Coerces the remaining template arguments in INNER_ARGS (from
7257 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
7258 Returns the coerced argument pack. PARM_IDX is the position of this
7259 parameter in the template parameter list. ARGS is the original
7260 template argument list. */
7262 coerce_template_parameter_pack (tree parms
,
7270 tsubst_flags_t complain
)
7272 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
7273 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
7276 tree packed_parms
= NULL_TREE
;
7278 if (arg_idx
> nargs
)
7281 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
7283 /* When the template parameter is a non-type template parameter pack
7284 or template template parameter pack whose type or template
7285 parameters use parameter packs, we know exactly how many arguments
7286 we are looking for. Build a vector of the instantiated decls for
7287 these template parameters in PACKED_PARMS. */
7288 /* We can't use make_pack_expansion here because it would interpret a
7289 _DECL as a use rather than a declaration. */
7290 tree decl
= TREE_VALUE (parm
);
7291 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
7292 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
7293 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
7294 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
7296 TREE_VEC_LENGTH (args
)--;
7297 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
7298 TREE_VEC_LENGTH (args
)++;
7300 if (packed_parms
== error_mark_node
)
7301 return error_mark_node
;
7303 /* If we're doing a partial instantiation of a member template,
7304 verify that all of the types used for the non-type
7305 template parameter pack are, in fact, valid for non-type
7306 template parameters. */
7308 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
7310 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
7311 for (j
= 0; j
< len
; ++j
)
7313 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
7314 if (invalid_nontype_parm_type_p (t
, complain
))
7315 return error_mark_node
;
7317 /* We don't know how many args we have yet, just
7318 use the unconverted ones for now. */
7322 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
7324 /* Check if we have a placeholder pack, which indicates we're
7325 in the context of a introduction list. In that case we want
7326 to match this pack to the single placeholder. */
7327 else if (arg_idx
< nargs
7328 && TREE_CODE (TREE_VEC_ELT (inner_args
, arg_idx
)) == WILDCARD_DECL
7329 && WILDCARD_PACK_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
7331 nargs
= arg_idx
+ 1;
7332 packed_args
= make_tree_vec (1);
7335 packed_args
= make_tree_vec (nargs
- arg_idx
);
7337 /* Convert the remaining arguments, which will be a part of the
7338 parameter pack "parm". */
7339 for (; arg_idx
< nargs
; ++arg_idx
)
7341 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
7342 tree actual_parm
= TREE_VALUE (parm
);
7343 int pack_idx
= arg_idx
- parm_idx
;
7347 /* Once we've packed as many args as we have types, stop. */
7348 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
7350 else if (PACK_EXPANSION_P (arg
))
7351 /* We don't know how many args we have yet, just
7352 use the unconverted ones for now. */
7355 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
7358 if (arg
== error_mark_node
)
7360 if (complain
& tf_error
)
7361 error ("template argument %d is invalid", arg_idx
+ 1);
7364 arg
= convert_template_argument (actual_parm
,
7365 arg
, new_args
, complain
, parm_idx
,
7367 if (arg
== error_mark_node
)
7369 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
7372 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
7373 && TREE_VEC_LENGTH (packed_args
) > 0)
7375 if (complain
& tf_error
)
7376 error ("wrong number of template arguments (%d, should be %d)",
7377 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
7378 return error_mark_node
;
7381 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
7382 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
7383 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
7386 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
7387 TREE_TYPE (argument_pack
)
7388 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
7389 TREE_CONSTANT (argument_pack
) = 1;
7392 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
7394 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
7395 TREE_VEC_LENGTH (packed_args
));
7396 return argument_pack
;
7399 /* Returns the number of pack expansions in the template argument vector
7403 pack_expansion_args_count (tree args
)
7408 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
7410 tree elt
= TREE_VEC_ELT (args
, i
);
7411 if (elt
&& PACK_EXPANSION_P (elt
))
7417 /* Convert all template arguments to their appropriate types, and
7418 return a vector containing the innermost resulting template
7419 arguments. If any error occurs, return error_mark_node. Error and
7420 warning messages are issued under control of COMPLAIN.
7422 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
7423 for arguments not specified in ARGS. Otherwise, if
7424 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
7425 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
7426 USE_DEFAULT_ARGS is false, then all arguments must be specified in
7430 coerce_template_parms (tree parms
,
7433 tsubst_flags_t complain
,
7434 bool require_all_args
,
7435 bool use_default_args
)
7437 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
7438 tree orig_inner_args
;
7441 tree new_inner_args
;
7442 int saved_unevaluated_operand
;
7443 int saved_inhibit_evaluation_warnings
;
7445 /* When used as a boolean value, indicates whether this is a
7446 variadic template parameter list. Since it's an int, we can also
7447 subtract it from nparms to get the number of non-variadic
7450 int variadic_args_p
= 0;
7451 int post_variadic_parms
= 0;
7453 /* Likewise for parameters with default arguments. */
7456 if (args
== error_mark_node
)
7457 return error_mark_node
;
7459 nparms
= TREE_VEC_LENGTH (parms
);
7461 /* Determine if there are any parameter packs or default arguments. */
7462 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
7464 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
7466 ++post_variadic_parms
;
7467 if (template_parameter_pack_p (TREE_VALUE (parm
)))
7469 if (TREE_PURPOSE (parm
))
7473 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
7474 /* If there are no parameters that follow a parameter pack, we need to
7475 expand any argument packs so that we can deduce a parameter pack from
7476 some non-packed args followed by an argument pack, as in variadic85.C.
7477 If there are such parameters, we need to leave argument packs intact
7478 so the arguments are assigned properly. This can happen when dealing
7479 with a nested class inside a partial specialization of a class
7480 template, as in variadic92.C, or when deducing a template parameter pack
7481 from a sub-declarator, as in variadic114.C. */
7482 if (!post_variadic_parms
)
7483 inner_args
= expand_template_argument_pack (inner_args
);
7485 /* Count any pack expansion args. */
7486 variadic_args_p
= pack_expansion_args_count (inner_args
);
7488 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
7489 if ((nargs
> nparms
&& !variadic_p
)
7490 || (nargs
< nparms
- variadic_p
7493 && (!use_default_args
7494 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
7495 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
7497 if (complain
& tf_error
)
7499 if (variadic_p
|| default_p
)
7501 nparms
-= variadic_p
+ default_p
;
7502 error ("wrong number of template arguments "
7503 "(%d, should be at least %d)", nargs
, nparms
);
7506 error ("wrong number of template arguments "
7507 "(%d, should be %d)", nargs
, nparms
);
7510 inform (DECL_SOURCE_LOCATION (in_decl
),
7511 "provided for %qD", in_decl
);
7514 return error_mark_node
;
7516 /* We can't pass a pack expansion to a non-pack parameter of an alias
7517 template (DR 1430). */
7519 && (DECL_ALIAS_TEMPLATE_P (in_decl
)
7520 || concept_template_p (in_decl
))
7522 && nargs
- variadic_args_p
< nparms
- variadic_p
)
7524 if (complain
& tf_error
)
7526 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
7528 tree arg
= TREE_VEC_ELT (inner_args
, i
);
7529 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
7531 if (PACK_EXPANSION_P (arg
)
7532 && !template_parameter_pack_p (parm
))
7534 if (DECL_ALIAS_TEMPLATE_P (in_decl
))
7535 error_at (location_of (arg
),
7536 "pack expansion argument for non-pack parameter "
7537 "%qD of alias template %qD", parm
, in_decl
);
7539 error_at (location_of (arg
),
7540 "pack expansion argument for non-pack parameter "
7541 "%qD of concept %qD", parm
, in_decl
);
7542 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
7549 return error_mark_node
;
7552 /* We need to evaluate the template arguments, even though this
7553 template-id may be nested within a "sizeof". */
7554 saved_unevaluated_operand
= cp_unevaluated_operand
;
7555 cp_unevaluated_operand
= 0;
7556 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
7557 c_inhibit_evaluation_warnings
= 0;
7558 new_inner_args
= make_tree_vec (nparms
);
7559 new_args
= add_outermost_template_args (args
, new_inner_args
);
7560 int pack_adjust
= 0;
7561 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
7566 /* Get the Ith template parameter. */
7567 parm
= TREE_VEC_ELT (parms
, parm_idx
);
7569 if (parm
== error_mark_node
)
7571 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
7575 /* Calculate the next argument. */
7576 if (arg_idx
< nargs
)
7577 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
7581 if (template_parameter_pack_p (TREE_VALUE (parm
))
7582 && !(arg
&& ARGUMENT_PACK_P (arg
)))
7584 /* Some arguments will be placed in the
7585 template parameter pack PARM. */
7586 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
7587 inner_args
, arg_idx
,
7591 if (arg
== NULL_TREE
)
7593 /* We don't know how many args we have yet, just use the
7594 unconverted (and still packed) ones for now. */
7595 new_inner_args
= orig_inner_args
;
7600 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
7602 /* Store this argument. */
7603 if (arg
== error_mark_node
)
7606 /* We are done with all of the arguments. */
7611 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
7612 arg_idx
+= pack_adjust
;
7619 if (PACK_EXPANSION_P (arg
))
7621 /* "If every valid specialization of a variadic template
7622 requires an empty template parameter pack, the template is
7623 ill-formed, no diagnostic required." So check that the
7624 pattern works with this parameter. */
7625 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
7626 tree conv
= convert_template_argument (TREE_VALUE (parm
),
7630 if (conv
== error_mark_node
)
7632 inform (input_location
, "so any instantiation with a "
7633 "non-empty parameter pack would be ill-formed");
7636 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
7637 /* Recover from missing typename. */
7638 TREE_VEC_ELT (inner_args
, arg_idx
)
7639 = make_pack_expansion (conv
);
7641 /* We don't know how many args we have yet, just
7642 use the unconverted ones for now. */
7643 new_inner_args
= inner_args
;
7648 else if (require_all_args
)
7650 /* There must be a default arg in this case. */
7651 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
7653 /* The position of the first default template argument,
7654 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7656 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7657 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7658 arg_idx
- pack_adjust
);
7663 if (arg
== error_mark_node
)
7665 if (complain
& tf_error
)
7666 error ("template argument %d is invalid", arg_idx
+ 1);
7669 /* This only occurs if there was an error in the template
7670 parameter list itself (which we would already have
7671 reported) that we are trying to recover from, e.g., a class
7672 template with a parameter list such as
7673 template<typename..., typename>. */
7676 arg
= convert_template_argument (TREE_VALUE (parm
),
7677 arg
, new_args
, complain
,
7680 if (arg
== error_mark_node
)
7682 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7684 cp_unevaluated_operand
= saved_unevaluated_operand
;
7685 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7687 if (variadic_p
&& arg_idx
< nargs
)
7689 if (complain
& tf_error
)
7691 error ("wrong number of template arguments "
7692 "(%d, should be %d)", nargs
, arg_idx
);
7694 error ("provided for %q+D", in_decl
);
7696 return error_mark_node
;
7700 return error_mark_node
;
7702 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7703 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7704 TREE_VEC_LENGTH (new_inner_args
));
7706 return new_inner_args
;
7709 /* Convert all template arguments to their appropriate types, and
7710 return a vector containing the innermost resulting template
7711 arguments. If any error occurs, return error_mark_node. Error and
7712 warning messages are not issued.
7714 Note that no function argument deduction is performed, and default
7715 arguments are used to fill in unspecified arguments. */
7717 coerce_template_parms (tree parms
, tree args
, tree in_decl
)
7719 return coerce_template_parms (parms
, args
, in_decl
, tf_none
, true, true);
7722 /* Convert all template arguments to their appropriate type, and
7723 instantiate default arguments as needed. This returns a vector
7724 containing the innermost resulting template arguments, or
7725 error_mark_node if unsuccessful. */
7727 coerce_template_parms (tree parms
, tree args
, tree in_decl
,
7728 tsubst_flags_t complain
)
7730 return coerce_template_parms (parms
, args
, in_decl
, complain
, true, true);
7733 /* Like coerce_template_parms. If PARMS represents all template
7734 parameters levels, this function returns a vector of vectors
7735 representing all the resulting argument levels. Note that in this
7736 case, only the innermost arguments are coerced because the
7737 outermost ones are supposed to have been coerced already.
7739 Otherwise, if PARMS represents only (the innermost) vector of
7740 parameters, this function returns a vector containing just the
7741 innermost resulting arguments. */
7744 coerce_innermost_template_parms (tree parms
,
7747 tsubst_flags_t complain
,
7748 bool require_all_args
,
7749 bool use_default_args
)
7751 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7752 int args_depth
= TMPL_ARGS_DEPTH (args
);
7755 if (parms_depth
> 1)
7757 coerced_args
= make_tree_vec (parms_depth
);
7761 for (level
= parms
, cur_depth
= parms_depth
;
7762 parms_depth
> 0 && level
!= NULL_TREE
;
7763 level
= TREE_CHAIN (level
), --cur_depth
)
7766 if (cur_depth
== args_depth
)
7767 l
= coerce_template_parms (TREE_VALUE (level
),
7768 args
, in_decl
, complain
,
7772 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7774 if (l
== error_mark_node
)
7775 return error_mark_node
;
7777 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7781 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7782 args
, in_decl
, complain
,
7785 return coerced_args
;
7788 /* Returns 1 if template args OT and NT are equivalent. */
7791 template_args_equal (tree ot
, tree nt
)
7795 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7798 if (TREE_CODE (nt
) == TREE_VEC
)
7799 /* For member templates */
7800 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7801 else if (PACK_EXPANSION_P (ot
))
7802 return (PACK_EXPANSION_P (nt
)
7803 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7804 PACK_EXPANSION_PATTERN (nt
))
7805 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7806 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7807 else if (ARGUMENT_PACK_P (ot
))
7812 if (!ARGUMENT_PACK_P (nt
))
7815 opack
= ARGUMENT_PACK_ARGS (ot
);
7816 npack
= ARGUMENT_PACK_ARGS (nt
);
7817 len
= TREE_VEC_LENGTH (opack
);
7818 if (TREE_VEC_LENGTH (npack
) != len
)
7820 for (i
= 0; i
< len
; ++i
)
7821 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7822 TREE_VEC_ELT (npack
, i
)))
7826 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7828 /* We get here probably because we are in the middle of substituting
7829 into the pattern of a pack expansion. In that case the
7830 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7831 interested in. So we want to use the initial pack argument for
7833 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7834 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7835 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7836 return template_args_equal (ot
, nt
);
7838 else if (TYPE_P (nt
))
7842 /* Don't treat an alias template specialization with dependent
7843 arguments as equivalent to its underlying type when used as a
7844 template argument; we need them to be distinct so that we
7845 substitute into the specialization arguments at instantiation
7846 time. And aliases can't be equivalent without being ==, so
7847 we don't need to look any deeper. */
7848 if (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
))
7851 return same_type_p (ot
, nt
);
7853 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7857 /* Try to treat a template non-type argument that has been converted
7858 to the parameter type as equivalent to one that hasn't yet. */
7859 for (enum tree_code code1
= TREE_CODE (ot
);
7860 CONVERT_EXPR_CODE_P (code1
)
7861 || code1
== NON_LVALUE_EXPR
;
7862 code1
= TREE_CODE (ot
))
7863 ot
= TREE_OPERAND (ot
, 0);
7864 for (enum tree_code code2
= TREE_CODE (nt
);
7865 CONVERT_EXPR_CODE_P (code2
)
7866 || code2
== NON_LVALUE_EXPR
;
7867 code2
= TREE_CODE (nt
))
7868 nt
= TREE_OPERAND (nt
, 0);
7870 return cp_tree_equal (ot
, nt
);
7874 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7875 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7876 NEWARG_PTR with the offending arguments if they are non-NULL. */
7879 comp_template_args_with_info (tree oldargs
, tree newargs
,
7880 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7884 if (oldargs
== newargs
)
7887 if (!oldargs
|| !newargs
)
7890 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7893 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7895 tree nt
= TREE_VEC_ELT (newargs
, i
);
7896 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7898 if (! template_args_equal (ot
, nt
))
7900 if (oldarg_ptr
!= NULL
)
7902 if (newarg_ptr
!= NULL
)
7910 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7911 of template arguments. Returns 0 otherwise. */
7914 comp_template_args (tree oldargs
, tree newargs
)
7916 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7920 add_pending_template (tree d
)
7922 tree ti
= (TYPE_P (d
)
7923 ? CLASSTYPE_TEMPLATE_INFO (d
)
7924 : DECL_TEMPLATE_INFO (d
));
7925 struct pending_template
*pt
;
7928 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7931 /* We are called both from instantiate_decl, where we've already had a
7932 tinst_level pushed, and instantiate_template, where we haven't.
7934 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7937 push_tinst_level (d
);
7939 pt
= ggc_alloc
<pending_template
> ();
7941 pt
->tinst
= current_tinst_level
;
7942 if (last_pending_template
)
7943 last_pending_template
->next
= pt
;
7945 pending_templates
= pt
;
7947 last_pending_template
= pt
;
7949 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7956 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7957 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7958 documentation for TEMPLATE_ID_EXPR. */
7961 lookup_template_function (tree fns
, tree arglist
)
7965 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7966 return error_mark_node
;
7968 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7970 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7972 error ("%q#D is not a function template", fns
);
7973 return error_mark_node
;
7976 if (BASELINK_P (fns
))
7978 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7980 BASELINK_FUNCTIONS (fns
),
7985 type
= TREE_TYPE (fns
);
7986 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7987 type
= unknown_type_node
;
7989 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7992 /* Within the scope of a template class S<T>, the name S gets bound
7993 (in build_self_reference) to a TYPE_DECL for the class, not a
7994 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7995 or one of its enclosing classes, and that type is a template,
7996 return the associated TEMPLATE_DECL. Otherwise, the original
7999 Also handle the case when DECL is a TREE_LIST of ambiguous
8000 injected-class-names from different bases. */
8003 maybe_get_template_decl_from_type_decl (tree decl
)
8005 if (decl
== NULL_TREE
)
8008 /* DR 176: A lookup that finds an injected-class-name (10.2
8009 [class.member.lookup]) can result in an ambiguity in certain cases
8010 (for example, if it is found in more than one base class). If all of
8011 the injected-class-names that are found refer to specializations of
8012 the same class template, and if the name is followed by a
8013 template-argument-list, the reference refers to the class template
8014 itself and not a specialization thereof, and is not ambiguous. */
8015 if (TREE_CODE (decl
) == TREE_LIST
)
8017 tree t
, tmpl
= NULL_TREE
;
8018 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
8020 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
8023 else if (tmpl
!= elt
)
8026 if (tmpl
&& t
== NULL_TREE
)
8032 return (decl
!= NULL_TREE
8033 && DECL_SELF_REFERENCE_P (decl
)
8034 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
8035 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
8038 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
8039 parameters, find the desired type.
8041 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
8043 IN_DECL, if non-NULL, is the template declaration we are trying to
8046 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
8047 the class we are looking up.
8049 Issue error and warning messages under control of COMPLAIN.
8051 If the template class is really a local class in a template
8052 function, then the FUNCTION_CONTEXT is the function in which it is
8055 ??? Note that this function is currently called *twice* for each
8056 template-id: the first time from the parser, while creating the
8057 incomplete type (finish_template_type), and the second type during the
8058 real instantiation (instantiate_template_class). This is surely something
8059 that we want to avoid. It also causes some problems with argument
8060 coercion (see convert_nontype_argument for more information on this). */
8063 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
8064 int entering_scope
, tsubst_flags_t complain
)
8066 tree templ
= NULL_TREE
, parmlist
;
8073 if (identifier_p (d1
))
8075 tree value
= innermost_non_namespace_value (d1
);
8076 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
8081 push_decl_namespace (context
);
8082 templ
= lookup_name (d1
);
8083 templ
= maybe_get_template_decl_from_type_decl (templ
);
8085 pop_decl_namespace ();
8088 context
= DECL_CONTEXT (templ
);
8090 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
8092 tree type
= TREE_TYPE (d1
);
8094 /* If we are declaring a constructor, say A<T>::A<T>, we will get
8095 an implicit typename for the second A. Deal with it. */
8096 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
8097 type
= TREE_TYPE (type
);
8099 if (CLASSTYPE_TEMPLATE_INFO (type
))
8101 templ
= CLASSTYPE_TI_TEMPLATE (type
);
8102 d1
= DECL_NAME (templ
);
8105 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
8106 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
8108 templ
= TYPE_TI_TEMPLATE (d1
);
8109 d1
= DECL_NAME (templ
);
8111 else if (DECL_TYPE_TEMPLATE_P (d1
))
8114 d1
= DECL_NAME (templ
);
8115 context
= DECL_CONTEXT (templ
);
8117 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
8120 d1
= DECL_NAME (templ
);
8123 /* Issue an error message if we didn't find a template. */
8126 if (complain
& tf_error
)
8127 error ("%qT is not a template", d1
);
8128 return error_mark_node
;
8131 if (TREE_CODE (templ
) != TEMPLATE_DECL
8132 /* Make sure it's a user visible template, if it was named by
8134 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
8135 && !PRIMARY_TEMPLATE_P (templ
)))
8137 if (complain
& tf_error
)
8139 error ("non-template type %qT used as a template", d1
);
8141 error ("for template declaration %q+D", in_decl
);
8143 return error_mark_node
;
8146 complain
&= ~tf_user
;
8148 /* An alias that just changes the name of a template is equivalent to the
8149 other template, so if any of the arguments are pack expansions, strip
8150 the alias to avoid problems with a pack expansion passed to a non-pack
8151 alias template parameter (DR 1430). */
8152 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
8153 templ
= get_underlying_template (templ
);
8155 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
8157 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
8158 template arguments */
8164 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
8166 /* Consider an example where a template template parameter declared as
8168 template <class T, class U = std::allocator<T> > class TT
8170 The template parameter level of T and U are one level larger than
8171 of TT. To proper process the default argument of U, say when an
8172 instantiation `TT<int>' is seen, we need to build the full
8173 arguments containing {int} as the innermost level. Outer levels,
8174 available when not appearing as default template argument, can be
8175 obtained from the arguments of the enclosing template.
8177 Suppose that TT is later substituted with std::vector. The above
8178 instantiation is `TT<int, std::allocator<T> >' with TT at
8179 level 1, and T at level 2, while the template arguments at level 1
8180 becomes {std::vector} and the inner level 2 is {int}. */
8182 outer
= DECL_CONTEXT (templ
);
8184 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
8185 else if (current_template_parms
)
8187 /* This is an argument of the current template, so we haven't set
8188 DECL_CONTEXT yet. */
8189 tree relevant_template_parms
;
8191 /* Parameter levels that are greater than the level of the given
8192 template template parm are irrelevant. */
8193 relevant_template_parms
= current_template_parms
;
8194 while (TMPL_PARMS_DEPTH (relevant_template_parms
)
8195 != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ
)))
8196 relevant_template_parms
= TREE_CHAIN (relevant_template_parms
);
8198 outer
= template_parms_to_args (relevant_template_parms
);
8202 arglist
= add_to_template_args (outer
, arglist
);
8204 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
8206 /*require_all_args=*/true,
8207 /*use_default_args=*/true);
8208 if (arglist2
== error_mark_node
8209 || (!uses_template_parms (arglist2
)
8210 && check_instantiated_args (templ
, arglist2
, complain
)))
8211 return error_mark_node
;
8213 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
8218 tree template_type
= TREE_TYPE (templ
);
8221 tree found
= NULL_TREE
;
8224 int is_dependent_type
;
8225 int use_partial_inst_tmpl
= false;
8227 if (template_type
== error_mark_node
)
8228 /* An error occurred while building the template TEMPL, and a
8229 diagnostic has most certainly been emitted for that
8230 already. Let's propagate that error. */
8231 return error_mark_node
;
8233 gen_tmpl
= most_general_template (templ
);
8234 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
8235 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
8236 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
8238 if (arg_depth
== 1 && parm_depth
> 1)
8240 /* We've been given an incomplete set of template arguments.
8243 template <class T> struct S1 {
8244 template <class U> struct S2 {};
8245 template <class U> struct S2<U*> {};
8248 we will be called with an ARGLIST of `U*', but the
8249 TEMPLATE will be `template <class T> template
8250 <class U> struct S1<T>::S2'. We must fill in the missing
8253 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
8255 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
8258 /* Now we should have enough arguments. */
8259 gcc_assert (parm_depth
== arg_depth
);
8261 /* From here on, we're only interested in the most general
8264 /* Calculate the BOUND_ARGS. These will be the args that are
8265 actually tsubst'd into the definition to create the
8267 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
8269 /*require_all_args=*/true,
8270 /*use_default_args=*/true);
8272 if (arglist
== error_mark_node
)
8273 /* We were unable to bind the arguments. */
8274 return error_mark_node
;
8276 /* In the scope of a template class, explicit references to the
8277 template class refer to the type of the template, not any
8278 instantiation of it. For example, in:
8280 template <class T> class C { void f(C<T>); }
8282 the `C<T>' is just the same as `C'. Outside of the
8283 class, however, such a reference is an instantiation. */
8285 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
8286 || currently_open_class (template_type
))
8287 /* comp_template_args is expensive, check it last. */
8288 && comp_template_args (TYPE_TI_ARGS (template_type
),
8290 return template_type
;
8292 /* If we already have this specialization, return it. */
8293 elt
.tmpl
= gen_tmpl
;
8295 elt
.spec
= NULL_TREE
;
8296 hash
= spec_hasher::hash (&elt
);
8297 entry
= type_specializations
->find_with_hash (&elt
, hash
);
8302 /* If the the template's constraints are not satisfied,
8303 then we cannot form a valid type.
8305 Note that the check is deferred until after the hash
8306 lookup. This prevents redundant checks on previously
8307 instantiated specializations. */
8308 if (flag_concepts
&& !constraints_satisfied_p (gen_tmpl
, arglist
))
8310 if (complain
& tf_error
)
8312 error ("template constraint failure");
8313 diagnose_constraints (input_location
, gen_tmpl
, arglist
);
8315 return error_mark_node
;
8318 is_dependent_type
= uses_template_parms (arglist
);
8320 /* If the deduced arguments are invalid, then the binding
8322 if (!is_dependent_type
8323 && check_instantiated_args (gen_tmpl
,
8324 INNERMOST_TEMPLATE_ARGS (arglist
),
8326 return error_mark_node
;
8328 if (!is_dependent_type
8329 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
8330 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
8331 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
8333 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
8334 DECL_NAME (gen_tmpl
),
8335 /*tag_scope=*/ts_global
);
8339 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
8341 if (context
== error_mark_node
)
8342 return error_mark_node
;
8345 context
= global_namespace
;
8347 /* Create the type. */
8348 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8350 /* The user referred to a specialization of an alias
8351 template represented by GEN_TMPL.
8353 [temp.alias]/2 says:
8355 When a template-id refers to the specialization of an
8356 alias template, it is equivalent to the associated
8357 type obtained by substitution of its
8358 template-arguments for the template-parameters in the
8359 type-id of the alias template. */
8361 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
8362 /* Note that the call above (by indirectly calling
8363 register_specialization in tsubst_decl) registers the
8364 TYPE_DECL representing the specialization of the alias
8365 template. So next time someone substitutes ARGLIST for
8366 the template parms into the alias template (GEN_TMPL),
8367 she'll get that TYPE_DECL back. */
8369 if (t
== error_mark_node
)
8372 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
8374 if (!is_dependent_type
)
8376 set_current_access_from_decl (TYPE_NAME (template_type
));
8377 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
8378 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
8379 arglist
, complain
, in_decl
),
8380 SCOPED_ENUM_P (template_type
), NULL
);
8382 if (t
== error_mark_node
)
8387 /* We don't want to call start_enum for this type, since
8388 the values for the enumeration constants may involve
8389 template parameters. And, no one should be interested
8390 in the enumeration constants for such a type. */
8391 t
= cxx_make_type (ENUMERAL_TYPE
);
8392 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
8394 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
8395 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
8396 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
8398 else if (CLASS_TYPE_P (template_type
))
8400 t
= make_class_type (TREE_CODE (template_type
));
8401 CLASSTYPE_DECLARED_CLASS (t
)
8402 = CLASSTYPE_DECLARED_CLASS (template_type
);
8403 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
8404 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
8406 /* A local class. Make sure the decl gets registered properly. */
8407 if (context
== current_function_decl
)
8408 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
8410 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
8411 /* This instantiation is another name for the primary
8412 template type. Set the TYPE_CANONICAL field
8414 TYPE_CANONICAL (t
) = template_type
;
8415 else if (any_template_arguments_need_structural_equality_p (arglist
))
8416 /* Some of the template arguments require structural
8417 equality testing, so this template class requires
8418 structural equality testing. */
8419 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8424 /* If we called start_enum or pushtag above, this information
8425 will already be set up. */
8428 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
8430 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
8431 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
8432 DECL_SOURCE_LOCATION (type_decl
)
8433 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
8436 type_decl
= TYPE_NAME (t
);
8438 if (CLASS_TYPE_P (template_type
))
8440 TREE_PRIVATE (type_decl
)
8441 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
8442 TREE_PROTECTED (type_decl
)
8443 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
8444 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
8446 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
8447 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
8451 if (OVERLOAD_TYPE_P (t
)
8452 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8454 static const char *tags
[] = {"abi_tag", "may_alias"};
8456 for (unsigned ix
= 0; ix
!= 2; ix
++)
8459 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
8463 else if (!TREE_CHAIN (attributes
) && !TYPE_ATTRIBUTES (t
))
8464 TYPE_ATTRIBUTES (t
) = attributes
;
8467 = tree_cons (TREE_PURPOSE (attributes
),
8468 TREE_VALUE (attributes
),
8469 TYPE_ATTRIBUTES (t
));
8473 /* Let's consider the explicit specialization of a member
8474 of a class template specialization that is implicitly instantiated,
8479 template<class U> struct M {}; //#0
8484 struct S<int>::M<char> //#1
8488 [temp.expl.spec]/4 says this is valid.
8490 In this case, when we write:
8493 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
8496 When we encounter #1, we want to store the partial instantiation
8497 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
8499 For all cases other than this "explicit specialization of member of a
8500 class template", we just want to store the most general template into
8501 the CLASSTYPE_TI_TEMPLATE of M.
8503 This case of "explicit specialization of member of a class template"
8505 1/ the enclosing class is an instantiation of, and therefore not
8506 the same as, the context of the most general template, and
8507 2/ we aren't looking at the partial instantiation itself, i.e.
8508 the innermost arguments are not the same as the innermost parms of
8509 the most general template.
8511 So it's only when 1/ and 2/ happens that we want to use the partial
8512 instantiation of the member template in lieu of its most general
8515 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
8516 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
8517 /* the enclosing class must be an instantiation... */
8518 && CLASS_TYPE_P (context
)
8519 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
8521 tree partial_inst_args
;
8522 TREE_VEC_LENGTH (arglist
)--;
8523 ++processing_template_decl
;
8525 tsubst (INNERMOST_TEMPLATE_ARGS
8526 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
8527 arglist
, complain
, NULL_TREE
);
8528 --processing_template_decl
;
8529 TREE_VEC_LENGTH (arglist
)++;
8530 use_partial_inst_tmpl
=
8531 /*...and we must not be looking at the partial instantiation
8533 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
8537 if (!use_partial_inst_tmpl
)
8538 /* This case is easy; there are no member templates involved. */
8542 /* This is a full instantiation of a member template. Find
8543 the partial instantiation of which this is an instance. */
8545 /* Temporarily reduce by one the number of levels in the ARGLIST
8546 so as to avoid comparing the last set of arguments. */
8547 TREE_VEC_LENGTH (arglist
)--;
8548 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
8549 TREE_VEC_LENGTH (arglist
)++;
8550 /* FOUND is either a proper class type, or an alias
8551 template specialization. In the later case, it's a
8552 TYPE_DECL, resulting from the substituting of arguments
8553 for parameters in the TYPE_DECL of the alias template
8554 done earlier. So be careful while getting the template
8556 found
= TREE_CODE (found
) == TYPE_DECL
8557 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
8558 : CLASSTYPE_TI_TEMPLATE (found
);
8561 // Build template info for the new specialization.
8562 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
8565 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
8566 entry
= ggc_alloc
<spec_entry
> ();
8570 /* Note this use of the partial instantiation so we can check it
8571 later in maybe_process_partial_specialization. */
8572 DECL_TEMPLATE_INSTANTIATIONS (found
)
8573 = tree_cons (arglist
, t
,
8574 DECL_TEMPLATE_INSTANTIATIONS (found
));
8576 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
8577 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8578 /* Now that the type has been registered on the instantiations
8579 list, we set up the enumerators. Because the enumeration
8580 constants may involve the enumeration type itself, we make
8581 sure to register the type first, and then create the
8582 constants. That way, doing tsubst_expr for the enumeration
8583 constants won't result in recursive calls here; we'll find
8584 the instantiation and exit above. */
8585 tsubst_enum (template_type
, t
, arglist
);
8587 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
8588 /* If the type makes use of template parameters, the
8589 code that generates debugging information will crash. */
8590 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
8592 /* Possibly limit visibility based on template args. */
8593 TREE_PUBLIC (type_decl
) = 1;
8594 determine_visibility (type_decl
);
8596 inherit_targ_abi_tags (t
);
8602 /* Wrapper for lookup_template_class_1. */
8605 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
8606 int entering_scope
, tsubst_flags_t complain
)
8609 timevar_push (TV_TEMPLATE_INST
);
8610 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
8611 entering_scope
, complain
);
8612 timevar_pop (TV_TEMPLATE_INST
);
8616 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
8619 lookup_template_variable (tree templ
, tree arglist
)
8621 /* The type of the expression is NULL_TREE since the template-id could refer
8622 to an explicit or partial specialization. */
8623 tree type
= NULL_TREE
;
8624 if (flag_concepts
&& variable_concept_p (templ
))
8625 /* Except that concepts are always bool. */
8626 type
= boolean_type_node
;
8627 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
8630 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
8633 finish_template_variable (tree var
, tsubst_flags_t complain
)
8635 tree templ
= TREE_OPERAND (var
, 0);
8636 tree arglist
= TREE_OPERAND (var
, 1);
8638 /* We never want to return a VAR_DECL for a variable concept, since they
8639 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
8640 bool concept_p
= flag_concepts
&& variable_concept_p (templ
);
8641 if (concept_p
&& processing_template_decl
)
8644 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
8645 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
8647 tree parms
= DECL_TEMPLATE_PARMS (templ
);
8648 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
8650 /*use_default*/true);
8652 if (flag_concepts
&& !constraints_satisfied_p (templ
, arglist
))
8654 if (complain
& tf_error
)
8656 error ("constraints for %qD not satisfied", templ
);
8657 diagnose_constraints (location_of (var
), templ
, arglist
);
8659 return error_mark_node
;
8662 /* If a template-id refers to a specialization of a variable
8663 concept, then the expression is true if and only if the
8664 concept's constraints are satisfied by the given template
8667 NOTE: This is an extension of Concepts Lite TS that
8668 allows constraints to be used in expressions. */
8671 tree decl
= DECL_TEMPLATE_RESULT (templ
);
8672 return evaluate_variable_concept (decl
, arglist
);
8675 return instantiate_template (templ
, arglist
, complain
);
8682 /* True when we should also visit template parameters that occur in
8683 non-deduced contexts. */
8684 bool include_nondeduced_p
;
8685 hash_set
<tree
> *visited
;
8688 /* Called from for_each_template_parm via walk_tree. */
8691 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
8694 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
8695 tree_fn_t fn
= pfd
->fn
;
8696 void *data
= pfd
->data
;
8697 tree result
= NULL_TREE
;
8699 #define WALK_SUBTREE(NODE) \
8702 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
8703 pfd->include_nondeduced_p); \
8704 if (result) goto out; \
8709 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
))
8710 WALK_SUBTREE (TYPE_CONTEXT (t
));
8712 switch (TREE_CODE (t
))
8715 if (TYPE_PTRMEMFUNC_P (t
))
8721 if (!TYPE_TEMPLATE_INFO (t
))
8724 WALK_SUBTREE (TYPE_TI_ARGS (t
));
8728 WALK_SUBTREE (TYPE_MIN_VALUE (t
));
8729 WALK_SUBTREE (TYPE_MAX_VALUE (t
));
8733 /* Since we're not going to walk subtrees, we have to do this
8735 WALK_SUBTREE (TYPE_METHOD_BASETYPE (t
));
8739 /* Check the return type. */
8740 WALK_SUBTREE (TREE_TYPE (t
));
8742 /* Check the parameter types. Since default arguments are not
8743 instantiated until they are needed, the TYPE_ARG_TYPES may
8744 contain expressions that involve template parameters. But,
8745 no-one should be looking at them yet. And, once they're
8746 instantiated, they don't contain template parameters, so
8747 there's no point in looking at them then, either. */
8751 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
8752 WALK_SUBTREE (TREE_VALUE (parm
));
8754 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8755 want walk_tree walking into them itself. */
8761 case UNDERLYING_TYPE
:
8762 if (pfd
->include_nondeduced_p
8763 && for_each_template_parm (TYPE_VALUES_RAW (t
), fn
, data
,
8765 pfd
->include_nondeduced_p
))
8766 return error_mark_node
;
8771 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
8772 WALK_SUBTREE (DECL_TI_ARGS (t
));
8777 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
))
8778 WALK_SUBTREE (DECL_INITIAL (t
));
8779 if (DECL_CONTEXT (t
)
8780 && pfd
->include_nondeduced_p
)
8781 WALK_SUBTREE (DECL_CONTEXT (t
));
8784 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8785 /* Record template parameters such as `T' inside `TT<T>'. */
8786 WALK_SUBTREE (TYPE_TI_ARGS (t
));
8789 case TEMPLATE_TEMPLATE_PARM
:
8790 case TEMPLATE_TYPE_PARM
:
8791 case TEMPLATE_PARM_INDEX
:
8792 if (fn
&& (*fn
)(t
, data
))
8799 /* A template template parameter is encountered. */
8800 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
8801 WALK_SUBTREE (TREE_TYPE (t
));
8803 /* Already substituted template template parameter */
8809 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
8813 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8814 && pfd
->include_nondeduced_p
)
8815 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
8820 /* If there's no type, then this thing must be some expression
8821 involving template parameters. */
8822 if (!fn
&& !TREE_TYPE (t
))
8823 return error_mark_node
;
8828 case IMPLICIT_CONV_EXPR
:
8829 case REINTERPRET_CAST_EXPR
:
8830 case CONST_CAST_EXPR
:
8831 case STATIC_CAST_EXPR
:
8832 case DYNAMIC_CAST_EXPR
:
8836 case PSEUDO_DTOR_EXPR
:
8838 return error_mark_node
;
8847 /* We didn't find any template parameters we liked. */
8852 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8853 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8854 call FN with the parameter and the DATA.
8855 If FN returns nonzero, the iteration is terminated, and
8856 for_each_template_parm returns 1. Otherwise, the iteration
8857 continues. If FN never returns a nonzero value, the value
8858 returned by for_each_template_parm is 0. If FN is NULL, it is
8859 considered to be the function which always returns 1.
8861 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8862 parameters that occur in non-deduced contexts. When false, only
8863 visits those template parameters that can be deduced. */
8866 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8867 hash_set
<tree
> *visited
,
8868 bool include_nondeduced_p
)
8870 struct pair_fn_data pfd
;
8876 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8878 /* Walk the tree. (Conceptually, we would like to walk without
8879 duplicates, but for_each_template_parm_r recursively calls
8880 for_each_template_parm, so we would need to reorganize a fair
8881 bit to use walk_tree_without_duplicates, so we keep our own
8884 pfd
.visited
= visited
;
8886 pfd
.visited
= new hash_set
<tree
>;
8887 result
= cp_walk_tree (&t
,
8888 for_each_template_parm_r
,
8902 /* Returns true if T depends on any template parameter. */
8905 uses_template_parms (tree t
)
8911 int saved_processing_template_decl
;
8913 saved_processing_template_decl
= processing_template_decl
;
8914 if (!saved_processing_template_decl
)
8915 processing_template_decl
= 1;
8917 dependent_p
= dependent_type_p (t
);
8918 else if (TREE_CODE (t
) == TREE_VEC
)
8919 dependent_p
= any_dependent_template_arguments_p (t
);
8920 else if (TREE_CODE (t
) == TREE_LIST
)
8921 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8922 || uses_template_parms (TREE_CHAIN (t
)));
8923 else if (TREE_CODE (t
) == TYPE_DECL
)
8924 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8927 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8928 || TREE_CODE (t
) == OVERLOAD
8931 || TREE_CODE (t
) == TRAIT_EXPR
8932 || TREE_CODE (t
) == CONSTRUCTOR
8933 || CONSTANT_CLASS_P (t
))
8934 dependent_p
= (type_dependent_expression_p (t
)
8935 || value_dependent_expression_p (t
));
8938 gcc_assert (t
== error_mark_node
);
8939 dependent_p
= false;
8942 processing_template_decl
= saved_processing_template_decl
;
8947 /* Returns true iff current_function_decl is an incompletely instantiated
8948 template. Useful instead of processing_template_decl because the latter
8949 is set to 0 during instantiate_non_dependent_expr. */
8952 in_template_function (void)
8954 tree fn
= current_function_decl
;
8956 ++processing_template_decl
;
8957 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8958 && DECL_TEMPLATE_INFO (fn
)
8959 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8960 --processing_template_decl
;
8964 /* Returns true if T depends on any template parameter with level LEVEL. */
8967 uses_template_parms_level (tree t
, int level
)
8969 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8970 /*include_nondeduced_p=*/true);
8973 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8974 ill-formed translation unit, i.e. a variable or function that isn't
8975 usable in a constant expression. */
8978 neglectable_inst_p (tree d
)
8981 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8982 : decl_maybe_constant_var_p (d
)));
8985 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8986 neglectable and instantiated from within an erroneous instantiation. */
8989 limit_bad_template_recursion (tree decl
)
8991 struct tinst_level
*lev
= current_tinst_level
;
8992 int errs
= errorcount
+ sorrycount
;
8993 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8996 for (; lev
; lev
= lev
->next
)
8997 if (neglectable_inst_p (lev
->decl
))
9000 return (lev
&& errs
> lev
->errors
);
9003 static int tinst_depth
;
9004 extern int max_tinst_depth
;
9007 static GTY(()) struct tinst_level
*last_error_tinst_level
;
9009 /* We're starting to instantiate D; record the template instantiation context
9010 for diagnostics and to restore it later. */
9013 push_tinst_level (tree d
)
9015 return push_tinst_level_loc (d
, input_location
);
9018 /* We're starting to instantiate D; record the template instantiation context
9019 at LOC for diagnostics and to restore it later. */
9022 push_tinst_level_loc (tree d
, location_t loc
)
9024 struct tinst_level
*new_level
;
9026 if (tinst_depth
>= max_tinst_depth
)
9028 fatal_error (input_location
,
9029 "template instantiation depth exceeds maximum of %d"
9030 " (use -ftemplate-depth= to increase the maximum)",
9035 /* If the current instantiation caused problems, don't let it instantiate
9036 anything else. Do allow deduction substitution and decls usable in
9037 constant expressions. */
9038 if (limit_bad_template_recursion (d
))
9041 new_level
= ggc_alloc
<tinst_level
> ();
9042 new_level
->decl
= d
;
9043 new_level
->locus
= loc
;
9044 new_level
->errors
= errorcount
+sorrycount
;
9045 new_level
->in_system_header_p
= in_system_header_at (input_location
);
9046 new_level
->next
= current_tinst_level
;
9047 current_tinst_level
= new_level
;
9050 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
9051 depth_reached
= tinst_depth
;
9056 /* We're done instantiating this template; return to the instantiation
9060 pop_tinst_level (void)
9062 /* Restore the filename and line number stashed away when we started
9063 this instantiation. */
9064 input_location
= current_tinst_level
->locus
;
9065 current_tinst_level
= current_tinst_level
->next
;
9069 /* We're instantiating a deferred template; restore the template
9070 instantiation context in which the instantiation was requested, which
9071 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
9074 reopen_tinst_level (struct tinst_level
*level
)
9076 struct tinst_level
*t
;
9079 for (t
= level
; t
; t
= t
->next
)
9082 current_tinst_level
= level
;
9084 if (current_tinst_level
)
9085 current_tinst_level
->errors
= errorcount
+sorrycount
;
9089 /* Returns the TINST_LEVEL which gives the original instantiation
9092 struct tinst_level
*
9093 outermost_tinst_level (void)
9095 struct tinst_level
*level
= current_tinst_level
;
9098 level
= level
->next
;
9102 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
9103 vector of template arguments, as for tsubst.
9105 Returns an appropriate tsubst'd friend declaration. */
9108 tsubst_friend_function (tree decl
, tree args
)
9112 if (TREE_CODE (decl
) == FUNCTION_DECL
9113 && DECL_TEMPLATE_INSTANTIATION (decl
)
9114 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
9115 /* This was a friend declared with an explicit template
9116 argument list, e.g.:
9120 to indicate that f was a template instantiation, not a new
9121 function declaration. Now, we have to figure out what
9122 instantiation of what template. */
9124 tree template_id
, arglist
, fns
;
9127 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
9129 /* Friend functions are looked up in the containing namespace scope.
9130 We must enter that scope, to avoid finding member functions of the
9131 current class with same name. */
9132 push_nested_namespace (ns
);
9133 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
9134 tf_warning_or_error
, NULL_TREE
,
9135 /*integral_constant_expression_p=*/false);
9136 pop_nested_namespace (ns
);
9137 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
9138 tf_warning_or_error
, NULL_TREE
);
9139 template_id
= lookup_template_function (fns
, arglist
);
9141 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
9142 tmpl
= determine_specialization (template_id
, new_friend
,
9144 /*need_member_template=*/0,
9145 TREE_VEC_LENGTH (args
),
9147 return instantiate_template (tmpl
, new_args
, tf_error
);
9150 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
9152 /* The NEW_FRIEND will look like an instantiation, to the
9153 compiler, but is not an instantiation from the point of view of
9154 the language. For example, we might have had:
9156 template <class T> struct S {
9157 template <class U> friend void f(T, U);
9160 Then, in S<int>, template <class U> void f(int, U) is not an
9161 instantiation of anything. */
9162 if (new_friend
== error_mark_node
)
9163 return error_mark_node
;
9165 DECL_USE_TEMPLATE (new_friend
) = 0;
9166 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
9168 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
9169 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
9170 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
9173 /* The mangled name for the NEW_FRIEND is incorrect. The function
9174 is not a template instantiation and should not be mangled like
9175 one. Therefore, we forget the mangling here; we'll recompute it
9176 later if we need it. */
9177 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
9179 SET_DECL_RTL (new_friend
, NULL
);
9180 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
9183 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
9186 tree new_friend_template_info
;
9187 tree new_friend_result_template_info
;
9189 int new_friend_is_defn
;
9191 /* We must save some information from NEW_FRIEND before calling
9192 duplicate decls since that function will free NEW_FRIEND if
9194 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
9195 new_friend_is_defn
=
9196 (DECL_INITIAL (DECL_TEMPLATE_RESULT
9197 (template_for_substitution (new_friend
)))
9199 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
9201 /* This declaration is a `primary' template. */
9202 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
9204 new_friend_result_template_info
9205 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
9208 new_friend_result_template_info
= NULL_TREE
;
9210 /* Make the init_value nonzero so pushdecl knows this is a defn. */
9211 if (new_friend_is_defn
)
9212 DECL_INITIAL (new_friend
) = error_mark_node
;
9214 /* Inside pushdecl_namespace_level, we will push into the
9215 current namespace. However, the friend function should go
9216 into the namespace of the template. */
9217 ns
= decl_namespace_context (new_friend
);
9218 push_nested_namespace (ns
);
9219 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
9220 pop_nested_namespace (ns
);
9222 if (old_decl
== error_mark_node
)
9223 return error_mark_node
;
9225 if (old_decl
!= new_friend
)
9227 /* This new friend declaration matched an existing
9228 declaration. For example, given:
9230 template <class T> void f(T);
9231 template <class U> class C {
9232 template <class T> friend void f(T) {}
9235 the friend declaration actually provides the definition
9236 of `f', once C has been instantiated for some type. So,
9237 old_decl will be the out-of-class template declaration,
9238 while new_friend is the in-class definition.
9240 But, if `f' was called before this point, the
9241 instantiation of `f' will have DECL_TI_ARGS corresponding
9242 to `T' but not to `U', references to which might appear
9243 in the definition of `f'. Previously, the most general
9244 template for an instantiation of `f' was the out-of-class
9245 version; now it is the in-class version. Therefore, we
9246 run through all specialization of `f', adding to their
9247 DECL_TI_ARGS appropriately. In particular, they need a
9248 new set of outer arguments, corresponding to the
9249 arguments for this class instantiation.
9251 The same situation can arise with something like this:
9254 template <class T> class C {
9258 when `C<int>' is instantiated. Now, `f(int)' is defined
9261 if (!new_friend_is_defn
)
9262 /* On the other hand, if the in-class declaration does
9263 *not* provide a definition, then we don't want to alter
9264 existing definitions. We can just leave everything
9269 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
9270 tree new_args
= TI_ARGS (new_friend_template_info
);
9272 /* Overwrite whatever template info was there before, if
9273 any, with the new template information pertaining to
9275 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
9277 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
9279 /* We should have called reregister_specialization in
9281 gcc_assert (retrieve_specialization (new_template
,
9285 /* Instantiate it if the global has already been used. */
9286 if (DECL_ODR_USED (old_decl
))
9287 instantiate_decl (old_decl
, /*defer_ok=*/true,
9288 /*expl_inst_class_mem_p=*/false);
9294 /* Indicate that the old function template is a partial
9296 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
9297 = new_friend_result_template_info
;
9299 gcc_assert (new_template
9300 == most_general_template (new_template
));
9301 gcc_assert (new_template
!= old_decl
);
9303 /* Reassign any specializations already in the hash table
9304 to the new more general template, and add the
9305 additional template args. */
9306 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
9310 tree spec
= TREE_VALUE (t
);
9313 elt
.tmpl
= old_decl
;
9314 elt
.args
= DECL_TI_ARGS (spec
);
9315 elt
.spec
= NULL_TREE
;
9317 decl_specializations
->remove_elt (&elt
);
9320 = add_outermost_template_args (new_args
,
9321 DECL_TI_ARGS (spec
));
9323 register_specialization
9324 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
9327 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
9331 /* The information from NEW_FRIEND has been merged into OLD_DECL
9332 by duplicate_decls. */
9333 new_friend
= old_decl
;
9338 tree context
= DECL_CONTEXT (new_friend
);
9342 template <class T> class C {
9343 template <class U> friend void C1<U>::f (); // case 1
9344 friend void C2<T>::f (); // case 2
9346 we only need to make sure CONTEXT is a complete type for
9347 case 2. To distinguish between the two cases, we note that
9348 CONTEXT of case 1 remains dependent type after tsubst while
9349 this isn't true for case 2. */
9350 ++processing_template_decl
;
9351 dependent_p
= dependent_type_p (context
);
9352 --processing_template_decl
;
9355 && !complete_type_or_else (context
, NULL_TREE
))
9356 return error_mark_node
;
9358 if (COMPLETE_TYPE_P (context
))
9360 tree fn
= new_friend
;
9361 /* do_friend adds the TEMPLATE_DECL for any member friend
9362 template even if it isn't a member template, i.e.
9363 template <class T> friend A<T>::f();
9364 Look through it in that case. */
9365 if (TREE_CODE (fn
) == TEMPLATE_DECL
9366 && !PRIMARY_TEMPLATE_P (fn
))
9367 fn
= DECL_TEMPLATE_RESULT (fn
);
9368 /* Check to see that the declaration is really present, and,
9369 possibly obtain an improved declaration. */
9370 fn
= check_classfn (context
, fn
, NULL_TREE
);
9380 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
9381 template arguments, as for tsubst.
9383 Returns an appropriate tsubst'd friend type or error_mark_node on
9387 tsubst_friend_class (tree friend_tmpl
, tree args
)
9393 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
9395 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
9396 return TREE_TYPE (t
);
9399 context
= CP_DECL_CONTEXT (friend_tmpl
);
9401 if (context
!= global_namespace
)
9403 if (TREE_CODE (context
) == NAMESPACE_DECL
)
9404 push_nested_namespace (context
);
9406 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
9409 /* Look for a class template declaration. We look for hidden names
9410 because two friend declarations of the same template are the
9411 same. For example, in:
9414 template <typename> friend class F;
9416 template <typename> struct B {
9417 template <typename> friend class F;
9420 both F templates are the same. */
9421 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
9422 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
9424 /* But, if we don't find one, it might be because we're in a
9425 situation like this:
9433 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
9434 for `S<int>', not the TEMPLATE_DECL. */
9435 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
9437 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
9438 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
9441 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
9443 /* The friend template has already been declared. Just
9444 check to see that the declarations match, and install any new
9445 default parameters. We must tsubst the default parameters,
9446 of course. We only need the innermost template parameters
9447 because that is all that redeclare_class_template will look
9449 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
9450 > TMPL_ARGS_DEPTH (args
))
9453 location_t saved_input_location
;
9454 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
9455 args
, tf_warning_or_error
);
9457 saved_input_location
= input_location
;
9458 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
9459 tree cons
= get_constraints (tmpl
);
9460 redeclare_class_template (TREE_TYPE (tmpl
), parms
, cons
);
9461 input_location
= saved_input_location
;
9465 friend_type
= TREE_TYPE (tmpl
);
9469 /* The friend template has not already been declared. In this
9470 case, the instantiation of the template class will cause the
9471 injection of this template into the global scope. */
9472 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
9473 if (tmpl
== error_mark_node
)
9474 return error_mark_node
;
9476 /* The new TMPL is not an instantiation of anything, so we
9477 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
9478 the new type because that is supposed to be the corresponding
9479 template decl, i.e., TMPL. */
9480 DECL_USE_TEMPLATE (tmpl
) = 0;
9481 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
9482 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
9483 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
9484 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
9486 /* Inject this template into the global scope. */
9487 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
9490 if (context
!= global_namespace
)
9492 if (TREE_CODE (context
) == NAMESPACE_DECL
)
9493 pop_nested_namespace (context
);
9495 pop_nested_class ();
9501 /* Returns zero if TYPE cannot be completed later due to circularity.
9502 Otherwise returns one. */
9505 can_complete_type_without_circularity (tree type
)
9507 if (type
== NULL_TREE
|| type
== error_mark_node
)
9509 else if (COMPLETE_TYPE_P (type
))
9511 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
9512 return can_complete_type_without_circularity (TREE_TYPE (type
));
9513 else if (CLASS_TYPE_P (type
)
9514 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
9520 static tree
tsubst_omp_clauses (tree
, bool, bool, tree
, tsubst_flags_t
, tree
);
9522 /* Apply any attributes which had to be deferred until instantiation
9523 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
9524 ARGS, COMPLAIN, IN_DECL are as tsubst. */
9527 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
9528 tree args
, tsubst_flags_t complain
, tree in_decl
)
9530 tree last_dep
= NULL_TREE
;
9534 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
9535 if (ATTR_IS_DEPENDENT (t
))
9538 attributes
= copy_list (attributes
);
9542 if (DECL_P (*decl_p
))
9544 if (TREE_TYPE (*decl_p
) == error_mark_node
)
9546 p
= &DECL_ATTRIBUTES (*decl_p
);
9549 p
= &TYPE_ATTRIBUTES (*decl_p
);
9553 tree late_attrs
= NULL_TREE
;
9554 tree
*q
= &late_attrs
;
9556 for (*p
= attributes
; *p
; )
9559 if (ATTR_IS_DEPENDENT (t
))
9561 *p
= TREE_CHAIN (t
);
9562 TREE_CHAIN (t
) = NULL_TREE
;
9563 if ((flag_openmp
|| flag_openmp_simd
|| flag_cilkplus
)
9564 && is_attribute_p ("omp declare simd",
9565 get_attribute_name (t
))
9568 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
9569 clauses
= tsubst_omp_clauses (clauses
, true, false, args
,
9571 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
9572 clauses
= finish_omp_clauses (clauses
, false, true);
9573 tree parms
= DECL_ARGUMENTS (*decl_p
);
9575 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
9577 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
9579 TREE_VALUE (t
) = NULL_TREE
;
9581 /* If the first attribute argument is an identifier, don't
9582 pass it through tsubst. Attributes like mode, format,
9583 cleanup and several target specific attributes expect it
9585 else if (attribute_takes_identifier_p (get_attribute_name (t
))
9589 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
9591 /*integral_constant_expression_p=*/false);
9592 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
9594 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
9597 else if (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
)))
9599 /* An attribute pack expansion. */
9600 tree purp
= TREE_PURPOSE (t
);
9601 tree pack
= (tsubst_pack_expansion
9602 (TREE_VALUE (t
), args
, complain
, in_decl
));
9603 int len
= TREE_VEC_LENGTH (pack
);
9604 for (int i
= 0; i
< len
; ++i
)
9606 tree elt
= TREE_VEC_ELT (pack
, i
);
9607 *q
= build_tree_list (purp
, elt
);
9608 q
= &TREE_CHAIN (*q
);
9614 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
9615 /*integral_constant_expression_p=*/false);
9617 q
= &TREE_CHAIN (t
);
9620 p
= &TREE_CHAIN (t
);
9623 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
9627 /* Perform (or defer) access check for typedefs that were referenced
9628 from within the template TMPL code.
9629 This is a subroutine of instantiate_decl and instantiate_class_template.
9630 TMPL is the template to consider and TARGS is the list of arguments of
9634 perform_typedefs_access_check (tree tmpl
, tree targs
)
9636 location_t saved_location
;
9638 qualified_typedef_usage_t
*iter
;
9641 || (!CLASS_TYPE_P (tmpl
)
9642 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
9645 saved_location
= input_location
;
9646 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
9648 tree type_decl
= iter
->typedef_decl
;
9649 tree type_scope
= iter
->context
;
9651 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
9654 if (uses_template_parms (type_decl
))
9655 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
9656 if (uses_template_parms (type_scope
))
9657 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
9659 /* Make access check error messages point to the location
9660 of the use of the typedef. */
9661 input_location
= iter
->locus
;
9662 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
9663 type_decl
, type_decl
,
9664 tf_warning_or_error
);
9666 input_location
= saved_location
;
9670 instantiate_class_template_1 (tree type
)
9672 tree templ
, args
, pattern
, t
, member
;
9676 unsigned int saved_maximum_field_alignment
;
9679 if (type
== error_mark_node
)
9680 return error_mark_node
;
9682 if (COMPLETE_OR_OPEN_TYPE_P (type
)
9683 || uses_template_parms (type
))
9686 /* Figure out which template is being instantiated. */
9687 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
9688 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
9690 /* Determine what specialization of the original template to
9692 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
9693 if (t
== error_mark_node
)
9695 TYPE_BEING_DEFINED (type
) = 1;
9696 return error_mark_node
;
9700 /* This TYPE is actually an instantiation of a partial
9701 specialization. We replace the innermost set of ARGS with
9702 the arguments appropriate for substitution. For example,
9705 template <class T> struct S {};
9706 template <class T> struct S<T*> {};
9708 and supposing that we are instantiating S<int*>, ARGS will
9709 presently be {int*} -- but we need {int}. */
9710 pattern
= TREE_TYPE (t
);
9711 args
= TREE_PURPOSE (t
);
9715 pattern
= TREE_TYPE (templ
);
9716 args
= CLASSTYPE_TI_ARGS (type
);
9719 /* If the template we're instantiating is incomplete, then clearly
9720 there's nothing we can do. */
9721 if (!COMPLETE_TYPE_P (pattern
))
9724 /* If we've recursively instantiated too many templates, stop. */
9725 if (! push_tinst_level (type
))
9728 /* Now we're really doing the instantiation. Mark the type as in
9729 the process of being defined. */
9730 TYPE_BEING_DEFINED (type
) = 1;
9732 /* We may be in the middle of deferred access check. Disable
9734 push_deferring_access_checks (dk_no_deferred
);
9736 int saved_unevaluated_operand
= cp_unevaluated_operand
;
9737 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
9739 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
9740 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9741 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
9742 fn_context
= error_mark_node
;
9744 push_to_top_level ();
9747 cp_unevaluated_operand
= 0;
9748 c_inhibit_evaluation_warnings
= 0;
9750 /* Use #pragma pack from the template context. */
9751 saved_maximum_field_alignment
= maximum_field_alignment
;
9752 maximum_field_alignment
= TYPE_PRECISION (pattern
);
9754 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
9756 /* Set the input location to the most specialized template definition.
9757 This is needed if tsubsting causes an error. */
9758 typedecl
= TYPE_MAIN_DECL (pattern
);
9759 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
9760 DECL_SOURCE_LOCATION (typedecl
);
9762 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
9763 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
9764 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
9765 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
9766 if (ANON_AGGR_TYPE_P (pattern
))
9767 SET_ANON_AGGR_TYPE_P (type
);
9768 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
9770 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
9771 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
9772 /* Adjust visibility for template arguments. */
9773 determine_visibility (TYPE_MAIN_DECL (type
));
9775 if (CLASS_TYPE_P (type
))
9776 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
9778 pbinfo
= TYPE_BINFO (pattern
);
9780 /* We should never instantiate a nested class before its enclosing
9781 class; we need to look up the nested class by name before we can
9782 instantiate it, and that lookup should instantiate the enclosing
9784 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
9785 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
9787 base_list
= NULL_TREE
;
9788 if (BINFO_N_BASE_BINFOS (pbinfo
))
9794 /* We must enter the scope containing the type, as that is where
9795 the accessibility of types named in dependent bases are
9797 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9799 /* Substitute into each of the bases to determine the actual
9801 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9804 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9805 tree expanded_bases
= NULL_TREE
;
9808 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9811 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9812 args
, tf_error
, NULL_TREE
);
9813 if (expanded_bases
== error_mark_node
)
9816 len
= TREE_VEC_LENGTH (expanded_bases
);
9819 for (idx
= 0; idx
< len
; idx
++)
9822 /* Extract the already-expanded base class. */
9823 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9825 /* Substitute to figure out the base class. */
9826 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9829 if (base
== error_mark_node
)
9832 base_list
= tree_cons (access
, base
, base_list
);
9833 if (BINFO_VIRTUAL_P (pbase_binfo
))
9834 TREE_TYPE (base_list
) = integer_type_node
;
9838 /* The list is now in reverse order; correct that. */
9839 base_list
= nreverse (base_list
);
9842 pop_scope (pushed_scope
);
9844 /* Now call xref_basetypes to set up all the base-class
9846 xref_basetypes (type
, base_list
);
9848 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9849 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9850 args
, tf_error
, NULL_TREE
);
9851 fixup_attribute_variants (type
);
9853 /* Now that our base classes are set up, enter the scope of the
9854 class, so that name lookups into base classes, etc. will work
9855 correctly. This is precisely analogous to what we do in
9856 begin_class_definition when defining an ordinary non-template
9857 class, except we also need to push the enclosing classes. */
9858 push_nested_class (type
);
9860 /* Now members are processed in the order of declaration. */
9861 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9862 member
; member
= TREE_CHAIN (member
))
9864 tree t
= TREE_VALUE (member
);
9866 if (TREE_PURPOSE (member
))
9870 /* Build new CLASSTYPE_NESTED_UTDS. */
9873 bool class_template_p
;
9875 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9876 && TYPE_LANG_SPECIFIC (t
)
9877 && CLASSTYPE_IS_TEMPLATE (t
));
9878 /* If the member is a class template, then -- even after
9879 substitution -- there may be dependent types in the
9880 template argument list for the class. We increment
9881 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9882 that function will assume that no types are dependent
9883 when outside of a template. */
9884 if (class_template_p
)
9885 ++processing_template_decl
;
9886 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9887 if (class_template_p
)
9888 --processing_template_decl
;
9889 if (newtag
== error_mark_node
)
9892 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9894 tree name
= TYPE_IDENTIFIER (t
);
9896 if (class_template_p
)
9897 /* Unfortunately, lookup_template_class sets
9898 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9899 instantiation (i.e., for the type of a member
9900 template class nested within a template class.)
9901 This behavior is required for
9902 maybe_process_partial_specialization to work
9903 correctly, but is not accurate in this case;
9904 the TAG is not an instantiation of anything.
9905 (The corresponding TEMPLATE_DECL is an
9906 instantiation, but the TYPE is not.) */
9907 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9909 /* Now, we call pushtag to put this NEWTAG into the scope of
9910 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9911 pushtag calling push_template_decl. We don't have to do
9912 this for enums because it will already have been done in
9915 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9916 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9919 else if (DECL_DECLARES_FUNCTION_P (t
))
9921 /* Build new TYPE_METHODS. */
9924 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9925 ++processing_template_decl
;
9926 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9927 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9928 --processing_template_decl
;
9929 set_current_access_from_decl (r
);
9930 finish_member_declaration (r
);
9931 /* Instantiate members marked with attribute used. */
9932 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9934 if (TREE_CODE (r
) == FUNCTION_DECL
9935 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9936 cp_check_omp_declare_reduction (r
);
9938 else if (DECL_CLASS_TEMPLATE_P (t
)
9939 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
9940 /* A closure type for a lambda in a default argument for a
9941 member template. Ignore it; it will be instantiated with
9942 the default argument. */;
9945 /* Build new TYPE_FIELDS. */
9946 if (TREE_CODE (t
) == STATIC_ASSERT
)
9950 ++c_inhibit_evaluation_warnings
;
9952 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9953 tf_warning_or_error
, NULL_TREE
,
9954 /*integral_constant_expression_p=*/true);
9955 --c_inhibit_evaluation_warnings
;
9957 finish_static_assert (condition
,
9958 STATIC_ASSERT_MESSAGE (t
),
9959 STATIC_ASSERT_SOURCE_LOCATION (t
),
9962 else if (TREE_CODE (t
) != CONST_DECL
)
9965 tree vec
= NULL_TREE
;
9968 /* The file and line for this declaration, to
9969 assist in error message reporting. Since we
9970 called push_tinst_level above, we don't need to
9972 input_location
= DECL_SOURCE_LOCATION (t
);
9974 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9975 ++processing_template_decl
;
9976 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9977 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9978 --processing_template_decl
;
9980 if (TREE_CODE (r
) == TREE_VEC
)
9982 /* A capture pack became multiple fields. */
9984 len
= TREE_VEC_LENGTH (vec
);
9987 for (int i
= 0; i
< len
; ++i
)
9990 r
= TREE_VEC_ELT (vec
, i
);
9995 [t]he initialization (and any associated
9996 side-effects) of a static data member does
9997 not occur unless the static data member is
9998 itself used in a way that requires the
9999 definition of the static data member to
10002 Therefore, we do not substitute into the
10003 initialized for the static data member here. */
10004 finish_static_data_member_decl
10006 /*init=*/NULL_TREE
,
10007 /*init_const_expr_p=*/false,
10008 /*asmspec_tree=*/NULL_TREE
,
10010 /* Instantiate members marked with attribute used. */
10011 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
10014 else if (TREE_CODE (r
) == FIELD_DECL
)
10016 /* Determine whether R has a valid type and can be
10017 completed later. If R is invalid, then its type
10018 is replaced by error_mark_node. */
10019 tree rtype
= TREE_TYPE (r
);
10020 if (can_complete_type_without_circularity (rtype
))
10021 complete_type (rtype
);
10023 if (!COMPLETE_TYPE_P (rtype
))
10025 cxx_incomplete_type_error (r
, rtype
);
10026 TREE_TYPE (r
) = error_mark_node
;
10030 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
10031 such a thing will already have been added to the field
10032 list by tsubst_enum in finish_member_declaration in the
10033 CLASSTYPE_NESTED_UTDS case above. */
10034 if (!(TREE_CODE (r
) == TYPE_DECL
10035 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
10036 && DECL_ARTIFICIAL (r
)))
10038 set_current_access_from_decl (r
);
10039 finish_member_declaration (r
);
10047 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
10048 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10050 /* Build new CLASSTYPE_FRIEND_CLASSES. */
10052 tree friend_type
= t
;
10053 bool adjust_processing_template_decl
= false;
10055 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
10057 /* template <class T> friend class C; */
10058 friend_type
= tsubst_friend_class (friend_type
, args
);
10059 adjust_processing_template_decl
= true;
10061 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
10063 /* template <class T> friend class C::D; */
10064 friend_type
= tsubst (friend_type
, args
,
10065 tf_warning_or_error
, NULL_TREE
);
10066 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
10067 friend_type
= TREE_TYPE (friend_type
);
10068 adjust_processing_template_decl
= true;
10070 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
10071 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
10073 /* This could be either
10077 when dependent_type_p is false or
10079 template <class U> friend class T::C;
10082 friend_type
= tsubst (friend_type
, args
,
10083 tf_warning_or_error
, NULL_TREE
);
10084 /* Bump processing_template_decl for correct
10085 dependent_type_p calculation. */
10086 ++processing_template_decl
;
10087 if (dependent_type_p (friend_type
))
10088 adjust_processing_template_decl
= true;
10089 --processing_template_decl
;
10091 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
10092 && hidden_name_p (TYPE_NAME (friend_type
)))
10096 where C hasn't been declared yet. Let's lookup name
10097 from namespace scope directly, bypassing any name that
10098 come from dependent base class. */
10099 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
10101 /* The call to xref_tag_from_type does injection for friend
10103 push_nested_namespace (ns
);
10105 xref_tag_from_type (friend_type
, NULL_TREE
,
10106 /*tag_scope=*/ts_current
);
10107 pop_nested_namespace (ns
);
10109 else if (uses_template_parms (friend_type
))
10110 /* friend class C<T>; */
10111 friend_type
= tsubst (friend_type
, args
,
10112 tf_warning_or_error
, NULL_TREE
);
10117 where C is already declared or
10119 friend class C<int>;
10121 We don't have to do anything in these cases. */
10123 if (adjust_processing_template_decl
)
10124 /* Trick make_friend_class into realizing that the friend
10125 we're adding is a template, not an ordinary class. It's
10126 important that we use make_friend_class since it will
10127 perform some error-checking and output cross-reference
10129 ++processing_template_decl
;
10131 if (friend_type
!= error_mark_node
)
10132 make_friend_class (type
, friend_type
, /*complain=*/false);
10134 if (adjust_processing_template_decl
)
10135 --processing_template_decl
;
10139 /* Build new DECL_FRIENDLIST. */
10142 /* The file and line for this declaration, to
10143 assist in error message reporting. Since we
10144 called push_tinst_level above, we don't need to
10146 input_location
= DECL_SOURCE_LOCATION (t
);
10148 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10150 ++processing_template_decl
;
10151 push_deferring_access_checks (dk_no_check
);
10154 r
= tsubst_friend_function (t
, args
);
10155 add_friend (type
, r
, /*complain=*/false);
10156 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10158 pop_deferring_access_checks ();
10159 --processing_template_decl
;
10167 /* Restore these before substituting into the lambda capture
10169 cp_unevaluated_operand
= saved_unevaluated_operand
;
10170 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10173 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
10175 tree decl
= lambda_function (type
);
10178 if (!DECL_TEMPLATE_INFO (decl
)
10179 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
10181 /* Set function_depth to avoid garbage collection. */
10183 instantiate_decl (decl
, false, false);
10187 /* We need to instantiate the capture list from the template
10188 after we've instantiated the closure members, but before we
10189 consider adding the conversion op. Also keep any captures
10190 that may have been added during instantiation of the op(). */
10191 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
10193 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
10194 args
, tf_warning_or_error
, NULL_TREE
,
10197 LAMBDA_EXPR_CAPTURE_LIST (expr
)
10198 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
10200 maybe_add_lambda_conv_op (type
);
10203 gcc_assert (errorcount
);
10206 /* Set the file and line number information to whatever is given for
10207 the class itself. This puts error messages involving generated
10208 implicit functions at a predictable point, and the same point
10209 that would be used for non-template classes. */
10210 input_location
= DECL_SOURCE_LOCATION (typedecl
);
10212 unreverse_member_declarations (type
);
10213 finish_struct_1 (type
);
10214 TYPE_BEING_DEFINED (type
) = 0;
10216 /* We don't instantiate default arguments for member functions. 14.7.1:
10218 The implicit instantiation of a class template specialization causes
10219 the implicit instantiation of the declarations, but not of the
10220 definitions or default arguments, of the class member functions,
10221 member classes, static data members and member templates.... */
10223 /* Some typedefs referenced from within the template code need to be access
10224 checked at template instantiation time, i.e now. These types were
10225 added to the template at parsing time. Let's get those and perform
10226 the access checks then. */
10227 perform_typedefs_access_check (pattern
, args
);
10228 perform_deferred_access_checks (tf_warning_or_error
);
10229 pop_nested_class ();
10230 maximum_field_alignment
= saved_maximum_field_alignment
;
10232 pop_from_top_level ();
10233 pop_deferring_access_checks ();
10234 pop_tinst_level ();
10236 /* The vtable for a template class can be emitted in any translation
10237 unit in which the class is instantiated. When there is no key
10238 method, however, finish_struct_1 will already have added TYPE to
10239 the keyed_classes list. */
10240 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
10241 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
10246 /* Wrapper for instantiate_class_template_1. */
10249 instantiate_class_template (tree type
)
10252 timevar_push (TV_TEMPLATE_INST
);
10253 ret
= instantiate_class_template_1 (type
);
10254 timevar_pop (TV_TEMPLATE_INST
);
10259 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10265 else if (TYPE_P (t
))
10266 r
= tsubst (t
, args
, complain
, in_decl
);
10269 if (!(complain
& tf_warning
))
10270 ++c_inhibit_evaluation_warnings
;
10271 r
= tsubst_expr (t
, args
, complain
, in_decl
,
10272 /*integral_constant_expression_p=*/true);
10273 if (!(complain
& tf_warning
))
10274 --c_inhibit_evaluation_warnings
;
10279 /* Given a function parameter pack TMPL_PARM and some function parameters
10280 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
10281 and set *SPEC_P to point at the next point in the list. */
10284 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
10286 /* Collect all of the extra "packed" parameters into an
10290 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
10291 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
10292 tree spec_parm
= *spec_p
;
10295 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
10297 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
10300 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
10301 parmvec
= make_tree_vec (len
);
10302 parmtypevec
= make_tree_vec (len
);
10303 spec_parm
= *spec_p
;
10304 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
10306 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
10307 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
10310 /* Build the argument packs. */
10311 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
10312 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
10313 TREE_TYPE (argpack
) = argtypepack
;
10314 *spec_p
= spec_parm
;
10319 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
10320 NONTYPE_ARGUMENT_PACK. */
10323 make_fnparm_pack (tree spec_parm
)
10325 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
10328 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
10329 pack expansion with no extra args, 2 if it has extra args, or 0
10330 if it is not a pack expansion. */
10333 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
10335 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
10336 if (i
>= TREE_VEC_LENGTH (vec
))
10338 tree elt
= TREE_VEC_ELT (vec
, i
);
10340 /* A decl pack is itself an expansion. */
10341 elt
= TREE_TYPE (elt
);
10342 if (!PACK_EXPANSION_P (elt
))
10344 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
10350 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
10353 make_argument_pack_select (tree arg_pack
, unsigned index
)
10355 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
10357 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
10358 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
10363 /* This is a subroutine of tsubst_pack_expansion.
10365 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
10366 mechanism to store the (non complete list of) arguments of the
10367 substitution and return a non substituted pack expansion, in order
10368 to wait for when we have enough arguments to really perform the
10372 use_pack_expansion_extra_args_p (tree parm_packs
,
10374 bool has_empty_arg
)
10376 /* If one pack has an expansion and another pack has a normal
10377 argument or if one pack has an empty argument and an another
10378 one hasn't then tsubst_pack_expansion cannot perform the
10379 substitution and need to fall back on the
10380 PACK_EXPANSION_EXTRA mechanism. */
10381 if (parm_packs
== NULL_TREE
)
10383 else if (has_empty_arg
)
10386 bool has_expansion_arg
= false;
10387 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
10389 bool has_non_expansion_arg
= false;
10390 for (tree parm_pack
= parm_packs
;
10392 parm_pack
= TREE_CHAIN (parm_pack
))
10394 tree arg
= TREE_VALUE (parm_pack
);
10396 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
10398 /* We can't substitute a pack expansion with extra args into
10402 has_expansion_arg
= true;
10404 has_non_expansion_arg
= true;
10407 if (has_expansion_arg
&& has_non_expansion_arg
)
10413 /* [temp.variadic]/6 says that:
10415 The instantiation of a pack expansion [...]
10416 produces a list E1,E2, ..., En, where N is the number of elements
10417 in the pack expansion parameters.
10419 This subroutine of tsubst_pack_expansion produces one of these Ei.
10421 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
10422 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
10423 PATTERN, and each TREE_VALUE is its corresponding argument pack.
10424 INDEX is the index 'i' of the element Ei to produce. ARGS,
10425 COMPLAIN, and IN_DECL are the same parameters as for the
10426 tsubst_pack_expansion function.
10428 The function returns the resulting Ei upon successful completion,
10429 or error_mark_node.
10431 Note that this function possibly modifies the ARGS parameter, so
10432 it's the responsibility of the caller to restore it. */
10435 gen_elem_of_pack_expansion_instantiation (tree pattern
,
10438 tree args
/* This parm gets
10440 tsubst_flags_t complain
,
10444 bool ith_elem_is_expansion
= false;
10446 /* For each parameter pack, change the substitution of the parameter
10447 pack to the ith argument in its argument pack, then expand the
10449 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
10451 tree parm
= TREE_PURPOSE (pack
);
10452 tree arg_pack
= TREE_VALUE (pack
);
10453 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
10455 ith_elem_is_expansion
|=
10456 argument_pack_element_is_expansion_p (arg_pack
, index
);
10458 /* Select the Ith argument from the pack. */
10459 if (TREE_CODE (parm
) == PARM_DECL
10460 || TREE_CODE (parm
) == FIELD_DECL
)
10464 aps
= make_argument_pack_select (arg_pack
, index
);
10465 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
10466 return error_mark_node
;
10467 register_local_specialization (aps
, parm
);
10470 aps
= retrieve_local_specialization (parm
);
10475 template_parm_level_and_index (parm
, &level
, &idx
);
10479 aps
= make_argument_pack_select (arg_pack
, index
);
10480 /* Update the corresponding argument. */
10481 TMPL_ARG (args
, level
, idx
) = aps
;
10484 /* Re-use the ARGUMENT_PACK_SELECT. */
10485 aps
= TMPL_ARG (args
, level
, idx
);
10487 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
10490 /* Substitute into the PATTERN with the (possibly altered)
10492 if (pattern
== in_decl
)
10493 /* Expanding a fixed parameter pack from
10494 coerce_template_parameter_pack. */
10495 t
= tsubst_decl (pattern
, args
, complain
);
10496 else if (pattern
== error_mark_node
)
10497 t
= error_mark_node
;
10498 else if (constraint_p (pattern
))
10500 if (processing_template_decl
)
10501 t
= tsubst_constraint (pattern
, args
, complain
, in_decl
);
10503 t
= (constraints_satisfied_p (pattern
, args
)
10504 ? boolean_true_node
: boolean_false_node
);
10506 else if (!TYPE_P (pattern
))
10507 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
10508 /*integral_constant_expression_p=*/false);
10510 t
= tsubst (pattern
, args
, complain
, in_decl
);
10512 /* If the Ith argument pack element is a pack expansion, then
10513 the Ith element resulting from the substituting is going to
10514 be a pack expansion as well. */
10515 if (ith_elem_is_expansion
)
10516 t
= make_pack_expansion (t
);
10521 /* When the unexpanded parameter pack in a fold expression expands to an empty
10522 sequence, the value of the expression is as follows; the program is
10523 ill-formed if the operator is not listed in this table.
10534 expand_empty_fold (tree t
, tsubst_flags_t complain
)
10536 tree_code code
= (tree_code
)TREE_INT_CST_LOW (TREE_OPERAND (t
, 0));
10537 if (!FOLD_EXPR_MODIFY_P (t
))
10541 return integer_one_node
;
10543 return integer_zero_node
;
10545 return integer_minus_one_node
;
10547 return integer_zero_node
;
10548 case TRUTH_ANDIF_EXPR
:
10549 return boolean_true_node
;
10550 case TRUTH_ORIF_EXPR
:
10551 return boolean_false_node
;
10552 case COMPOUND_EXPR
:
10558 if (complain
& tf_error
)
10559 error_at (location_of (t
),
10560 "fold of empty expansion over %O", code
);
10561 return error_mark_node
;
10564 /* Given a fold-expression T and a current LEFT and RIGHT operand,
10565 form an expression that combines the two terms using the
10569 fold_expression (tree t
, tree left
, tree right
, tsubst_flags_t complain
)
10571 tree op
= FOLD_EXPR_OP (t
);
10572 tree_code code
= (tree_code
)TREE_INT_CST_LOW (op
);
10574 // Handle compound assignment operators.
10575 if (FOLD_EXPR_MODIFY_P (t
))
10576 return build_x_modify_expr (input_location
, left
, code
, right
, complain
);
10580 case COMPOUND_EXPR
:
10581 return build_x_compound_expr (input_location
, left
, right
, complain
);
10583 return build_m_component_ref (left
, right
, complain
);
10585 return build_x_binary_op (input_location
, code
,
10586 left
, TREE_CODE (left
),
10587 right
, TREE_CODE (right
),
10593 /* Substitute ARGS into the pack of a fold expression T. */
10596 tsubst_fold_expr_pack (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10598 return tsubst_pack_expansion (FOLD_EXPR_PACK (t
), args
, complain
, in_decl
);
10601 /* Substitute ARGS into the pack of a fold expression T. */
10604 tsubst_fold_expr_init (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10606 return tsubst_expr (FOLD_EXPR_INIT (t
), args
, complain
, in_decl
, false);
10609 /* Expand a PACK of arguments into a grouped as left fold.
10610 Given a pack containing elements A0, A1, ..., An and an
10611 operator @, this builds the expression:
10613 ((A0 @ A1) @ A2) ... @ An
10615 Note that PACK must not be empty.
10617 The operator is defined by the original fold expression T. */
10620 expand_left_fold (tree t
, tree pack
, tsubst_flags_t complain
)
10622 tree left
= TREE_VEC_ELT (pack
, 0);
10623 for (int i
= 1; i
< TREE_VEC_LENGTH (pack
); ++i
)
10625 tree right
= TREE_VEC_ELT (pack
, i
);
10626 left
= fold_expression (t
, left
, right
, complain
);
10631 /* Substitute into a unary left fold expression. */
10634 tsubst_unary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
10637 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
10638 if (pack
== error_mark_node
)
10639 return error_mark_node
;
10640 if (TREE_VEC_LENGTH (pack
) == 0)
10641 return expand_empty_fold (t
, complain
);
10643 return expand_left_fold (t
, pack
, complain
);
10646 /* Substitute into a binary left fold expression.
10648 Do ths by building a single (non-empty) vector of argumnts and
10649 building the expression from those elements. */
10652 tsubst_binary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
10655 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
10656 if (pack
== error_mark_node
)
10657 return error_mark_node
;
10658 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
10659 if (init
== error_mark_node
)
10660 return error_mark_node
;
10662 tree vec
= make_tree_vec (TREE_VEC_LENGTH (pack
) + 1);
10663 TREE_VEC_ELT (vec
, 0) = init
;
10664 for (int i
= 0; i
< TREE_VEC_LENGTH (pack
); ++i
)
10665 TREE_VEC_ELT (vec
, i
+ 1) = TREE_VEC_ELT (pack
, i
);
10667 return expand_left_fold (t
, vec
, complain
);
10670 /* Expand a PACK of arguments into a grouped as right fold.
10671 Given a pack containing elementns A0, A1, ..., and an
10672 operator @, this builds the expression:
10674 A0@ ... (An-2 @ (An-1 @ An))
10676 Note that PACK must not be empty.
10678 The operator is defined by the original fold expression T. */
10681 expand_right_fold (tree t
, tree pack
, tsubst_flags_t complain
)
10683 // Build the expression.
10684 int n
= TREE_VEC_LENGTH (pack
);
10685 tree right
= TREE_VEC_ELT (pack
, n
- 1);
10686 for (--n
; n
!= 0; --n
)
10688 tree left
= TREE_VEC_ELT (pack
, n
- 1);
10689 right
= fold_expression (t
, left
, right
, complain
);
10694 /* Substitute into a unary right fold expression. */
10697 tsubst_unary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
10700 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
10701 if (pack
== error_mark_node
)
10702 return error_mark_node
;
10703 if (TREE_VEC_LENGTH (pack
) == 0)
10704 return expand_empty_fold (t
, complain
);
10706 return expand_right_fold (t
, pack
, complain
);
10709 /* Substitute into a binary right fold expression.
10711 Do ths by building a single (non-empty) vector of arguments and
10712 building the expression from those elements. */
10715 tsubst_binary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
10718 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
10719 if (pack
== error_mark_node
)
10720 return error_mark_node
;
10721 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
10722 if (init
== error_mark_node
)
10723 return error_mark_node
;
10725 int n
= TREE_VEC_LENGTH (pack
);
10726 tree vec
= make_tree_vec (n
+ 1);
10727 for (int i
= 0; i
< n
; ++i
)
10728 TREE_VEC_ELT (vec
, i
) = TREE_VEC_ELT (pack
, i
);
10729 TREE_VEC_ELT (vec
, n
) = init
;
10731 return expand_right_fold (t
, vec
, complain
);
10735 /* Substitute ARGS into T, which is an pack expansion
10736 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
10737 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
10738 (if only a partial substitution could be performed) or
10739 ERROR_MARK_NODE if there was an error. */
10741 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
10745 tree pack
, packs
= NULL_TREE
;
10746 bool unsubstituted_packs
= false;
10749 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
10750 bool need_local_specializations
= false;
10753 gcc_assert (PACK_EXPANSION_P (t
));
10754 pattern
= PACK_EXPANSION_PATTERN (t
);
10756 /* Add in any args remembered from an earlier partial instantiation. */
10757 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
10759 levels
= TMPL_ARGS_DEPTH (args
);
10761 /* Determine the argument packs that will instantiate the parameter
10762 packs used in the expansion expression. While we're at it,
10763 compute the number of arguments to be expanded and make sure it
10765 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
10766 pack
= TREE_CHAIN (pack
))
10768 tree parm_pack
= TREE_VALUE (pack
);
10769 tree arg_pack
= NULL_TREE
;
10770 tree orig_arg
= NULL_TREE
;
10773 if (TREE_CODE (parm_pack
) == BASES
)
10775 if (BASES_DIRECT (parm_pack
))
10776 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
10777 args
, complain
, in_decl
, false));
10779 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
10780 args
, complain
, in_decl
, false));
10782 if (TREE_CODE (parm_pack
) == PARM_DECL
)
10784 /* We know we have correct local_specializations if this
10785 expansion is at function scope, or if we're dealing with a
10786 local parameter in a requires expression; for the latter,
10787 tsubst_requires_expr set it up appropriately. */
10788 if (PACK_EXPANSION_LOCAL_P (t
) || CONSTRAINT_VAR_P (parm_pack
))
10789 arg_pack
= retrieve_local_specialization (parm_pack
);
10792 /* We can't rely on local_specializations for a parameter
10793 name used later in a function declaration (such as in a
10794 late-specified return type). Even if it exists, it might
10795 have the wrong value for a recursive call. Just make a
10796 dummy decl, since it's only used for its type. */
10797 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
10798 if (arg_pack
&& DECL_PACK_P (arg_pack
))
10799 /* Partial instantiation of the parm_pack, we can't build
10800 up an argument pack yet. */
10801 arg_pack
= NULL_TREE
;
10803 arg_pack
= make_fnparm_pack (arg_pack
);
10804 need_local_specializations
= true;
10807 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
10808 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
10812 template_parm_level_and_index (parm_pack
, &level
, &idx
);
10814 if (level
<= levels
)
10815 arg_pack
= TMPL_ARG (args
, level
, idx
);
10818 orig_arg
= arg_pack
;
10819 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
10820 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
10822 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
10823 /* This can only happen if we forget to expand an argument
10824 pack somewhere else. Just return an error, silently. */
10826 result
= make_tree_vec (1);
10827 TREE_VEC_ELT (result
, 0) = error_mark_node
;
10834 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
10836 /* Don't bother trying to do a partial substitution with
10837 incomplete packs; we'll try again after deduction. */
10838 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
10843 else if (len
!= my_len
)
10845 if (!(complain
& tf_error
))
10846 /* Fail quietly. */;
10847 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
10848 error ("mismatched argument pack lengths while expanding "
10852 error ("mismatched argument pack lengths while expanding "
10855 return error_mark_node
;
10858 /* Keep track of the parameter packs and their corresponding
10860 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
10861 TREE_TYPE (packs
) = orig_arg
;
10865 /* We can't substitute for this parameter pack. We use a flag as
10866 well as the missing_level counter because function parameter
10867 packs don't have a level. */
10868 unsubstituted_packs
= true;
10872 /* If the expansion is just T..., return the matching argument pack, unless
10873 we need to call convert_from_reference on all the elements. This is an
10874 important optimization; see c++/68422. */
10875 if (!unsubstituted_packs
10876 && TREE_PURPOSE (packs
) == pattern
)
10878 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
10879 /* Types need no adjustment, nor does sizeof..., and if we still have
10880 some pack expansion args we won't do anything yet. */
10881 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
10882 || PACK_EXPANSION_SIZEOF_P (t
)
10883 || pack_expansion_args_count (args
))
10885 /* Also optimize expression pack expansions if we can tell that the
10886 elements won't have reference type. */
10887 tree type
= TREE_TYPE (pattern
);
10888 if (type
&& TREE_CODE (type
) != REFERENCE_TYPE
10889 && !PACK_EXPANSION_P (type
)
10890 && !WILDCARD_TYPE_P (type
))
10892 /* Otherwise use the normal path so we get convert_from_reference. */
10895 /* We cannot expand this expansion expression, because we don't have
10896 all of the argument packs we need. */
10897 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
10899 /* We got some full packs, but we can't substitute them in until we
10900 have values for all the packs. So remember these until then. */
10902 t
= make_pack_expansion (pattern
);
10903 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
10906 else if (unsubstituted_packs
)
10908 /* There were no real arguments, we're just replacing a parameter
10909 pack with another version of itself. Substitute into the
10910 pattern and return a PACK_EXPANSION_*. The caller will need to
10912 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
10913 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
10914 /*integral_constant_expression_p=*/false);
10916 t
= tsubst (pattern
, args
, complain
, in_decl
);
10917 t
= make_pack_expansion (t
);
10921 gcc_assert (len
>= 0);
10923 if (need_local_specializations
)
10925 /* We're in a late-specified return type, so create our own local
10926 specializations map; the current map is either NULL or (in the
10927 case of recursive unification) might have bindings that we don't
10928 want to use or alter. */
10929 saved_local_specializations
= local_specializations
;
10930 local_specializations
= new hash_map
<tree
, tree
>;
10933 /* For each argument in each argument pack, substitute into the
10935 result
= make_tree_vec (len
);
10936 for (i
= 0; i
< len
; ++i
)
10938 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
10942 TREE_VEC_ELT (result
, i
) = t
;
10943 if (t
== error_mark_node
)
10945 result
= error_mark_node
;
10950 /* Update ARGS to restore the substitution from parameter packs to
10951 their argument packs. */
10952 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
10954 tree parm
= TREE_PURPOSE (pack
);
10956 if (TREE_CODE (parm
) == PARM_DECL
10957 || TREE_CODE (parm
) == FIELD_DECL
)
10958 register_local_specialization (TREE_TYPE (pack
), parm
);
10963 if (TREE_VALUE (pack
) == NULL_TREE
)
10966 template_parm_level_and_index (parm
, &level
, &idx
);
10968 /* Update the corresponding argument. */
10969 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
10970 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
10973 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
10977 if (need_local_specializations
)
10979 delete local_specializations
;
10980 local_specializations
= saved_local_specializations
;
10986 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10987 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10988 parameter packs; all parms generated from a function parameter pack will
10989 have the same DECL_PARM_INDEX. */
10992 get_pattern_parm (tree parm
, tree tmpl
)
10994 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
10997 if (DECL_ARTIFICIAL (parm
))
10999 for (patparm
= DECL_ARGUMENTS (pattern
);
11000 patparm
; patparm
= DECL_CHAIN (patparm
))
11001 if (DECL_ARTIFICIAL (patparm
)
11002 && DECL_NAME (parm
) == DECL_NAME (patparm
))
11007 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
11008 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
11009 gcc_assert (DECL_PARM_INDEX (patparm
)
11010 == DECL_PARM_INDEX (parm
));
11016 /* Substitute ARGS into the vector or list of template arguments T. */
11019 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11022 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
11025 if (t
== error_mark_node
)
11026 return error_mark_node
;
11028 len
= TREE_VEC_LENGTH (t
);
11029 elts
= XALLOCAVEC (tree
, len
);
11031 for (i
= 0; i
< len
; i
++)
11033 tree orig_arg
= TREE_VEC_ELT (t
, i
);
11036 if (TREE_CODE (orig_arg
) == TREE_VEC
)
11037 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
11038 else if (PACK_EXPANSION_P (orig_arg
))
11040 /* Substitute into an expansion expression. */
11041 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
11043 if (TREE_CODE (new_arg
) == TREE_VEC
)
11044 /* Add to the expanded length adjustment the number of
11045 expanded arguments. We subtract one from this
11046 measurement, because the argument pack expression
11047 itself is already counted as 1 in
11048 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
11049 the argument pack is empty. */
11050 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
11052 else if (ARGUMENT_PACK_P (orig_arg
))
11054 /* Substitute into each of the arguments. */
11055 new_arg
= TYPE_P (orig_arg
)
11056 ? cxx_make_type (TREE_CODE (orig_arg
))
11057 : make_node (TREE_CODE (orig_arg
));
11059 SET_ARGUMENT_PACK_ARGS (
11061 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
11062 args
, complain
, in_decl
));
11064 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
11065 new_arg
= error_mark_node
;
11067 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
11068 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
11069 complain
, in_decl
);
11070 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
11072 if (TREE_TYPE (new_arg
) == error_mark_node
)
11073 new_arg
= error_mark_node
;
11077 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
11079 if (new_arg
== error_mark_node
)
11080 return error_mark_node
;
11083 if (new_arg
!= orig_arg
)
11090 /* Make space for the expanded arguments coming from template
11092 t
= make_tree_vec (len
+ expanded_len_adjust
);
11093 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
11094 arguments for a member template.
11095 In that case each TREE_VEC in ORIG_T represents a level of template
11096 arguments, and ORIG_T won't carry any non defaulted argument count.
11097 It will rather be the nested TREE_VECs that will carry one.
11098 In other words, ORIG_T carries a non defaulted argument count only
11099 if it doesn't contain any nested TREE_VEC. */
11100 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
11102 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
11103 count
+= expanded_len_adjust
;
11104 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
11106 for (i
= 0, out
= 0; i
< len
; i
++)
11108 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
11109 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
11110 && TREE_CODE (elts
[i
]) == TREE_VEC
)
11114 /* Now expand the template argument pack "in place". */
11115 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
11116 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
11120 TREE_VEC_ELT (t
, out
) = elts
[i
];
11128 /* Return the result of substituting ARGS into the template parameters
11129 given by PARMS. If there are m levels of ARGS and m + n levels of
11130 PARMS, then the result will contain n levels of PARMS. For
11131 example, if PARMS is `template <class T> template <class U>
11132 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
11133 result will be `template <int*, double, class V>'. */
11136 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
11138 tree r
= NULL_TREE
;
11141 /* When substituting into a template, we must set
11142 PROCESSING_TEMPLATE_DECL as the template parameters may be
11143 dependent if they are based on one-another, and the dependency
11144 predicates are short-circuit outside of templates. */
11145 ++processing_template_decl
;
11147 for (new_parms
= &r
;
11148 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
11149 new_parms
= &(TREE_CHAIN (*new_parms
)),
11150 parms
= TREE_CHAIN (parms
))
11153 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
11156 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
11160 if (parms
== error_mark_node
)
11163 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
11165 if (tuple
== error_mark_node
)
11168 TREE_VEC_ELT (new_vec
, i
) =
11169 tsubst_template_parm (tuple
, args
, complain
);
11173 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
11174 - TMPL_ARGS_DEPTH (args
)),
11175 new_vec
, NULL_TREE
);
11178 --processing_template_decl
;
11183 /* Return the result of substituting ARGS into one template parameter
11184 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
11185 parameter and which TREE_PURPOSE is the default argument of the
11186 template parameter. */
11189 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
11191 tree default_value
, parm_decl
;
11193 if (args
== NULL_TREE
11195 || t
== error_mark_node
)
11198 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
11200 default_value
= TREE_PURPOSE (t
);
11201 parm_decl
= TREE_VALUE (t
);
11203 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
11204 if (TREE_CODE (parm_decl
) == PARM_DECL
11205 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
11206 parm_decl
= error_mark_node
;
11207 default_value
= tsubst_template_arg (default_value
, args
,
11208 complain
, NULL_TREE
);
11210 return build_tree_list (default_value
, parm_decl
);
11213 /* Substitute the ARGS into the indicated aggregate (or enumeration)
11214 type T. If T is not an aggregate or enumeration type, it is
11215 handled as if by tsubst. IN_DECL is as for tsubst. If
11216 ENTERING_SCOPE is nonzero, T is the context for a template which
11217 we are presently tsubst'ing. Return the substituted value. */
11220 tsubst_aggr_type (tree t
,
11222 tsubst_flags_t complain
,
11224 int entering_scope
)
11226 if (t
== NULL_TREE
)
11229 switch (TREE_CODE (t
))
11232 if (TYPE_PTRMEMFUNC_P (t
))
11233 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
11235 /* Else fall through. */
11236 case ENUMERAL_TYPE
:
11238 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
11243 int saved_unevaluated_operand
;
11244 int saved_inhibit_evaluation_warnings
;
11246 /* In "sizeof(X<I>)" we need to evaluate "I". */
11247 saved_unevaluated_operand
= cp_unevaluated_operand
;
11248 cp_unevaluated_operand
= 0;
11249 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
11250 c_inhibit_evaluation_warnings
= 0;
11252 /* First, determine the context for the type we are looking
11254 context
= TYPE_CONTEXT (t
);
11255 if (context
&& TYPE_P (context
))
11257 context
= tsubst_aggr_type (context
, args
, complain
,
11258 in_decl
, /*entering_scope=*/1);
11259 /* If context is a nested class inside a class template,
11260 it may still need to be instantiated (c++/33959). */
11261 context
= complete_type (context
);
11264 /* Then, figure out what arguments are appropriate for the
11265 type we are trying to find. For example, given:
11267 template <class T> struct S;
11268 template <class T, class U> void f(T, U) { S<U> su; }
11270 and supposing that we are instantiating f<int, double>,
11271 then our ARGS will be {int, double}, but, when looking up
11272 S we only want {double}. */
11273 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
11274 complain
, in_decl
);
11275 if (argvec
== error_mark_node
)
11276 r
= error_mark_node
;
11279 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
11280 entering_scope
, complain
);
11281 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
11284 cp_unevaluated_operand
= saved_unevaluated_operand
;
11285 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
11290 /* This is not a template type, so there's nothing to do. */
11294 return tsubst (t
, args
, complain
, in_decl
);
11298 /* Substitute into the default argument ARG (a default argument for
11299 FN), which has the indicated TYPE. */
11302 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
11304 tree saved_class_ptr
= NULL_TREE
;
11305 tree saved_class_ref
= NULL_TREE
;
11306 int errs
= errorcount
+ sorrycount
;
11308 /* This can happen in invalid code. */
11309 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11312 /* This default argument came from a template. Instantiate the
11313 default argument here, not in tsubst. In the case of
11322 we must be careful to do name lookup in the scope of S<T>,
11323 rather than in the current class. */
11324 push_access_scope (fn
);
11325 /* The "this" pointer is not valid in a default argument. */
11328 saved_class_ptr
= current_class_ptr
;
11329 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
11330 saved_class_ref
= current_class_ref
;
11331 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
11334 push_deferring_access_checks(dk_no_deferred
);
11335 /* The default argument expression may cause implicitly defined
11336 member functions to be synthesized, which will result in garbage
11337 collection. We must treat this situation as if we were within
11338 the body of function so as to avoid collecting live data on the
11341 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
11342 complain
, NULL_TREE
,
11343 /*integral_constant_expression_p=*/false);
11345 pop_deferring_access_checks();
11347 /* Restore the "this" pointer. */
11350 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
11351 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
11354 if (errorcount
+sorrycount
> errs
11355 && (complain
& tf_warning_or_error
))
11356 inform (input_location
,
11357 " when instantiating default argument for call to %D", fn
);
11359 /* Make sure the default argument is reasonable. */
11360 arg
= check_default_argument (type
, arg
, complain
);
11362 pop_access_scope (fn
);
11367 /* Substitute into all the default arguments for FN. */
11370 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
11375 tmpl_args
= DECL_TI_ARGS (fn
);
11377 /* If this function is not yet instantiated, we certainly don't need
11378 its default arguments. */
11379 if (uses_template_parms (tmpl_args
))
11381 /* Don't do this again for clones. */
11382 if (DECL_CLONED_FUNCTION_P (fn
))
11385 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
11387 arg
= TREE_CHAIN (arg
))
11388 if (TREE_PURPOSE (arg
))
11389 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
11391 TREE_PURPOSE (arg
),
11395 /* Substitute the ARGS into the T, which is a _DECL. Return the
11396 result of the substitution. Issue error and warning messages under
11397 control of COMPLAIN. */
11400 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
11402 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
11403 location_t saved_loc
;
11404 tree r
= NULL_TREE
;
11406 hashval_t hash
= 0;
11408 /* Set the filename and linenumber to improve error-reporting. */
11409 saved_loc
= input_location
;
11410 input_location
= DECL_SOURCE_LOCATION (t
);
11412 switch (TREE_CODE (t
))
11414 case TEMPLATE_DECL
:
11416 /* We can get here when processing a member function template,
11417 member class template, or template template parameter. */
11418 tree decl
= DECL_TEMPLATE_RESULT (t
);
11423 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
11425 /* Template template parameter is treated here. */
11426 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11427 if (new_type
== error_mark_node
)
11428 r
= error_mark_node
;
11429 /* If we get a real template back, return it. This can happen in
11430 the context of most_specialized_partial_spec. */
11431 else if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
11434 /* The new TEMPLATE_DECL was built in
11435 reduce_template_parm_level. */
11436 r
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (new_type
);
11440 /* We might already have an instance of this template.
11441 The ARGS are for the surrounding class type, so the
11442 full args contain the tsubst'd args for the context,
11443 plus the innermost args from the template decl. */
11444 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
11445 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
11446 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
11447 /* Because this is a template, the arguments will still be
11448 dependent, even after substitution. If
11449 PROCESSING_TEMPLATE_DECL is not set, the dependency
11450 predicates will short-circuit. */
11451 ++processing_template_decl
;
11452 full_args
= tsubst_template_args (tmpl_args
, args
,
11453 complain
, in_decl
);
11454 --processing_template_decl
;
11455 if (full_args
== error_mark_node
)
11456 RETURN (error_mark_node
);
11458 /* If this is a default template template argument,
11459 tsubst might not have changed anything. */
11460 if (full_args
== tmpl_args
)
11463 hash
= hash_tmpl_and_args (t
, full_args
);
11464 spec
= retrieve_specialization (t
, full_args
, hash
);
11465 if (spec
!= NULL_TREE
)
11471 /* Make a new template decl. It will be similar to the
11472 original, but will record the current template arguments.
11473 We also create a new function declaration, which is just
11474 like the old one, but points to this new template, rather
11475 than the old one. */
11477 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
11478 DECL_CHAIN (r
) = NULL_TREE
;
11480 // Build new template info linking to the original template decl.
11481 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
11483 if (TREE_CODE (decl
) == TYPE_DECL
11484 && !TYPE_DECL_ALIAS_P (decl
))
11487 ++processing_template_decl
;
11488 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11489 --processing_template_decl
;
11490 if (new_type
== error_mark_node
)
11491 RETURN (error_mark_node
);
11493 TREE_TYPE (r
) = new_type
;
11494 /* For a partial specialization, we need to keep pointing to
11495 the primary template. */
11496 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
11497 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
11498 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
11499 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
11500 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
11505 ++processing_template_decl
;
11506 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
11507 --processing_template_decl
;
11508 if (new_decl
== error_mark_node
)
11509 RETURN (error_mark_node
);
11511 DECL_TEMPLATE_RESULT (r
) = new_decl
;
11512 DECL_TI_TEMPLATE (new_decl
) = r
;
11513 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
11514 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
11515 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
11518 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11519 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
11520 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
11522 /* The template parameters for this new template are all the
11523 template parameters for the old template, except the
11524 outermost level of parameters. */
11525 DECL_TEMPLATE_PARMS (r
)
11526 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
11529 if (PRIMARY_TEMPLATE_P (t
))
11530 DECL_PRIMARY_TEMPLATE (r
) = r
;
11532 if (TREE_CODE (decl
) != TYPE_DECL
&& !VAR_P (decl
))
11533 /* Record this non-type partial instantiation. */
11534 register_specialization (r
, t
,
11535 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
11540 case FUNCTION_DECL
:
11543 tree argvec
= NULL_TREE
;
11551 /* Nobody should be tsubst'ing into non-template functions. */
11552 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
11554 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
11559 /* If T is not dependent, just return it. We have to
11560 increment PROCESSING_TEMPLATE_DECL because
11561 value_dependent_expression_p assumes that nothing is
11562 dependent when PROCESSING_TEMPLATE_DECL is zero. */
11563 ++processing_template_decl
;
11564 dependent_p
= value_dependent_expression_p (t
);
11565 --processing_template_decl
;
11569 /* Calculate the most general template of which R is a
11570 specialization, and the complete set of arguments used to
11572 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
11573 argvec
= tsubst_template_args (DECL_TI_ARGS
11574 (DECL_TEMPLATE_RESULT
11575 (DECL_TI_TEMPLATE (t
))),
11576 args
, complain
, in_decl
);
11577 if (argvec
== error_mark_node
)
11578 RETURN (error_mark_node
);
11580 /* Check to see if we already have this specialization. */
11581 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11582 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11590 /* We can see more levels of arguments than parameters if
11591 there was a specialization of a member template, like
11594 template <class T> struct S { template <class U> void f(); }
11595 template <> template <class U> void S<int>::f(U);
11597 Here, we'll be substituting into the specialization,
11598 because that's where we can find the code we actually
11599 want to generate, but we'll have enough arguments for
11600 the most general template.
11602 We also deal with the peculiar case:
11604 template <class T> struct S {
11605 template <class U> friend void f();
11607 template <class U> void f() {}
11609 template void f<double>();
11611 Here, the ARGS for the instantiation of will be {int,
11612 double}. But, we only need as many ARGS as there are
11613 levels of template parameters in CODE_PATTERN. We are
11614 careful not to get fooled into reducing the ARGS in
11617 template <class T> struct S { template <class U> void f(U); }
11618 template <class T> template <> void S<T>::f(int) {}
11620 which we can spot because the pattern will be a
11621 specialization in this case. */
11622 args_depth
= TMPL_ARGS_DEPTH (args
);
11624 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
11625 if (args_depth
> parms_depth
11626 && !DECL_TEMPLATE_SPECIALIZATION (t
))
11627 args
= get_innermost_template_args (args
, parms_depth
);
11631 /* This special case arises when we have something like this:
11633 template <class T> struct S {
11634 friend void f<int>(int, double);
11637 Here, the DECL_TI_TEMPLATE for the friend declaration
11638 will be an IDENTIFIER_NODE. We are being called from
11639 tsubst_friend_function, and we want only to create a
11640 new decl (R) with appropriate types so that we can call
11641 determine_specialization. */
11642 gen_tmpl
= NULL_TREE
;
11645 if (DECL_CLASS_SCOPE_P (t
))
11647 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
11651 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
11652 complain
, t
, /*entering_scope=*/1);
11657 ctx
= DECL_CONTEXT (t
);
11659 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11660 if (type
== error_mark_node
)
11661 RETURN (error_mark_node
);
11663 /* If we hit excessive deduction depth, the type is bogus even if
11664 it isn't error_mark_node, so don't build a decl. */
11665 if (excessive_deduction_depth
)
11666 RETURN (error_mark_node
);
11668 /* We do NOT check for matching decls pushed separately at this
11669 point, as they may not represent instantiations of this
11670 template, and in any case are considered separate under the
11673 DECL_USE_TEMPLATE (r
) = 0;
11674 TREE_TYPE (r
) = type
;
11675 /* Clear out the mangled name and RTL for the instantiation. */
11676 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11677 SET_DECL_RTL (r
, NULL
);
11678 /* Leave DECL_INITIAL set on deleted instantiations. */
11679 if (!DECL_DELETED_FN (r
))
11680 DECL_INITIAL (r
) = NULL_TREE
;
11681 DECL_CONTEXT (r
) = ctx
;
11683 /* OpenMP UDRs have the only argument a reference to the declared
11684 type. We want to diagnose if the declared type is a reference,
11685 which is invalid, but as references to references are usually
11686 quietly merged, diagnose it here. */
11687 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
11690 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
11691 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
11692 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
11693 error_at (DECL_SOURCE_LOCATION (t
),
11694 "reference type %qT in "
11695 "%<#pragma omp declare reduction%>", argtype
);
11696 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
11697 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
11701 if (member
&& DECL_CONV_FN_P (r
))
11702 /* Type-conversion operator. Reconstruct the name, in
11703 case it's the name of one of the template's parameters. */
11704 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
11706 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
11708 DECL_RESULT (r
) = NULL_TREE
;
11710 TREE_STATIC (r
) = 0;
11711 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
11712 DECL_EXTERNAL (r
) = 1;
11713 /* If this is an instantiation of a function with internal
11714 linkage, we already know what object file linkage will be
11715 assigned to the instantiation. */
11716 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
11717 DECL_DEFER_OUTPUT (r
) = 0;
11718 DECL_CHAIN (r
) = NULL_TREE
;
11719 DECL_PENDING_INLINE_INFO (r
) = 0;
11720 DECL_PENDING_INLINE_P (r
) = 0;
11721 DECL_SAVED_TREE (r
) = NULL_TREE
;
11722 DECL_STRUCT_FUNCTION (r
) = NULL
;
11724 /* We'll re-clone as appropriate in instantiate_template. */
11725 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
11727 /* If we aren't complaining now, return on error before we register
11728 the specialization so that we'll complain eventually. */
11729 if ((complain
& tf_error
) == 0
11730 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
11731 && !grok_op_properties (r
, /*complain=*/false))
11732 RETURN (error_mark_node
);
11734 /* When instantiating a constrained member, substitute
11735 into the constraints to create a new constraint. */
11736 if (tree ci
= get_constraints (t
))
11739 ci
= tsubst_constraint_info (ci
, argvec
, complain
, NULL_TREE
);
11740 set_constraints (r
, ci
);
11743 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
11744 this in the special friend case mentioned above where
11745 GEN_TMPL is NULL. */
11748 DECL_TEMPLATE_INFO (r
)
11749 = build_template_info (gen_tmpl
, argvec
);
11750 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11753 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11755 /* We instantiated this while substituting into
11756 the type earlier (template/friend54.C). */
11759 /* We're not supposed to instantiate default arguments
11760 until they are called, for a template. But, for a
11763 template <class T> void f ()
11764 { extern void g(int i = T()); }
11766 we should do the substitution when the template is
11767 instantiated. We handle the member function case in
11768 instantiate_class_template since the default arguments
11769 might refer to other members of the class. */
11771 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
11772 && !uses_template_parms (argvec
))
11773 tsubst_default_arguments (r
, complain
);
11776 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
11778 /* Copy the list of befriending classes. */
11779 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
11781 friends
= &TREE_CHAIN (*friends
))
11783 *friends
= copy_node (*friends
);
11784 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
11789 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
11791 maybe_retrofit_in_chrg (r
);
11792 if (DECL_CONSTRUCTOR_P (r
))
11793 grok_ctor_properties (ctx
, r
);
11794 if (DECL_INHERITED_CTOR_BASE (r
))
11795 deduce_inheriting_ctor (r
);
11796 /* If this is an instantiation of a member template, clone it.
11797 If it isn't, that'll be handled by
11798 clone_constructors_and_destructors. */
11799 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
11800 clone_function_decl (r
, /*update_method_vec_p=*/0);
11802 else if ((complain
& tf_error
) != 0
11803 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
11804 && !grok_op_properties (r
, /*complain=*/true))
11805 RETURN (error_mark_node
);
11807 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
11808 SET_DECL_FRIEND_CONTEXT (r
,
11809 tsubst (DECL_FRIEND_CONTEXT (t
),
11810 args
, complain
, in_decl
));
11812 /* Possibly limit visibility based on template args. */
11813 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11814 if (DECL_VISIBILITY_SPECIFIED (t
))
11816 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11817 DECL_ATTRIBUTES (r
)
11818 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11820 determine_visibility (r
);
11821 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
11822 && !processing_template_decl
)
11823 defaulted_late_check (r
);
11825 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11826 args
, complain
, in_decl
);
11832 tree type
= NULL_TREE
;
11834 tree expanded_types
= NULL_TREE
;
11835 tree prev_r
= NULL_TREE
;
11836 tree first_r
= NULL_TREE
;
11838 if (DECL_PACK_P (t
))
11840 /* If there is a local specialization that isn't a
11841 parameter pack, it means that we're doing a "simple"
11842 substitution from inside tsubst_pack_expansion. Just
11843 return the local specialization (which will be a single
11845 tree spec
= retrieve_local_specialization (t
);
11847 && TREE_CODE (spec
) == PARM_DECL
11848 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
11851 /* Expand the TYPE_PACK_EXPANSION that provides the types for
11852 the parameters in this function parameter pack. */
11853 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11854 complain
, in_decl
);
11855 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11857 len
= TREE_VEC_LENGTH (expanded_types
);
11859 /* Zero-length parameter packs are boring. Just substitute
11862 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
11867 /* All we did was update the type. Make a note of that. */
11868 type
= expanded_types
;
11869 expanded_types
= NULL_TREE
;
11873 /* Loop through all of the parameters we'll build. When T is
11874 a function parameter pack, LEN is the number of expanded
11875 types in EXPANDED_TYPES; otherwise, LEN is 1. */
11877 for (i
= 0; i
< len
; ++i
)
11881 if (DECL_TEMPLATE_PARM_P (t
))
11882 SET_DECL_TEMPLATE_PARM_P (r
);
11884 if (expanded_types
)
11885 /* We're on the Ith parameter of the function parameter
11888 /* Get the Ith type. */
11889 type
= TREE_VEC_ELT (expanded_types
, i
);
11891 /* Rename the parameter to include the index. */
11893 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11896 /* We're dealing with a normal parameter. */
11897 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11899 type
= type_decays_to (type
);
11900 TREE_TYPE (r
) = type
;
11901 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11903 if (DECL_INITIAL (r
))
11905 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
11906 DECL_INITIAL (r
) = TREE_TYPE (r
);
11908 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
11909 complain
, in_decl
);
11912 DECL_CONTEXT (r
) = NULL_TREE
;
11914 if (!DECL_TEMPLATE_PARM_P (r
))
11915 DECL_ARG_TYPE (r
) = type_passed_as (type
);
11917 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11918 args
, complain
, in_decl
);
11920 /* Keep track of the first new parameter we
11921 generate. That's what will be returned to the
11926 /* Build a proper chain of parameters when substituting
11927 into a function parameter pack. */
11929 DECL_CHAIN (prev_r
) = r
;
11932 /* If cp_unevaluated_operand is set, we're just looking for a
11933 single dummy parameter, so don't keep going. */
11934 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
11935 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
11936 complain
, DECL_CHAIN (t
));
11938 /* FIRST_R contains the start of the chain we've built. */
11945 tree type
= NULL_TREE
;
11946 tree vec
= NULL_TREE
;
11947 tree expanded_types
= NULL_TREE
;
11950 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
11952 /* This field is a lambda capture pack. Return a TREE_VEC of
11953 the expanded fields to instantiate_class_template_1 and
11954 store them in the specializations hash table as a
11955 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11956 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11957 complain
, in_decl
);
11958 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11960 len
= TREE_VEC_LENGTH (expanded_types
);
11961 vec
= make_tree_vec (len
);
11965 /* All we did was update the type. Make a note of that. */
11966 type
= expanded_types
;
11967 expanded_types
= NULL_TREE
;
11971 for (int i
= 0; i
< len
; ++i
)
11974 if (expanded_types
)
11976 type
= TREE_VEC_ELT (expanded_types
, i
);
11978 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11981 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11983 if (type
== error_mark_node
)
11984 RETURN (error_mark_node
);
11985 TREE_TYPE (r
) = type
;
11986 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11988 if (DECL_C_BIT_FIELD (r
))
11989 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11990 non-bit-fields DECL_INITIAL is a non-static data member
11991 initializer, which gets deferred instantiation. */
11993 = tsubst_expr (DECL_INITIAL (t
), args
,
11995 /*integral_constant_expression_p=*/true);
11996 else if (DECL_INITIAL (t
))
11998 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11999 NSDMI in perform_member_init. Still set DECL_INITIAL
12000 so that we know there is one. */
12001 DECL_INITIAL (r
) = void_node
;
12002 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
12003 retrofit_lang_decl (r
);
12004 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
12006 /* We don't have to set DECL_CONTEXT here; it is set by
12007 finish_member_declaration. */
12008 DECL_CHAIN (r
) = NULL_TREE
;
12010 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
12011 args
, complain
, in_decl
);
12014 TREE_VEC_ELT (vec
, i
) = r
;
12020 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
12021 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
12022 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
12023 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
12024 TREE_TYPE (pack
) = tpack
;
12025 register_specialization (pack
, t
, args
, false, 0);
12031 /* We reach here only for member using decls. We also need to check
12032 uses_template_parms because DECL_DEPENDENT_P is not set for a
12033 using-declaration that designates a member of the current
12034 instantiation (c++/53549). */
12035 if (DECL_DEPENDENT_P (t
)
12036 || uses_template_parms (USING_DECL_SCOPE (t
)))
12038 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
12039 complain
, in_decl
);
12040 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
12041 r
= do_class_using_decl (inst_scope
, name
);
12043 r
= error_mark_node
;
12046 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
12047 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
12053 DECL_CHAIN (r
) = NULL_TREE
;
12060 tree argvec
= NULL_TREE
;
12061 tree gen_tmpl
= NULL_TREE
;
12063 tree tmpl
= NULL_TREE
;
12065 tree type
= NULL_TREE
;
12068 if (TREE_TYPE (t
) == error_mark_node
)
12069 RETURN (error_mark_node
);
12071 if (TREE_CODE (t
) == TYPE_DECL
12072 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
12074 /* If this is the canonical decl, we don't have to
12075 mess with instantiations, and often we can't (for
12076 typename, template type parms and such). Note that
12077 TYPE_NAME is not correct for the above test if
12078 we've copied the type for a typedef. */
12079 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12080 if (type
== error_mark_node
)
12081 RETURN (error_mark_node
);
12082 r
= TYPE_NAME (type
);
12086 /* Check to see if we already have the specialization we
12089 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
12091 /* T is a static data member or namespace-scope entity.
12092 We have to substitute into namespace-scope variables
12093 (not just variable templates) because of cases like:
12095 template <class T> void f() { extern T t; }
12097 where the entity referenced is not known until
12098 instantiation time. */
12100 ctx
= DECL_CONTEXT (t
);
12101 if (DECL_CLASS_SCOPE_P (t
))
12103 ctx
= tsubst_aggr_type (ctx
, args
,
12105 in_decl
, /*entering_scope=*/1);
12106 /* If CTX is unchanged, then T is in fact the
12107 specialization we want. That situation occurs when
12108 referencing a static data member within in its own
12109 class. We can use pointer equality, rather than
12110 same_type_p, because DECL_CONTEXT is always
12112 if (ctx
== DECL_CONTEXT (t
)
12113 /* ... unless T is a member template; in which
12114 case our caller can be willing to create a
12115 specialization of that template represented
12117 && !(DECL_TI_TEMPLATE (t
)
12118 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
12124 tmpl
= DECL_TI_TEMPLATE (t
);
12125 gen_tmpl
= most_general_template (tmpl
);
12126 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
12127 if (argvec
!= error_mark_node
)
12128 argvec
= (coerce_innermost_template_parms
12129 (DECL_TEMPLATE_PARMS (gen_tmpl
),
12130 argvec
, t
, complain
,
12131 /*all*/true, /*defarg*/true));
12132 if (argvec
== error_mark_node
)
12133 RETURN (error_mark_node
);
12134 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
12135 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
12140 /* A local variable. */
12142 /* Subsequent calls to pushdecl will fill this in. */
12144 spec
= retrieve_local_specialization (t
);
12146 /* If we already have the specialization we need, there is
12147 nothing more to do. */
12154 /* Create a new node for the specialization we need. */
12156 if (type
== NULL_TREE
)
12158 if (is_typedef_decl (t
))
12159 type
= DECL_ORIGINAL_TYPE (t
);
12161 type
= TREE_TYPE (t
);
12163 && VAR_HAD_UNKNOWN_BOUND (t
)
12164 && type
!= error_mark_node
)
12165 type
= strip_array_domain (type
);
12166 type
= tsubst (type
, args
, complain
, in_decl
);
12170 /* Even if the original location is out of scope, the
12171 newly substituted one is not. */
12172 DECL_DEAD_FOR_LOCAL (r
) = 0;
12173 DECL_INITIALIZED_P (r
) = 0;
12174 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
12175 if (type
== error_mark_node
)
12176 RETURN (error_mark_node
);
12177 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12179 /* It may seem that this case cannot occur, since:
12184 declares a function, not a variable. However:
12187 template <typename T> void g() { T t; }
12188 template void g<f>();
12190 is an attempt to declare a variable with function
12192 error ("variable %qD has function type",
12193 /* R is not yet sufficiently initialized, so we
12194 just use its name. */
12196 RETURN (error_mark_node
);
12198 type
= complete_type (type
);
12199 /* Wait until cp_finish_decl to set this again, to handle
12200 circular dependency (template/instantiate6.C). */
12201 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
12202 type
= check_var_type (DECL_NAME (r
), type
);
12204 if (DECL_HAS_VALUE_EXPR_P (t
))
12206 tree ve
= DECL_VALUE_EXPR (t
);
12207 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
12208 /*constant_expression_p=*/false);
12209 if (REFERENCE_REF_P (ve
))
12211 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
12212 ve
= TREE_OPERAND (ve
, 0);
12214 SET_DECL_VALUE_EXPR (r
, ve
);
12216 if (CP_DECL_THREAD_LOCAL_P (r
)
12217 && !processing_template_decl
)
12218 set_decl_tls_model (r
, decl_default_tls_model (r
));
12220 else if (DECL_SELF_REFERENCE_P (t
))
12221 SET_DECL_SELF_REFERENCE_P (r
);
12222 TREE_TYPE (r
) = type
;
12223 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
12224 DECL_CONTEXT (r
) = ctx
;
12225 /* Clear out the mangled name and RTL for the instantiation. */
12226 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
12227 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
12228 SET_DECL_RTL (r
, NULL
);
12229 /* The initializer must not be expanded until it is required;
12230 see [temp.inst]. */
12231 DECL_INITIAL (r
) = NULL_TREE
;
12232 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
12233 SET_DECL_RTL (r
, NULL
);
12234 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
12237 /* Possibly limit visibility based on template args. */
12238 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
12239 if (DECL_VISIBILITY_SPECIFIED (t
))
12241 DECL_VISIBILITY_SPECIFIED (r
) = 0;
12242 DECL_ATTRIBUTES (r
)
12243 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
12245 determine_visibility (r
);
12250 /* A static data member declaration is always marked
12251 external when it is declared in-class, even if an
12252 initializer is present. We mimic the non-template
12253 processing here. */
12254 DECL_EXTERNAL (r
) = 1;
12255 if (DECL_NAMESPACE_SCOPE_P (t
))
12256 DECL_NOT_REALLY_EXTERN (r
) = 1;
12258 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
12259 SET_DECL_IMPLICIT_INSTANTIATION (r
);
12260 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
12262 else if (!cp_unevaluated_operand
)
12263 register_local_specialization (r
, t
);
12265 DECL_CHAIN (r
) = NULL_TREE
;
12267 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
12269 args
, complain
, in_decl
);
12271 /* Preserve a typedef that names a type. */
12272 if (is_typedef_decl (r
))
12274 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
12275 set_underlying_type (r
);
12276 if (TYPE_DECL_ALIAS_P (r
) && type
!= error_mark_node
)
12277 /* An alias template specialization can be dependent
12278 even if its underlying type is not. */
12279 TYPE_DEPENDENT_P_VALID (TREE_TYPE (r
)) = false;
12282 layout_decl (r
, 0);
12287 gcc_unreachable ();
12292 /* Restore the file and line information. */
12293 input_location
= saved_loc
;
12298 /* Substitute into the ARG_TYPES of a function type.
12299 If END is a TREE_CHAIN, leave it and any following types
12303 tsubst_arg_types (tree arg_types
,
12306 tsubst_flags_t complain
,
12309 tree remaining_arg_types
;
12310 tree type
= NULL_TREE
;
12312 tree expanded_args
= NULL_TREE
;
12315 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
12318 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
12319 args
, end
, complain
, in_decl
);
12320 if (remaining_arg_types
== error_mark_node
)
12321 return error_mark_node
;
12323 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
12325 /* For a pack expansion, perform substitution on the
12326 entire expression. Later on, we'll handle the arguments
12328 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
12329 args
, complain
, in_decl
);
12331 if (TREE_CODE (expanded_args
) == TREE_VEC
)
12332 /* So that we'll spin through the parameters, one by one. */
12333 i
= TREE_VEC_LENGTH (expanded_args
);
12336 /* We only partially substituted into the parameter
12337 pack. Our type is TYPE_PACK_EXPANSION. */
12338 type
= expanded_args
;
12339 expanded_args
= NULL_TREE
;
12347 type
= TREE_VEC_ELT (expanded_args
, i
);
12349 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
12351 if (type
== error_mark_node
)
12352 return error_mark_node
;
12353 if (VOID_TYPE_P (type
))
12355 if (complain
& tf_error
)
12357 error ("invalid parameter type %qT", type
);
12359 error ("in declaration %q+D", in_decl
);
12361 return error_mark_node
;
12364 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
12365 return error_mark_node
;
12367 /* Do array-to-pointer, function-to-pointer conversion, and ignore
12368 top-level qualifiers as required. */
12369 type
= cv_unqualified (type_decays_to (type
));
12371 /* We do not substitute into default arguments here. The standard
12372 mandates that they be instantiated only when needed, which is
12373 done in build_over_call. */
12374 default_arg
= TREE_PURPOSE (arg_types
);
12376 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
12378 /* We've instantiated a template before its default arguments
12379 have been parsed. This can happen for a nested template
12380 class, and is not an error unless we require the default
12381 argument in a call of this function. */
12382 remaining_arg_types
=
12383 tree_cons (default_arg
, type
, remaining_arg_types
);
12384 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
12387 remaining_arg_types
=
12388 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
12391 return remaining_arg_types
;
12394 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
12395 *not* handle the exception-specification for FNTYPE, because the
12396 initial substitution of explicitly provided template parameters
12397 during argument deduction forbids substitution into the
12398 exception-specification:
12402 All references in the function type of the function template to the
12403 corresponding template parameters are replaced by the specified tem-
12404 plate argument values. If a substitution in a template parameter or
12405 in the function type of the function template results in an invalid
12406 type, type deduction fails. [Note: The equivalent substitution in
12407 exception specifications is done only when the function is instanti-
12408 ated, at which point a program is ill-formed if the substitution
12409 results in an invalid type.] */
12412 tsubst_function_type (tree t
,
12414 tsubst_flags_t complain
,
12418 tree arg_types
= NULL_TREE
;
12421 /* The TYPE_CONTEXT is not used for function/method types. */
12422 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
12424 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
12426 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
12428 if (late_return_type_p
)
12430 /* Substitute the argument types. */
12431 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
12432 complain
, in_decl
);
12433 if (arg_types
== error_mark_node
)
12434 return error_mark_node
;
12436 tree save_ccp
= current_class_ptr
;
12437 tree save_ccr
= current_class_ref
;
12438 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
12439 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
12440 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
12443 /* DR 1207: 'this' is in scope in the trailing return type. */
12444 inject_this_parameter (this_type
, cp_type_quals (this_type
));
12447 /* Substitute the return type. */
12448 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12452 current_class_ptr
= save_ccp
;
12453 current_class_ref
= save_ccr
;
12457 /* Substitute the return type. */
12458 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12460 if (return_type
== error_mark_node
)
12461 return error_mark_node
;
12462 /* DR 486 clarifies that creation of a function type with an
12463 invalid return type is a deduction failure. */
12464 if (TREE_CODE (return_type
) == ARRAY_TYPE
12465 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
12467 if (complain
& tf_error
)
12469 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
12470 error ("function returning an array");
12472 error ("function returning a function");
12474 return error_mark_node
;
12477 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
12478 return error_mark_node
;
12480 if (!late_return_type_p
)
12482 /* Substitute the argument types. */
12483 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
12484 complain
, in_decl
);
12485 if (arg_types
== error_mark_node
)
12486 return error_mark_node
;
12489 /* Construct a new type node and return it. */
12490 if (TREE_CODE (t
) == FUNCTION_TYPE
)
12492 fntype
= build_function_type (return_type
, arg_types
);
12493 fntype
= apply_memfn_quals (fntype
,
12494 type_memfn_quals (t
),
12495 type_memfn_rqual (t
));
12499 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
12500 /* Don't pick up extra function qualifiers from the basetype. */
12501 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
12502 if (! MAYBE_CLASS_TYPE_P (r
))
12506 Type deduction may fail for any of the following
12509 -- Attempting to create "pointer to member of T" when T
12510 is not a class type. */
12511 if (complain
& tf_error
)
12512 error ("creating pointer to member function of non-class type %qT",
12514 return error_mark_node
;
12517 fntype
= build_method_type_directly (r
, return_type
,
12518 TREE_CHAIN (arg_types
));
12519 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
12521 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
12523 if (late_return_type_p
)
12524 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
12529 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
12530 ARGS into that specification, and return the substituted
12531 specification. If there is no specification, return NULL_TREE. */
12534 tsubst_exception_specification (tree fntype
,
12536 tsubst_flags_t complain
,
12543 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
12544 new_specs
= NULL_TREE
;
12545 if (specs
&& TREE_PURPOSE (specs
))
12547 /* A noexcept-specifier. */
12548 tree expr
= TREE_PURPOSE (specs
);
12549 if (TREE_CODE (expr
) == INTEGER_CST
)
12553 /* Defer instantiation of noexcept-specifiers to avoid
12554 excessive instantiations (c++/49107). */
12555 new_specs
= make_node (DEFERRED_NOEXCEPT
);
12556 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
12558 /* We already partially instantiated this member template,
12559 so combine the new args with the old. */
12560 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
12561 = DEFERRED_NOEXCEPT_PATTERN (expr
);
12562 DEFERRED_NOEXCEPT_ARGS (new_specs
)
12563 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
12567 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
12568 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
12572 new_specs
= tsubst_copy_and_build
12573 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
12574 /*integral_constant_expression_p=*/true);
12575 new_specs
= build_noexcept_spec (new_specs
, complain
);
12579 if (! TREE_VALUE (specs
))
12586 tree expanded_specs
= NULL_TREE
;
12588 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
12590 /* Expand the pack expansion type. */
12591 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
12595 if (expanded_specs
== error_mark_node
)
12596 return error_mark_node
;
12597 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
12598 len
= TREE_VEC_LENGTH (expanded_specs
);
12601 /* We're substituting into a member template, so
12602 we got a TYPE_PACK_EXPANSION back. Add that
12603 expansion and move on. */
12604 gcc_assert (TREE_CODE (expanded_specs
)
12605 == TYPE_PACK_EXPANSION
);
12606 new_specs
= add_exception_specifier (new_specs
,
12609 specs
= TREE_CHAIN (specs
);
12614 for (i
= 0; i
< len
; ++i
)
12616 if (expanded_specs
)
12617 spec
= TREE_VEC_ELT (expanded_specs
, i
);
12619 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
12620 if (spec
== error_mark_node
)
12622 new_specs
= add_exception_specifier (new_specs
, spec
,
12626 specs
= TREE_CHAIN (specs
);
12632 /* Take the tree structure T and replace template parameters used
12633 therein with the argument vector ARGS. IN_DECL is an associated
12634 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
12635 Issue error and warning messages under control of COMPLAIN. Note
12636 that we must be relatively non-tolerant of extensions here, in
12637 order to preserve conformance; if we allow substitutions that
12638 should not be allowed, we may allow argument deductions that should
12639 not succeed, and therefore report ambiguous overload situations
12640 where there are none. In theory, we could allow the substitution,
12641 but indicate that it should have failed, and allow our caller to
12642 make sure that the right thing happens, but we don't try to do this
12645 This function is used for dealing with types, decls and the like;
12646 for expressions, use tsubst_expr or tsubst_copy. */
12649 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12651 enum tree_code code
;
12652 tree type
, r
= NULL_TREE
;
12654 if (t
== NULL_TREE
|| t
== error_mark_node
12655 || t
== integer_type_node
12656 || t
== void_type_node
12657 || t
== char_type_node
12658 || t
== unknown_type_node
12659 || TREE_CODE (t
) == NAMESPACE_DECL
12660 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
12664 return tsubst_decl (t
, args
, complain
);
12666 if (args
== NULL_TREE
)
12669 code
= TREE_CODE (t
);
12671 if (code
== IDENTIFIER_NODE
)
12672 type
= IDENTIFIER_TYPE_VALUE (t
);
12674 type
= TREE_TYPE (t
);
12676 gcc_assert (type
!= unknown_type_node
);
12678 /* Reuse typedefs. We need to do this to handle dependent attributes,
12679 such as attribute aligned. */
12681 && typedef_variant_p (t
))
12683 tree decl
= TYPE_NAME (t
);
12685 if (alias_template_specialization_p (t
))
12687 /* DECL represents an alias template and we want to
12689 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
12690 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
12691 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
12693 else if (DECL_CLASS_SCOPE_P (decl
)
12694 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
12695 && uses_template_parms (DECL_CONTEXT (decl
)))
12697 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
12698 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
12699 r
= retrieve_specialization (tmpl
, gen_args
, 0);
12701 else if (DECL_FUNCTION_SCOPE_P (decl
)
12702 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
12703 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
12704 r
= retrieve_local_specialization (decl
);
12706 /* The typedef is from a non-template context. */
12712 r
= cp_build_qualified_type_real
12713 (r
, cp_type_quals (t
) | cp_type_quals (r
),
12714 complain
| tf_ignore_bad_quals
);
12719 /* We don't have an instantiation yet, so drop the typedef. */
12720 int quals
= cp_type_quals (t
);
12721 t
= DECL_ORIGINAL_TYPE (decl
);
12722 t
= cp_build_qualified_type_real (t
, quals
,
12723 complain
| tf_ignore_bad_quals
);
12728 && code
!= TYPENAME_TYPE
12729 && code
!= TEMPLATE_TYPE_PARM
12730 && code
!= IDENTIFIER_NODE
12731 && code
!= FUNCTION_TYPE
12732 && code
!= METHOD_TYPE
)
12733 type
= tsubst (type
, args
, complain
, in_decl
);
12734 if (type
== error_mark_node
)
12735 return error_mark_node
;
12741 case ENUMERAL_TYPE
:
12742 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
12743 /*entering_scope=*/0);
12746 case IDENTIFIER_NODE
:
12757 if (t
== integer_type_node
)
12760 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
12761 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
12765 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
12767 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
12768 /*integral_constant_expression_p=*/false);
12770 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
12772 if (TREE_CODE (max
) == NOP_EXPR
12773 && TREE_SIDE_EFFECTS (omax
)
12774 && !TREE_TYPE (max
))
12775 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
12777 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
12778 with TREE_SIDE_EFFECTS that indicates this is not an integral
12779 constant expression. */
12780 if (processing_template_decl
12781 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
12783 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
12784 TREE_SIDE_EFFECTS (max
) = 1;
12787 return compute_array_index_type (NULL_TREE
, max
, complain
);
12790 case TEMPLATE_TYPE_PARM
:
12791 case TEMPLATE_TEMPLATE_PARM
:
12792 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12793 case TEMPLATE_PARM_INDEX
:
12798 tree arg
= NULL_TREE
;
12800 /* Early in template argument deduction substitution, we don't
12801 want to reduce the level of 'auto', or it will be confused
12802 with a normal template parm in subsequent deduction. */
12803 if (is_auto (t
) && (complain
& tf_partial
))
12808 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
12809 template_parm_level_and_index (t
, &level
, &idx
);
12811 levels
= TMPL_ARGS_DEPTH (args
);
12812 if (level
<= levels
12813 && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args
, level
)) > 0)
12815 arg
= TMPL_ARG (args
, level
, idx
);
12817 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
12819 /* See through ARGUMENT_PACK_SELECT arguments. */
12820 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
12821 /* If the selected argument is an expansion E, that most
12822 likely means we were called from
12823 gen_elem_of_pack_expansion_instantiation during the
12824 substituting of pack an argument pack (which Ith
12825 element is a pack expansion, where I is
12826 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
12827 In this case, the Ith element resulting from this
12828 substituting is going to be a pack expansion, which
12829 pattern is the pattern of E. Let's return the
12831 gen_elem_of_pack_expansion_instantiation will
12832 build the resulting pack expansion from it. */
12833 if (PACK_EXPANSION_P (arg
))
12835 /* Make sure we aren't throwing away arg info. */
12836 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
12837 arg
= PACK_EXPANSION_PATTERN (arg
);
12842 if (arg
== error_mark_node
)
12843 return error_mark_node
;
12844 else if (arg
!= NULL_TREE
)
12846 if (ARGUMENT_PACK_P (arg
))
12847 /* If ARG is an argument pack, we don't actually want to
12848 perform a substitution here, because substitutions
12849 for argument packs are only done
12850 element-by-element. We can get to this point when
12851 substituting the type of a non-type template
12852 parameter pack, when that type actually contains
12853 template parameter packs from an outer template, e.g.,
12855 template<typename... Types> struct A {
12856 template<Types... Values> struct B { };
12860 if (code
== TEMPLATE_TYPE_PARM
)
12863 gcc_assert (TYPE_P (arg
));
12865 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
12867 return cp_build_qualified_type_real
12868 (arg
, quals
, complain
| tf_ignore_bad_quals
);
12870 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12872 /* We are processing a type constructed from a
12873 template template parameter. */
12874 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
12875 args
, complain
, in_decl
);
12876 if (argvec
== error_mark_node
)
12877 return error_mark_node
;
12879 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
12880 || TREE_CODE (arg
) == TEMPLATE_DECL
12881 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
12883 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
12884 /* Consider this code:
12886 template <template <class> class Template>
12888 template <class Arg> using Bind = Template<Arg>;
12891 template <template <class> class Template, class Arg>
12892 using Instantiate = Template<Arg>; //#0
12894 template <template <class> class Template,
12897 Instantiate<Internal<Template>::template Bind,
12900 When #1 is parsed, the
12901 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12902 parameter `Template' in #0 matches the
12903 UNBOUND_CLASS_TEMPLATE representing the argument
12904 `Internal<Template>::template Bind'; We then want
12905 to assemble the type `Bind<Argument>' that can't
12906 be fully created right now, because
12907 `Internal<Template>' not being complete, the Bind
12908 template cannot be looked up in that context. So
12909 we need to "store" `Bind<Argument>' for later
12910 when the context of Bind becomes complete. Let's
12911 store that in a TYPENAME_TYPE. */
12912 return make_typename_type (TYPE_CONTEXT (arg
),
12913 build_nt (TEMPLATE_ID_EXPR
,
12914 TYPE_IDENTIFIER (arg
),
12919 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12920 are resolving nested-types in the signature of a
12921 member function templates. Otherwise ARG is a
12922 TEMPLATE_DECL and is the real template to be
12924 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
12925 arg
= TYPE_NAME (arg
);
12927 r
= lookup_template_class (arg
,
12929 DECL_CONTEXT (arg
),
12930 /*entering_scope=*/0,
12932 return cp_build_qualified_type_real
12933 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
12936 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12937 return convert_from_reference (unshare_expr (arg
));
12941 /* This can happen during the attempted tsubst'ing in
12942 unify. This means that we don't yet have any information
12943 about the template parameter in question. */
12946 /* If we get here, we must have been looking at a parm for a
12947 more deeply nested template. Make a new version of this
12948 template parameter, but with a lower level. */
12951 case TEMPLATE_TYPE_PARM
:
12952 case TEMPLATE_TEMPLATE_PARM
:
12953 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12954 if (cp_type_quals (t
))
12956 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
12957 r
= cp_build_qualified_type_real
12958 (r
, cp_type_quals (t
),
12959 complain
| (code
== TEMPLATE_TYPE_PARM
12960 ? tf_ignore_bad_quals
: 0));
12962 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
12963 && PLACEHOLDER_TYPE_CONSTRAINTS (t
)
12964 && (r
= (TEMPLATE_PARM_DESCENDANTS
12965 (TEMPLATE_TYPE_PARM_INDEX (t
))))
12966 && (r
= TREE_TYPE (r
))
12967 && !PLACEHOLDER_TYPE_CONSTRAINTS (r
))
12968 /* Break infinite recursion when substituting the constraints
12969 of a constrained placeholder. */;
12973 TEMPLATE_TYPE_PARM_INDEX (r
)
12974 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
12975 r
, levels
, args
, complain
);
12976 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
12977 TYPE_MAIN_VARIANT (r
) = r
;
12978 TYPE_POINTER_TO (r
) = NULL_TREE
;
12979 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
12981 /* Propagate constraints on placeholders. */
12982 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
12983 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
12984 PLACEHOLDER_TYPE_CONSTRAINTS (r
)
12985 = tsubst_constraint (constr
, args
, complain
, in_decl
);
12987 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
12988 /* We have reduced the level of the template
12989 template parameter, but not the levels of its
12990 template parameters, so canonical_type_parameter
12991 will not be able to find the canonical template
12992 template parameter for this level. Thus, we
12993 require structural equality checking to compare
12994 TEMPLATE_TEMPLATE_PARMs. */
12995 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12996 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
12997 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12999 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
13001 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
13003 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
13004 complain
, in_decl
);
13005 if (argvec
== error_mark_node
)
13006 return error_mark_node
;
13008 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
13009 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
13014 case TEMPLATE_PARM_INDEX
:
13015 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
13019 gcc_unreachable ();
13027 tree purpose
, value
, chain
;
13029 if (t
== void_list_node
)
13032 purpose
= TREE_PURPOSE (t
);
13035 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
13036 if (purpose
== error_mark_node
)
13037 return error_mark_node
;
13039 value
= TREE_VALUE (t
);
13042 value
= tsubst (value
, args
, complain
, in_decl
);
13043 if (value
== error_mark_node
)
13044 return error_mark_node
;
13046 chain
= TREE_CHAIN (t
);
13047 if (chain
&& chain
!= void_type_node
)
13049 chain
= tsubst (chain
, args
, complain
, in_decl
);
13050 if (chain
== error_mark_node
)
13051 return error_mark_node
;
13053 if (purpose
== TREE_PURPOSE (t
)
13054 && value
== TREE_VALUE (t
)
13055 && chain
== TREE_CHAIN (t
))
13057 return hash_tree_cons (purpose
, value
, chain
);
13061 /* We should never be tsubsting a binfo. */
13062 gcc_unreachable ();
13065 /* A vector of template arguments. */
13066 gcc_assert (!type
);
13067 return tsubst_template_args (t
, args
, complain
, in_decl
);
13070 case REFERENCE_TYPE
:
13072 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
13077 Type deduction may fail for any of the following
13080 -- Attempting to create a pointer to reference type.
13081 -- Attempting to create a reference to a reference type or
13082 a reference to void.
13084 Core issue 106 says that creating a reference to a reference
13085 during instantiation is no longer a cause for failure. We
13086 only enforce this check in strict C++98 mode. */
13087 if ((TREE_CODE (type
) == REFERENCE_TYPE
13088 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
13089 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
13091 static location_t last_loc
;
13093 /* We keep track of the last time we issued this error
13094 message to avoid spewing a ton of messages during a
13095 single bad template instantiation. */
13096 if (complain
& tf_error
13097 && last_loc
!= input_location
)
13099 if (VOID_TYPE_P (type
))
13100 error ("forming reference to void");
13101 else if (code
== POINTER_TYPE
)
13102 error ("forming pointer to reference type %qT", type
);
13104 error ("forming reference to reference type %qT", type
);
13105 last_loc
= input_location
;
13108 return error_mark_node
;
13110 else if (TREE_CODE (type
) == FUNCTION_TYPE
13111 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
13112 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
13114 if (complain
& tf_error
)
13116 if (code
== POINTER_TYPE
)
13117 error ("forming pointer to qualified function type %qT",
13120 error ("forming reference to qualified function type %qT",
13123 return error_mark_node
;
13125 else if (code
== POINTER_TYPE
)
13127 r
= build_pointer_type (type
);
13128 if (TREE_CODE (type
) == METHOD_TYPE
)
13129 r
= build_ptrmemfunc_type (r
);
13131 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
13132 /* In C++0x, during template argument substitution, when there is an
13133 attempt to create a reference to a reference type, reference
13134 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
13136 "If a template-argument for a template-parameter T names a type
13137 that is a reference to a type A, an attempt to create the type
13138 'lvalue reference to cv T' creates the type 'lvalue reference to
13139 A,' while an attempt to create the type type rvalue reference to
13140 cv T' creates the type T"
13142 r
= cp_build_reference_type
13144 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
13146 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
13147 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
13149 if (r
!= error_mark_node
)
13150 /* Will this ever be needed for TYPE_..._TO values? */
13157 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
13158 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
13162 Type deduction may fail for any of the following
13165 -- Attempting to create "pointer to member of T" when T
13166 is not a class type. */
13167 if (complain
& tf_error
)
13168 error ("creating pointer to member of non-class type %qT", r
);
13169 return error_mark_node
;
13171 if (TREE_CODE (type
) == REFERENCE_TYPE
)
13173 if (complain
& tf_error
)
13174 error ("creating pointer to member reference type %qT", type
);
13175 return error_mark_node
;
13177 if (VOID_TYPE_P (type
))
13179 if (complain
& tf_error
)
13180 error ("creating pointer to member of type void");
13181 return error_mark_node
;
13183 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
13184 if (TREE_CODE (type
) == FUNCTION_TYPE
)
13186 /* The type of the implicit object parameter gets its
13187 cv-qualifiers from the FUNCTION_TYPE. */
13190 = build_memfn_type (type
, r
, type_memfn_quals (type
),
13191 type_memfn_rqual (type
));
13192 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
13193 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
13197 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
13201 case FUNCTION_TYPE
:
13206 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
13207 if (fntype
== error_mark_node
)
13208 return error_mark_node
;
13210 /* Substitute the exception specification. */
13211 specs
= tsubst_exception_specification (t
, args
, complain
,
13212 in_decl
, /*defer_ok*/true);
13213 if (specs
== error_mark_node
)
13214 return error_mark_node
;
13216 fntype
= build_exception_variant (fntype
, specs
);
13221 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
13222 if (domain
== error_mark_node
)
13223 return error_mark_node
;
13225 /* As an optimization, we avoid regenerating the array type if
13226 it will obviously be the same as T. */
13227 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
13230 /* These checks should match the ones in create_array_type_for_decl.
13234 The deduction may fail for any of the following reasons:
13236 -- Attempting to create an array with an element type that
13237 is void, a function type, or a reference type, or [DR337]
13238 an abstract class type. */
13239 if (VOID_TYPE_P (type
)
13240 || TREE_CODE (type
) == FUNCTION_TYPE
13241 || (TREE_CODE (type
) == ARRAY_TYPE
13242 && TYPE_DOMAIN (type
) == NULL_TREE
)
13243 || TREE_CODE (type
) == REFERENCE_TYPE
)
13245 if (complain
& tf_error
)
13246 error ("creating array of %qT", type
);
13247 return error_mark_node
;
13250 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
13251 return error_mark_node
;
13253 r
= build_cplus_array_type (type
, domain
);
13255 if (TYPE_USER_ALIGN (t
))
13257 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
13258 TYPE_USER_ALIGN (r
) = 1;
13264 case TYPENAME_TYPE
:
13266 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
13267 in_decl
, /*entering_scope=*/1);
13268 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
13269 complain
, in_decl
);
13271 if (ctx
== error_mark_node
|| f
== error_mark_node
)
13272 return error_mark_node
;
13274 if (!MAYBE_CLASS_TYPE_P (ctx
))
13276 if (complain
& tf_error
)
13277 error ("%qT is not a class, struct, or union type", ctx
);
13278 return error_mark_node
;
13280 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
13282 /* Normally, make_typename_type does not require that the CTX
13283 have complete type in order to allow things like:
13285 template <class T> struct S { typename S<T>::X Y; };
13287 But, such constructs have already been resolved by this
13288 point, so here CTX really should have complete type, unless
13289 it's a partial instantiation. */
13290 ctx
= complete_type (ctx
);
13291 if (!COMPLETE_TYPE_P (ctx
))
13293 if (complain
& tf_error
)
13294 cxx_incomplete_type_error (NULL_TREE
, ctx
);
13295 return error_mark_node
;
13299 f
= make_typename_type (ctx
, f
, typename_type
,
13300 complain
| tf_keep_type_decl
);
13301 if (f
== error_mark_node
)
13303 if (TREE_CODE (f
) == TYPE_DECL
)
13305 complain
|= tf_ignore_bad_quals
;
13309 if (TREE_CODE (f
) != TYPENAME_TYPE
)
13311 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
13313 if (complain
& tf_error
)
13314 error ("%qT resolves to %qT, which is not an enumeration type",
13317 return error_mark_node
;
13319 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
13321 if (complain
& tf_error
)
13322 error ("%qT resolves to %qT, which is is not a class type",
13325 return error_mark_node
;
13329 return cp_build_qualified_type_real
13330 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
13333 case UNBOUND_CLASS_TEMPLATE
:
13335 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
13336 in_decl
, /*entering_scope=*/1);
13337 tree name
= TYPE_IDENTIFIER (t
);
13338 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
13340 if (ctx
== error_mark_node
|| name
== error_mark_node
)
13341 return error_mark_node
;
13344 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
13345 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
13352 ++cp_unevaluated_operand
;
13353 ++c_inhibit_evaluation_warnings
;
13355 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
13357 /*integral_constant_expression_p=*/false);
13359 --cp_unevaluated_operand
;
13360 --c_inhibit_evaluation_warnings
;
13362 type
= finish_typeof (type
);
13363 return cp_build_qualified_type_real (type
,
13365 | cp_type_quals (type
),
13369 case DECLTYPE_TYPE
:
13373 ++cp_unevaluated_operand
;
13374 ++c_inhibit_evaluation_warnings
;
13376 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
13377 complain
|tf_decltype
, in_decl
,
13378 /*function_p*/false,
13379 /*integral_constant_expression*/false);
13381 --cp_unevaluated_operand
;
13382 --c_inhibit_evaluation_warnings
;
13384 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
13385 type
= lambda_capture_field_type (type
,
13386 DECLTYPE_FOR_INIT_CAPTURE (t
));
13387 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
13388 type
= lambda_proxy_type (type
);
13391 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
13392 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
13394 /* In a template ~id could be either a complement expression
13395 or an unqualified-id naming a destructor; if instantiating
13396 it produces an expression, it's not an id-expression or
13399 type
= finish_decltype_type (type
, id
, complain
);
13401 return cp_build_qualified_type_real (type
,
13403 | cp_type_quals (type
),
13404 complain
| tf_ignore_bad_quals
);
13407 case UNDERLYING_TYPE
:
13409 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
13410 complain
, in_decl
);
13411 return finish_underlying_type (type
);
13414 case TYPE_ARGUMENT_PACK
:
13415 case NONTYPE_ARGUMENT_PACK
:
13417 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
13419 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
13423 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
13425 /* For template nontype argument packs, also substitute into
13427 if (code
== NONTYPE_ARGUMENT_PACK
)
13428 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13447 /* We should use one of the expression tsubsts for these codes. */
13448 gcc_unreachable ();
13451 sorry ("use of %qs in template", get_tree_code_name (code
));
13452 return error_mark_node
;
13456 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
13457 type of the expression on the left-hand side of the "." or "->"
13461 tsubst_baselink (tree baselink
, tree object_type
,
13462 tree args
, tsubst_flags_t complain
, tree in_decl
)
13465 tree qualifying_scope
;
13468 tree template_args
= 0;
13469 bool template_id_p
= false;
13470 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
13472 /* A baselink indicates a function from a base class. Both the
13473 BASELINK_ACCESS_BINFO and the base class referenced may
13474 indicate bases of the template class, rather than the
13475 instantiated class. In addition, lookups that were not
13476 ambiguous before may be ambiguous now. Therefore, we perform
13477 the lookup again. */
13478 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
13479 qualifying_scope
= tsubst (qualifying_scope
, args
,
13480 complain
, in_decl
);
13481 fns
= BASELINK_FUNCTIONS (baselink
);
13482 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
13483 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
13485 template_id_p
= true;
13486 template_args
= TREE_OPERAND (fns
, 1);
13487 fns
= TREE_OPERAND (fns
, 0);
13489 template_args
= tsubst_template_args (template_args
, args
,
13490 complain
, in_decl
);
13492 name
= DECL_NAME (get_first_fn (fns
));
13493 if (IDENTIFIER_TYPENAME_P (name
))
13494 name
= mangle_conv_op_name_for_type (optype
);
13495 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
13497 return error_mark_node
;
13499 /* If lookup found a single function, mark it as used at this
13500 point. (If it lookup found multiple functions the one selected
13501 later by overload resolution will be marked as used at that
13503 if (BASELINK_P (baselink
))
13504 fns
= BASELINK_FUNCTIONS (baselink
);
13505 if (!template_id_p
&& !really_overloaded_fn (fns
)
13506 && !mark_used (OVL_CURRENT (fns
), complain
) && !(complain
& tf_error
))
13507 return error_mark_node
;
13509 /* Add back the template arguments, if present. */
13510 if (BASELINK_P (baselink
) && template_id_p
)
13511 BASELINK_FUNCTIONS (baselink
)
13512 = build_nt (TEMPLATE_ID_EXPR
,
13513 BASELINK_FUNCTIONS (baselink
),
13515 /* Update the conversion operator type. */
13516 BASELINK_OPTYPE (baselink
) = optype
;
13519 object_type
= current_class_type
;
13522 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
13528 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
13529 true if the qualified-id will be a postfix-expression in-and-of
13530 itself; false if more of the postfix-expression follows the
13531 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
13535 tsubst_qualified_id (tree qualified_id
, tree args
,
13536 tsubst_flags_t complain
, tree in_decl
,
13537 bool done
, bool address_p
)
13543 tree template_args
;
13544 location_t loc
= UNKNOWN_LOCATION
;
13546 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
13548 /* Figure out what name to look up. */
13549 name
= TREE_OPERAND (qualified_id
, 1);
13550 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
13552 is_template
= true;
13553 loc
= EXPR_LOCATION (name
);
13554 template_args
= TREE_OPERAND (name
, 1);
13556 template_args
= tsubst_template_args (template_args
, args
,
13557 complain
, in_decl
);
13558 name
= TREE_OPERAND (name
, 0);
13562 is_template
= false;
13563 template_args
= NULL_TREE
;
13566 /* Substitute into the qualifying scope. When there are no ARGS, we
13567 are just trying to simplify a non-dependent expression. In that
13568 case the qualifying scope may be dependent, and, in any case,
13569 substituting will not help. */
13570 scope
= TREE_OPERAND (qualified_id
, 0);
13573 scope
= tsubst (scope
, args
, complain
, in_decl
);
13574 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
13579 if (dependent_scope_p (scope
))
13582 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
13583 return build_qualified_name (NULL_TREE
, scope
, expr
,
13584 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
13587 if (!BASELINK_P (name
) && !DECL_P (expr
))
13589 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
13591 /* A BIT_NOT_EXPR is used to represent a destructor. */
13592 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
13594 error ("qualifying type %qT does not match destructor name ~%qT",
13595 scope
, TREE_OPERAND (expr
, 0));
13596 expr
= error_mark_node
;
13599 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
13600 /*is_type_p=*/0, false);
13603 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
13604 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
13605 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
13607 if (complain
& tf_error
)
13609 error ("dependent-name %qE is parsed as a non-type, but "
13610 "instantiation yields a type", qualified_id
);
13611 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
13613 return error_mark_node
;
13619 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
13621 /* Remember that there was a reference to this entity. */
13622 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
13623 return error_mark_node
;
13626 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
13628 if (complain
& tf_error
)
13629 qualified_name_lookup_error (scope
,
13630 TREE_OPERAND (qualified_id
, 1),
13631 expr
, input_location
);
13632 return error_mark_node
;
13636 expr
= lookup_template_function (expr
, template_args
);
13638 if (expr
== error_mark_node
&& complain
& tf_error
)
13639 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
13640 expr
, input_location
);
13641 else if (TYPE_P (scope
))
13643 expr
= (adjust_result_of_qualified_name_lookup
13644 (expr
, scope
, current_nonlambda_class_type ()));
13645 expr
= (finish_qualified_id_expr
13646 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
13647 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
13648 /*template_arg_p=*/false, complain
));
13651 /* Expressions do not generally have reference type. */
13652 if (TREE_CODE (expr
) != SCOPE_REF
13653 /* However, if we're about to form a pointer-to-member, we just
13654 want the referenced member referenced. */
13655 && TREE_CODE (expr
) != OFFSET_REF
)
13656 expr
= convert_from_reference (expr
);
13661 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
13662 initializer, DECL is the substituted VAR_DECL. Other arguments are as
13666 tsubst_init (tree init
, tree decl
, tree args
,
13667 tsubst_flags_t complain
, tree in_decl
)
13672 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
13676 /* If we had an initializer but it
13677 instantiated to nothing,
13678 value-initialize the object. This will
13679 only occur when the initializer was a
13680 pack expansion where the parameter packs
13681 used in that expansion were of length
13683 init
= build_value_init (TREE_TYPE (decl
),
13685 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
13686 init
= get_target_expr_sfinae (init
, complain
);
13692 /* Like tsubst, but deals with expressions. This function just replaces
13693 template parms; to finish processing the resultant expression, use
13694 tsubst_copy_and_build or tsubst_expr. */
13697 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
13699 enum tree_code code
;
13702 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
13705 code
= TREE_CODE (t
);
13710 r
= retrieve_local_specialization (t
);
13712 if (r
== NULL_TREE
)
13714 /* We get here for a use of 'this' in an NSDMI. */
13715 if (DECL_NAME (t
) == this_identifier
13716 && current_function_decl
13717 && DECL_CONSTRUCTOR_P (current_function_decl
))
13718 return current_class_ptr
;
13720 /* This can happen for a parameter name used later in a function
13721 declaration (such as in a late-specified return type). Just
13722 make a dummy decl, since it's only used for its type. */
13723 gcc_assert (cp_unevaluated_operand
!= 0);
13724 r
= tsubst_decl (t
, args
, complain
);
13725 /* Give it the template pattern as its context; its true context
13726 hasn't been instantiated yet and this is good enough for
13728 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
13731 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
13732 r
= ARGUMENT_PACK_SELECT_ARG (r
);
13733 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
13734 return error_mark_node
;
13742 if (DECL_TEMPLATE_PARM_P (t
))
13743 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
13744 /* There is no need to substitute into namespace-scope
13746 if (DECL_NAMESPACE_SCOPE_P (t
))
13748 /* If ARGS is NULL, then T is known to be non-dependent. */
13749 if (args
== NULL_TREE
)
13750 return scalar_constant_value (t
);
13752 /* Unfortunately, we cannot just call lookup_name here.
13755 template <int I> int f() {
13757 struct S { void g() { E e = a; } };
13760 When we instantiate f<7>::S::g(), say, lookup_name is not
13761 clever enough to find f<7>::a. */
13763 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
13764 /*entering_scope=*/0);
13766 for (v
= TYPE_VALUES (enum_type
);
13768 v
= TREE_CHAIN (v
))
13769 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
13770 return TREE_VALUE (v
);
13772 /* We didn't find the name. That should never happen; if
13773 name-lookup found it during preliminary parsing, we
13774 should find it again here during instantiation. */
13775 gcc_unreachable ();
13780 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
13782 /* Check for a local specialization set up by
13783 tsubst_pack_expansion. */
13784 if (tree r
= retrieve_local_specialization (t
))
13786 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
13787 r
= ARGUMENT_PACK_SELECT_ARG (r
);
13791 /* When retrieving a capture pack from a generic lambda, remove the
13792 lambda call op's own template argument list from ARGS. Only the
13793 template arguments active for the closure type should be used to
13794 retrieve the pack specialization. */
13795 if (LAMBDA_FUNCTION_P (current_function_decl
)
13796 && (template_class_depth (DECL_CONTEXT (t
))
13797 != TMPL_ARGS_DEPTH (args
)))
13798 args
= strip_innermost_template_args (args
, 1);
13800 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
13801 tsubst_decl put in the hash table. */
13802 return retrieve_specialization (t
, args
, 0);
13805 if (DECL_CONTEXT (t
))
13809 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
13810 /*entering_scope=*/1);
13811 if (ctx
!= DECL_CONTEXT (t
))
13813 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
13816 if (complain
& tf_error
)
13817 error ("using invalid field %qD", t
);
13818 return error_mark_node
;
13827 case FUNCTION_DECL
:
13828 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
13829 r
= tsubst (t
, args
, complain
, in_decl
);
13830 else if (local_variable_p (t
))
13832 r
= retrieve_local_specialization (t
);
13833 if (r
== NULL_TREE
)
13835 /* First try name lookup to find the instantiation. */
13836 r
= lookup_name (DECL_NAME (t
));
13839 /* Make sure that the one we found is the one we want. */
13840 tree ctx
= DECL_CONTEXT (t
);
13841 if (DECL_LANG_SPECIFIC (ctx
) && DECL_TEMPLATE_INFO (ctx
))
13842 ctx
= tsubst (ctx
, args
, complain
, in_decl
);
13843 if (ctx
!= DECL_CONTEXT (r
))
13851 /* This can happen for a variable used in a
13852 late-specified return type of a local lambda, or for a
13853 local static or constant. Building a new VAR_DECL
13854 should be OK in all those cases. */
13855 r
= tsubst_decl (t
, args
, complain
);
13856 if (decl_maybe_constant_var_p (r
))
13858 /* We can't call cp_finish_decl, so handle the
13859 initializer by hand. */
13860 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
13861 complain
, in_decl
);
13862 if (!processing_template_decl
)
13863 init
= maybe_constant_init (init
);
13864 if (processing_template_decl
13865 ? potential_constant_expression (init
)
13866 : reduced_constant_expression_p (init
))
13867 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
13868 = TREE_CONSTANT (r
) = true;
13869 DECL_INITIAL (r
) = init
;
13871 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
13872 || decl_constant_var_p (r
)
13873 || errorcount
|| sorrycount
);
13874 if (!processing_template_decl
)
13876 if (TREE_STATIC (r
))
13877 rest_of_decl_compilation (r
, toplevel_bindings_p (),
13880 r
= process_outer_var_ref (r
, complain
);
13883 /* Remember this for subsequent uses. */
13884 if (local_specializations
)
13885 register_local_specialization (r
, t
);
13890 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
13891 return error_mark_node
;
13894 case NAMESPACE_DECL
:
13898 /* An OVERLOAD will always be a non-dependent overload set; an
13899 overload set from function scope will just be represented with an
13900 IDENTIFIER_NODE, and from class scope with a BASELINK. */
13901 gcc_assert (!uses_template_parms (t
));
13905 return tsubst_baselink (t
, current_nonlambda_class_type (),
13906 args
, complain
, in_decl
);
13908 case TEMPLATE_DECL
:
13909 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13910 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
13911 args
, complain
, in_decl
);
13912 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
13913 return tsubst (t
, args
, complain
, in_decl
);
13914 else if (DECL_CLASS_SCOPE_P (t
)
13915 && uses_template_parms (DECL_CONTEXT (t
)))
13917 /* Template template argument like the following example need
13920 template <template <class> class TT> struct C {};
13921 template <class T> struct D {
13922 template <class U> struct E {};
13927 We are processing the template argument `E' in #1 for
13928 the template instantiation #2. Originally, `E' is a
13929 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13930 have to substitute this with one having context `D<int>'. */
13932 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
13933 return lookup_field (context
, DECL_NAME(t
), 0, false);
13936 /* Ordinary template template argument. */
13940 case REINTERPRET_CAST_EXPR
:
13941 case CONST_CAST_EXPR
:
13942 case STATIC_CAST_EXPR
:
13943 case DYNAMIC_CAST_EXPR
:
13944 case IMPLICIT_CONV_EXPR
:
13948 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13949 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13950 return build1 (code
, type
, op0
);
13954 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
13956 tree expanded
, op
= TREE_OPERAND (t
, 0);
13959 if (SIZEOF_EXPR_TYPE_P (t
))
13960 op
= TREE_TYPE (op
);
13962 ++cp_unevaluated_operand
;
13963 ++c_inhibit_evaluation_warnings
;
13964 /* We only want to compute the number of arguments. */
13965 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
13966 --cp_unevaluated_operand
;
13967 --c_inhibit_evaluation_warnings
;
13969 if (TREE_CODE (expanded
) == TREE_VEC
)
13970 len
= TREE_VEC_LENGTH (expanded
);
13972 if (expanded
== error_mark_node
)
13973 return error_mark_node
;
13974 else if (PACK_EXPANSION_P (expanded
)
13975 || (TREE_CODE (expanded
) == TREE_VEC
13977 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
13979 if (TREE_CODE (expanded
) == TREE_VEC
)
13980 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
13982 PACK_EXPANSION_SIZEOF_P (expanded
) = true;
13984 if (TYPE_P (expanded
))
13985 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
13986 complain
& tf_error
);
13988 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
13989 complain
& tf_error
);
13992 return build_int_cst (size_type_node
, len
);
13994 if (SIZEOF_EXPR_TYPE_P (t
))
13996 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
13997 args
, complain
, in_decl
);
13998 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
13999 r
= build1 (SIZEOF_EXPR
,
14000 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
14001 SIZEOF_EXPR_TYPE_P (r
) = 1;
14008 case TRUTH_NOT_EXPR
:
14011 case UNARY_PLUS_EXPR
: /* Unary + */
14013 case AT_ENCODE_EXPR
:
14017 case REALPART_EXPR
:
14018 case IMAGPART_EXPR
:
14021 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14022 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14023 return build1 (code
, type
, op0
);
14026 case COMPONENT_REF
:
14031 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14032 name
= TREE_OPERAND (t
, 1);
14033 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
14035 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
14036 complain
, in_decl
);
14037 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
14039 else if (TREE_CODE (name
) == SCOPE_REF
14040 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
14042 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
14043 complain
, in_decl
);
14044 name
= TREE_OPERAND (name
, 1);
14045 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
14046 complain
, in_decl
);
14047 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
14048 name
= build_qualified_name (/*type=*/NULL_TREE
,
14050 /*template_p=*/false);
14052 else if (BASELINK_P (name
))
14053 name
= tsubst_baselink (name
,
14054 non_reference (TREE_TYPE (object
)),
14058 name
= tsubst_copy (name
, args
, complain
, in_decl
);
14059 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
14065 case TRUNC_DIV_EXPR
:
14066 case CEIL_DIV_EXPR
:
14067 case FLOOR_DIV_EXPR
:
14068 case ROUND_DIV_EXPR
:
14069 case EXACT_DIV_EXPR
:
14073 case TRUNC_MOD_EXPR
:
14074 case FLOOR_MOD_EXPR
:
14075 case TRUTH_ANDIF_EXPR
:
14076 case TRUTH_ORIF_EXPR
:
14077 case TRUTH_AND_EXPR
:
14078 case TRUTH_OR_EXPR
:
14091 case COMPOUND_EXPR
:
14094 case PREDECREMENT_EXPR
:
14095 case PREINCREMENT_EXPR
:
14096 case POSTDECREMENT_EXPR
:
14097 case POSTINCREMENT_EXPR
:
14099 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14100 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14101 return build_nt (code
, op0
, op1
);
14106 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14107 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14108 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
14109 QUALIFIED_NAME_IS_TEMPLATE (t
));
14114 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14115 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14116 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
14121 int n
= VL_EXP_OPERAND_LENGTH (t
);
14122 tree result
= build_vl_exp (CALL_EXPR
, n
);
14124 for (i
= 0; i
< n
; i
++)
14125 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
14126 complain
, in_decl
);
14132 case PSEUDO_DTOR_EXPR
:
14133 case VEC_PERM_EXPR
:
14135 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14136 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14137 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
14138 r
= build_nt (code
, op0
, op1
, op2
);
14139 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14145 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14146 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14147 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
14148 r
= build_nt (code
, op0
, op1
, op2
);
14149 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
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 r
= build_nt (code
, op0
, op1
);
14158 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
14159 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
14163 case TEMPLATE_ID_EXPR
:
14165 /* Substituted template arguments */
14166 tree fn
= TREE_OPERAND (t
, 0);
14167 tree targs
= TREE_OPERAND (t
, 1);
14169 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
14171 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14173 return lookup_template_function (fn
, targs
);
14178 tree purpose
, value
, chain
;
14180 if (t
== void_list_node
)
14183 purpose
= TREE_PURPOSE (t
);
14185 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
14186 value
= TREE_VALUE (t
);
14188 value
= tsubst_copy (value
, args
, complain
, in_decl
);
14189 chain
= TREE_CHAIN (t
);
14190 if (chain
&& chain
!= void_type_node
)
14191 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
14192 if (purpose
== TREE_PURPOSE (t
)
14193 && value
== TREE_VALUE (t
)
14194 && chain
== TREE_CHAIN (t
))
14196 return tree_cons (purpose
, value
, chain
);
14201 case ENUMERAL_TYPE
:
14203 case TEMPLATE_TYPE_PARM
:
14204 case TEMPLATE_TEMPLATE_PARM
:
14205 case BOUND_TEMPLATE_TEMPLATE_PARM
:
14206 case TEMPLATE_PARM_INDEX
:
14208 case REFERENCE_TYPE
:
14210 case FUNCTION_TYPE
:
14213 case TYPENAME_TYPE
:
14214 case UNBOUND_CLASS_TEMPLATE
:
14216 case DECLTYPE_TYPE
:
14218 return tsubst (t
, args
, complain
, in_decl
);
14222 /* Fall through. */
14223 case IDENTIFIER_NODE
:
14224 if (IDENTIFIER_TYPENAME_P (t
))
14226 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14227 return mangle_conv_op_name_for_type (new_type
);
14233 /* This is handled by tsubst_copy_and_build. */
14234 gcc_unreachable ();
14238 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14239 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14240 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
14243 case CLEANUP_POINT_EXPR
:
14244 /* We shouldn't have built any of these during initial template
14245 generation. Instead, they should be built during instantiation
14246 in response to the saved STMT_IS_FULL_EXPR_P setting. */
14247 gcc_unreachable ();
14251 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14252 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14253 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14254 r
= build2 (code
, type
, op0
, op1
);
14255 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
14256 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
14257 && !(complain
& tf_error
))
14258 return error_mark_node
;
14262 case EXPR_PACK_EXPANSION
:
14263 error ("invalid use of pack expansion expression");
14264 return error_mark_node
;
14266 case NONTYPE_ARGUMENT_PACK
:
14267 error ("use %<...%> to expand argument pack");
14268 return error_mark_node
;
14271 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
14279 /* Instantiate any typedefs in the type. */
14280 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14281 r
= fold_convert (type
, t
);
14282 gcc_assert (TREE_CODE (r
) == code
);
14287 /* These can sometimes show up in a partial instantiation, but never
14288 involve template parms. */
14289 gcc_assert (!uses_template_parms (t
));
14292 case UNARY_LEFT_FOLD_EXPR
:
14293 return tsubst_unary_left_fold (t
, args
, complain
, in_decl
);
14294 case UNARY_RIGHT_FOLD_EXPR
:
14295 return tsubst_unary_right_fold (t
, args
, complain
, in_decl
);
14296 case BINARY_LEFT_FOLD_EXPR
:
14297 return tsubst_binary_left_fold (t
, args
, complain
, in_decl
);
14298 case BINARY_RIGHT_FOLD_EXPR
:
14299 return tsubst_binary_right_fold (t
, args
, complain
, in_decl
);
14302 /* We shouldn't get here, but keep going if !flag_checking. */
14304 gcc_unreachable ();
14309 /* Helper function for tsubst_omp_clauses, used for instantiation of
14310 OMP_CLAUSE_DECL of clauses. */
14313 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
14316 if (decl
== NULL_TREE
)
14319 /* Handle an OpenMP array section represented as a TREE_LIST (or
14320 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
14321 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
14322 TREE_LIST. We can handle it exactly the same as an array section
14323 (purpose, value, and a chain), even though the nomenclature
14324 (low_bound, length, etc) is different. */
14325 if (TREE_CODE (decl
) == TREE_LIST
)
14328 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
14329 /*integral_constant_expression_p=*/false);
14330 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
14331 /*integral_constant_expression_p=*/false);
14332 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
14334 if (TREE_PURPOSE (decl
) == low_bound
14335 && TREE_VALUE (decl
) == length
14336 && TREE_CHAIN (decl
) == chain
)
14338 tree ret
= tree_cons (low_bound
, length
, chain
);
14339 OMP_CLAUSE_DEPEND_SINK_NEGATIVE (ret
)
14340 = OMP_CLAUSE_DEPEND_SINK_NEGATIVE (decl
);
14343 tree ret
= tsubst_expr (decl
, args
, complain
, in_decl
,
14344 /*integral_constant_expression_p=*/false);
14345 /* Undo convert_from_reference tsubst_expr could have called. */
14347 && REFERENCE_REF_P (ret
)
14348 && !REFERENCE_REF_P (decl
))
14349 ret
= TREE_OPERAND (ret
, 0);
14353 /* Like tsubst_copy, but specifically for OpenMP clauses. */
14356 tsubst_omp_clauses (tree clauses
, bool declare_simd
, bool allow_fields
,
14357 tree args
, tsubst_flags_t complain
, tree in_decl
)
14359 tree new_clauses
= NULL_TREE
, nc
, oc
;
14360 tree linear_no_step
= NULL_TREE
;
14362 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
14364 nc
= copy_node (oc
);
14365 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
14368 switch (OMP_CLAUSE_CODE (nc
))
14370 case OMP_CLAUSE_LASTPRIVATE
:
14371 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
14373 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
14374 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
14375 in_decl
, /*integral_constant_expression_p=*/false);
14376 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
14377 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
14380 case OMP_CLAUSE_PRIVATE
:
14381 case OMP_CLAUSE_SHARED
:
14382 case OMP_CLAUSE_FIRSTPRIVATE
:
14383 case OMP_CLAUSE_COPYIN
:
14384 case OMP_CLAUSE_COPYPRIVATE
:
14385 case OMP_CLAUSE_UNIFORM
:
14386 case OMP_CLAUSE_DEPEND
:
14387 case OMP_CLAUSE_FROM
:
14388 case OMP_CLAUSE_TO
:
14389 case OMP_CLAUSE_MAP
:
14390 case OMP_CLAUSE_USE_DEVICE_PTR
:
14391 case OMP_CLAUSE_IS_DEVICE_PTR
:
14392 OMP_CLAUSE_DECL (nc
)
14393 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
14396 case OMP_CLAUSE_IF
:
14397 case OMP_CLAUSE_NUM_THREADS
:
14398 case OMP_CLAUSE_SCHEDULE
:
14399 case OMP_CLAUSE_COLLAPSE
:
14400 case OMP_CLAUSE_FINAL
:
14401 case OMP_CLAUSE_DEVICE
:
14402 case OMP_CLAUSE_DIST_SCHEDULE
:
14403 case OMP_CLAUSE_NUM_TEAMS
:
14404 case OMP_CLAUSE_THREAD_LIMIT
:
14405 case OMP_CLAUSE_SAFELEN
:
14406 case OMP_CLAUSE_SIMDLEN
:
14407 case OMP_CLAUSE_NUM_TASKS
:
14408 case OMP_CLAUSE_GRAINSIZE
:
14409 case OMP_CLAUSE_PRIORITY
:
14410 case OMP_CLAUSE_ORDERED
:
14411 case OMP_CLAUSE_HINT
:
14412 case OMP_CLAUSE_NUM_GANGS
:
14413 case OMP_CLAUSE_NUM_WORKERS
:
14414 case OMP_CLAUSE_VECTOR_LENGTH
:
14415 case OMP_CLAUSE_WORKER
:
14416 case OMP_CLAUSE_VECTOR
:
14417 case OMP_CLAUSE_ASYNC
:
14418 case OMP_CLAUSE_WAIT
:
14419 OMP_CLAUSE_OPERAND (nc
, 0)
14420 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
14421 in_decl
, /*integral_constant_expression_p=*/false);
14423 case OMP_CLAUSE_REDUCTION
:
14424 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
14426 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
14427 if (TREE_CODE (placeholder
) == SCOPE_REF
)
14429 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
14430 complain
, in_decl
);
14431 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
14432 = build_qualified_name (NULL_TREE
, scope
,
14433 TREE_OPERAND (placeholder
, 1),
14437 gcc_assert (identifier_p (placeholder
));
14439 OMP_CLAUSE_DECL (nc
)
14440 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
14443 case OMP_CLAUSE_GANG
:
14444 case OMP_CLAUSE_ALIGNED
:
14445 OMP_CLAUSE_DECL (nc
)
14446 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
14448 OMP_CLAUSE_OPERAND (nc
, 1)
14449 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
14450 in_decl
, /*integral_constant_expression_p=*/false);
14452 case OMP_CLAUSE_LINEAR
:
14453 OMP_CLAUSE_DECL (nc
)
14454 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
14456 if (OMP_CLAUSE_LINEAR_STEP (oc
) == NULL_TREE
)
14458 gcc_assert (!linear_no_step
);
14459 linear_no_step
= nc
;
14461 else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (oc
))
14462 OMP_CLAUSE_LINEAR_STEP (nc
)
14463 = tsubst_omp_clause_decl (OMP_CLAUSE_LINEAR_STEP (oc
), args
,
14464 complain
, in_decl
);
14466 OMP_CLAUSE_LINEAR_STEP (nc
)
14467 = tsubst_expr (OMP_CLAUSE_LINEAR_STEP (oc
), args
, complain
,
14469 /*integral_constant_expression_p=*/false);
14471 case OMP_CLAUSE_NOWAIT
:
14472 case OMP_CLAUSE_DEFAULT
:
14473 case OMP_CLAUSE_UNTIED
:
14474 case OMP_CLAUSE_MERGEABLE
:
14475 case OMP_CLAUSE_INBRANCH
:
14476 case OMP_CLAUSE_NOTINBRANCH
:
14477 case OMP_CLAUSE_PROC_BIND
:
14478 case OMP_CLAUSE_FOR
:
14479 case OMP_CLAUSE_PARALLEL
:
14480 case OMP_CLAUSE_SECTIONS
:
14481 case OMP_CLAUSE_TASKGROUP
:
14482 case OMP_CLAUSE_NOGROUP
:
14483 case OMP_CLAUSE_THREADS
:
14484 case OMP_CLAUSE_SIMD
:
14485 case OMP_CLAUSE_DEFAULTMAP
:
14486 case OMP_CLAUSE_INDEPENDENT
:
14487 case OMP_CLAUSE_AUTO
:
14488 case OMP_CLAUSE_SEQ
:
14490 case OMP_CLAUSE_TILE
:
14493 for (lnc
= OMP_CLAUSE_TILE_LIST (nc
),
14494 loc
= OMP_CLAUSE_TILE_LIST (oc
);
14496 loc
= TREE_CHAIN (loc
), lnc
= TREE_CHAIN (lnc
))
14498 TREE_VALUE (lnc
) = tsubst_expr (TREE_VALUE (loc
), args
,
14499 complain
, in_decl
, false);
14504 gcc_unreachable ();
14507 switch (OMP_CLAUSE_CODE (nc
))
14509 case OMP_CLAUSE_SHARED
:
14510 case OMP_CLAUSE_PRIVATE
:
14511 case OMP_CLAUSE_FIRSTPRIVATE
:
14512 case OMP_CLAUSE_LASTPRIVATE
:
14513 case OMP_CLAUSE_COPYPRIVATE
:
14514 case OMP_CLAUSE_LINEAR
:
14515 case OMP_CLAUSE_REDUCTION
:
14516 case OMP_CLAUSE_USE_DEVICE_PTR
:
14517 case OMP_CLAUSE_IS_DEVICE_PTR
:
14518 /* tsubst_expr on SCOPE_REF results in returning
14519 finish_non_static_data_member result. Undo that here. */
14520 if (TREE_CODE (OMP_CLAUSE_DECL (oc
)) == SCOPE_REF
14521 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (oc
), 1))
14522 == IDENTIFIER_NODE
))
14524 tree t
= OMP_CLAUSE_DECL (nc
);
14527 switch (TREE_CODE (v
))
14529 case COMPONENT_REF
:
14533 case POINTER_PLUS_EXPR
:
14534 v
= TREE_OPERAND (v
, 0);
14537 if (DECL_CONTEXT (v
) == current_function_decl
14538 && DECL_ARTIFICIAL (v
)
14539 && DECL_NAME (v
) == this_identifier
)
14540 OMP_CLAUSE_DECL (nc
) = TREE_OPERAND (t
, 1);
14547 else if (VAR_P (OMP_CLAUSE_DECL (oc
))
14548 && DECL_HAS_VALUE_EXPR_P (OMP_CLAUSE_DECL (oc
))
14549 && DECL_ARTIFICIAL (OMP_CLAUSE_DECL (oc
))
14550 && DECL_LANG_SPECIFIC (OMP_CLAUSE_DECL (oc
))
14551 && DECL_OMP_PRIVATIZED_MEMBER (OMP_CLAUSE_DECL (oc
)))
14553 tree decl
= OMP_CLAUSE_DECL (nc
);
14556 if (!DECL_LANG_SPECIFIC (decl
))
14557 retrofit_lang_decl (decl
);
14558 DECL_OMP_PRIVATIZED_MEMBER (decl
) = 1;
14567 new_clauses
= nreverse (new_clauses
);
14570 new_clauses
= finish_omp_clauses (new_clauses
, allow_fields
);
14571 if (linear_no_step
)
14572 for (nc
= new_clauses
; nc
; nc
= OMP_CLAUSE_CHAIN (nc
))
14573 if (nc
== linear_no_step
)
14575 OMP_CLAUSE_LINEAR_STEP (nc
) = NULL_TREE
;
14579 return new_clauses
;
14582 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
14585 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
14588 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
14590 tree purpose
, value
, chain
;
14595 if (TREE_CODE (t
) != TREE_LIST
)
14596 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14597 /*function_p=*/false,
14598 /*integral_constant_expression_p=*/false);
14600 if (t
== void_list_node
)
14603 purpose
= TREE_PURPOSE (t
);
14605 purpose
= RECUR (purpose
);
14606 value
= TREE_VALUE (t
);
14609 if (TREE_CODE (value
) != LABEL_DECL
)
14610 value
= RECUR (value
);
14613 value
= lookup_label (DECL_NAME (value
));
14614 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
14615 TREE_USED (value
) = 1;
14618 chain
= TREE_CHAIN (t
);
14619 if (chain
&& chain
!= void_type_node
)
14620 chain
= RECUR (chain
);
14621 return tree_cons (purpose
, value
, chain
);
14625 /* Used to temporarily communicate the list of #pragma omp parallel
14626 clauses to #pragma omp for instantiation if they are combined
14629 static tree
*omp_parallel_combined_clauses
;
14631 /* Substitute one OMP_FOR iterator. */
14634 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree orig_declv
,
14635 tree initv
, tree condv
, tree incrv
, tree
*clauses
,
14636 tree args
, tsubst_flags_t complain
, tree in_decl
,
14637 bool integral_constant_expression_p
)
14639 #define RECUR(NODE) \
14640 tsubst_expr ((NODE), args, complain, in_decl, \
14641 integral_constant_expression_p)
14642 tree decl
, init
, cond
, incr
;
14644 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
14645 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
14647 if (orig_declv
&& OMP_FOR_ORIG_DECLS (t
))
14649 tree o
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t
), i
);
14650 TREE_VEC_ELT (orig_declv
, i
) = RECUR (o
);
14653 decl
= TREE_OPERAND (init
, 0);
14654 init
= TREE_OPERAND (init
, 1);
14655 tree decl_expr
= NULL_TREE
;
14656 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
14658 /* We need to jump through some hoops to handle declarations in the
14659 for-init-statement, since we might need to handle auto deduction,
14660 but we need to keep control of initialization. */
14662 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
14663 decl
= tsubst_decl (decl
, args
, complain
);
14667 if (TREE_CODE (decl
) == SCOPE_REF
)
14669 decl
= RECUR (decl
);
14670 if (TREE_CODE (decl
) == COMPONENT_REF
)
14674 switch (TREE_CODE (v
))
14676 case COMPONENT_REF
:
14680 case POINTER_PLUS_EXPR
:
14681 v
= TREE_OPERAND (v
, 0);
14684 if (DECL_CONTEXT (v
) == current_function_decl
14685 && DECL_ARTIFICIAL (v
)
14686 && DECL_NAME (v
) == this_identifier
)
14688 decl
= TREE_OPERAND (decl
, 1);
14689 decl
= omp_privatize_field (decl
, false);
14699 decl
= RECUR (decl
);
14701 init
= RECUR (init
);
14703 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
14704 if (auto_node
&& init
)
14706 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
14708 gcc_assert (!type_dependent_expression_p (decl
));
14710 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
14714 /* Declare the variable, but don't let that initialize it. */
14715 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
14716 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
14718 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
14721 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
14722 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
14723 if (TREE_CODE (incr
) == MODIFY_EXPR
)
14725 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
14726 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
14727 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
14728 NOP_EXPR
, rhs
, complain
);
14731 incr
= RECUR (incr
);
14732 TREE_VEC_ELT (declv
, i
) = decl
;
14733 TREE_VEC_ELT (initv
, i
) = init
;
14734 TREE_VEC_ELT (condv
, i
) = cond
;
14735 TREE_VEC_ELT (incrv
, i
) = incr
;
14741 /* Declare and initialize the variable. */
14749 for (j
= (omp_parallel_combined_clauses
== NULL
? 1 : 0); j
< 2; j
++)
14751 for (pc
= j
? clauses
: omp_parallel_combined_clauses
; *pc
; )
14753 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
14754 && OMP_CLAUSE_DECL (*pc
) == decl
)
14756 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
14757 && OMP_CLAUSE_DECL (*pc
) == decl
)
14761 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
14763 *pc
= OMP_CLAUSE_CHAIN (c
);
14764 OMP_CLAUSE_CHAIN (c
) = *clauses
;
14767 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
14768 && OMP_CLAUSE_DECL (*pc
) == decl
)
14770 error ("iteration variable %qD should not be firstprivate",
14772 *pc
= OMP_CLAUSE_CHAIN (*pc
);
14774 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_REDUCTION
14775 && OMP_CLAUSE_DECL (*pc
) == decl
)
14777 error ("iteration variable %qD should not be reduction",
14779 *pc
= OMP_CLAUSE_CHAIN (*pc
);
14782 pc
= &OMP_CLAUSE_CHAIN (*pc
);
14787 if (*pc
== NULL_TREE
)
14789 tree c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
14790 OMP_CLAUSE_DECL (c
) = decl
;
14791 c
= finish_omp_clauses (c
, true);
14794 OMP_CLAUSE_CHAIN (c
) = *clauses
;
14799 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
14800 if (COMPARISON_CLASS_P (cond
))
14802 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
14803 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
14804 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
14807 cond
= RECUR (cond
);
14808 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
14809 switch (TREE_CODE (incr
))
14811 case PREINCREMENT_EXPR
:
14812 case PREDECREMENT_EXPR
:
14813 case POSTINCREMENT_EXPR
:
14814 case POSTDECREMENT_EXPR
:
14815 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
14816 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
14819 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
14820 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
14822 tree rhs
= TREE_OPERAND (incr
, 1);
14823 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
14824 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
14825 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
14826 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
14827 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
14831 incr
= RECUR (incr
);
14834 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
14835 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
14837 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
14838 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
14839 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
14840 TREE_TYPE (decl
), lhs
,
14841 RECUR (TREE_OPERAND (incr
, 2))));
14843 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
14844 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
14845 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
14847 tree rhs
= TREE_OPERAND (incr
, 2);
14848 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
14849 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
14850 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
14851 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
14852 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
14856 incr
= RECUR (incr
);
14859 incr
= RECUR (incr
);
14863 TREE_VEC_ELT (declv
, i
) = decl
;
14864 TREE_VEC_ELT (initv
, i
) = init
;
14865 TREE_VEC_ELT (condv
, i
) = cond
;
14866 TREE_VEC_ELT (incrv
, i
) = incr
;
14870 /* Helper function of tsubst_expr, find OMP_TEAMS inside
14871 of OMP_TARGET's body. */
14874 tsubst_find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
14876 *walk_subtrees
= 0;
14877 switch (TREE_CODE (*tp
))
14882 case STATEMENT_LIST
:
14883 *walk_subtrees
= 1;
14891 /* Like tsubst_copy for expressions, etc. but also does semantic
14895 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
14896 bool integral_constant_expression_p
)
14898 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
14899 #define RECUR(NODE) \
14900 tsubst_expr ((NODE), args, complain, in_decl, \
14901 integral_constant_expression_p)
14907 if (t
== NULL_TREE
|| t
== error_mark_node
)
14910 loc
= input_location
;
14911 if (EXPR_HAS_LOCATION (t
))
14912 input_location
= EXPR_LOCATION (t
);
14913 if (STATEMENT_CODE_P (TREE_CODE (t
)))
14914 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
14916 switch (TREE_CODE (t
))
14918 case STATEMENT_LIST
:
14920 tree_stmt_iterator i
;
14921 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
14922 RECUR (tsi_stmt (i
));
14926 case CTOR_INITIALIZER
:
14927 finish_mem_initializers (tsubst_initializer_list
14928 (TREE_OPERAND (t
, 0), args
));
14932 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
14936 tmp
= RECUR (EXPR_STMT_EXPR (t
));
14937 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
14938 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
14940 finish_expr_stmt (tmp
);
14944 do_using_directive (USING_STMT_NAMESPACE (t
));
14949 tree decl
, pattern_decl
;
14952 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
14953 if (TREE_CODE (decl
) == LABEL_DECL
)
14954 finish_label_decl (DECL_NAME (decl
));
14955 else if (TREE_CODE (decl
) == USING_DECL
)
14957 tree scope
= USING_DECL_SCOPE (decl
);
14958 tree name
= DECL_NAME (decl
);
14961 scope
= tsubst (scope
, args
, complain
, in_decl
);
14962 decl
= lookup_qualified_name (scope
, name
,
14963 /*is_type_p=*/false,
14964 /*complain=*/false);
14965 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
14966 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
14968 do_local_using_decl (decl
, scope
, name
);
14970 else if (DECL_PACK_P (decl
))
14972 /* Don't build up decls for a variadic capture proxy, we'll
14973 instantiate the elements directly as needed. */
14978 init
= DECL_INITIAL (decl
);
14979 decl
= tsubst (decl
, args
, complain
, in_decl
);
14980 if (decl
!= error_mark_node
)
14982 /* By marking the declaration as instantiated, we avoid
14983 trying to instantiate it. Since instantiate_decl can't
14984 handle local variables, and since we've already done
14985 all that needs to be done, that's the right thing to
14988 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
14990 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
14991 /* Anonymous aggregates are a special case. */
14992 finish_anon_union (decl
);
14993 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
14995 DECL_CONTEXT (decl
) = current_function_decl
;
14996 if (DECL_NAME (decl
) == this_identifier
)
14998 tree lam
= DECL_CONTEXT (current_function_decl
);
14999 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
15000 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
15002 insert_capture_proxy (decl
);
15004 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
15005 /* We already did a pushtag. */;
15006 else if (TREE_CODE (decl
) == FUNCTION_DECL
15007 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
15008 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
15010 DECL_CONTEXT (decl
) = NULL_TREE
;
15012 DECL_CONTEXT (decl
) = current_function_decl
;
15013 cp_check_omp_declare_reduction (decl
);
15017 int const_init
= false;
15018 maybe_push_decl (decl
);
15020 && DECL_PRETTY_FUNCTION_P (decl
))
15022 /* For __PRETTY_FUNCTION__ we have to adjust the
15024 const char *const name
15025 = cxx_printable_name (current_function_decl
, 2);
15026 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
15029 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
15032 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
15034 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
15043 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
15044 RECUR (FOR_INIT_STMT (t
));
15045 finish_for_init_stmt (stmt
);
15046 tmp
= RECUR (FOR_COND (t
));
15047 finish_for_cond (tmp
, stmt
, false);
15048 tmp
= RECUR (FOR_EXPR (t
));
15049 finish_for_expr (tmp
, stmt
);
15050 RECUR (FOR_BODY (t
));
15051 finish_for_stmt (stmt
);
15054 case RANGE_FOR_STMT
:
15057 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
15058 decl
= RANGE_FOR_DECL (t
);
15059 decl
= tsubst (decl
, args
, complain
, in_decl
);
15060 maybe_push_decl (decl
);
15061 expr
= RECUR (RANGE_FOR_EXPR (t
));
15062 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
15063 RECUR (RANGE_FOR_BODY (t
));
15064 finish_for_stmt (stmt
);
15069 stmt
= begin_while_stmt ();
15070 tmp
= RECUR (WHILE_COND (t
));
15071 finish_while_stmt_cond (tmp
, stmt
, false);
15072 RECUR (WHILE_BODY (t
));
15073 finish_while_stmt (stmt
);
15077 stmt
= begin_do_stmt ();
15078 RECUR (DO_BODY (t
));
15079 finish_do_body (stmt
);
15080 tmp
= RECUR (DO_COND (t
));
15081 finish_do_stmt (tmp
, stmt
, false);
15085 stmt
= begin_if_stmt ();
15086 tmp
= RECUR (IF_COND (t
));
15087 finish_if_stmt_cond (tmp
, stmt
);
15088 RECUR (THEN_CLAUSE (t
));
15089 finish_then_clause (stmt
);
15091 if (ELSE_CLAUSE (t
))
15093 begin_else_clause (stmt
);
15094 RECUR (ELSE_CLAUSE (t
));
15095 finish_else_clause (stmt
);
15098 finish_if_stmt (stmt
);
15102 if (BIND_EXPR_BODY_BLOCK (t
))
15103 stmt
= begin_function_body ();
15105 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
15106 ? BCS_TRY_BLOCK
: 0);
15108 RECUR (BIND_EXPR_BODY (t
));
15110 if (BIND_EXPR_BODY_BLOCK (t
))
15111 finish_function_body (stmt
);
15113 finish_compound_stmt (stmt
);
15117 finish_break_stmt ();
15120 case CONTINUE_STMT
:
15121 finish_continue_stmt ();
15125 stmt
= begin_switch_stmt ();
15126 tmp
= RECUR (SWITCH_STMT_COND (t
));
15127 finish_switch_cond (tmp
, stmt
);
15128 RECUR (SWITCH_STMT_BODY (t
));
15129 finish_switch_stmt (stmt
);
15132 case CASE_LABEL_EXPR
:
15134 tree low
= RECUR (CASE_LOW (t
));
15135 tree high
= RECUR (CASE_HIGH (t
));
15136 finish_case_label (EXPR_LOCATION (t
), low
, high
);
15142 tree decl
= LABEL_EXPR_LABEL (t
);
15145 label
= finish_label_stmt (DECL_NAME (decl
));
15146 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
15147 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
15152 tmp
= GOTO_DESTINATION (t
);
15153 if (TREE_CODE (tmp
) != LABEL_DECL
)
15154 /* Computed goto's must be tsubst'd into. On the other hand,
15155 non-computed gotos must not be; the identifier in question
15156 will have no binding. */
15159 tmp
= DECL_NAME (tmp
);
15160 finish_goto_stmt (tmp
);
15165 tree string
= RECUR (ASM_STRING (t
));
15166 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
15167 complain
, in_decl
);
15168 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
15169 complain
, in_decl
);
15170 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
15171 complain
, in_decl
);
15172 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
15173 complain
, in_decl
);
15174 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
15176 tree asm_expr
= tmp
;
15177 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
15178 asm_expr
= TREE_OPERAND (asm_expr
, 0);
15179 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
15186 stmt
= begin_try_block ();
15187 RECUR (TRY_STMTS (t
));
15188 finish_cleanup_try_block (stmt
);
15189 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
15193 tree compound_stmt
= NULL_TREE
;
15195 if (FN_TRY_BLOCK_P (t
))
15196 stmt
= begin_function_try_block (&compound_stmt
);
15198 stmt
= begin_try_block ();
15200 RECUR (TRY_STMTS (t
));
15202 if (FN_TRY_BLOCK_P (t
))
15203 finish_function_try_block (stmt
);
15205 finish_try_block (stmt
);
15207 RECUR (TRY_HANDLERS (t
));
15208 if (FN_TRY_BLOCK_P (t
))
15209 finish_function_handler_sequence (stmt
, compound_stmt
);
15211 finish_handler_sequence (stmt
);
15217 tree decl
= HANDLER_PARMS (t
);
15221 decl
= tsubst (decl
, args
, complain
, in_decl
);
15222 /* Prevent instantiate_decl from trying to instantiate
15223 this variable. We've already done all that needs to be
15225 if (decl
!= error_mark_node
)
15226 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
15228 stmt
= begin_handler ();
15229 finish_handler_parms (decl
, stmt
);
15230 RECUR (HANDLER_BODY (t
));
15231 finish_handler (stmt
);
15236 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
15237 if (CLASS_TYPE_P (tmp
))
15239 /* Local classes are not independent templates; they are
15240 instantiated along with their containing function. And this
15241 way we don't have to deal with pushing out of one local class
15242 to instantiate a member of another local class. */
15244 /* Closures are handled by the LAMBDA_EXPR. */
15245 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
15246 complete_type (tmp
);
15247 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
15248 if (!DECL_ARTIFICIAL (fn
))
15249 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
15253 case STATIC_ASSERT
:
15257 ++c_inhibit_evaluation_warnings
;
15259 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
15262 /*integral_constant_expression_p=*/true);
15263 --c_inhibit_evaluation_warnings
;
15265 finish_static_assert (condition
,
15266 STATIC_ASSERT_MESSAGE (t
),
15267 STATIC_ASSERT_SOURCE_LOCATION (t
),
15268 /*member_p=*/false);
15273 case OACC_PARALLEL
:
15274 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false, false, args
, complain
,
15276 stmt
= begin_omp_parallel ();
15277 RECUR (OMP_BODY (t
));
15278 finish_omp_construct (TREE_CODE (t
), stmt
, tmp
);
15282 r
= push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t
));
15283 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false, true,
15284 args
, complain
, in_decl
);
15285 if (OMP_PARALLEL_COMBINED (t
))
15286 omp_parallel_combined_clauses
= &tmp
;
15287 stmt
= begin_omp_parallel ();
15288 RECUR (OMP_PARALLEL_BODY (t
));
15289 gcc_assert (omp_parallel_combined_clauses
== NULL
);
15290 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
15291 = OMP_PARALLEL_COMBINED (t
);
15292 pop_omp_privatization_clauses (r
);
15296 r
= push_omp_privatization_clauses (false);
15297 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false, true,
15298 args
, complain
, in_decl
);
15299 stmt
= begin_omp_task ();
15300 RECUR (OMP_TASK_BODY (t
));
15301 finish_omp_task (tmp
, stmt
);
15302 pop_omp_privatization_clauses (r
);
15309 case OMP_DISTRIBUTE
:
15313 tree clauses
, body
, pre_body
;
15314 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
15315 tree orig_declv
= NULL_TREE
;
15316 tree incrv
= NULL_TREE
;
15319 r
= push_omp_privatization_clauses (OMP_FOR_INIT (t
) == NULL_TREE
);
15320 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
15321 TREE_CODE (t
) != OACC_LOOP
,
15322 args
, complain
, in_decl
);
15323 if (OMP_FOR_INIT (t
) != NULL_TREE
)
15325 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
15326 if (OMP_FOR_ORIG_DECLS (t
))
15327 orig_declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
15328 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
15329 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
15330 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
15333 stmt
= begin_omp_structured_block ();
15335 pre_body
= push_stmt_list ();
15336 RECUR (OMP_FOR_PRE_BODY (t
));
15337 pre_body
= pop_stmt_list (pre_body
);
15339 if (OMP_FOR_INIT (t
) != NULL_TREE
)
15340 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
15341 tsubst_omp_for_iterator (t
, i
, declv
, orig_declv
, initv
, condv
,
15342 incrv
, &clauses
, args
, complain
, in_decl
,
15343 integral_constant_expression_p
);
15344 omp_parallel_combined_clauses
= NULL
;
15346 body
= push_stmt_list ();
15347 RECUR (OMP_FOR_BODY (t
));
15348 body
= pop_stmt_list (body
);
15350 if (OMP_FOR_INIT (t
) != NULL_TREE
)
15351 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
,
15352 orig_declv
, initv
, condv
, incrv
, body
, pre_body
,
15356 t
= make_node (TREE_CODE (t
));
15357 TREE_TYPE (t
) = void_type_node
;
15358 OMP_FOR_BODY (t
) = body
;
15359 OMP_FOR_PRE_BODY (t
) = pre_body
;
15360 OMP_FOR_CLAUSES (t
) = clauses
;
15361 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
15365 add_stmt (finish_omp_structured_block (stmt
));
15366 pop_omp_privatization_clauses (r
);
15371 omp_parallel_combined_clauses
= NULL
;
15376 r
= push_omp_privatization_clauses (TREE_CODE (t
) == OMP_TEAMS
15377 && OMP_TEAMS_COMBINED (t
));
15378 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false, true,
15379 args
, complain
, in_decl
);
15380 stmt
= push_stmt_list ();
15381 RECUR (OMP_BODY (t
));
15382 stmt
= pop_stmt_list (stmt
);
15385 OMP_BODY (t
) = stmt
;
15386 OMP_CLAUSES (t
) = tmp
;
15388 pop_omp_privatization_clauses (r
);
15392 case OMP_TARGET_DATA
:
15394 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
15395 TREE_CODE (t
) != OACC_DATA
,
15396 args
, complain
, in_decl
);
15397 keep_next_level (true);
15398 stmt
= begin_omp_structured_block ();
15400 RECUR (OMP_BODY (t
));
15401 stmt
= finish_omp_structured_block (stmt
);
15404 OMP_BODY (t
) = stmt
;
15405 OMP_CLAUSES (t
) = tmp
;
15406 if (TREE_CODE (t
) == OMP_TARGET
&& OMP_TARGET_COMBINED (t
))
15408 tree teams
= cp_walk_tree (&stmt
, tsubst_find_omp_teams
, NULL
, NULL
);
15411 /* For combined target teams, ensure the num_teams and
15412 thread_limit clause expressions are evaluated on the host,
15413 before entering the target construct. */
15415 for (c
= OMP_TEAMS_CLAUSES (teams
);
15416 c
; c
= OMP_CLAUSE_CHAIN (c
))
15417 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
15418 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
15419 && TREE_CODE (OMP_CLAUSE_OPERAND (c
, 0)) != INTEGER_CST
)
15421 tree expr
= OMP_CLAUSE_OPERAND (c
, 0);
15422 expr
= force_target_expr (TREE_TYPE (expr
), expr
, tf_none
);
15423 if (expr
== error_mark_node
)
15425 tmp
= TARGET_EXPR_SLOT (expr
);
15427 OMP_CLAUSE_OPERAND (c
, 0) = expr
;
15428 tree tc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
15429 OMP_CLAUSE_FIRSTPRIVATE
);
15430 OMP_CLAUSE_DECL (tc
) = tmp
;
15431 OMP_CLAUSE_CHAIN (tc
) = OMP_TARGET_CLAUSES (t
);
15432 OMP_TARGET_CLAUSES (t
) = tc
;
15441 tmp
= tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t
), false, false,
15442 args
, complain
, in_decl
);
15443 OACC_DECLARE_CLAUSES (t
) = tmp
;
15447 case OMP_TARGET_UPDATE
:
15448 case OMP_TARGET_ENTER_DATA
:
15449 case OMP_TARGET_EXIT_DATA
:
15450 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), false, true,
15451 args
, complain
, in_decl
);
15453 OMP_STANDALONE_CLAUSES (t
) = tmp
;
15457 case OACC_ENTER_DATA
:
15458 case OACC_EXIT_DATA
:
15460 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), false, false,
15461 args
, complain
, in_decl
);
15463 OMP_STANDALONE_CLAUSES (t
) = tmp
;
15468 tmp
= tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t
), false, true,
15469 args
, complain
, in_decl
);
15470 stmt
= push_stmt_list ();
15471 RECUR (OMP_BODY (t
));
15472 stmt
= pop_stmt_list (stmt
);
15475 OMP_BODY (t
) = stmt
;
15476 OMP_ORDERED_CLAUSES (t
) = tmp
;
15482 case OMP_TASKGROUP
:
15483 stmt
= push_stmt_list ();
15484 RECUR (OMP_BODY (t
));
15485 stmt
= pop_stmt_list (stmt
);
15488 OMP_BODY (t
) = stmt
;
15493 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
15494 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
15496 tree op1
= TREE_OPERAND (t
, 1);
15497 tree rhs1
= NULL_TREE
;
15499 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
15501 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
15502 op1
= TREE_OPERAND (op1
, 1);
15504 lhs
= RECUR (TREE_OPERAND (op1
, 0));
15505 rhs
= RECUR (TREE_OPERAND (op1
, 1));
15506 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
15507 NULL_TREE
, NULL_TREE
, rhs1
,
15508 OMP_ATOMIC_SEQ_CST (t
));
15512 tree op1
= TREE_OPERAND (t
, 1);
15513 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
15514 tree rhs1
= NULL_TREE
;
15515 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
15516 enum tree_code opcode
= NOP_EXPR
;
15517 if (code
== OMP_ATOMIC_READ
)
15519 v
= RECUR (TREE_OPERAND (op1
, 0));
15520 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
15522 else if (code
== OMP_ATOMIC_CAPTURE_OLD
15523 || code
== OMP_ATOMIC_CAPTURE_NEW
)
15525 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
15526 v
= RECUR (TREE_OPERAND (op1
, 0));
15527 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
15528 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
15530 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
15531 op11
= TREE_OPERAND (op11
, 1);
15533 lhs
= RECUR (TREE_OPERAND (op11
, 0));
15534 rhs
= RECUR (TREE_OPERAND (op11
, 1));
15535 opcode
= TREE_CODE (op11
);
15536 if (opcode
== MODIFY_EXPR
)
15542 lhs
= RECUR (TREE_OPERAND (op1
, 0));
15543 rhs
= RECUR (TREE_OPERAND (op1
, 1));
15545 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
15546 OMP_ATOMIC_SEQ_CST (t
));
15550 case TRANSACTION_EXPR
:
15553 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
15554 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
15556 if (TRANSACTION_EXPR_IS_STMT (t
))
15558 tree body
= TRANSACTION_EXPR_BODY (t
);
15559 tree noex
= NULL_TREE
;
15560 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
15562 noex
= MUST_NOT_THROW_COND (body
);
15563 if (noex
== NULL_TREE
)
15564 noex
= boolean_true_node
;
15565 body
= TREE_OPERAND (body
, 0);
15567 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
15569 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
15573 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
15574 RECUR (TRANSACTION_EXPR_BODY (t
)),
15581 case MUST_NOT_THROW_EXPR
:
15583 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15584 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
15585 RETURN (build_must_not_throw_expr (op0
, cond
));
15588 case EXPR_PACK_EXPANSION
:
15589 error ("invalid use of pack expansion expression");
15590 RETURN (error_mark_node
);
15592 case NONTYPE_ARGUMENT_PACK
:
15593 error ("use %<...%> to expand argument pack");
15594 RETURN (error_mark_node
);
15596 case CILK_SPAWN_STMT
:
15597 cfun
->calls_cilk_spawn
= 1;
15598 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
15600 case CILK_SYNC_STMT
:
15601 RETURN (build_cilk_sync ());
15603 case COMPOUND_EXPR
:
15604 tmp
= RECUR (TREE_OPERAND (t
, 0));
15605 if (tmp
== NULL_TREE
)
15606 /* If the first operand was a statement, we're done with it. */
15607 RETURN (RECUR (TREE_OPERAND (t
, 1)));
15608 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
15609 RECUR (TREE_OPERAND (t
, 1)),
15612 case ANNOTATE_EXPR
:
15613 tmp
= RECUR (TREE_OPERAND (t
, 0));
15614 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
15615 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
15618 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
15620 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
15621 /*function_p=*/false,
15622 integral_constant_expression_p
));
15625 RETURN (NULL_TREE
);
15627 input_location
= loc
;
15633 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
15634 function. For description of the body see comment above
15635 cp_parser_omp_declare_reduction_exprs. */
15638 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
15640 if (t
== NULL_TREE
|| t
== error_mark_node
)
15643 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
15645 tree_stmt_iterator tsi
;
15648 memset (stmts
, 0, sizeof stmts
);
15649 for (i
= 0, tsi
= tsi_start (t
);
15650 i
< 7 && !tsi_end_p (tsi
);
15651 i
++, tsi_next (&tsi
))
15652 stmts
[i
] = tsi_stmt (tsi
);
15653 gcc_assert (tsi_end_p (tsi
));
15657 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
15658 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
15659 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
15660 args
, complain
, in_decl
);
15661 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
15662 args
, complain
, in_decl
);
15663 DECL_CONTEXT (omp_out
) = current_function_decl
;
15664 DECL_CONTEXT (omp_in
) = current_function_decl
;
15665 keep_next_level (true);
15666 tree block
= begin_omp_structured_block ();
15667 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
15668 block
= finish_omp_structured_block (block
);
15669 block
= maybe_cleanup_point_expr_void (block
);
15670 add_decl_expr (omp_out
);
15671 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
15672 TREE_NO_WARNING (omp_out
) = 1;
15673 add_decl_expr (omp_in
);
15674 finish_expr_stmt (block
);
15678 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
15679 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
15680 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
15681 args
, complain
, in_decl
);
15682 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
15683 args
, complain
, in_decl
);
15684 DECL_CONTEXT (omp_priv
) = current_function_decl
;
15685 DECL_CONTEXT (omp_orig
) = current_function_decl
;
15686 keep_next_level (true);
15687 tree block
= begin_omp_structured_block ();
15688 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
15689 block
= finish_omp_structured_block (block
);
15690 block
= maybe_cleanup_point_expr_void (block
);
15691 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
15692 add_decl_expr (omp_priv
);
15693 add_decl_expr (omp_orig
);
15694 finish_expr_stmt (block
);
15696 add_decl_expr (omp_orig
);
15700 /* T is a postfix-expression that is not being used in a function
15701 call. Return the substituted version of T. */
15704 tsubst_non_call_postfix_expression (tree t
, tree args
,
15705 tsubst_flags_t complain
,
15708 if (TREE_CODE (t
) == SCOPE_REF
)
15709 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
15710 /*done=*/false, /*address_p=*/false);
15712 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
15713 /*function_p=*/false,
15714 /*integral_constant_expression_p=*/false);
15719 /* Like tsubst but deals with expressions and performs semantic
15720 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
15723 tsubst_copy_and_build (tree t
,
15725 tsubst_flags_t complain
,
15728 bool integral_constant_expression_p
)
15730 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
15731 #define RECUR(NODE) \
15732 tsubst_copy_and_build (NODE, args, complain, in_decl, \
15733 /*function_p=*/false, \
15734 integral_constant_expression_p)
15739 if (t
== NULL_TREE
|| t
== error_mark_node
)
15742 loc
= input_location
;
15743 if (EXPR_HAS_LOCATION (t
))
15744 input_location
= EXPR_LOCATION (t
);
15746 /* N3276 decltype magic only applies to calls at the top level or on the
15747 right side of a comma. */
15748 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
15749 complain
&= ~tf_decltype
;
15751 switch (TREE_CODE (t
))
15755 /* Fall through. */
15756 case IDENTIFIER_NODE
:
15760 bool non_integral_constant_expression_p
;
15761 const char *error_msg
;
15763 if (IDENTIFIER_TYPENAME_P (t
))
15765 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15766 t
= mangle_conv_op_name_for_type (new_type
);
15769 /* Look up the name. */
15770 decl
= lookup_name (t
);
15772 /* By convention, expressions use ERROR_MARK_NODE to indicate
15773 failure, not NULL_TREE. */
15774 if (decl
== NULL_TREE
)
15775 decl
= error_mark_node
;
15777 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
15779 integral_constant_expression_p
,
15780 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
15781 &non_integral_constant_expression_p
,
15782 /*template_p=*/false,
15784 /*address_p=*/false,
15785 /*template_arg_p=*/false,
15790 if (!function_p
&& identifier_p (decl
))
15792 if (complain
& tf_error
)
15793 unqualified_name_lookup_error (decl
);
15794 decl
= error_mark_node
;
15799 case TEMPLATE_ID_EXPR
:
15802 tree templ
= RECUR (TREE_OPERAND (t
, 0));
15803 tree targs
= TREE_OPERAND (t
, 1);
15806 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
15807 if (targs
== error_mark_node
)
15808 return error_mark_node
;
15810 if (variable_template_p (templ
))
15812 templ
= lookup_template_variable (templ
, targs
);
15813 if (!any_dependent_template_arguments_p (targs
))
15815 templ
= finish_template_variable (templ
, complain
);
15818 RETURN (convert_from_reference (templ
));
15821 if (TREE_CODE (templ
) == COMPONENT_REF
)
15823 object
= TREE_OPERAND (templ
, 0);
15824 templ
= TREE_OPERAND (templ
, 1);
15827 object
= NULL_TREE
;
15828 templ
= lookup_template_function (templ
, targs
);
15831 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
15832 object
, templ
, NULL_TREE
));
15834 RETURN (baselink_for_fns (templ
));
15839 tree r
= RECUR (TREE_OPERAND (t
, 0));
15841 if (REFERENCE_REF_P (t
))
15843 /* A type conversion to reference type will be enclosed in
15844 such an indirect ref, but the substitution of the cast
15845 will have also added such an indirect ref. */
15846 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
15847 r
= convert_from_reference (r
);
15850 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
15851 complain
|decltype_flag
);
15857 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15858 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15859 RETURN (build_nop (type
, op0
));
15862 case IMPLICIT_CONV_EXPR
:
15864 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15865 tree expr
= RECUR (TREE_OPERAND (t
, 0));
15866 int flags
= LOOKUP_IMPLICIT
;
15867 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
15868 flags
= LOOKUP_NORMAL
;
15869 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
15875 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15876 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15877 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
15881 case REINTERPRET_CAST_EXPR
:
15882 case CONST_CAST_EXPR
:
15883 case DYNAMIC_CAST_EXPR
:
15884 case STATIC_CAST_EXPR
:
15887 tree op
, r
= NULL_TREE
;
15889 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15890 if (integral_constant_expression_p
15891 && !cast_valid_in_integral_constant_expression_p (type
))
15893 if (complain
& tf_error
)
15894 error ("a cast to a type other than an integral or "
15895 "enumeration type cannot appear in a constant-expression");
15896 RETURN (error_mark_node
);
15899 op
= RECUR (TREE_OPERAND (t
, 0));
15901 warning_sentinel
s(warn_useless_cast
);
15902 switch (TREE_CODE (t
))
15905 r
= build_functional_cast (type
, op
, complain
);
15907 case REINTERPRET_CAST_EXPR
:
15908 r
= build_reinterpret_cast (type
, op
, complain
);
15910 case CONST_CAST_EXPR
:
15911 r
= build_const_cast (type
, op
, complain
);
15913 case DYNAMIC_CAST_EXPR
:
15914 r
= build_dynamic_cast (type
, op
, complain
);
15916 case STATIC_CAST_EXPR
:
15917 r
= build_static_cast (type
, op
, complain
);
15920 gcc_unreachable ();
15926 case POSTDECREMENT_EXPR
:
15927 case POSTINCREMENT_EXPR
:
15928 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15929 args
, complain
, in_decl
);
15930 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
15931 complain
|decltype_flag
));
15933 case PREDECREMENT_EXPR
:
15934 case PREINCREMENT_EXPR
:
15938 case TRUTH_NOT_EXPR
:
15939 case UNARY_PLUS_EXPR
: /* Unary + */
15940 case REALPART_EXPR
:
15941 case IMAGPART_EXPR
:
15942 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
15943 RECUR (TREE_OPERAND (t
, 0)),
15944 complain
|decltype_flag
));
15946 case FIX_TRUNC_EXPR
:
15947 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
15951 op1
= TREE_OPERAND (t
, 0);
15952 if (TREE_CODE (op1
) == LABEL_DECL
)
15953 RETURN (finish_label_address_expr (DECL_NAME (op1
),
15954 EXPR_LOCATION (op1
)));
15955 if (TREE_CODE (op1
) == SCOPE_REF
)
15956 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
15957 /*done=*/true, /*address_p=*/true);
15959 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
15961 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
15962 complain
|decltype_flag
));
15967 case TRUNC_DIV_EXPR
:
15968 case CEIL_DIV_EXPR
:
15969 case FLOOR_DIV_EXPR
:
15970 case ROUND_DIV_EXPR
:
15971 case EXACT_DIV_EXPR
:
15975 case TRUNC_MOD_EXPR
:
15976 case FLOOR_MOD_EXPR
:
15977 case TRUTH_ANDIF_EXPR
:
15978 case TRUTH_ORIF_EXPR
:
15979 case TRUTH_AND_EXPR
:
15980 case TRUTH_OR_EXPR
:
15996 warning_sentinel
s1(warn_type_limits
);
15997 warning_sentinel
s2(warn_div_by_zero
);
15998 warning_sentinel
s3(warn_logical_op
);
15999 warning_sentinel
s4(warn_tautological_compare
);
16000 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16001 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16002 tree r
= build_x_binary_op
16003 (input_location
, TREE_CODE (t
),
16005 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
16007 : TREE_CODE (TREE_OPERAND (t
, 0))),
16009 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
16011 : TREE_CODE (TREE_OPERAND (t
, 1))),
16013 complain
|decltype_flag
);
16014 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
16015 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
16020 case POINTER_PLUS_EXPR
:
16022 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16023 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16024 return fold_build_pointer_plus (op0
, op1
);
16028 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
16029 /*address_p=*/false));
16031 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
16032 args
, complain
, in_decl
);
16033 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
16034 RECUR (TREE_OPERAND (t
, 1)),
16035 complain
|decltype_flag
));
16037 case ARRAY_NOTATION_REF
:
16039 tree start_index
, length
, stride
;
16040 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
16041 args
, complain
, in_decl
);
16042 start_index
= RECUR (ARRAY_NOTATION_START (t
));
16043 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
16044 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
16045 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
16046 length
, stride
, TREE_TYPE (op1
)));
16049 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
16050 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
16057 op1
= TREE_OPERAND (t
, 0);
16058 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
16059 op1
= TREE_TYPE (op1
);
16062 /* When there are no ARGS, we are trying to evaluate a
16063 non-dependent expression from the parser. Trying to do
16064 the substitutions may not work. */
16066 op1
= TREE_TYPE (op1
);
16070 ++cp_unevaluated_operand
;
16071 ++c_inhibit_evaluation_warnings
;
16073 op1
= tsubst (op1
, args
, complain
, in_decl
);
16075 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
16076 /*function_p=*/false,
16077 /*integral_constant_expression_p=*/
16079 --cp_unevaluated_operand
;
16080 --c_inhibit_evaluation_warnings
;
16083 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
16084 complain
& tf_error
);
16086 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
16087 complain
& tf_error
);
16088 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
16090 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
16092 if (!processing_template_decl
&& TYPE_P (op1
))
16094 r
= build_min (SIZEOF_EXPR
, size_type_node
,
16095 build1 (NOP_EXPR
, op1
, error_mark_node
));
16096 SIZEOF_EXPR_TYPE_P (r
) = 1;
16099 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
16100 TREE_SIDE_EFFECTS (r
) = 0;
16101 TREE_READONLY (r
) = 1;
16103 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
16108 case AT_ENCODE_EXPR
:
16110 op1
= TREE_OPERAND (t
, 0);
16111 ++cp_unevaluated_operand
;
16112 ++c_inhibit_evaluation_warnings
;
16113 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
16114 /*function_p=*/false,
16115 /*integral_constant_expression_p=*/false);
16116 --cp_unevaluated_operand
;
16117 --c_inhibit_evaluation_warnings
;
16118 RETURN (objc_build_encode_expr (op1
));
16121 case NOEXCEPT_EXPR
:
16122 op1
= TREE_OPERAND (t
, 0);
16123 ++cp_unevaluated_operand
;
16124 ++c_inhibit_evaluation_warnings
;
16125 ++cp_noexcept_operand
;
16126 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
16127 /*function_p=*/false,
16128 /*integral_constant_expression_p=*/false);
16129 --cp_unevaluated_operand
;
16130 --c_inhibit_evaluation_warnings
;
16131 --cp_noexcept_operand
;
16132 RETURN (finish_noexcept_expr (op1
, complain
));
16136 warning_sentinel
s(warn_div_by_zero
);
16137 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
16138 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
16139 tree r
= build_x_modify_expr
16140 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
16141 complain
|decltype_flag
);
16142 /* TREE_NO_WARNING must be set if either the expression was
16143 parenthesized or it uses an operator such as >>= rather
16144 than plain assignment. In the former case, it was already
16145 set and must be copied. In the latter case,
16146 build_x_modify_expr sets it and it must not be reset
16148 if (TREE_NO_WARNING (t
))
16149 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
16155 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
16156 args
, complain
, in_decl
);
16157 /* Remember that there was a reference to this entity. */
16159 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
16160 RETURN (error_mark_node
);
16161 RETURN (build_x_arrow (input_location
, op1
, complain
));
16165 tree placement
= RECUR (TREE_OPERAND (t
, 0));
16166 tree init
= RECUR (TREE_OPERAND (t
, 3));
16167 vec
<tree
, va_gc
> *placement_vec
;
16168 vec
<tree
, va_gc
> *init_vec
;
16171 if (placement
== NULL_TREE
)
16172 placement_vec
= NULL
;
16175 placement_vec
= make_tree_vector ();
16176 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
16177 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
16180 /* If there was an initializer in the original tree, but it
16181 instantiated to an empty list, then we should pass a
16182 non-NULL empty vector to tell build_new that it was an
16183 empty initializer() rather than no initializer. This can
16184 only happen when the initializer is a pack expansion whose
16185 parameter packs are of length zero. */
16186 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
16190 init_vec
= make_tree_vector ();
16191 if (init
== void_node
)
16192 gcc_assert (init_vec
!= NULL
);
16195 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
16196 vec_safe_push (init_vec
, TREE_VALUE (init
));
16200 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16201 tree op2
= RECUR (TREE_OPERAND (t
, 2));
16202 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
16203 NEW_EXPR_USE_GLOBAL (t
),
16206 if (placement_vec
!= NULL
)
16207 release_tree_vector (placement_vec
);
16208 if (init_vec
!= NULL
)
16209 release_tree_vector (init_vec
);
16216 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16217 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16218 RETURN (delete_sanity (op0
, op1
,
16219 DELETE_EXPR_USE_VEC (t
),
16220 DELETE_EXPR_USE_GLOBAL (t
),
16224 case COMPOUND_EXPR
:
16226 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
16227 complain
& ~tf_decltype
, in_decl
,
16228 /*function_p=*/false,
16229 integral_constant_expression_p
);
16230 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
16232 RECUR (TREE_OPERAND (t
, 1)),
16233 complain
|decltype_flag
));
16239 vec
<tree
, va_gc
> *call_args
;
16240 unsigned int nargs
, i
;
16245 function
= CALL_EXPR_FN (t
);
16246 /* When we parsed the expression, we determined whether or
16247 not Koenig lookup should be performed. */
16248 koenig_p
= KOENIG_LOOKUP_P (t
);
16249 if (TREE_CODE (function
) == SCOPE_REF
)
16251 qualified_p
= true;
16252 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
16254 /*address_p=*/false);
16256 else if (koenig_p
&& identifier_p (function
))
16258 /* Do nothing; calling tsubst_copy_and_build on an identifier
16259 would incorrectly perform unqualified lookup again.
16261 Note that we can also have an IDENTIFIER_NODE if the earlier
16262 unqualified lookup found a member function; in that case
16263 koenig_p will be false and we do want to do the lookup
16264 again to find the instantiated member function.
16266 FIXME but doing that causes c++/15272, so we need to stop
16267 using IDENTIFIER_NODE in that situation. */
16268 qualified_p
= false;
16272 if (TREE_CODE (function
) == COMPONENT_REF
)
16274 tree op
= TREE_OPERAND (function
, 1);
16276 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
16277 || (BASELINK_P (op
)
16278 && BASELINK_QUALIFIED_P (op
)));
16281 qualified_p
= false;
16283 if (TREE_CODE (function
) == ADDR_EXPR
16284 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
16285 /* Avoid error about taking the address of a constructor. */
16286 function
= TREE_OPERAND (function
, 0);
16288 function
= tsubst_copy_and_build (function
, args
, complain
,
16291 integral_constant_expression_p
);
16293 if (BASELINK_P (function
))
16294 qualified_p
= true;
16297 nargs
= call_expr_nargs (t
);
16298 call_args
= make_tree_vector ();
16299 for (i
= 0; i
< nargs
; ++i
)
16301 tree arg
= CALL_EXPR_ARG (t
, i
);
16303 if (!PACK_EXPANSION_P (arg
))
16304 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
16307 /* Expand the pack expansion and push each entry onto
16309 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
16310 if (TREE_CODE (arg
) == TREE_VEC
)
16312 unsigned int len
, j
;
16314 len
= TREE_VEC_LENGTH (arg
);
16315 for (j
= 0; j
< len
; ++j
)
16317 tree value
= TREE_VEC_ELT (arg
, j
);
16318 if (value
!= NULL_TREE
)
16319 value
= convert_from_reference (value
);
16320 vec_safe_push (call_args
, value
);
16325 /* A partial substitution. Add one entry. */
16326 vec_safe_push (call_args
, arg
);
16331 /* We do not perform argument-dependent lookup if normal
16332 lookup finds a non-function, in accordance with the
16333 expected resolution of DR 218. */
16335 && ((is_overloaded_fn (function
)
16336 /* If lookup found a member function, the Koenig lookup is
16337 not appropriate, even if an unqualified-name was used
16338 to denote the function. */
16339 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
16340 || identifier_p (function
))
16341 /* Only do this when substitution turns a dependent call
16342 into a non-dependent call. */
16343 && type_dependent_expression_p_push (t
)
16344 && !any_type_dependent_arguments_p (call_args
))
16345 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
16347 if (identifier_p (function
)
16348 && !any_type_dependent_arguments_p (call_args
))
16350 if (koenig_p
&& (complain
& tf_warning_or_error
))
16352 /* For backwards compatibility and good diagnostics, try
16353 the unqualified lookup again if we aren't in SFINAE
16355 tree unq
= (tsubst_copy_and_build
16356 (function
, args
, complain
, in_decl
, true,
16357 integral_constant_expression_p
));
16358 if (unq
== error_mark_node
)
16359 RETURN (error_mark_node
);
16361 if (unq
!= function
)
16364 if (INDIRECT_REF_P (fn
))
16365 fn
= TREE_OPERAND (fn
, 0);
16366 if (TREE_CODE (fn
) == COMPONENT_REF
)
16367 fn
= TREE_OPERAND (fn
, 1);
16368 if (is_overloaded_fn (fn
))
16369 fn
= get_first_fn (fn
);
16370 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
16371 "%qD was not declared in this scope, "
16372 "and no declarations were found by "
16373 "argument-dependent lookup at the point "
16374 "of instantiation", function
))
16377 /* Can't say anything more. */;
16378 else if (DECL_CLASS_SCOPE_P (fn
))
16380 location_t loc
= EXPR_LOC_OR_LOC (t
,
16383 "declarations in dependent base %qT are "
16384 "not found by unqualified lookup",
16385 DECL_CLASS_CONTEXT (fn
));
16386 if (current_class_ptr
)
16388 "use %<this->%D%> instead", function
);
16391 "use %<%T::%D%> instead",
16392 current_class_name
, function
);
16395 inform (DECL_SOURCE_LOCATION (fn
),
16396 "%qD declared here, later in the "
16397 "translation unit", fn
);
16402 if (identifier_p (function
))
16404 if (complain
& tf_error
)
16405 unqualified_name_lookup_error (function
);
16406 release_tree_vector (call_args
);
16407 RETURN (error_mark_node
);
16411 /* Remember that there was a reference to this entity. */
16412 if (DECL_P (function
)
16413 && !mark_used (function
, complain
) && !(complain
& tf_error
))
16414 RETURN (error_mark_node
);
16416 /* Put back tf_decltype for the actual call. */
16417 complain
|= decltype_flag
;
16419 if (TREE_CODE (function
) == OFFSET_REF
)
16420 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
16422 else if (TREE_CODE (function
) == COMPONENT_REF
)
16424 tree instance
= TREE_OPERAND (function
, 0);
16425 tree fn
= TREE_OPERAND (function
, 1);
16427 if (processing_template_decl
16428 && (type_dependent_expression_p (instance
)
16429 || (!BASELINK_P (fn
)
16430 && TREE_CODE (fn
) != FIELD_DECL
)
16431 || type_dependent_expression_p (fn
)
16432 || any_type_dependent_arguments_p (call_args
)))
16433 ret
= build_nt_call_vec (function
, call_args
);
16434 else if (!BASELINK_P (fn
))
16435 ret
= finish_call_expr (function
, &call_args
,
16436 /*disallow_virtual=*/false,
16437 /*koenig_p=*/false,
16440 ret
= (build_new_method_call
16442 &call_args
, NULL_TREE
,
16443 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
16448 ret
= finish_call_expr (function
, &call_args
,
16449 /*disallow_virtual=*/qualified_p
,
16453 release_tree_vector (call_args
);
16460 tree cond
= RECUR (TREE_OPERAND (t
, 0));
16461 tree folded_cond
= fold_non_dependent_expr (cond
);
16464 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
16466 if (integer_zerop (folded_cond
))
16468 ++c_inhibit_evaluation_warnings
;
16469 exp1
= RECUR (TREE_OPERAND (t
, 1));
16470 --c_inhibit_evaluation_warnings
;
16471 exp2
= RECUR (TREE_OPERAND (t
, 2));
16475 exp1
= RECUR (TREE_OPERAND (t
, 1));
16476 ++c_inhibit_evaluation_warnings
;
16477 exp2
= RECUR (TREE_OPERAND (t
, 2));
16478 --c_inhibit_evaluation_warnings
;
16480 cond
= folded_cond
;
16484 exp1
= RECUR (TREE_OPERAND (t
, 1));
16485 exp2
= RECUR (TREE_OPERAND (t
, 2));
16488 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
16489 cond
, exp1
, exp2
, complain
));
16492 case PSEUDO_DTOR_EXPR
:
16494 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16495 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16496 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
16497 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
16503 tree purpose
, value
, chain
;
16505 if (t
== void_list_node
)
16508 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
16509 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
16511 /* We have pack expansions, so expand those and
16512 create a new list out of it. */
16513 tree purposevec
= NULL_TREE
;
16514 tree valuevec
= NULL_TREE
;
16518 /* Expand the argument expressions. */
16519 if (TREE_PURPOSE (t
))
16520 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
16521 complain
, in_decl
);
16522 if (TREE_VALUE (t
))
16523 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
16524 complain
, in_decl
);
16526 /* Build the rest of the list. */
16527 chain
= TREE_CHAIN (t
);
16528 if (chain
&& chain
!= void_type_node
)
16529 chain
= RECUR (chain
);
16531 /* Determine the number of arguments. */
16532 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
16534 len
= TREE_VEC_LENGTH (purposevec
);
16535 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
16537 else if (TREE_CODE (valuevec
) == TREE_VEC
)
16538 len
= TREE_VEC_LENGTH (valuevec
);
16541 /* Since we only performed a partial substitution into
16542 the argument pack, we only RETURN (a single list
16544 if (purposevec
== TREE_PURPOSE (t
)
16545 && valuevec
== TREE_VALUE (t
)
16546 && chain
== TREE_CHAIN (t
))
16549 RETURN (tree_cons (purposevec
, valuevec
, chain
));
16552 /* Convert the argument vectors into a TREE_LIST */
16556 /* Grab the Ith values. */
16558 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
16561 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
16564 /* Build the list (backwards). */
16565 chain
= tree_cons (purpose
, value
, chain
);
16571 purpose
= TREE_PURPOSE (t
);
16573 purpose
= RECUR (purpose
);
16574 value
= TREE_VALUE (t
);
16576 value
= RECUR (value
);
16577 chain
= TREE_CHAIN (t
);
16578 if (chain
&& chain
!= void_type_node
)
16579 chain
= RECUR (chain
);
16580 if (purpose
== TREE_PURPOSE (t
)
16581 && value
== TREE_VALUE (t
)
16582 && chain
== TREE_CHAIN (t
))
16584 RETURN (tree_cons (purpose
, value
, chain
));
16587 case COMPONENT_REF
:
16594 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
16595 args
, complain
, in_decl
);
16596 /* Remember that there was a reference to this entity. */
16597 if (DECL_P (object
)
16598 && !mark_used (object
, complain
) && !(complain
& tf_error
))
16599 RETURN (error_mark_node
);
16600 object_type
= TREE_TYPE (object
);
16602 member
= TREE_OPERAND (t
, 1);
16603 if (BASELINK_P (member
))
16604 member
= tsubst_baselink (member
,
16605 non_reference (TREE_TYPE (object
)),
16606 args
, complain
, in_decl
);
16608 member
= tsubst_copy (member
, args
, complain
, in_decl
);
16609 if (member
== error_mark_node
)
16610 RETURN (error_mark_node
);
16612 if (type_dependent_expression_p (object
))
16613 /* We can't do much here. */;
16614 else if (!CLASS_TYPE_P (object_type
))
16616 if (scalarish_type_p (object_type
))
16618 tree s
= NULL_TREE
;
16619 tree dtor
= member
;
16621 if (TREE_CODE (dtor
) == SCOPE_REF
)
16623 s
= TREE_OPERAND (dtor
, 0);
16624 dtor
= TREE_OPERAND (dtor
, 1);
16626 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
16628 dtor
= TREE_OPERAND (dtor
, 0);
16630 RETURN (finish_pseudo_destructor_expr
16631 (object
, s
, dtor
, input_location
));
16635 else if (TREE_CODE (member
) == SCOPE_REF
16636 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
16638 /* Lookup the template functions now that we know what the
16640 tree scope
= TREE_OPERAND (member
, 0);
16641 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
16642 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
16643 member
= lookup_qualified_name (scope
, tmpl
,
16644 /*is_type_p=*/false,
16645 /*complain=*/false);
16646 if (BASELINK_P (member
))
16648 BASELINK_FUNCTIONS (member
)
16649 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
16651 member
= (adjust_result_of_qualified_name_lookup
16652 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
16657 qualified_name_lookup_error (scope
, tmpl
, member
,
16659 RETURN (error_mark_node
);
16662 else if (TREE_CODE (member
) == SCOPE_REF
16663 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
16664 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
16666 if (complain
& tf_error
)
16668 if (TYPE_P (TREE_OPERAND (member
, 0)))
16669 error ("%qT is not a class or namespace",
16670 TREE_OPERAND (member
, 0));
16672 error ("%qD is not a class or namespace",
16673 TREE_OPERAND (member
, 0));
16675 RETURN (error_mark_node
);
16677 else if (TREE_CODE (member
) == FIELD_DECL
)
16679 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
16680 if (TREE_CODE (r
) == COMPONENT_REF
)
16681 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
16685 r
= finish_class_member_access_expr (object
, member
,
16686 /*template_p=*/false,
16688 if (TREE_CODE (r
) == COMPONENT_REF
)
16689 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
16694 RETURN (build_throw
16695 (RECUR (TREE_OPERAND (t
, 0))));
16699 vec
<constructor_elt
, va_gc
> *n
;
16700 constructor_elt
*ce
;
16701 unsigned HOST_WIDE_INT idx
;
16702 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16703 bool process_index_p
;
16705 bool need_copy_p
= false;
16708 if (type
== error_mark_node
)
16709 RETURN (error_mark_node
);
16711 /* digest_init will do the wrong thing if we let it. */
16712 if (type
&& TYPE_PTRMEMFUNC_P (type
))
16715 /* We do not want to process the index of aggregate
16716 initializers as they are identifier nodes which will be
16717 looked up by digest_init. */
16718 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
16720 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
16721 newlen
= vec_safe_length (n
);
16722 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
16724 if (ce
->index
&& process_index_p
16725 /* An identifier index is looked up in the type
16726 being initialized, not the current scope. */
16727 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
16728 ce
->index
= RECUR (ce
->index
);
16730 if (PACK_EXPANSION_P (ce
->value
))
16732 /* Substitute into the pack expansion. */
16733 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
16736 if (ce
->value
== error_mark_node
16737 || PACK_EXPANSION_P (ce
->value
))
16739 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
16740 /* Just move the argument into place. */
16741 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
16744 /* Update the length of the final CONSTRUCTOR
16745 arguments vector, and note that we will need to
16747 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
16748 need_copy_p
= true;
16752 ce
->value
= RECUR (ce
->value
);
16757 vec
<constructor_elt
, va_gc
> *old_n
= n
;
16759 vec_alloc (n
, newlen
);
16760 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
16762 if (TREE_CODE (ce
->value
) == TREE_VEC
)
16764 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
16765 for (i
= 0; i
< len
; ++i
)
16766 CONSTRUCTOR_APPEND_ELT (n
, 0,
16767 TREE_VEC_ELT (ce
->value
, i
));
16770 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
16774 r
= build_constructor (init_list_type_node
, n
);
16775 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
16777 if (TREE_HAS_CONSTRUCTOR (t
))
16778 RETURN (finish_compound_literal (type
, r
, complain
));
16780 TREE_TYPE (r
) = type
;
16786 tree operand_0
= TREE_OPERAND (t
, 0);
16787 if (TYPE_P (operand_0
))
16789 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
16790 RETURN (get_typeid (operand_0
, complain
));
16794 operand_0
= RECUR (operand_0
);
16795 RETURN (build_typeid (operand_0
, complain
));
16802 else if (DECL_PACK_P (t
))
16804 /* We don't build decls for an instantiation of a
16805 variadic capture proxy, we instantiate the elements
16807 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
16808 return RECUR (DECL_VALUE_EXPR (t
));
16814 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
16815 /* ??? We're doing a subset of finish_id_expression here. */
16817 && !processing_template_decl
16818 && !cp_unevaluated_operand
16819 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
16820 && CP_DECL_THREAD_LOCAL_P (r
))
16822 if (tree wrap
= get_tls_wrapper_fn (r
))
16823 /* Replace an evaluated use of the thread_local variable with
16824 a call to its wrapper. */
16825 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
16827 else if (outer_automatic_var_p (r
))
16829 r
= process_outer_var_ref (r
, complain
);
16830 if (is_capture_proxy (r
))
16831 register_local_specialization (r
, t
);
16834 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
16835 /* If the original type was a reference, we'll be wrapped in
16836 the appropriate INDIRECT_REF. */
16837 r
= convert_from_reference (r
);
16843 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16844 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16845 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
16848 case OFFSETOF_EXPR
:
16849 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0)),
16850 EXPR_LOCATION (t
)));
16854 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
16855 complain
, in_decl
);
16857 tree type2
= TRAIT_EXPR_TYPE2 (t
);
16858 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
16859 type2
= RECUR (type2
);
16861 type2
= tsubst (type2
, args
, complain
, in_decl
);
16863 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
16868 tree old_stmt_expr
= cur_stmt_expr
;
16869 tree stmt_expr
= begin_stmt_expr ();
16871 cur_stmt_expr
= stmt_expr
;
16872 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
16873 integral_constant_expression_p
);
16874 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
16875 cur_stmt_expr
= old_stmt_expr
;
16877 /* If the resulting list of expression statement is empty,
16878 fold it further into void_node. */
16879 if (empty_expr_stmt_p (stmt_expr
))
16880 stmt_expr
= void_node
;
16882 RETURN (stmt_expr
);
16887 tree r
= build_lambda_expr ();
16889 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
16890 LAMBDA_EXPR_CLOSURE (r
) = type
;
16891 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
16893 LAMBDA_EXPR_LOCATION (r
)
16894 = LAMBDA_EXPR_LOCATION (t
);
16895 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
16896 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
16897 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
16898 LAMBDA_EXPR_DISCRIMINATOR (r
)
16899 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
16900 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
16902 /* No substitution needed. */;
16903 else if (VAR_OR_FUNCTION_DECL_P (scope
))
16904 /* For a function or variable scope, we want to use tsubst so that we
16905 don't complain about referring to an auto before deduction. */
16906 scope
= tsubst (scope
, args
, complain
, in_decl
);
16907 else if (TREE_CODE (scope
) == PARM_DECL
)
16909 /* Look up the parameter we want directly, as tsubst_copy
16910 doesn't do what we need. */
16911 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
16912 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
16913 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
16914 parm
= DECL_CHAIN (parm
);
16916 /* FIXME Work around the parm not having DECL_CONTEXT set. */
16917 if (DECL_CONTEXT (scope
) == NULL_TREE
)
16918 DECL_CONTEXT (scope
) = fn
;
16920 else if (TREE_CODE (scope
) == FIELD_DECL
)
16921 /* For a field, use tsubst_copy so that we look up the existing field
16922 rather than build a new one. */
16923 scope
= RECUR (scope
);
16925 gcc_unreachable ();
16926 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
16927 LAMBDA_EXPR_RETURN_TYPE (r
)
16928 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
16930 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
16931 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
16933 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
16934 determine_visibility (TYPE_NAME (type
));
16935 /* Now that we know visibility, instantiate the type so we have a
16936 declaration of the op() for later calls to lambda_function. */
16937 complete_type (type
);
16939 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
16941 insert_pending_capture_proxies ();
16943 RETURN (build_lambda_object (r
));
16947 /* We can get here for a constant initializer of non-dependent type.
16948 FIXME stop folding in cp_parser_initializer_clause. */
16950 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
16955 case TRANSACTION_EXPR
:
16956 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
16957 integral_constant_expression_p
));
16960 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
16962 case VEC_PERM_EXPR
:
16964 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16965 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16966 tree op2
= RECUR (TREE_OPERAND (t
, 2));
16967 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
16971 case REQUIRES_EXPR
:
16972 RETURN (tsubst_requires_expr (t
, args
, complain
, in_decl
));
16975 /* Handle Objective-C++ constructs, if appropriate. */
16978 = objcp_tsubst_copy_and_build (t
, args
, complain
,
16979 in_decl
, /*function_p=*/false);
16983 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
16989 input_location
= loc
;
16993 /* Verify that the instantiated ARGS are valid. For type arguments,
16994 make sure that the type's linkage is ok. For non-type arguments,
16995 make sure they are constants if they are integral or enumerations.
16996 Emit an error under control of COMPLAIN, and return TRUE on error. */
16999 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
17001 if (dependent_template_arg_p (t
))
17003 if (ARGUMENT_PACK_P (t
))
17005 tree vec
= ARGUMENT_PACK_ARGS (t
);
17006 int len
= TREE_VEC_LENGTH (vec
);
17007 bool result
= false;
17010 for (i
= 0; i
< len
; ++i
)
17011 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
17015 else if (TYPE_P (t
))
17017 /* [basic.link]: A name with no linkage (notably, the name
17018 of a class or enumeration declared in a local scope)
17019 shall not be used to declare an entity with linkage.
17020 This implies that names with no linkage cannot be used as
17023 DR 757 relaxes this restriction for C++0x. */
17024 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
17025 : no_linkage_check (t
, /*relaxed_p=*/false));
17029 /* DR 488 makes use of a type with no linkage cause
17030 type deduction to fail. */
17031 if (complain
& tf_error
)
17033 if (TYPE_ANONYMOUS_P (nt
))
17034 error ("%qT is/uses anonymous type", t
);
17036 error ("template argument for %qD uses local type %qT",
17041 /* In order to avoid all sorts of complications, we do not
17042 allow variably-modified types as template arguments. */
17043 else if (variably_modified_type_p (t
, NULL_TREE
))
17045 if (complain
& tf_error
)
17046 error ("%qT is a variably modified type", t
);
17050 /* Class template and alias template arguments should be OK. */
17051 else if (DECL_TYPE_TEMPLATE_P (t
))
17053 /* A non-type argument of integral or enumerated type must be a
17055 else if (TREE_TYPE (t
)
17056 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
17057 && !REFERENCE_REF_P (t
)
17058 && !TREE_CONSTANT (t
))
17060 if (complain
& tf_error
)
17061 error ("integral expression %qE is not constant", t
);
17068 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
17070 int ix
, len
= DECL_NTPARMS (tmpl
);
17071 bool result
= false;
17073 for (ix
= 0; ix
!= len
; ix
++)
17075 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
17078 if (result
&& (complain
& tf_error
))
17079 error (" trying to instantiate %qD", tmpl
);
17083 /* We're out of SFINAE context now, so generate diagnostics for the access
17084 errors we saw earlier when instantiating D from TMPL and ARGS. */
17087 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
17089 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
17090 tree type
= TREE_TYPE (pattern
);
17091 location_t loc
= input_location
;
17093 push_access_scope (d
);
17094 push_deferring_access_checks (dk_no_deferred
);
17095 input_location
= DECL_SOURCE_LOCATION (pattern
);
17096 tsubst (type
, args
, tf_warning_or_error
, d
);
17097 input_location
= loc
;
17098 pop_deferring_access_checks ();
17099 pop_access_scope (d
);
17102 /* Instantiate the indicated variable, function, or alias template TMPL with
17103 the template arguments in TARG_PTR. */
17106 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
17108 tree targ_ptr
= orig_args
;
17112 bool access_ok
= true;
17114 if (tmpl
== error_mark_node
)
17115 return error_mark_node
;
17117 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
17119 /* If this function is a clone, handle it specially. */
17120 if (DECL_CLONED_FUNCTION_P (tmpl
))
17125 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
17126 DECL_CLONED_FUNCTION. */
17127 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
17128 targ_ptr
, complain
);
17129 if (spec
== error_mark_node
)
17130 return error_mark_node
;
17132 /* Look for the clone. */
17133 FOR_EACH_CLONE (clone
, spec
)
17134 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
17136 /* We should always have found the clone by now. */
17137 gcc_unreachable ();
17141 if (targ_ptr
== error_mark_node
)
17142 return error_mark_node
;
17144 /* Check to see if we already have this specialization. */
17145 gen_tmpl
= most_general_template (tmpl
);
17146 if (tmpl
!= gen_tmpl
)
17147 /* The TMPL is a partial instantiation. To get a full set of
17148 arguments we must add the arguments used to perform the
17149 partial instantiation. */
17150 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
17153 /* It would be nice to avoid hashing here and then again in tsubst_decl,
17154 but it doesn't seem to be on the hot path. */
17155 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
17157 gcc_assert (tmpl
== gen_tmpl
17158 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
17160 || fndecl
== NULL_TREE
);
17162 if (spec
!= NULL_TREE
)
17164 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
17166 if (complain
& tf_error
)
17167 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
17168 return error_mark_node
;
17173 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
17175 return error_mark_node
;
17177 /* We are building a FUNCTION_DECL, during which the access of its
17178 parameters and return types have to be checked. However this
17179 FUNCTION_DECL which is the desired context for access checking
17180 is not built yet. We solve this chicken-and-egg problem by
17181 deferring all checks until we have the FUNCTION_DECL. */
17182 push_deferring_access_checks (dk_deferred
);
17184 /* Instantiation of the function happens in the context of the function
17185 template, not the context of the overload resolution we're doing. */
17186 push_to_top_level ();
17187 /* If there are dependent arguments, e.g. because we're doing partial
17188 ordering, make sure processing_template_decl stays set. */
17189 if (uses_template_parms (targ_ptr
))
17190 ++processing_template_decl
;
17191 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
17193 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
17194 complain
, gen_tmpl
, true);
17195 push_nested_class (ctx
);
17198 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
17200 if (VAR_P (pattern
))
17202 /* We need to determine if we're using a partial or explicit
17203 specialization now, because the type of the variable could be
17205 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
17206 tree elt
= most_specialized_partial_spec (tid
, complain
);
17207 if (elt
== error_mark_node
)
17208 pattern
= error_mark_node
;
17211 tmpl
= TREE_VALUE (elt
);
17212 pattern
= DECL_TEMPLATE_RESULT (tmpl
);
17213 targ_ptr
= TREE_PURPOSE (elt
);
17217 /* Substitute template parameters to obtain the specialization. */
17218 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
17219 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
17220 pop_nested_class ();
17221 pop_from_top_level ();
17223 if (fndecl
== error_mark_node
)
17225 pop_deferring_access_checks ();
17226 return error_mark_node
;
17229 /* The DECL_TI_TEMPLATE should always be the immediate parent
17230 template, not the most general template. */
17231 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
17232 DECL_TI_ARGS (fndecl
) = targ_ptr
;
17234 /* Now we know the specialization, compute access previously
17236 push_access_scope (fndecl
);
17237 if (!perform_deferred_access_checks (complain
))
17239 pop_access_scope (fndecl
);
17240 pop_deferring_access_checks ();
17242 /* If we've just instantiated the main entry point for a function,
17243 instantiate all the alternate entry points as well. We do this
17244 by cloning the instantiation of the main entry point, not by
17245 instantiating the template clones. */
17246 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
17247 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
17251 if (!(complain
& tf_error
))
17253 /* Remember to reinstantiate when we're out of SFINAE so the user
17254 can see the errors. */
17255 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
17257 return error_mark_node
;
17262 /* Wrapper for instantiate_template_1. */
17265 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
17268 timevar_push (TV_TEMPLATE_INST
);
17269 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
17270 timevar_pop (TV_TEMPLATE_INST
);
17274 /* Instantiate the alias template TMPL with ARGS. Also push a template
17275 instantiation level, which instantiate_template doesn't do because
17276 functions and variables have sufficient context established by the
17280 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
17282 struct pending_template
*old_last_pend
= last_pending_template
;
17283 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
17284 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
17285 return error_mark_node
;
17286 tree tinst
= build_tree_list (tmpl
, args
);
17287 if (!push_tinst_level (tinst
))
17290 return error_mark_node
;
17294 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
17295 args
, tmpl
, complain
,
17296 /*require_all_args=*/true,
17297 /*use_default_args=*/true);
17299 tree r
= instantiate_template (tmpl
, args
, complain
);
17300 pop_tinst_level ();
17301 /* We can't free this if a pending_template entry or last_error_tinst_level
17302 is pointing at it. */
17303 if (last_pending_template
== old_last_pend
17304 && last_error_tinst_level
== old_error_tinst
)
17310 /* PARM is a template parameter pack for FN. Returns true iff
17311 PARM is used in a deducible way in the argument list of FN. */
17314 pack_deducible_p (tree parm
, tree fn
)
17316 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
17317 for (; t
; t
= TREE_CHAIN (t
))
17319 tree type
= TREE_VALUE (t
);
17321 if (!PACK_EXPANSION_P (type
))
17323 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
17324 packs
; packs
= TREE_CHAIN (packs
))
17325 if (template_args_equal (TREE_VALUE (packs
), parm
))
17327 /* The template parameter pack is used in a function parameter
17328 pack. If this is the end of the parameter list, the
17329 template parameter pack is deducible. */
17330 if (TREE_CHAIN (t
) == void_list_node
)
17333 /* Otherwise, not. Well, it could be deduced from
17334 a non-pack parameter, but doing so would end up with
17335 a deduction mismatch, so don't bother. */
17339 /* The template parameter pack isn't used in any function parameter
17340 packs, but it might be used deeper, e.g. tuple<Args...>. */
17344 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
17345 NARGS elements of the arguments that are being used when calling
17346 it. TARGS is a vector into which the deduced template arguments
17349 Returns either a FUNCTION_DECL for the matching specialization of FN or
17350 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
17351 true, diagnostics will be printed to explain why it failed.
17353 If FN is a conversion operator, or we are trying to produce a specific
17354 specialization, RETURN_TYPE is the return type desired.
17356 The EXPLICIT_TARGS are explicit template arguments provided via a
17359 The parameter STRICT is one of:
17362 We are deducing arguments for a function call, as in
17363 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
17364 deducing arguments for a call to the result of a conversion
17365 function template, as in [over.call.object].
17368 We are deducing arguments for a conversion function, as in
17369 [temp.deduct.conv].
17372 We are deducing arguments when doing an explicit instantiation
17373 as in [temp.explicit], when determining an explicit specialization
17374 as in [temp.expl.spec], or when taking the address of a function
17375 template, as in [temp.deduct.funcaddr]. */
17378 fn_type_unification (tree fn
,
17379 tree explicit_targs
,
17382 unsigned int nargs
,
17384 unification_kind_t strict
,
17391 tree decl
= NULL_TREE
;
17392 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
17394 static int deduction_depth
;
17395 struct pending_template
*old_last_pend
= last_pending_template
;
17396 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
17397 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
17399 tree r
= error_mark_node
;
17402 complain
|= tf_decltype
;
17404 /* In C++0x, it's possible to have a function template whose type depends
17405 on itself recursively. This is most obvious with decltype, but can also
17406 occur with enumeration scope (c++/48969). So we need to catch infinite
17407 recursion and reject the substitution at deduction time; this function
17408 will return error_mark_node for any repeated substitution.
17410 This also catches excessive recursion such as when f<N> depends on
17411 f<N-1> across all integers, and returns error_mark_node for all the
17412 substitutions back up to the initial one.
17414 This is, of course, not reentrant. */
17415 if (excessive_deduction_depth
)
17416 return error_mark_node
;
17417 tinst
= build_tree_list (fn
, NULL_TREE
);
17420 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
17422 fntype
= TREE_TYPE (fn
);
17423 if (explicit_targs
)
17427 The specified template arguments must match the template
17428 parameters in kind (i.e., type, nontype, template), and there
17429 must not be more arguments than there are parameters;
17430 otherwise type deduction fails.
17432 Nontype arguments must match the types of the corresponding
17433 nontype template parameters, or must be convertible to the
17434 types of the corresponding nontype parameters as specified in
17435 _temp.arg.nontype_, otherwise type deduction fails.
17437 All references in the function type of the function template
17438 to the corresponding template parameters are replaced by the
17439 specified template argument values. If a substitution in a
17440 template parameter or in the function type of the function
17441 template results in an invalid type, type deduction fails. */
17442 int i
, len
= TREE_VEC_LENGTH (tparms
);
17443 location_t loc
= input_location
;
17444 bool incomplete
= false;
17446 /* Adjust any explicit template arguments before entering the
17447 substitution context. */
17449 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
17451 /*require_all_args=*/false,
17452 /*use_default_args=*/false));
17453 if (explicit_targs
== error_mark_node
)
17456 /* Substitute the explicit args into the function type. This is
17457 necessary so that, for instance, explicitly declared function
17458 arguments can match null pointed constants. If we were given
17459 an incomplete set of explicit args, we must not do semantic
17460 processing during substitution as we could create partial
17462 for (i
= 0; i
< len
; i
++)
17464 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
17465 bool parameter_pack
= false;
17466 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
17468 /* Dig out the actual parm. */
17469 if (TREE_CODE (parm
) == TYPE_DECL
17470 || TREE_CODE (parm
) == TEMPLATE_DECL
)
17472 parm
= TREE_TYPE (parm
);
17473 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
17475 else if (TREE_CODE (parm
) == PARM_DECL
)
17477 parm
= DECL_INITIAL (parm
);
17478 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
17481 if (!parameter_pack
&& targ
== NULL_TREE
)
17482 /* No explicit argument for this template parameter. */
17485 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
17487 /* Mark the argument pack as "incomplete". We could
17488 still deduce more arguments during unification.
17489 We remove this mark in type_unification_real. */
17492 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
17493 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
17494 = ARGUMENT_PACK_ARGS (targ
);
17497 /* We have some incomplete argument packs. */
17502 TREE_VALUE (tinst
) = explicit_targs
;
17503 if (!push_tinst_level (tinst
))
17505 excessive_deduction_depth
= true;
17508 processing_template_decl
+= incomplete
;
17509 input_location
= DECL_SOURCE_LOCATION (fn
);
17510 /* Ignore any access checks; we'll see them again in
17511 instantiate_template and they might have the wrong
17512 access path at this point. */
17513 push_deferring_access_checks (dk_deferred
);
17514 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
17515 complain
| tf_partial
, NULL_TREE
);
17516 pop_deferring_access_checks ();
17517 input_location
= loc
;
17518 processing_template_decl
-= incomplete
;
17519 pop_tinst_level ();
17521 if (fntype
== error_mark_node
)
17524 /* Place the explicitly specified arguments in TARGS. */
17525 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
17526 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
17529 /* Never do unification on the 'this' parameter. */
17530 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
17532 if (return_type
&& strict
== DEDUCE_CALL
)
17534 /* We're deducing for a call to the result of a template conversion
17535 function. The parms we really want are in return_type. */
17536 if (POINTER_TYPE_P (return_type
))
17537 return_type
= TREE_TYPE (return_type
);
17538 parms
= TYPE_ARG_TYPES (return_type
);
17540 else if (return_type
)
17544 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
17545 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
17546 new_args
[0] = return_type
;
17547 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
17552 /* We allow incomplete unification without an error message here
17553 because the standard doesn't seem to explicitly prohibit it. Our
17554 callers must be ready to deal with unification failures in any
17557 TREE_VALUE (tinst
) = targs
;
17558 /* If we aren't explaining yet, push tinst context so we can see where
17559 any errors (e.g. from class instantiations triggered by instantiation
17560 of default template arguments) come from. If we are explaining, this
17561 context is redundant. */
17562 if (!explain_p
&& !push_tinst_level (tinst
))
17564 excessive_deduction_depth
= true;
17568 /* type_unification_real will pass back any access checks from default
17569 template argument substitution. */
17570 vec
<deferred_access_check
, va_gc
> *checks
;
17573 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17574 targs
, parms
, args
, nargs
, /*subr=*/0,
17575 strict
, flags
, &checks
, explain_p
);
17577 pop_tinst_level ();
17581 /* Now that we have bindings for all of the template arguments,
17582 ensure that the arguments deduced for the template template
17583 parameters have compatible template parameter lists. We cannot
17584 check this property before we have deduced all template
17585 arguments, because the template parameter types of a template
17586 template parameter might depend on prior template parameters
17587 deduced after the template template parameter. The following
17588 ill-formed example illustrates this issue:
17590 template<typename T, template<T> class C> void f(C<5>, T);
17592 template<int N> struct X {};
17595 f(X<5>(), 5l); // error: template argument deduction fails
17598 The template parameter list of 'C' depends on the template type
17599 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
17600 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
17601 time that we deduce 'C'. */
17602 if (!template_template_parm_bindings_ok_p
17603 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
17605 unify_inconsistent_template_template_parameters (explain_p
);
17609 /* All is well so far. Now, check:
17613 When all template arguments have been deduced, all uses of
17614 template parameters in nondeduced contexts are replaced with
17615 the corresponding deduced argument values. If the
17616 substitution results in an invalid type, as described above,
17617 type deduction fails. */
17618 TREE_VALUE (tinst
) = targs
;
17619 if (!push_tinst_level (tinst
))
17621 excessive_deduction_depth
= true;
17625 /* Also collect access checks from the instantiation. */
17626 reopen_deferring_access_checks (checks
);
17628 decl
= instantiate_template (fn
, targs
, complain
);
17630 checks
= get_deferred_access_checks ();
17631 pop_deferring_access_checks ();
17633 pop_tinst_level ();
17635 if (decl
== error_mark_node
)
17638 /* Now perform any access checks encountered during substitution. */
17639 push_access_scope (decl
);
17640 ok
= perform_access_checks (checks
, complain
);
17641 pop_access_scope (decl
);
17645 /* If we're looking for an exact match, check that what we got
17646 is indeed an exact match. It might not be if some template
17647 parameters are used in non-deduced contexts. But don't check
17648 for an exact match if we have dependent template arguments;
17649 in that case we're doing partial ordering, and we already know
17650 that we have two candidates that will provide the actual type. */
17651 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
17653 tree substed
= TREE_TYPE (decl
);
17657 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
17659 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
17660 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
17661 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
17663 unify_type_mismatch (explain_p
, args
[i
],
17664 TREE_VALUE (sarg
));
17673 if (excessive_deduction_depth
)
17675 if (deduction_depth
== 0)
17676 /* Reset once we're all the way out. */
17677 excessive_deduction_depth
= false;
17680 /* We can't free this if a pending_template entry or last_error_tinst_level
17681 is pointing at it. */
17682 if (last_pending_template
== old_last_pend
17683 && last_error_tinst_level
== old_error_tinst
)
17689 /* Adjust types before performing type deduction, as described in
17690 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
17691 sections are symmetric. PARM is the type of a function parameter
17692 or the return type of the conversion function. ARG is the type of
17693 the argument passed to the call, or the type of the value
17694 initialized with the result of the conversion function.
17695 ARG_EXPR is the original argument expression, which may be null. */
17698 maybe_adjust_types_for_deduction (unification_kind_t strict
,
17711 /* Swap PARM and ARG throughout the remainder of this
17712 function; the handling is precisely symmetric since PARM
17713 will initialize ARG rather than vice versa. */
17714 std::swap (parm
, arg
);
17718 /* Core issue #873: Do the DR606 thing (see below) for these cases,
17719 too, but here handle it by stripping the reference from PARM
17720 rather than by adding it to ARG. */
17721 if (TREE_CODE (*parm
) == REFERENCE_TYPE
17722 && TYPE_REF_IS_RVALUE (*parm
)
17723 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
17724 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
17725 && TREE_CODE (*arg
) == REFERENCE_TYPE
17726 && !TYPE_REF_IS_RVALUE (*arg
))
17727 *parm
= TREE_TYPE (*parm
);
17728 /* Nothing else to do in this case. */
17732 gcc_unreachable ();
17735 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
17737 /* [temp.deduct.call]
17739 If P is not a reference type:
17741 --If A is an array type, the pointer type produced by the
17742 array-to-pointer standard conversion (_conv.array_) is
17743 used in place of A for type deduction; otherwise,
17745 --If A is a function type, the pointer type produced by
17746 the function-to-pointer standard conversion
17747 (_conv.func_) is used in place of A for type deduction;
17750 --If A is a cv-qualified type, the top level
17751 cv-qualifiers of A's type are ignored for type
17753 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
17754 *arg
= build_pointer_type (TREE_TYPE (*arg
));
17755 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
17756 *arg
= build_pointer_type (*arg
);
17758 *arg
= TYPE_MAIN_VARIANT (*arg
);
17761 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
17762 of the form T&&, where T is a template parameter, and the argument
17763 is an lvalue, T is deduced as A& */
17764 if (TREE_CODE (*parm
) == REFERENCE_TYPE
17765 && TYPE_REF_IS_RVALUE (*parm
)
17766 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
17767 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
17768 && (arg_expr
? real_lvalue_p (arg_expr
)
17769 /* try_one_overload doesn't provide an arg_expr, but
17770 functions are always lvalues. */
17771 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
17772 *arg
= build_reference_type (*arg
);
17774 /* [temp.deduct.call]
17776 If P is a cv-qualified type, the top level cv-qualifiers
17777 of P's type are ignored for type deduction. If P is a
17778 reference type, the type referred to by P is used for
17780 *parm
= TYPE_MAIN_VARIANT (*parm
);
17781 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
17783 *parm
= TREE_TYPE (*parm
);
17784 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17787 /* DR 322. For conversion deduction, remove a reference type on parm
17788 too (which has been swapped into ARG). */
17789 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
17790 *arg
= TREE_TYPE (*arg
);
17795 /* Subroutine of unify_one_argument. PARM is a function parameter of a
17796 template which does contain any deducible template parameters; check if
17797 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
17798 unify_one_argument. */
17801 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
17802 int flags
, bool explain_p
)
17807 type
= TREE_TYPE (arg
);
17811 if (same_type_p (parm
, type
))
17812 return unify_success (explain_p
);
17814 if (strict
== DEDUCE_CONV
)
17816 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
17817 explain_p
? tf_warning_or_error
: tf_none
))
17818 return unify_success (explain_p
);
17820 else if (strict
!= DEDUCE_EXACT
)
17822 if (can_convert_arg (parm
, type
,
17823 TYPE_P (arg
) ? NULL_TREE
: arg
,
17824 flags
, explain_p
? tf_warning_or_error
: tf_none
))
17825 return unify_success (explain_p
);
17828 if (strict
== DEDUCE_EXACT
)
17829 return unify_type_mismatch (explain_p
, parm
, arg
);
17831 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
17834 static bool uses_deducible_template_parms (tree type
);
17836 /* Returns true iff the expression EXPR is one from which a template
17837 argument can be deduced. In other words, if it's an undecorated
17838 use of a template non-type parameter. */
17841 deducible_expression (tree expr
)
17843 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
17846 /* Returns true iff the array domain DOMAIN uses a template parameter in a
17847 deducible way; that is, if it has a max value of <PARM> - 1. */
17850 deducible_array_bound (tree domain
)
17852 if (domain
== NULL_TREE
)
17855 tree max
= TYPE_MAX_VALUE (domain
);
17856 if (TREE_CODE (max
) != MINUS_EXPR
)
17859 return deducible_expression (TREE_OPERAND (max
, 0));
17862 /* Returns true iff the template arguments ARGS use a template parameter
17863 in a deducible way. */
17866 deducible_template_args (tree args
)
17868 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
17871 tree elt
= TREE_VEC_ELT (args
, i
);
17872 if (ARGUMENT_PACK_P (elt
))
17873 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
17876 if (PACK_EXPANSION_P (elt
))
17877 elt
= PACK_EXPANSION_PATTERN (elt
);
17878 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
17880 else if (TYPE_P (elt
))
17881 deducible
= uses_deducible_template_parms (elt
);
17883 deducible
= deducible_expression (elt
);
17891 /* Returns true iff TYPE contains any deducible references to template
17892 parameters, as per 14.8.2.5. */
17895 uses_deducible_template_parms (tree type
)
17897 if (PACK_EXPANSION_P (type
))
17898 type
= PACK_EXPANSION_PATTERN (type
);
17905 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
17906 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17912 if (POINTER_TYPE_P (type
))
17913 return uses_deducible_template_parms (TREE_TYPE (type
));
17915 /* T[integer-constant ]
17917 if (TREE_CODE (type
) == ARRAY_TYPE
)
17918 return (uses_deducible_template_parms (TREE_TYPE (type
))
17919 || deducible_array_bound (TYPE_DOMAIN (type
)));
17931 if (TYPE_PTRMEM_P (type
))
17932 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
17933 || (uses_deducible_template_parms
17934 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
17936 /* template-name <T> (where template-name refers to a class template)
17937 template-name <i> (where template-name refers to a class template) */
17938 if (CLASS_TYPE_P (type
)
17939 && CLASSTYPE_TEMPLATE_INFO (type
)
17940 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
17941 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
17942 (CLASSTYPE_TI_ARGS (type
)));
17947 if (TREE_CODE (type
) == FUNCTION_TYPE
17948 || TREE_CODE (type
) == METHOD_TYPE
)
17950 if (uses_deducible_template_parms (TREE_TYPE (type
)))
17952 tree parm
= TYPE_ARG_TYPES (type
);
17953 if (TREE_CODE (type
) == METHOD_TYPE
)
17954 parm
= TREE_CHAIN (parm
);
17955 for (; parm
; parm
= TREE_CHAIN (parm
))
17956 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
17963 /* Subroutine of type_unification_real and unify_pack_expansion to
17964 handle unification of a single P/A pair. Parameters are as
17965 for those functions. */
17968 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
17969 int subr
, unification_kind_t strict
,
17972 tree arg_expr
= NULL_TREE
;
17975 if (arg
== error_mark_node
|| parm
== error_mark_node
)
17976 return unify_invalid (explain_p
);
17977 if (arg
== unknown_type_node
)
17978 /* We can't deduce anything from this, but we might get all the
17979 template args from other function args. */
17980 return unify_success (explain_p
);
17982 /* Implicit conversions (Clause 4) will be performed on a function
17983 argument to convert it to the type of the corresponding function
17984 parameter if the parameter type contains no template-parameters that
17985 participate in template argument deduction. */
17986 if (strict
!= DEDUCE_EXACT
17987 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
17988 /* For function parameters with no deducible template parameters,
17989 just return. We'll check non-dependent conversions later. */
17990 return unify_success (explain_p
);
17995 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
17996 | UNIFY_ALLOW_MORE_CV_QUAL
17997 | UNIFY_ALLOW_DERIVED
);
18001 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
18005 arg_strict
= UNIFY_ALLOW_NONE
;
18009 gcc_unreachable ();
18012 /* We only do these transformations if this is the top-level
18013 parameter_type_list in a call or declaration matching; in other
18014 situations (nested function declarators, template argument lists) we
18015 won't be comparing a type to an expression, and we don't do any type
18021 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
18022 if (type_unknown_p (arg
))
18024 /* [temp.deduct.type] A template-argument can be
18025 deduced from a pointer to function or pointer
18026 to member function argument if the set of
18027 overloaded functions does not contain function
18028 templates and at most one of a set of
18029 overloaded functions provides a unique
18032 if (resolve_overloaded_unification
18033 (tparms
, targs
, parm
, arg
, strict
,
18034 arg_strict
, explain_p
))
18035 return unify_success (explain_p
);
18036 return unify_overload_resolution_failure (explain_p
, arg
);
18040 arg
= unlowered_expr_type (arg
);
18041 if (arg
== error_mark_node
)
18042 return unify_invalid (explain_p
);
18046 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
18049 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
18050 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
18051 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18053 /* For deduction from an init-list we need the actual list. */
18054 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
18056 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
18059 /* Most parms like fn_type_unification.
18061 If SUBR is 1, we're being called recursively (to unify the
18062 arguments of a function or method parameter of a function
18065 CHECKS is a pointer to a vector of access checks encountered while
18066 substituting default template arguments. */
18069 type_unification_real (tree tparms
,
18073 unsigned int xnargs
,
18075 unification_kind_t strict
,
18077 vec
<deferred_access_check
, va_gc
> **checks
,
18082 int ntparms
= TREE_VEC_LENGTH (tparms
);
18083 int saw_undeduced
= 0;
18086 unsigned int nargs
;
18089 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
18090 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
18091 gcc_assert (ntparms
> 0);
18093 /* Reset the number of non-defaulted template arguments contained
18095 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
18103 while (parms
&& parms
!= void_list_node
18106 parm
= TREE_VALUE (parms
);
18108 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
18109 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
18110 /* For a function parameter pack that occurs at the end of the
18111 parameter-declaration-list, the type A of each remaining
18112 argument of the call is compared with the type P of the
18113 declarator-id of the function parameter pack. */
18116 parms
= TREE_CHAIN (parms
);
18118 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
18119 /* For a function parameter pack that does not occur at the
18120 end of the parameter-declaration-list, the type of the
18121 parameter pack is a non-deduced context. */
18127 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
18133 && parms
!= void_list_node
18134 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
18136 /* Unify the remaining arguments with the pack expansion type. */
18138 tree parmvec
= make_tree_vec (1);
18140 /* Allocate a TREE_VEC and copy in all of the arguments */
18141 argvec
= make_tree_vec (nargs
- ia
);
18142 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
18143 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
18145 /* Copy the parameter into parmvec. */
18146 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
18147 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
18148 /*subr=*/subr
, explain_p
))
18151 /* Advance to the end of the list of parameters. */
18152 parms
= TREE_CHAIN (parms
);
18155 /* Fail if we've reached the end of the parm list, and more args
18156 are present, and the parm list isn't variadic. */
18157 if (ia
< nargs
&& parms
== void_list_node
)
18158 return unify_too_many_arguments (explain_p
, nargs
, ia
);
18159 /* Fail if parms are left and they don't have default values and
18160 they aren't all deduced as empty packs (c++/57397). This is
18161 consistent with sufficient_parms_p. */
18162 if (parms
&& parms
!= void_list_node
18163 && TREE_PURPOSE (parms
) == NULL_TREE
)
18165 unsigned int count
= nargs
;
18170 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
18173 p
= TREE_CHAIN (p
);
18175 while (p
&& p
!= void_list_node
);
18176 if (count
!= nargs
)
18177 return unify_too_few_arguments (explain_p
, ia
, count
,
18183 tsubst_flags_t complain
= (explain_p
18184 ? tf_warning_or_error
18187 for (i
= 0; i
< ntparms
; i
++)
18189 tree targ
= TREE_VEC_ELT (targs
, i
);
18190 tree tparm
= TREE_VEC_ELT (tparms
, i
);
18192 /* Clear the "incomplete" flags on all argument packs now so that
18193 substituting them into later default arguments works. */
18194 if (targ
&& ARGUMENT_PACK_P (targ
))
18196 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
18197 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
18200 if (targ
|| tparm
== error_mark_node
)
18202 tparm
= TREE_VALUE (tparm
);
18204 /* If this is an undeduced nontype parameter that depends on
18205 a type parameter, try another pass; its type may have been
18206 deduced from a later argument than the one from which
18207 this parameter can be deduced. */
18208 if (TREE_CODE (tparm
) == PARM_DECL
18209 && uses_template_parms (TREE_TYPE (tparm
))
18210 && saw_undeduced
< 2)
18216 /* Core issue #226 (C++0x) [temp.deduct]:
18218 If a template argument has not been deduced, its
18219 default template argument, if any, is used.
18221 When we are in C++98 mode, TREE_PURPOSE will either
18222 be NULL_TREE or ERROR_MARK_NODE, so we do not need
18223 to explicitly check cxx_dialect here. */
18224 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
18225 /* OK, there is a default argument. Wait until after the
18226 conversion check to do substitution. */
18229 /* If the type parameter is a parameter pack, then it will
18230 be deduced to an empty parameter pack. */
18231 if (template_parameter_pack_p (tparm
))
18235 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
18237 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
18238 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
18239 TREE_CONSTANT (arg
) = 1;
18242 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
18244 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
18246 TREE_VEC_ELT (targs
, i
) = arg
;
18250 return unify_parameter_deduction_failure (explain_p
, tparm
);
18253 /* DR 1391: All parameters have args, now check non-dependent parms for
18255 if (saw_undeduced
< 2)
18256 for (ia
= 0, parms
= xparms
, args
= xargs
, nargs
= xnargs
;
18257 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
18259 parm
= TREE_VALUE (parms
);
18261 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
18262 && (!TREE_CHAIN (parms
)
18263 || TREE_CHAIN (parms
) == void_list_node
))
18264 /* For a function parameter pack that occurs at the end of the
18265 parameter-declaration-list, the type A of each remaining
18266 argument of the call is compared with the type P of the
18267 declarator-id of the function parameter pack. */
18270 parms
= TREE_CHAIN (parms
);
18272 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
18273 /* For a function parameter pack that does not occur at the
18274 end of the parameter-declaration-list, the type of the
18275 parameter pack is a non-deduced context. */
18281 if (uses_template_parms (parm
))
18283 if (check_non_deducible_conversion (parm
, arg
, strict
, flags
,
18288 /* Now substitute into the default template arguments. */
18289 for (i
= 0; i
< ntparms
; i
++)
18291 tree targ
= TREE_VEC_ELT (targs
, i
);
18292 tree tparm
= TREE_VEC_ELT (tparms
, i
);
18294 if (targ
|| tparm
== error_mark_node
)
18296 tree parm
= TREE_VALUE (tparm
);
18298 if (TREE_CODE (parm
) == PARM_DECL
18299 && uses_template_parms (TREE_TYPE (parm
))
18300 && saw_undeduced
< 2)
18303 tree arg
= TREE_PURPOSE (tparm
);
18304 reopen_deferring_access_checks (*checks
);
18305 location_t save_loc
= input_location
;
18307 input_location
= DECL_SOURCE_LOCATION (parm
);
18308 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
18309 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
18311 input_location
= save_loc
;
18312 *checks
= get_deferred_access_checks ();
18313 pop_deferring_access_checks ();
18314 if (arg
== error_mark_node
)
18318 TREE_VEC_ELT (targs
, i
) = arg
;
18319 /* The position of the first default template argument,
18320 is also the number of non-defaulted arguments in TARGS.
18322 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
18323 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
18328 if (saw_undeduced
++ == 1)
18332 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
18333 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
18335 return unify_success (explain_p
);
18338 /* Subroutine of type_unification_real. Args are like the variables
18339 at the call site. ARG is an overloaded function (or template-id);
18340 we try deducing template args from each of the overloads, and if
18341 only one succeeds, we go with that. Modifies TARGS and returns
18342 true on success. */
18345 resolve_overloaded_unification (tree tparms
,
18349 unification_kind_t strict
,
18353 tree tempargs
= copy_node (targs
);
18355 tree goodfn
= NULL_TREE
;
18358 if (TREE_CODE (arg
) == ADDR_EXPR
)
18360 arg
= TREE_OPERAND (arg
, 0);
18366 if (TREE_CODE (arg
) == COMPONENT_REF
)
18367 /* Handle `&x' where `x' is some static or non-static member
18369 arg
= TREE_OPERAND (arg
, 1);
18371 if (TREE_CODE (arg
) == OFFSET_REF
)
18372 arg
= TREE_OPERAND (arg
, 1);
18374 /* Strip baselink information. */
18375 if (BASELINK_P (arg
))
18376 arg
= BASELINK_FUNCTIONS (arg
);
18378 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
18380 /* If we got some explicit template args, we need to plug them into
18381 the affected templates before we try to unify, in case the
18382 explicit args will completely resolve the templates in question. */
18385 tree expl_subargs
= TREE_OPERAND (arg
, 1);
18386 arg
= TREE_OPERAND (arg
, 0);
18388 for (; arg
; arg
= OVL_NEXT (arg
))
18390 tree fn
= OVL_CURRENT (arg
);
18391 tree subargs
, elem
;
18393 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
18396 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
18397 expl_subargs
, NULL_TREE
, tf_none
,
18398 /*require_all_args=*/true,
18399 /*use_default_args=*/true);
18400 if (subargs
!= error_mark_node
18401 && !any_dependent_template_arguments_p (subargs
))
18403 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
18404 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
18405 elem
, strict
, sub_strict
, addr_p
, explain_p
)
18406 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
18415 /* If no templates (or more than one) are fully resolved by the
18416 explicit arguments, this template-id is a non-deduced context; it
18417 could still be OK if we deduce all template arguments for the
18418 enclosing call through other arguments. */
18422 else if (TREE_CODE (arg
) != OVERLOAD
18423 && TREE_CODE (arg
) != FUNCTION_DECL
)
18424 /* If ARG is, for example, "(0, &f)" then its type will be unknown
18425 -- but the deduction does not succeed because the expression is
18426 not just the function on its own. */
18429 for (; arg
; arg
= OVL_NEXT (arg
))
18430 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
18431 TREE_TYPE (OVL_CURRENT (arg
)),
18432 strict
, sub_strict
, addr_p
, explain_p
)
18433 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
18435 goodfn
= OVL_CURRENT (arg
);
18439 /* [temp.deduct.type] A template-argument can be deduced from a pointer
18440 to function or pointer to member function argument if the set of
18441 overloaded functions does not contain function templates and at most
18442 one of a set of overloaded functions provides a unique match.
18444 So if we found multiple possibilities, we return success but don't
18445 deduce anything. */
18449 int i
= TREE_VEC_LENGTH (targs
);
18451 if (TREE_VEC_ELT (tempargs
, i
))
18453 tree old
= TREE_VEC_ELT (targs
, i
);
18454 tree new_
= TREE_VEC_ELT (tempargs
, i
);
18455 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
18456 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
18457 /* Don't forget explicit template arguments in a pack. */
18458 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
18459 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
18460 TREE_VEC_ELT (targs
, i
) = new_
;
18469 /* Core DR 115: In contexts where deduction is done and fails, or in
18470 contexts where deduction is not done, if a template argument list is
18471 specified and it, along with any default template arguments, identifies
18472 a single function template specialization, then the template-id is an
18473 lvalue for the function template specialization. */
18476 resolve_nondeduced_context (tree orig_expr
)
18478 tree expr
, offset
, baselink
;
18481 if (!type_unknown_p (orig_expr
))
18486 offset
= NULL_TREE
;
18487 baselink
= NULL_TREE
;
18489 if (TREE_CODE (expr
) == ADDR_EXPR
)
18491 expr
= TREE_OPERAND (expr
, 0);
18494 if (TREE_CODE (expr
) == OFFSET_REF
)
18497 expr
= TREE_OPERAND (expr
, 1);
18499 if (BASELINK_P (expr
))
18502 expr
= BASELINK_FUNCTIONS (expr
);
18505 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
18508 tree goodfn
= NULL_TREE
;
18510 /* If we got some explicit template args, we need to plug them into
18511 the affected templates before we try to unify, in case the
18512 explicit args will completely resolve the templates in question. */
18514 tree expl_subargs
= TREE_OPERAND (expr
, 1);
18515 tree arg
= TREE_OPERAND (expr
, 0);
18516 tree badfn
= NULL_TREE
;
18517 tree badargs
= NULL_TREE
;
18519 for (; arg
; arg
= OVL_NEXT (arg
))
18521 tree fn
= OVL_CURRENT (arg
);
18522 tree subargs
, elem
;
18524 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
18527 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
18528 expl_subargs
, NULL_TREE
, tf_none
,
18529 /*require_all_args=*/true,
18530 /*use_default_args=*/true);
18531 if (subargs
!= error_mark_node
18532 && !any_dependent_template_arguments_p (subargs
))
18534 elem
= instantiate_template (fn
, subargs
, tf_none
);
18535 if (elem
== error_mark_node
)
18540 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
18549 mark_used (goodfn
);
18552 expr
= build_baselink (BASELINK_BINFO (baselink
),
18553 BASELINK_ACCESS_BINFO (baselink
),
18554 expr
, BASELINK_OPTYPE (baselink
));
18558 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
18559 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
18562 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
18565 else if (good
== 0 && badargs
)
18566 /* There were no good options and at least one bad one, so let the
18567 user know what the problem is. */
18568 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
18573 /* Subroutine of resolve_overloaded_unification; does deduction for a single
18574 overload. Fills TARGS with any deduced arguments, or error_mark_node if
18575 different overloads deduce different arguments for a given parm.
18576 ADDR_P is true if the expression for which deduction is being
18577 performed was of the form "& fn" rather than simply "fn".
18579 Returns 1 on success. */
18582 try_one_overload (tree tparms
,
18587 unification_kind_t strict
,
18596 if (arg
== error_mark_node
)
18599 /* [temp.deduct.type] A template-argument can be deduced from a pointer
18600 to function or pointer to member function argument if the set of
18601 overloaded functions does not contain function templates and at most
18602 one of a set of overloaded functions provides a unique match.
18604 So if this is a template, just return success. */
18606 if (uses_template_parms (arg
))
18609 if (TREE_CODE (arg
) == METHOD_TYPE
)
18610 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
18612 arg
= build_pointer_type (arg
);
18614 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
18616 /* We don't copy orig_targs for this because if we have already deduced
18617 some template args from previous args, unify would complain when we
18618 try to deduce a template parameter for the same argument, even though
18619 there isn't really a conflict. */
18620 nargs
= TREE_VEC_LENGTH (targs
);
18621 tempargs
= make_tree_vec (nargs
);
18623 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
18626 /* First make sure we didn't deduce anything that conflicts with
18627 explicitly specified args. */
18628 for (i
= nargs
; i
--; )
18630 tree elt
= TREE_VEC_ELT (tempargs
, i
);
18631 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
18635 else if (uses_template_parms (elt
))
18636 /* Since we're unifying against ourselves, we will fill in
18637 template args used in the function parm list with our own
18638 template parms. Discard them. */
18639 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
18640 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
18644 for (i
= nargs
; i
--; )
18646 tree elt
= TREE_VEC_ELT (tempargs
, i
);
18649 TREE_VEC_ELT (targs
, i
) = elt
;
18655 /* PARM is a template class (perhaps with unbound template
18656 parameters). ARG is a fully instantiated type. If ARG can be
18657 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
18658 TARGS are as for unify. */
18661 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
18664 tree copy_of_targs
;
18666 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
18667 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
18668 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
18671 /* We need to make a new template argument vector for the call to
18672 unify. If we used TARGS, we'd clutter it up with the result of
18673 the attempted unification, even if this class didn't work out.
18674 We also don't want to commit ourselves to all the unifications
18675 we've already done, since unification is supposed to be done on
18676 an argument-by-argument basis. In other words, consider the
18677 following pathological case:
18679 template <int I, int J, int K>
18682 template <int I, int J>
18683 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
18685 template <int I, int J, int K>
18686 void f(S<I, J, K>, S<I, I, I>);
18695 Now, by the time we consider the unification involving `s2', we
18696 already know that we must have `f<0, 0, 0>'. But, even though
18697 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
18698 because there are two ways to unify base classes of S<0, 1, 2>
18699 with S<I, I, I>. If we kept the already deduced knowledge, we
18700 would reject the possibility I=1. */
18701 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
18703 /* If unification failed, we're done. */
18704 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
18705 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
18711 /* Given a template type PARM and a class type ARG, find the unique
18712 base type in ARG that is an instance of PARM. We do not examine
18713 ARG itself; only its base-classes. If there is not exactly one
18714 appropriate base class, return NULL_TREE. PARM may be the type of
18715 a partial specialization, as well as a plain template type. Used
18718 static enum template_base_result
18719 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
18720 bool explain_p
, tree
*result
)
18722 tree rval
= NULL_TREE
;
18725 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
18727 binfo
= TYPE_BINFO (complete_type (arg
));
18730 /* The type could not be completed. */
18731 *result
= NULL_TREE
;
18732 return tbr_incomplete_type
;
18735 /* Walk in inheritance graph order. The search order is not
18736 important, and this avoids multiple walks of virtual bases. */
18737 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
18739 tree r
= try_class_unification (tparms
, targs
, parm
,
18740 BINFO_TYPE (binfo
), explain_p
);
18744 /* If there is more than one satisfactory baseclass, then:
18748 If they yield more than one possible deduced A, the type
18752 if (rval
&& !same_type_p (r
, rval
))
18754 *result
= NULL_TREE
;
18755 return tbr_ambiguous_baseclass
;
18763 return tbr_success
;
18766 /* Returns the level of DECL, which declares a template parameter. */
18769 template_decl_level (tree decl
)
18771 switch (TREE_CODE (decl
))
18774 case TEMPLATE_DECL
:
18775 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
18778 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
18781 gcc_unreachable ();
18786 /* Decide whether ARG can be unified with PARM, considering only the
18787 cv-qualifiers of each type, given STRICT as documented for unify.
18788 Returns nonzero iff the unification is OK on that basis. */
18791 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
18793 int arg_quals
= cp_type_quals (arg
);
18794 int parm_quals
= cp_type_quals (parm
);
18796 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
18797 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
18799 /* Although a CVR qualifier is ignored when being applied to a
18800 substituted template parameter ([8.3.2]/1 for example), that
18801 does not allow us to unify "const T" with "int&" because both
18802 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
18803 It is ok when we're allowing additional CV qualifiers
18804 at the outer level [14.8.2.1]/3,1st bullet. */
18805 if ((TREE_CODE (arg
) == REFERENCE_TYPE
18806 || TREE_CODE (arg
) == FUNCTION_TYPE
18807 || TREE_CODE (arg
) == METHOD_TYPE
)
18808 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
18811 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
18812 && (parm_quals
& TYPE_QUAL_RESTRICT
))
18816 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
18817 && (arg_quals
& parm_quals
) != parm_quals
)
18820 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
18821 && (parm_quals
& arg_quals
) != arg_quals
)
18827 /* Determines the LEVEL and INDEX for the template parameter PARM. */
18829 template_parm_level_and_index (tree parm
, int* level
, int* index
)
18831 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
18832 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18833 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18835 *index
= TEMPLATE_TYPE_IDX (parm
);
18836 *level
= TEMPLATE_TYPE_LEVEL (parm
);
18840 *index
= TEMPLATE_PARM_IDX (parm
);
18841 *level
= TEMPLATE_PARM_LEVEL (parm
);
18845 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
18847 if (unify (TP, TA, P, A, S, EP)) \
18851 /* Unifies the remaining arguments in PACKED_ARGS with the pack
18852 expansion at the end of PACKED_PARMS. Returns 0 if the type
18853 deduction succeeds, 1 otherwise. STRICT is the same as in
18854 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
18855 call argument list. We'll need to adjust the arguments to make them
18856 types. SUBR tells us if this is from a recursive call to
18857 type_unification_real, or for comparing two template argument
18861 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
18862 tree packed_args
, unification_kind_t strict
,
18863 bool subr
, bool explain_p
)
18866 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
18867 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
18868 tree pack
, packs
= NULL_TREE
;
18869 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
18871 packed_args
= expand_template_argument_pack (packed_args
);
18873 int len
= TREE_VEC_LENGTH (packed_args
);
18875 /* Determine the parameter packs we will be deducing from the
18876 pattern, and record their current deductions. */
18877 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
18878 pack
; pack
= TREE_CHAIN (pack
))
18880 tree parm_pack
= TREE_VALUE (pack
);
18883 /* Determine the index and level of this parameter pack. */
18884 template_parm_level_and_index (parm_pack
, &level
, &idx
);
18886 /* Keep track of the parameter packs and their corresponding
18888 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
18889 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
18892 /* Loop through all of the arguments that have not yet been
18893 unified and unify each with the pattern. */
18894 for (i
= start
; i
< len
; i
++)
18897 bool any_explicit
= false;
18898 tree arg
= TREE_VEC_ELT (packed_args
, i
);
18900 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
18901 or the element of its argument pack at the current index if
18902 this argument was explicitly specified. */
18903 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
18907 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
18910 if (TREE_VALUE (pack
)
18911 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
18912 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
18914 any_explicit
= true;
18915 arg
= TREE_VEC_ELT (pargs
, i
- start
);
18917 TMPL_ARG (targs
, level
, idx
) = arg
;
18920 /* If we had explicit template arguments, substitute them into the
18921 pattern before deduction. */
18924 /* Some arguments might still be unspecified or dependent. */
18926 ++processing_template_decl
;
18927 dependent
= any_dependent_template_arguments_p (targs
);
18929 --processing_template_decl
;
18930 parm
= tsubst (pattern
, targs
,
18931 explain_p
? tf_warning_or_error
: tf_none
,
18934 --processing_template_decl
;
18935 if (parm
== error_mark_node
)
18941 /* Unify the pattern with the current argument. */
18942 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
18946 /* For each parameter pack, collect the deduced value. */
18947 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
18950 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
18952 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
18953 TMPL_ARG (targs
, level
, idx
);
18957 /* Verify that the results of unification with the parameter packs
18958 produce results consistent with what we've seen before, and make
18959 the deduced argument packs available. */
18960 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
18962 tree old_pack
= TREE_VALUE (pack
);
18963 tree new_args
= TREE_TYPE (pack
);
18964 int i
, len
= TREE_VEC_LENGTH (new_args
);
18966 bool nondeduced_p
= false;
18968 /* By default keep the original deduced argument pack.
18969 If necessary, more specific code is going to update the
18970 resulting deduced argument later down in this function. */
18971 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
18972 TMPL_ARG (targs
, level
, idx
) = old_pack
;
18974 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
18975 actually deduce anything. */
18976 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
18977 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
18978 nondeduced_p
= true;
18982 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
18984 /* If we had fewer function args than explicit template args,
18985 just use the explicits. */
18986 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
18987 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
18988 if (len
< explicit_len
)
18989 new_args
= explicit_args
;
18995 /* Build the deduced *_ARGUMENT_PACK. */
18996 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
18998 result
= make_node (NONTYPE_ARGUMENT_PACK
);
18999 TREE_TYPE (result
) =
19000 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
19001 TREE_CONSTANT (result
) = 1;
19004 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
19006 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
19008 /* Note the deduced argument packs for this parameter
19010 TMPL_ARG (targs
, level
, idx
) = result
;
19012 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
19013 && (ARGUMENT_PACK_ARGS (old_pack
)
19014 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
19016 /* We only had the explicitly-provided arguments before, but
19017 now we have a complete set of arguments. */
19018 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
19020 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
19021 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
19022 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
19026 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
19027 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
19029 if (!comp_template_args_with_info (old_args
, new_args
,
19030 &bad_old_arg
, &bad_new_arg
))
19031 /* Inconsistent unification of this parameter pack. */
19032 return unify_parameter_pack_inconsistent (explain_p
,
19038 return unify_success (explain_p
);
19041 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
19042 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
19043 parameters and return value are as for unify. */
19046 unify_array_domain (tree tparms
, tree targs
,
19047 tree parm_dom
, tree arg_dom
,
19055 /* Our representation of array types uses "N - 1" as the
19056 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
19057 not an integer constant. We cannot unify arbitrarily
19058 complex expressions, so we eliminate the MINUS_EXPRs
19060 parm_max
= TYPE_MAX_VALUE (parm_dom
);
19061 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
19064 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
19065 parm_max
= TREE_OPERAND (parm_max
, 0);
19067 arg_max
= TYPE_MAX_VALUE (arg_dom
);
19068 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
19071 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
19072 trying to unify the type of a variable with the type
19073 of a template parameter. For example:
19075 template <unsigned int N>
19076 void f (char (&) [N]);
19083 Here, the type of the ARG will be "int [g(i)]", and
19084 may be a SAVE_EXPR, etc. */
19085 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
19086 return unify_vla_arg (explain_p
, arg_dom
);
19087 arg_max
= TREE_OPERAND (arg_max
, 0);
19090 /* If only one of the bounds used a MINUS_EXPR, compensate
19091 by adding one to the other bound. */
19092 if (parm_cst
&& !arg_cst
)
19093 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
19097 else if (arg_cst
&& !parm_cst
)
19098 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
19103 return unify (tparms
, targs
, parm_max
, arg_max
,
19104 UNIFY_ALLOW_INTEGER
, explain_p
);
19107 /* Deduce the value of template parameters. TPARMS is the (innermost)
19108 set of template parameters to a template. TARGS is the bindings
19109 for those template parameters, as determined thus far; TARGS may
19110 include template arguments for outer levels of template parameters
19111 as well. PARM is a parameter to a template function, or a
19112 subcomponent of that parameter; ARG is the corresponding argument.
19113 This function attempts to match PARM with ARG in a manner
19114 consistent with the existing assignments in TARGS. If more values
19115 are deduced, then TARGS is updated.
19117 Returns 0 if the type deduction succeeds, 1 otherwise. The
19118 parameter STRICT is a bitwise or of the following flags:
19121 Require an exact match between PARM and ARG.
19122 UNIFY_ALLOW_MORE_CV_QUAL:
19123 Allow the deduced ARG to be more cv-qualified (by qualification
19124 conversion) than ARG.
19125 UNIFY_ALLOW_LESS_CV_QUAL:
19126 Allow the deduced ARG to be less cv-qualified than ARG.
19127 UNIFY_ALLOW_DERIVED:
19128 Allow the deduced ARG to be a template base class of ARG,
19129 or a pointer to a template base class of the type pointed to by
19131 UNIFY_ALLOW_INTEGER:
19132 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
19133 case for more information.
19134 UNIFY_ALLOW_OUTER_LEVEL:
19135 This is the outermost level of a deduction. Used to determine validity
19136 of qualification conversions. A valid qualification conversion must
19137 have const qualified pointers leading up to the inner type which
19138 requires additional CV quals, except at the outer level, where const
19139 is not required [conv.qual]. It would be normal to set this flag in
19140 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
19141 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
19142 This is the outermost level of a deduction, and PARM can be more CV
19143 qualified at this point.
19144 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
19145 This is the outermost level of a deduction, and PARM can be less CV
19146 qualified at this point. */
19149 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
19155 int strict_in
= strict
;
19157 /* I don't think this will do the right thing with respect to types.
19158 But the only case I've seen it in so far has been array bounds, where
19159 signedness is the only information lost, and I think that will be
19161 while (TREE_CODE (parm
) == NOP_EXPR
)
19162 parm
= TREE_OPERAND (parm
, 0);
19164 if (arg
== error_mark_node
)
19165 return unify_invalid (explain_p
);
19166 if (arg
== unknown_type_node
19167 || arg
== init_list_type_node
)
19168 /* We can't deduce anything from this, but we might get all the
19169 template args from other function args. */
19170 return unify_success (explain_p
);
19172 /* If PARM uses template parameters, then we can't bail out here,
19173 even if ARG == PARM, since we won't record unifications for the
19174 template parameters. We might need them if we're trying to
19175 figure out which of two things is more specialized. */
19176 if (arg
== parm
&& !uses_template_parms (parm
))
19177 return unify_success (explain_p
);
19179 /* Handle init lists early, so the rest of the function can assume
19180 we're dealing with a type. */
19181 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
19185 tree orig_parm
= parm
;
19187 /* Replace T with std::initializer_list<T> for deduction. */
19188 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
19189 && flag_deduce_init_list
)
19190 parm
= listify (parm
);
19192 if (!is_std_init_list (parm
)
19193 && TREE_CODE (parm
) != ARRAY_TYPE
)
19194 /* We can only deduce from an initializer list argument if the
19195 parameter is std::initializer_list or an array; otherwise this
19196 is a non-deduced context. */
19197 return unify_success (explain_p
);
19199 if (TREE_CODE (parm
) == ARRAY_TYPE
)
19200 elttype
= TREE_TYPE (parm
);
19203 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
19204 /* Deduction is defined in terms of a single type, so just punt
19205 on the (bizarre) std::initializer_list<T...>. */
19206 if (PACK_EXPANSION_P (elttype
))
19207 return unify_success (explain_p
);
19210 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
19212 int elt_strict
= strict
;
19214 if (elt
== error_mark_node
)
19215 return unify_invalid (explain_p
);
19217 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
19219 tree type
= TREE_TYPE (elt
);
19220 if (type
== error_mark_node
)
19221 return unify_invalid (explain_p
);
19222 /* It should only be possible to get here for a call. */
19223 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
19224 elt_strict
|= maybe_adjust_types_for_deduction
19225 (DEDUCE_CALL
, &elttype
, &type
, elt
);
19229 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
19233 if (TREE_CODE (parm
) == ARRAY_TYPE
19234 && deducible_array_bound (TYPE_DOMAIN (parm
)))
19236 /* Also deduce from the length of the initializer list. */
19237 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
19238 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
19239 if (idx
== error_mark_node
)
19240 return unify_invalid (explain_p
);
19241 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
19245 /* If the std::initializer_list<T> deduction worked, replace the
19246 deduced A with std::initializer_list<A>. */
19247 if (orig_parm
!= parm
)
19249 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
19250 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
19251 targ
= listify (targ
);
19252 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
19254 return unify_success (explain_p
);
19257 /* Immediately reject some pairs that won't unify because of
19258 cv-qualification mismatches. */
19259 if (TREE_CODE (arg
) == TREE_CODE (parm
)
19261 /* It is the elements of the array which hold the cv quals of an array
19262 type, and the elements might be template type parms. We'll check
19263 when we recurse. */
19264 && TREE_CODE (arg
) != ARRAY_TYPE
19265 /* We check the cv-qualifiers when unifying with template type
19266 parameters below. We want to allow ARG `const T' to unify with
19267 PARM `T' for example, when computing which of two templates
19268 is more specialized, for example. */
19269 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
19270 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
19271 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
19273 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
19274 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
19275 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
19276 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
19277 strict
&= ~UNIFY_ALLOW_DERIVED
;
19278 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
19279 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
19281 switch (TREE_CODE (parm
))
19283 case TYPENAME_TYPE
:
19285 case UNBOUND_CLASS_TEMPLATE
:
19286 /* In a type which contains a nested-name-specifier, template
19287 argument values cannot be deduced for template parameters used
19288 within the nested-name-specifier. */
19289 return unify_success (explain_p
);
19291 case TEMPLATE_TYPE_PARM
:
19292 case TEMPLATE_TEMPLATE_PARM
:
19293 case BOUND_TEMPLATE_TEMPLATE_PARM
:
19294 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
19295 if (error_operand_p (tparm
))
19296 return unify_invalid (explain_p
);
19298 if (TEMPLATE_TYPE_LEVEL (parm
)
19299 != template_decl_level (tparm
))
19300 /* The PARM is not one we're trying to unify. Just check
19301 to see if it matches ARG. */
19303 if (TREE_CODE (arg
) == TREE_CODE (parm
)
19304 && (is_auto (parm
) ? is_auto (arg
)
19305 : same_type_p (parm
, arg
)))
19306 return unify_success (explain_p
);
19308 return unify_type_mismatch (explain_p
, parm
, arg
);
19310 idx
= TEMPLATE_TYPE_IDX (parm
);
19311 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
19312 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
19313 if (error_operand_p (tparm
))
19314 return unify_invalid (explain_p
);
19316 /* Check for mixed types and values. */
19317 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
19318 && TREE_CODE (tparm
) != TYPE_DECL
)
19319 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
19320 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
19321 gcc_unreachable ();
19323 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
19325 /* ARG must be constructed from a template class or a template
19326 template parameter. */
19327 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
19328 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
19329 return unify_template_deduction_failure (explain_p
, parm
, arg
);
19331 tree parmvec
= TYPE_TI_ARGS (parm
);
19332 /* An alias template name is never deduced. */
19333 if (TYPE_ALIAS_P (arg
))
19334 arg
= strip_typedefs (arg
);
19335 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
19336 tree full_argvec
= add_to_template_args (targs
, argvec
);
19338 = DECL_INNERMOST_TEMPLATE_PARMS
19339 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
19341 int parm_variadic_p
= 0;
19343 /* The resolution to DR150 makes clear that default
19344 arguments for an N-argument may not be used to bind T
19345 to a template template parameter with fewer than N
19346 parameters. It is not safe to permit the binding of
19347 default arguments as an extension, as that may change
19348 the meaning of a conforming program. Consider:
19350 struct Dense { static const unsigned int dim = 1; };
19352 template <template <typename> class View,
19354 void operator+(float, View<Block> const&);
19356 template <typename Block,
19357 unsigned int Dim = Block::dim>
19358 struct Lvalue_proxy { operator float() const; };
19362 Lvalue_proxy<Dense> p;
19367 Here, if Lvalue_proxy is permitted to bind to View, then
19368 the global operator+ will be used; if they are not, the
19369 Lvalue_proxy will be converted to float. */
19370 if (coerce_template_parms (parm_parms
,
19372 TYPE_TI_TEMPLATE (parm
),
19374 ? tf_warning_or_error
19376 /*require_all_args=*/true,
19377 /*use_default_args=*/false)
19378 == error_mark_node
)
19381 /* Deduce arguments T, i from TT<T> or TT<i>.
19382 We check each element of PARMVEC and ARGVEC individually
19383 rather than the whole TREE_VEC since they can have
19384 different number of elements. */
19386 parmvec
= expand_template_argument_pack (parmvec
);
19387 argvec
= expand_template_argument_pack (argvec
);
19389 len
= TREE_VEC_LENGTH (parmvec
);
19391 /* Check if the parameters end in a pack, making them
19394 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
19395 parm_variadic_p
= 1;
19397 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
19398 /* If the template argument list of P contains a pack
19399 expansion that is not the last template argument, the
19400 entire template argument list is a non-deduced
19402 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
19403 return unify_success (explain_p
);
19405 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
19406 return unify_too_few_arguments (explain_p
,
19407 TREE_VEC_LENGTH (argvec
), len
);
19409 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
19411 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
19412 TREE_VEC_ELT (parmvec
, i
),
19413 TREE_VEC_ELT (argvec
, i
),
19414 UNIFY_ALLOW_NONE
, explain_p
);
19417 if (parm_variadic_p
19418 && unify_pack_expansion (tparms
, targs
,
19421 /*subr=*/true, explain_p
))
19424 arg
= TYPE_TI_TEMPLATE (arg
);
19426 /* Fall through to deduce template name. */
19429 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
19430 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
19432 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
19434 /* Simple cases: Value already set, does match or doesn't. */
19435 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
19436 return unify_success (explain_p
);
19438 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
19442 /* If PARM is `const T' and ARG is only `int', we don't have
19443 a match unless we are allowing additional qualification.
19444 If ARG is `const int' and PARM is just `T' that's OK;
19445 that binds `const int' to `T'. */
19446 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
19448 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
19450 /* Consider the case where ARG is `const volatile int' and
19451 PARM is `const T'. Then, T should be `volatile int'. */
19452 arg
= cp_build_qualified_type_real
19453 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
19454 if (arg
== error_mark_node
)
19455 return unify_invalid (explain_p
);
19457 /* Simple cases: Value already set, does match or doesn't. */
19458 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
19459 return unify_success (explain_p
);
19461 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
19463 /* Make sure that ARG is not a variable-sized array. (Note
19464 that were talking about variable-sized arrays (like
19465 `int[n]'), rather than arrays of unknown size (like
19466 `int[]').) We'll get very confused by such a type since
19467 the bound of the array is not constant, and therefore
19468 not mangleable. Besides, such types are not allowed in
19469 ISO C++, so we can do as we please here. We do allow
19470 them for 'auto' deduction, since that isn't ABI-exposed. */
19471 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
19472 return unify_vla_arg (explain_p
, arg
);
19474 /* Strip typedefs as in convert_template_argument. */
19475 arg
= canonicalize_type_argument (arg
, tf_none
);
19478 /* If ARG is a parameter pack or an expansion, we cannot unify
19479 against it unless PARM is also a parameter pack. */
19480 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
19481 && !template_parameter_pack_p (parm
))
19482 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
19484 /* If the argument deduction results is a METHOD_TYPE,
19485 then there is a problem.
19486 METHOD_TYPE doesn't map to any real C++ type the result of
19487 the deduction can not be of that type. */
19488 if (TREE_CODE (arg
) == METHOD_TYPE
)
19489 return unify_method_type_error (explain_p
, arg
);
19491 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
19492 return unify_success (explain_p
);
19494 case TEMPLATE_PARM_INDEX
:
19495 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
19496 if (error_operand_p (tparm
))
19497 return unify_invalid (explain_p
);
19499 if (TEMPLATE_PARM_LEVEL (parm
)
19500 != template_decl_level (tparm
))
19502 /* The PARM is not one we're trying to unify. Just check
19503 to see if it matches ARG. */
19504 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
19505 && cp_tree_equal (parm
, arg
));
19507 unify_expression_unequal (explain_p
, parm
, arg
);
19511 idx
= TEMPLATE_PARM_IDX (parm
);
19512 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
19516 int x
= !cp_tree_equal (targ
, arg
);
19518 unify_inconsistency (explain_p
, parm
, targ
, arg
);
19522 /* [temp.deduct.type] If, in the declaration of a function template
19523 with a non-type template-parameter, the non-type
19524 template-parameter is used in an expression in the function
19525 parameter-list and, if the corresponding template-argument is
19526 deduced, the template-argument type shall match the type of the
19527 template-parameter exactly, except that a template-argument
19528 deduced from an array bound may be of any integral type.
19529 The non-type parameter might use already deduced type parameters. */
19530 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
19531 if (!TREE_TYPE (arg
))
19532 /* Template-parameter dependent expression. Just accept it for now.
19533 It will later be processed in convert_template_argument. */
19535 else if (same_type_p (TREE_TYPE (arg
), tparm
))
19537 else if ((strict
& UNIFY_ALLOW_INTEGER
)
19538 && CP_INTEGRAL_TYPE_P (tparm
))
19539 /* Convert the ARG to the type of PARM; the deduced non-type
19540 template argument must exactly match the types of the
19541 corresponding parameter. */
19542 arg
= fold (build_nop (tparm
, arg
));
19543 else if (uses_template_parms (tparm
))
19544 /* We haven't deduced the type of this parameter yet. Try again
19546 return unify_success (explain_p
);
19548 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
19550 /* If ARG is a parameter pack or an expansion, we cannot unify
19551 against it unless PARM is also a parameter pack. */
19552 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
19553 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
19554 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
19557 bool removed_attr
= false;
19558 arg
= strip_typedefs_expr (arg
, &removed_attr
);
19560 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
19561 return unify_success (explain_p
);
19565 /* A pointer-to-member constant can be unified only with
19566 another constant. */
19567 if (TREE_CODE (arg
) != PTRMEM_CST
)
19568 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
19570 /* Just unify the class member. It would be useless (and possibly
19571 wrong, depending on the strict flags) to unify also
19572 PTRMEM_CST_CLASS, because we want to be sure that both parm and
19573 arg refer to the same variable, even if through different
19574 classes. For instance:
19576 struct A { int x; };
19579 Unification of &A::x and &B::x must succeed. */
19580 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
19581 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
19586 if (!TYPE_PTR_P (arg
))
19587 return unify_type_mismatch (explain_p
, parm
, arg
);
19589 /* [temp.deduct.call]
19591 A can be another pointer or pointer to member type that can
19592 be converted to the deduced A via a qualification
19593 conversion (_conv.qual_).
19595 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
19596 This will allow for additional cv-qualification of the
19597 pointed-to types if appropriate. */
19599 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
19600 /* The derived-to-base conversion only persists through one
19601 level of pointers. */
19602 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
19604 return unify (tparms
, targs
, TREE_TYPE (parm
),
19605 TREE_TYPE (arg
), strict
, explain_p
);
19608 case REFERENCE_TYPE
:
19609 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
19610 return unify_type_mismatch (explain_p
, parm
, arg
);
19611 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
19612 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
19615 if (TREE_CODE (arg
) != ARRAY_TYPE
)
19616 return unify_type_mismatch (explain_p
, parm
, arg
);
19617 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
19618 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
19619 return unify_type_mismatch (explain_p
, parm
, arg
);
19620 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
19621 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
19622 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
19623 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
19624 TYPE_DOMAIN (arg
), explain_p
);
19625 return unify_success (explain_p
);
19632 case ENUMERAL_TYPE
:
19635 if (TREE_CODE (arg
) != TREE_CODE (parm
))
19636 return unify_type_mismatch (explain_p
, parm
, arg
);
19638 /* We have already checked cv-qualification at the top of the
19640 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
19641 return unify_type_mismatch (explain_p
, parm
, arg
);
19643 /* As far as unification is concerned, this wins. Later checks
19644 will invalidate it if necessary. */
19645 return unify_success (explain_p
);
19647 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
19648 /* Type INTEGER_CST can come from ordinary constant template args. */
19650 while (TREE_CODE (arg
) == NOP_EXPR
)
19651 arg
= TREE_OPERAND (arg
, 0);
19653 if (TREE_CODE (arg
) != INTEGER_CST
)
19654 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
19655 return (tree_int_cst_equal (parm
, arg
)
19656 ? unify_success (explain_p
)
19657 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
19661 int i
, len
, argslen
;
19662 int parm_variadic_p
= 0;
19664 if (TREE_CODE (arg
) != TREE_VEC
)
19665 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
19667 len
= TREE_VEC_LENGTH (parm
);
19668 argslen
= TREE_VEC_LENGTH (arg
);
19670 /* Check for pack expansions in the parameters. */
19671 for (i
= 0; i
< len
; ++i
)
19673 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
19676 /* We can unify against something with a trailing
19678 parm_variadic_p
= 1;
19680 /* [temp.deduct.type]/9: If the template argument list of
19681 P contains a pack expansion that is not the last
19682 template argument, the entire template argument list
19683 is a non-deduced context. */
19684 return unify_success (explain_p
);
19688 /* If we don't have enough arguments to satisfy the parameters
19689 (not counting the pack expression at the end), or we have
19690 too many arguments for a parameter list that doesn't end in
19691 a pack expression, we can't unify. */
19692 if (parm_variadic_p
19693 ? argslen
< len
- parm_variadic_p
19695 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
19697 /* Unify all of the parameters that precede the (optional)
19698 pack expression. */
19699 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
19701 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
19702 TREE_VEC_ELT (parm
, i
),
19703 TREE_VEC_ELT (arg
, i
),
19704 UNIFY_ALLOW_NONE
, explain_p
);
19706 if (parm_variadic_p
)
19707 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
19709 /*subr=*/true, explain_p
);
19710 return unify_success (explain_p
);
19715 if (TREE_CODE (arg
) != TREE_CODE (parm
))
19716 return unify_type_mismatch (explain_p
, parm
, arg
);
19718 if (TYPE_PTRMEMFUNC_P (parm
))
19720 if (!TYPE_PTRMEMFUNC_P (arg
))
19721 return unify_type_mismatch (explain_p
, parm
, arg
);
19723 return unify (tparms
, targs
,
19724 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
19725 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
19726 strict
, explain_p
);
19728 else if (TYPE_PTRMEMFUNC_P (arg
))
19729 return unify_type_mismatch (explain_p
, parm
, arg
);
19731 if (CLASSTYPE_TEMPLATE_INFO (parm
))
19733 tree t
= NULL_TREE
;
19735 if (strict_in
& UNIFY_ALLOW_DERIVED
)
19737 /* First, we try to unify the PARM and ARG directly. */
19738 t
= try_class_unification (tparms
, targs
,
19739 parm
, arg
, explain_p
);
19743 /* Fallback to the special case allowed in
19744 [temp.deduct.call]:
19746 If P is a class, and P has the form
19747 template-id, then A can be a derived class of
19748 the deduced A. Likewise, if P is a pointer to
19749 a class of the form template-id, A can be a
19750 pointer to a derived class pointed to by the
19752 enum template_base_result r
;
19753 r
= get_template_base (tparms
, targs
, parm
, arg
,
19758 /* Don't give the derived diagnostic if we're
19759 already dealing with the same template. */
19761 = (CLASSTYPE_TEMPLATE_INFO (arg
)
19762 && (CLASSTYPE_TI_TEMPLATE (parm
)
19763 == CLASSTYPE_TI_TEMPLATE (arg
)));
19764 return unify_no_common_base (explain_p
&& !same_template
,
19769 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
19770 && (CLASSTYPE_TI_TEMPLATE (parm
)
19771 == CLASSTYPE_TI_TEMPLATE (arg
)))
19772 /* Perhaps PARM is something like S<U> and ARG is S<int>.
19773 Then, we should unify `int' and `U'. */
19776 /* There's no chance of unification succeeding. */
19777 return unify_type_mismatch (explain_p
, parm
, arg
);
19779 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
19780 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
19782 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
19783 return unify_type_mismatch (explain_p
, parm
, arg
);
19784 return unify_success (explain_p
);
19787 case FUNCTION_TYPE
:
19789 unsigned int nargs
;
19794 if (TREE_CODE (arg
) != TREE_CODE (parm
))
19795 return unify_type_mismatch (explain_p
, parm
, arg
);
19797 /* CV qualifications for methods can never be deduced, they must
19798 match exactly. We need to check them explicitly here,
19799 because type_unification_real treats them as any other
19800 cv-qualified parameter. */
19801 if (TREE_CODE (parm
) == METHOD_TYPE
19802 && (!check_cv_quals_for_unify
19804 class_of_this_parm (arg
),
19805 class_of_this_parm (parm
))))
19806 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
19808 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
19809 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
19811 nargs
= list_length (TYPE_ARG_TYPES (arg
));
19812 args
= XALLOCAVEC (tree
, nargs
);
19813 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
19814 a
!= NULL_TREE
&& a
!= void_list_node
;
19815 a
= TREE_CHAIN (a
), ++i
)
19816 args
[i
] = TREE_VALUE (a
);
19819 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
19820 args
, nargs
, 1, DEDUCE_EXACT
,
19821 LOOKUP_NORMAL
, NULL
, explain_p
);
19825 /* Unify a pointer to member with a pointer to member function, which
19826 deduces the type of the member as a function type. */
19827 if (TYPE_PTRMEMFUNC_P (arg
))
19829 /* Check top-level cv qualifiers */
19830 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
19831 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
19833 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
19834 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
19835 UNIFY_ALLOW_NONE
, explain_p
);
19837 /* Determine the type of the function we are unifying against. */
19838 tree fntype
= static_fn_type (arg
);
19840 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
19843 if (TREE_CODE (arg
) != OFFSET_TYPE
)
19844 return unify_type_mismatch (explain_p
, parm
, arg
);
19845 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
19846 TYPE_OFFSET_BASETYPE (arg
),
19847 UNIFY_ALLOW_NONE
, explain_p
);
19848 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
19849 strict
, explain_p
);
19852 if (DECL_TEMPLATE_PARM_P (parm
))
19853 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
19854 if (arg
!= scalar_constant_value (parm
))
19855 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
19856 return unify_success (explain_p
);
19859 case TEMPLATE_DECL
:
19860 /* Matched cases are handled by the ARG == PARM test above. */
19861 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
19864 /* A non-type template parameter that is a variable should be a
19865 an integral constant, in which case, it whould have been
19866 folded into its (constant) value. So we should not be getting
19867 a variable here. */
19868 gcc_unreachable ();
19870 case TYPE_ARGUMENT_PACK
:
19871 case NONTYPE_ARGUMENT_PACK
:
19872 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
19873 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
19876 case DECLTYPE_TYPE
:
19877 case UNDERLYING_TYPE
:
19878 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
19879 or UNDERLYING_TYPE nodes. */
19880 return unify_success (explain_p
);
19883 /* Unification fails if we hit an error node. */
19884 return unify_invalid (explain_p
);
19887 if (REFERENCE_REF_P (parm
))
19889 if (REFERENCE_REF_P (arg
))
19890 arg
= TREE_OPERAND (arg
, 0);
19891 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
19892 strict
, explain_p
);
19897 /* An unresolved overload is a nondeduced context. */
19898 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
19899 return unify_success (explain_p
);
19900 gcc_assert (EXPR_P (parm
));
19902 /* We must be looking at an expression. This can happen with
19906 void foo(S<I>, S<I + 2>);
19908 This is a "nondeduced context":
19912 The nondeduced contexts are:
19914 --A type that is a template-id in which one or more of
19915 the template-arguments is an expression that references
19916 a template-parameter.
19918 In these cases, we assume deduction succeeded, but don't
19919 actually infer any unifications. */
19921 if (!uses_template_parms (parm
)
19922 && !template_args_equal (parm
, arg
))
19923 return unify_expression_unequal (explain_p
, parm
, arg
);
19925 return unify_success (explain_p
);
19928 #undef RECUR_AND_CHECK_FAILURE
19930 /* Note that DECL can be defined in this translation unit, if
19934 mark_definable (tree decl
)
19937 DECL_NOT_REALLY_EXTERN (decl
) = 1;
19938 FOR_EACH_CLONE (clone
, decl
)
19939 DECL_NOT_REALLY_EXTERN (clone
) = 1;
19942 /* Called if RESULT is explicitly instantiated, or is a member of an
19943 explicitly instantiated class. */
19946 mark_decl_instantiated (tree result
, int extern_p
)
19948 SET_DECL_EXPLICIT_INSTANTIATION (result
);
19950 /* If this entity has already been written out, it's too late to
19951 make any modifications. */
19952 if (TREE_ASM_WRITTEN (result
))
19955 /* For anonymous namespace we don't need to do anything. */
19956 if (decl_anon_ns_mem_p (result
))
19958 gcc_assert (!TREE_PUBLIC (result
));
19962 if (TREE_CODE (result
) != FUNCTION_DECL
)
19963 /* The TREE_PUBLIC flag for function declarations will have been
19964 set correctly by tsubst. */
19965 TREE_PUBLIC (result
) = 1;
19967 /* This might have been set by an earlier implicit instantiation. */
19968 DECL_COMDAT (result
) = 0;
19971 DECL_NOT_REALLY_EXTERN (result
) = 0;
19974 mark_definable (result
);
19975 mark_needed (result
);
19976 /* Always make artificials weak. */
19977 if (DECL_ARTIFICIAL (result
) && flag_weak
)
19978 comdat_linkage (result
);
19979 /* For WIN32 we also want to put explicit instantiations in
19980 linkonce sections. */
19981 else if (TREE_PUBLIC (result
))
19982 maybe_make_one_only (result
);
19985 /* If EXTERN_P, then this function will not be emitted -- unless
19986 followed by an explicit instantiation, at which point its linkage
19987 will be adjusted. If !EXTERN_P, then this function will be
19988 emitted here. In neither circumstance do we want
19989 import_export_decl to adjust the linkage. */
19990 DECL_INTERFACE_KNOWN (result
) = 1;
19993 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
19994 important template arguments. If any are missing, we check whether
19995 they're important by using error_mark_node for substituting into any
19996 args that were used for partial ordering (the ones between ARGS and END)
19997 and seeing if it bubbles up. */
20000 check_undeduced_parms (tree targs
, tree args
, tree end
)
20002 bool found
= false;
20004 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
20005 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
20008 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
20012 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
20013 if (substed
== error_mark_node
)
20019 /* Given two function templates PAT1 and PAT2, return:
20021 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
20022 -1 if PAT2 is more specialized than PAT1.
20023 0 if neither is more specialized.
20025 LEN indicates the number of parameters we should consider
20026 (defaulted parameters should not be considered).
20028 The 1998 std underspecified function template partial ordering, and
20029 DR214 addresses the issue. We take pairs of arguments, one from
20030 each of the templates, and deduce them against each other. One of
20031 the templates will be more specialized if all the *other*
20032 template's arguments deduce against its arguments and at least one
20033 of its arguments *does* *not* deduce against the other template's
20034 corresponding argument. Deduction is done as for class templates.
20035 The arguments used in deduction have reference and top level cv
20036 qualifiers removed. Iff both arguments were originally reference
20037 types *and* deduction succeeds in both directions, an lvalue reference
20038 wins against an rvalue reference and otherwise the template
20039 with the more cv-qualified argument wins for that pairing (if
20040 neither is more cv-qualified, they both are equal). Unlike regular
20041 deduction, after all the arguments have been deduced in this way,
20042 we do *not* verify the deduced template argument values can be
20043 substituted into non-deduced contexts.
20045 The logic can be a bit confusing here, because we look at deduce1 and
20046 targs1 to see if pat2 is at least as specialized, and vice versa; if we
20047 can find template arguments for pat1 to make arg1 look like arg2, that
20048 means that arg2 is at least as specialized as arg1. */
20051 more_specialized_fn (tree pat1
, tree pat2
, int len
)
20053 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
20054 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
20055 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
20056 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
20057 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
20058 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
20059 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
20060 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
20061 tree origs1
, origs2
;
20062 bool lose1
= false;
20063 bool lose2
= false;
20065 /* Remove the this parameter from non-static member functions. If
20066 one is a non-static member function and the other is not a static
20067 member function, remove the first parameter from that function
20068 also. This situation occurs for operator functions where we
20069 locate both a member function (with this pointer) and non-member
20070 operator (with explicit first operand). */
20071 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
20073 len
--; /* LEN is the number of significant arguments for DECL1 */
20074 args1
= TREE_CHAIN (args1
);
20075 if (!DECL_STATIC_FUNCTION_P (decl2
))
20076 args2
= TREE_CHAIN (args2
);
20078 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
20080 args2
= TREE_CHAIN (args2
);
20081 if (!DECL_STATIC_FUNCTION_P (decl1
))
20084 args1
= TREE_CHAIN (args1
);
20088 /* If only one is a conversion operator, they are unordered. */
20089 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
20092 /* Consider the return type for a conversion function */
20093 if (DECL_CONV_FN_P (decl1
))
20095 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
20096 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
20100 processing_template_decl
++;
20106 /* Stop when an ellipsis is seen. */
20107 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
20109 tree arg1
= TREE_VALUE (args1
);
20110 tree arg2
= TREE_VALUE (args2
);
20111 int deduce1
, deduce2
;
20117 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
20118 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
20120 /* When both arguments are pack expansions, we need only
20121 unify the patterns themselves. */
20122 arg1
= PACK_EXPANSION_PATTERN (arg1
);
20123 arg2
= PACK_EXPANSION_PATTERN (arg2
);
20125 /* This is the last comparison we need to do. */
20129 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
20131 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
20132 arg1
= TREE_TYPE (arg1
);
20133 quals1
= cp_type_quals (arg1
);
20136 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
20138 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
20139 arg2
= TREE_TYPE (arg2
);
20140 quals2
= cp_type_quals (arg2
);
20143 arg1
= TYPE_MAIN_VARIANT (arg1
);
20144 arg2
= TYPE_MAIN_VARIANT (arg2
);
20146 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
20148 int i
, len2
= list_length (args2
);
20149 tree parmvec
= make_tree_vec (1);
20150 tree argvec
= make_tree_vec (len2
);
20153 /* Setup the parameter vector, which contains only ARG1. */
20154 TREE_VEC_ELT (parmvec
, 0) = arg1
;
20156 /* Setup the argument vector, which contains the remaining
20158 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
20159 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
20161 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
20162 argvec
, DEDUCE_EXACT
,
20163 /*subr=*/true, /*explain_p=*/false)
20166 /* We cannot deduce in the other direction, because ARG1 is
20167 a pack expansion but ARG2 is not. */
20170 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
20172 int i
, len1
= list_length (args1
);
20173 tree parmvec
= make_tree_vec (1);
20174 tree argvec
= make_tree_vec (len1
);
20177 /* Setup the parameter vector, which contains only ARG1. */
20178 TREE_VEC_ELT (parmvec
, 0) = arg2
;
20180 /* Setup the argument vector, which contains the remaining
20182 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
20183 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
20185 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
20186 argvec
, DEDUCE_EXACT
,
20187 /*subr=*/true, /*explain_p=*/false)
20190 /* We cannot deduce in the other direction, because ARG2 is
20191 a pack expansion but ARG1 is not.*/
20197 /* The normal case, where neither argument is a pack
20199 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
20200 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
20202 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
20203 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
20207 /* If we couldn't deduce arguments for tparms1 to make arg1 match
20208 arg2, then arg2 is not as specialized as arg1. */
20214 /* "If, for a given type, deduction succeeds in both directions
20215 (i.e., the types are identical after the transformations above)
20216 and both P and A were reference types (before being replaced with
20217 the type referred to above):
20218 - if the type from the argument template was an lvalue reference and
20219 the type from the parameter template was not, the argument type is
20220 considered to be more specialized than the other; otherwise,
20221 - if the type from the argument template is more cv-qualified
20222 than the type from the parameter template (as described above),
20223 the argument type is considered to be more specialized than the other;
20225 - neither type is more specialized than the other." */
20227 if (deduce1
&& deduce2
)
20229 if (ref1
&& ref2
&& ref1
!= ref2
)
20236 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
20238 if ((quals1
& quals2
) == quals2
)
20240 if ((quals1
& quals2
) == quals1
)
20245 if (lose1
&& lose2
)
20246 /* We've failed to deduce something in either direction.
20247 These must be unordered. */
20250 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
20251 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
20252 /* We have already processed all of the arguments in our
20253 handing of the pack expansion type. */
20256 args1
= TREE_CHAIN (args1
);
20257 args2
= TREE_CHAIN (args2
);
20260 /* "In most cases, all template parameters must have values in order for
20261 deduction to succeed, but for partial ordering purposes a template
20262 parameter may remain without a value provided it is not used in the
20263 types being used for partial ordering."
20265 Thus, if we are missing any of the targs1 we need to substitute into
20266 origs1, then pat2 is not as specialized as pat1. This can happen when
20267 there is a nondeduced context. */
20268 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
20270 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
20273 processing_template_decl
--;
20275 /* If both deductions succeed, the partial ordering selects the more
20276 constrained template. */
20277 if (!lose1
&& !lose2
)
20279 tree c1
= get_constraints (DECL_TEMPLATE_RESULT (pat1
));
20280 tree c2
= get_constraints (DECL_TEMPLATE_RESULT (pat2
));
20281 lose1
= !subsumes_constraints (c1
, c2
);
20282 lose2
= !subsumes_constraints (c2
, c1
);
20285 /* All things being equal, if the next argument is a pack expansion
20286 for one function but not for the other, prefer the
20287 non-variadic function. FIXME this is bogus; see c++/41958. */
20289 && args1
&& TREE_VALUE (args1
)
20290 && args2
&& TREE_VALUE (args2
))
20292 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
20293 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
20296 if (lose1
== lose2
)
20304 /* Determine which of two partial specializations of TMPL is more
20307 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
20308 to the first partial specialization. The TREE_PURPOSE is the
20309 innermost set of template parameters for the partial
20310 specialization. PAT2 is similar, but for the second template.
20312 Return 1 if the first partial specialization is more specialized;
20313 -1 if the second is more specialized; 0 if neither is more
20316 See [temp.class.order] for information about determining which of
20317 two templates is more specialized. */
20320 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
20324 bool any_deductions
= false;
20326 tree tmpl1
= TREE_VALUE (pat1
);
20327 tree tmpl2
= TREE_VALUE (pat2
);
20328 tree parms1
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl1
);
20329 tree parms2
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl2
);
20330 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
20331 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
20333 /* Just like what happens for functions, if we are ordering between
20334 different template specializations, we may encounter dependent
20335 types in the arguments, and we need our dependency check functions
20336 to behave correctly. */
20337 ++processing_template_decl
;
20338 targs
= get_partial_spec_bindings (tmpl
, parms1
, specargs1
, specargs2
);
20342 any_deductions
= true;
20345 targs
= get_partial_spec_bindings (tmpl
, parms2
, specargs2
, specargs1
);
20349 any_deductions
= true;
20351 --processing_template_decl
;
20353 /* If both deductions succeed, the partial ordering selects the more
20354 constrained template. */
20355 if (!winner
&& any_deductions
)
20356 return more_constrained (tmpl1
, tmpl2
);
20358 /* In the case of a tie where at least one of the templates
20359 has a parameter pack at the end, the template with the most
20360 non-packed parameters wins. */
20363 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
20364 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
20366 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
20367 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
20368 int len1
= TREE_VEC_LENGTH (args1
);
20369 int len2
= TREE_VEC_LENGTH (args2
);
20371 /* We don't count the pack expansion at the end. */
20372 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
20374 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
20379 else if (len1
< len2
)
20386 /* Return the template arguments that will produce the function signature
20387 DECL from the function template FN, with the explicit template
20388 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
20389 also match. Return NULL_TREE if no satisfactory arguments could be
20393 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
20395 int ntparms
= DECL_NTPARMS (fn
);
20396 tree targs
= make_tree_vec (ntparms
);
20397 tree decl_type
= TREE_TYPE (decl
);
20398 tree decl_arg_types
;
20400 unsigned int nargs
, ix
;
20403 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
20405 /* Never do unification on the 'this' parameter. */
20406 decl_arg_types
= skip_artificial_parms_for (decl
,
20407 TYPE_ARG_TYPES (decl_type
));
20409 nargs
= list_length (decl_arg_types
);
20410 args
= XALLOCAVEC (tree
, nargs
);
20411 for (arg
= decl_arg_types
, ix
= 0;
20412 arg
!= NULL_TREE
&& arg
!= void_list_node
;
20413 arg
= TREE_CHAIN (arg
), ++ix
)
20414 args
[ix
] = TREE_VALUE (arg
);
20416 if (fn_type_unification (fn
, explicit_args
, targs
,
20418 (check_rettype
|| DECL_CONV_FN_P (fn
)
20419 ? TREE_TYPE (decl_type
) : NULL_TREE
),
20420 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
20422 == error_mark_node
)
20428 /* Return the innermost template arguments that, when applied to a partial
20429 specialization of TMPL whose innermost template parameters are
20430 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
20433 For example, suppose we have:
20435 template <class T, class U> struct S {};
20436 template <class T> struct S<T*, int> {};
20438 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
20439 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
20440 int}. The resulting vector will be {double}, indicating that `T'
20441 is bound to `double'. */
20444 get_partial_spec_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
20446 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
20448 tree innermost_deduced_args
;
20450 innermost_deduced_args
= make_tree_vec (ntparms
);
20451 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
20453 deduced_args
= copy_node (args
);
20454 SET_TMPL_ARGS_LEVEL (deduced_args
,
20455 TMPL_ARGS_DEPTH (deduced_args
),
20456 innermost_deduced_args
);
20459 deduced_args
= innermost_deduced_args
;
20461 if (unify (tparms
, deduced_args
,
20462 INNERMOST_TEMPLATE_ARGS (spec_args
),
20463 INNERMOST_TEMPLATE_ARGS (args
),
20464 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
20467 for (i
= 0; i
< ntparms
; ++i
)
20468 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
20471 /* Verify that nondeduced template arguments agree with the type
20472 obtained from argument deduction.
20476 struct A { typedef int X; };
20477 template <class T, class U> struct C {};
20478 template <class T> struct C<T, typename T::X> {};
20480 Then with the instantiation `C<A, int>', we can deduce that
20481 `T' is `A' but unify () does not check whether `typename T::X'
20483 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
20484 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
20486 tf_none
, false, false);
20487 if (spec_args
== error_mark_node
20488 /* We only need to check the innermost arguments; the other
20489 arguments will always agree. */
20490 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
20491 INNERMOST_TEMPLATE_ARGS (args
)))
20494 /* Now that we have bindings for all of the template arguments,
20495 ensure that the arguments deduced for the template template
20496 parameters have compatible template parameter lists. See the use
20497 of template_template_parm_bindings_ok_p in fn_type_unification
20498 for more information. */
20499 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
20502 return deduced_args
;
20505 // Compare two function templates T1 and T2 by deducing bindings
20506 // from one against the other. If both deductions succeed, compare
20507 // constraints to see which is more constrained.
20509 more_specialized_inst (tree t1
, tree t2
)
20514 if (get_bindings (t1
, DECL_TEMPLATE_RESULT (t2
), NULL_TREE
, true))
20520 if (get_bindings (t2
, DECL_TEMPLATE_RESULT (t1
), NULL_TREE
, true))
20526 // If both deductions succeed, then one may be more constrained.
20527 if (count
== 2 && fate
== 0)
20528 fate
= more_constrained (t1
, t2
);
20533 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
20534 Return the TREE_LIST node with the most specialized template, if
20535 any. If there is no most specialized template, the error_mark_node
20538 Note that this function does not look at, or modify, the
20539 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
20540 returned is one of the elements of INSTANTIATIONS, callers may
20541 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
20542 and retrieve it from the value returned. */
20545 most_specialized_instantiation (tree templates
)
20549 ++processing_template_decl
;
20552 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
20554 int fate
= more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
));
20559 /* Equally specialized, move to next function. If there
20560 is no next function, nothing's most specialized. */
20561 fn
= TREE_CHAIN (fn
);
20569 /* Now verify that champ is better than everything earlier in the
20570 instantiation list. */
20571 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
)) {
20572 if (more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
)) != 1)
20579 processing_template_decl
--;
20582 return error_mark_node
;
20587 /* If DECL is a specialization of some template, return the most
20588 general such template. Otherwise, returns NULL_TREE.
20590 For example, given:
20592 template <class T> struct S { template <class U> void f(U); };
20594 if TMPL is `template <class U> void S<int>::f(U)' this will return
20595 the full template. This function will not trace past partial
20596 specializations, however. For example, given in addition:
20598 template <class T> struct S<T*> { template <class U> void f(U); };
20600 if TMPL is `template <class U> void S<int*>::f(U)' this will return
20601 `template <class T> template <class U> S<T*>::f(U)'. */
20604 most_general_template (tree decl
)
20606 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
20608 if (tree tinfo
= get_template_info (decl
))
20609 decl
= TI_TEMPLATE (tinfo
);
20610 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
20611 template friend, or a FIELD_DECL for a capture pack. */
20612 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
20616 /* Look for more and more general templates. */
20617 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
20619 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
20620 (See cp-tree.h for details.) */
20621 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
20624 if (CLASS_TYPE_P (TREE_TYPE (decl
))
20625 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
20626 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
20629 /* Stop if we run into an explicitly specialized class template. */
20630 if (!DECL_NAMESPACE_SCOPE_P (decl
)
20631 && DECL_CONTEXT (decl
)
20632 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
20635 decl
= DECL_TI_TEMPLATE (decl
);
20641 /* Return the most specialized of the template partial specializations
20642 which can produce TARGET, a specialization of some class or variable
20643 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
20644 a TEMPLATE_DECL node corresponding to the partial specialization, while
20645 the TREE_PURPOSE is the set of template arguments that must be
20646 substituted into the template pattern in order to generate TARGET.
20648 If the choice of partial specialization is ambiguous, a diagnostic
20649 is issued, and the error_mark_node is returned. If there are no
20650 partial specializations matching TARGET, then NULL_TREE is
20651 returned, indicating that the primary template should be used. */
20654 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
20656 tree list
= NULL_TREE
;
20661 tree outer_args
= NULL_TREE
;
20664 if (TYPE_P (target
))
20666 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
20667 tmpl
= TI_TEMPLATE (tinfo
);
20668 args
= TI_ARGS (tinfo
);
20670 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
20672 tmpl
= TREE_OPERAND (target
, 0);
20673 args
= TREE_OPERAND (target
, 1);
20675 else if (VAR_P (target
))
20677 tree tinfo
= DECL_TEMPLATE_INFO (target
);
20678 tmpl
= TI_TEMPLATE (tinfo
);
20679 args
= TI_ARGS (tinfo
);
20682 gcc_unreachable ();
20684 tree main_tmpl
= most_general_template (tmpl
);
20686 /* For determining which partial specialization to use, only the
20687 innermost args are interesting. */
20688 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
20690 outer_args
= strip_innermost_template_args (args
, 1);
20691 args
= INNERMOST_TEMPLATE_ARGS (args
);
20694 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
20696 tree partial_spec_args
;
20698 tree spec_tmpl
= TREE_VALUE (t
);
20700 partial_spec_args
= TREE_PURPOSE (t
);
20702 ++processing_template_decl
;
20706 /* Discard the outer levels of args, and then substitute in the
20707 template args from the enclosing class. */
20708 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
20709 partial_spec_args
= tsubst_template_args
20710 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
20712 /* And the same for the partial specialization TEMPLATE_DECL. */
20713 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
20716 partial_spec_args
=
20717 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
20720 /*require_all_args=*/true,
20721 /*use_default_args=*/true);
20723 --processing_template_decl
;
20725 if (partial_spec_args
== error_mark_node
)
20726 return error_mark_node
;
20727 if (spec_tmpl
== error_mark_node
)
20728 return error_mark_node
;
20730 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
20731 spec_args
= get_partial_spec_bindings (tmpl
, parms
,
20737 spec_args
= add_to_template_args (outer_args
, spec_args
);
20739 /* Keep the candidate only if the constraints are satisfied,
20740 or if we're not compiling with concepts. */
20742 || constraints_satisfied_p (spec_tmpl
, spec_args
))
20744 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
20745 TREE_TYPE (list
) = TREE_TYPE (t
);
20753 ambiguous_p
= false;
20756 t
= TREE_CHAIN (t
);
20757 for (; t
; t
= TREE_CHAIN (t
))
20759 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
20766 t
= TREE_CHAIN (t
);
20769 ambiguous_p
= true;
20778 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
20780 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
20783 ambiguous_p
= true;
20791 char *spaces
= NULL
;
20792 if (!(complain
& tf_error
))
20793 return error_mark_node
;
20794 if (TYPE_P (target
))
20795 error ("ambiguous template instantiation for %q#T", target
);
20797 error ("ambiguous template instantiation for %q#D", target
);
20798 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
20799 for (t
= list
; t
; t
= TREE_CHAIN (t
))
20801 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
20802 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
20803 "%s %#S", spaces
? spaces
: str
, subst
);
20804 spaces
= spaces
? spaces
: get_spaces (str
);
20807 return error_mark_node
;
20813 /* Explicitly instantiate DECL. */
20816 do_decl_instantiation (tree decl
, tree storage
)
20818 tree result
= NULL_TREE
;
20821 if (!decl
|| decl
== error_mark_node
)
20822 /* An error occurred, for which grokdeclarator has already issued
20823 an appropriate message. */
20825 else if (! DECL_LANG_SPECIFIC (decl
))
20827 error ("explicit instantiation of non-template %q#D", decl
);
20831 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
20832 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
20834 if (VAR_P (decl
) && !var_templ
)
20836 /* There is an asymmetry here in the way VAR_DECLs and
20837 FUNCTION_DECLs are handled by grokdeclarator. In the case of
20838 the latter, the DECL we get back will be marked as a
20839 template instantiation, and the appropriate
20840 DECL_TEMPLATE_INFO will be set up. This does not happen for
20841 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
20842 should handle VAR_DECLs as it currently handles
20844 if (!DECL_CLASS_SCOPE_P (decl
))
20846 error ("%qD is not a static data member of a class template", decl
);
20849 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
20850 if (!result
|| !VAR_P (result
))
20852 error ("no matching template for %qD found", decl
);
20855 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
20857 error ("type %qT for explicit instantiation %qD does not match "
20858 "declared type %qT", TREE_TYPE (result
), decl
,
20863 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
20865 error ("explicit instantiation of %q#D", decl
);
20871 /* Check for various error cases. Note that if the explicit
20872 instantiation is valid the RESULT will currently be marked as an
20873 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
20874 until we get here. */
20876 if (DECL_TEMPLATE_SPECIALIZATION (result
))
20878 /* DR 259 [temp.spec].
20880 Both an explicit instantiation and a declaration of an explicit
20881 specialization shall not appear in a program unless the explicit
20882 instantiation follows a declaration of the explicit specialization.
20884 For a given set of template parameters, if an explicit
20885 instantiation of a template appears after a declaration of an
20886 explicit specialization for that template, the explicit
20887 instantiation has no effect. */
20890 else if (DECL_EXPLICIT_INSTANTIATION (result
))
20894 No program shall explicitly instantiate any template more
20897 We check DECL_NOT_REALLY_EXTERN so as not to complain when
20898 the first instantiation was `extern' and the second is not,
20899 and EXTERN_P for the opposite case. */
20900 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
20901 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
20902 /* If an "extern" explicit instantiation follows an ordinary
20903 explicit instantiation, the template is instantiated. */
20907 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
20909 error ("no matching template for %qD found", result
);
20912 else if (!DECL_TEMPLATE_INFO (result
))
20914 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
20918 if (storage
== NULL_TREE
)
20920 else if (storage
== ridpointers
[(int) RID_EXTERN
])
20922 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
20923 pedwarn (input_location
, OPT_Wpedantic
,
20924 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
20929 error ("storage class %qD applied to template instantiation", storage
);
20931 check_explicit_instantiation_namespace (result
);
20932 mark_decl_instantiated (result
, extern_p
);
20934 instantiate_decl (result
, /*defer_ok=*/1,
20935 /*expl_inst_class_mem_p=*/false);
20939 mark_class_instantiated (tree t
, int extern_p
)
20941 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
20942 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
20943 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
20944 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
20947 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
20948 rest_of_type_compilation (t
, 1);
20952 /* Called from do_type_instantiation through binding_table_foreach to
20953 do recursive instantiation for the type bound in ENTRY. */
20955 bt_instantiate_type_proc (binding_entry entry
, void *data
)
20957 tree storage
= *(tree
*) data
;
20959 if (MAYBE_CLASS_TYPE_P (entry
->type
)
20960 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
20961 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
20964 /* Called from do_type_instantiation to instantiate a member
20965 (a member function or a static member variable) of an
20966 explicitly instantiated class template. */
20968 instantiate_class_member (tree decl
, int extern_p
)
20970 mark_decl_instantiated (decl
, extern_p
);
20972 instantiate_decl (decl
, /*defer_ok=*/1,
20973 /*expl_inst_class_mem_p=*/true);
20976 /* Perform an explicit instantiation of template class T. STORAGE, if
20977 non-null, is the RID for extern, inline or static. COMPLAIN is
20978 nonzero if this is called from the parser, zero if called recursively,
20979 since the standard is unclear (as detailed below). */
20982 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
20987 int previous_instantiation_extern_p
= 0;
20989 if (TREE_CODE (t
) == TYPE_DECL
)
20992 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
20995 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
20997 error ("explicit instantiation of non-class template %qD", tmpl
);
20999 error ("explicit instantiation of non-template type %qT", t
);
21005 if (!COMPLETE_TYPE_P (t
))
21007 if (complain
& tf_error
)
21008 error ("explicit instantiation of %q#T before definition of template",
21013 if (storage
!= NULL_TREE
)
21015 if (!in_system_header_at (input_location
))
21017 if (storage
== ridpointers
[(int) RID_EXTERN
])
21019 if (cxx_dialect
== cxx98
)
21020 pedwarn (input_location
, OPT_Wpedantic
,
21021 "ISO C++ 1998 forbids the use of %<extern%> on "
21022 "explicit instantiations");
21025 pedwarn (input_location
, OPT_Wpedantic
,
21026 "ISO C++ forbids the use of %qE"
21027 " on explicit instantiations", storage
);
21030 if (storage
== ridpointers
[(int) RID_INLINE
])
21032 else if (storage
== ridpointers
[(int) RID_EXTERN
])
21034 else if (storage
== ridpointers
[(int) RID_STATIC
])
21038 error ("storage class %qD applied to template instantiation",
21044 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
21046 /* DR 259 [temp.spec].
21048 Both an explicit instantiation and a declaration of an explicit
21049 specialization shall not appear in a program unless the explicit
21050 instantiation follows a declaration of the explicit specialization.
21052 For a given set of template parameters, if an explicit
21053 instantiation of a template appears after a declaration of an
21054 explicit specialization for that template, the explicit
21055 instantiation has no effect. */
21058 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
21062 No program shall explicitly instantiate any template more
21065 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
21066 instantiation was `extern'. If EXTERN_P then the second is.
21067 These cases are OK. */
21068 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
21070 if (!previous_instantiation_extern_p
&& !extern_p
21071 && (complain
& tf_error
))
21072 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
21074 /* If we've already instantiated the template, just return now. */
21075 if (!CLASSTYPE_INTERFACE_ONLY (t
))
21079 check_explicit_instantiation_namespace (TYPE_NAME (t
));
21080 mark_class_instantiated (t
, extern_p
);
21088 /* In contrast to implicit instantiation, where only the
21089 declarations, and not the definitions, of members are
21090 instantiated, we have here:
21094 The explicit instantiation of a class template specialization
21095 implies the instantiation of all of its members not
21096 previously explicitly specialized in the translation unit
21097 containing the explicit instantiation.
21099 Of course, we can't instantiate member template classes, since
21100 we don't have any arguments for them. Note that the standard
21101 is unclear on whether the instantiation of the members are
21102 *explicit* instantiations or not. However, the most natural
21103 interpretation is that it should be an explicit instantiation. */
21106 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
21107 if (TREE_CODE (tmp
) == FUNCTION_DECL
21108 && DECL_TEMPLATE_INSTANTIATION (tmp
))
21109 instantiate_class_member (tmp
, extern_p
);
21111 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
21112 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
21113 instantiate_class_member (tmp
, extern_p
);
21115 if (CLASSTYPE_NESTED_UTDS (t
))
21116 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
21117 bt_instantiate_type_proc
, &storage
);
21121 /* Given a function DECL, which is a specialization of TMPL, modify
21122 DECL to be a re-instantiation of TMPL with the same template
21123 arguments. TMPL should be the template into which tsubst'ing
21124 should occur for DECL, not the most general template.
21126 One reason for doing this is a scenario like this:
21129 void f(const T&, int i);
21131 void g() { f(3, 7); }
21134 void f(const T& t, const int i) { }
21136 Note that when the template is first instantiated, with
21137 instantiate_template, the resulting DECL will have no name for the
21138 first parameter, and the wrong type for the second. So, when we go
21139 to instantiate the DECL, we regenerate it. */
21142 regenerate_decl_from_template (tree decl
, tree tmpl
)
21144 /* The arguments used to instantiate DECL, from the most general
21149 args
= DECL_TI_ARGS (decl
);
21150 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
21152 /* Make sure that we can see identifiers, and compute access
21154 push_access_scope (decl
);
21156 if (TREE_CODE (decl
) == FUNCTION_DECL
)
21164 args_depth
= TMPL_ARGS_DEPTH (args
);
21165 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
21166 if (args_depth
> parms_depth
)
21167 args
= get_innermost_template_args (args
, parms_depth
);
21169 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
21170 args
, tf_error
, NULL_TREE
,
21171 /*defer_ok*/false);
21172 if (specs
&& specs
!= error_mark_node
)
21173 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
21176 /* Merge parameter declarations. */
21177 decl_parm
= skip_artificial_parms_for (decl
,
21178 DECL_ARGUMENTS (decl
));
21180 = skip_artificial_parms_for (code_pattern
,
21181 DECL_ARGUMENTS (code_pattern
));
21182 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
21187 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
21188 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
21189 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
21191 parm_type
= type_decays_to (parm_type
);
21192 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
21193 TREE_TYPE (decl_parm
) = parm_type
;
21194 attributes
= DECL_ATTRIBUTES (pattern_parm
);
21195 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
21197 DECL_ATTRIBUTES (decl_parm
) = attributes
;
21198 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
21200 decl_parm
= DECL_CHAIN (decl_parm
);
21201 pattern_parm
= DECL_CHAIN (pattern_parm
);
21203 /* Merge any parameters that match with the function parameter
21205 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
21208 tree expanded_types
;
21209 /* Expand the TYPE_PACK_EXPANSION that provides the types for
21210 the parameters in this function parameter pack. */
21211 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
21212 args
, tf_error
, NULL_TREE
);
21213 len
= TREE_VEC_LENGTH (expanded_types
);
21214 for (i
= 0; i
< len
; i
++)
21219 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
21220 /* Rename the parameter to include the index. */
21221 DECL_NAME (decl_parm
) =
21222 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
21223 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
21224 parm_type
= type_decays_to (parm_type
);
21225 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
21226 TREE_TYPE (decl_parm
) = parm_type
;
21227 attributes
= DECL_ATTRIBUTES (pattern_parm
);
21228 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
21230 DECL_ATTRIBUTES (decl_parm
) = attributes
;
21231 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
21233 decl_parm
= DECL_CHAIN (decl_parm
);
21236 /* Merge additional specifiers from the CODE_PATTERN. */
21237 if (DECL_DECLARED_INLINE_P (code_pattern
)
21238 && !DECL_DECLARED_INLINE_P (decl
))
21239 DECL_DECLARED_INLINE_P (decl
) = 1;
21241 else if (VAR_P (decl
))
21243 DECL_INITIAL (decl
) =
21244 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
21245 tf_error
, DECL_TI_TEMPLATE (decl
),
21246 /*integral_constant_expression_p=*/false);
21247 if (VAR_HAD_UNKNOWN_BOUND (decl
))
21248 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
21249 tf_error
, DECL_TI_TEMPLATE (decl
));
21252 gcc_unreachable ();
21254 pop_access_scope (decl
);
21257 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
21258 substituted to get DECL. */
21261 template_for_substitution (tree decl
)
21263 tree tmpl
= DECL_TI_TEMPLATE (decl
);
21265 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
21266 for the instantiation. This is not always the most general
21267 template. Consider, for example:
21270 struct S { template <class U> void f();
21271 template <> void f<int>(); };
21273 and an instantiation of S<double>::f<int>. We want TD to be the
21274 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
21275 while (/* An instantiation cannot have a definition, so we need a
21276 more general template. */
21277 DECL_TEMPLATE_INSTANTIATION (tmpl
)
21278 /* We must also deal with friend templates. Given:
21280 template <class T> struct S {
21281 template <class U> friend void f() {};
21284 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
21285 so far as the language is concerned, but that's still
21286 where we get the pattern for the instantiation from. On
21287 other hand, if the definition comes outside the class, say:
21289 template <class T> struct S {
21290 template <class U> friend void f();
21292 template <class U> friend void f() {}
21294 we don't need to look any further. That's what the check for
21295 DECL_INITIAL is for. */
21296 || (TREE_CODE (decl
) == FUNCTION_DECL
21297 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
21298 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
21300 /* The present template, TD, should not be a definition. If it
21301 were a definition, we should be using it! Note that we
21302 cannot restructure the loop to just keep going until we find
21303 a template with a definition, since that might go too far if
21304 a specialization was declared, but not defined. */
21306 /* Fetch the more general template. */
21307 tmpl
= DECL_TI_TEMPLATE (tmpl
);
21313 /* Returns true if we need to instantiate this template instance even if we
21314 know we aren't going to emit it. */
21317 always_instantiate_p (tree decl
)
21319 /* We always instantiate inline functions so that we can inline them. An
21320 explicit instantiation declaration prohibits implicit instantiation of
21321 non-inline functions. With high levels of optimization, we would
21322 normally inline non-inline functions -- but we're not allowed to do
21323 that for "extern template" functions. Therefore, we check
21324 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
21325 return ((TREE_CODE (decl
) == FUNCTION_DECL
21326 && (DECL_DECLARED_INLINE_P (decl
)
21327 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
21328 /* And we need to instantiate static data members so that
21329 their initializers are available in integral constant
21332 && decl_maybe_constant_var_p (decl
)));
21335 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
21336 instantiate it now, modifying TREE_TYPE (fn). */
21339 maybe_instantiate_noexcept (tree fn
)
21341 tree fntype
, spec
, noex
, clone
;
21343 /* Don't instantiate a noexcept-specification from template context. */
21344 if (processing_template_decl
)
21347 if (DECL_CLONED_FUNCTION_P (fn
))
21348 fn
= DECL_CLONED_FUNCTION (fn
);
21349 fntype
= TREE_TYPE (fn
);
21350 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
21352 if (!spec
|| !TREE_PURPOSE (spec
))
21355 noex
= TREE_PURPOSE (spec
);
21357 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
21359 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
21360 spec
= get_defaulted_eh_spec (fn
);
21361 else if (push_tinst_level (fn
))
21363 push_access_scope (fn
);
21364 push_deferring_access_checks (dk_no_deferred
);
21365 input_location
= DECL_SOURCE_LOCATION (fn
);
21366 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
21367 DEFERRED_NOEXCEPT_ARGS (noex
),
21368 tf_warning_or_error
, fn
,
21369 /*function_p=*/false,
21370 /*integral_constant_expression_p=*/true);
21371 pop_deferring_access_checks ();
21372 pop_access_scope (fn
);
21373 pop_tinst_level ();
21374 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
21375 if (spec
== error_mark_node
)
21376 spec
= noexcept_false_spec
;
21379 spec
= noexcept_false_spec
;
21381 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
21384 FOR_EACH_CLONE (clone
, fn
)
21386 if (TREE_TYPE (clone
) == fntype
)
21387 TREE_TYPE (clone
) = TREE_TYPE (fn
);
21389 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
21393 /* Produce the definition of D, a _DECL generated from a template. If
21394 DEFER_OK is nonzero, then we don't have to actually do the
21395 instantiation now; we just have to do it sometime. Normally it is
21396 an error if this is an explicit instantiation but D is undefined.
21397 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
21398 explicitly instantiated class template. */
21401 instantiate_decl (tree d
, int defer_ok
,
21402 bool expl_inst_class_mem_p
)
21404 tree tmpl
= DECL_TI_TEMPLATE (d
);
21411 bool pattern_defined
;
21412 location_t saved_loc
= input_location
;
21413 int saved_unevaluated_operand
= cp_unevaluated_operand
;
21414 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
21418 bool nested
= false;
21420 /* This function should only be used to instantiate templates for
21421 functions and static member variables. */
21422 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
21424 /* A concept is never instantiated. */
21425 gcc_assert (!DECL_DECLARED_CONCEPT_P (d
));
21427 /* Variables are never deferred; if instantiation is required, they
21428 are instantiated right away. That allows for better code in the
21429 case that an expression refers to the value of the variable --
21430 if the variable has a constant value the referring expression can
21431 take advantage of that fact. */
21433 || DECL_DECLARED_CONSTEXPR_P (d
))
21436 /* Don't instantiate cloned functions. Instead, instantiate the
21437 functions they cloned. */
21438 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
21439 d
= DECL_CLONED_FUNCTION (d
);
21441 if (DECL_TEMPLATE_INSTANTIATED (d
)
21442 || (TREE_CODE (d
) == FUNCTION_DECL
21443 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
21444 || DECL_TEMPLATE_SPECIALIZATION (d
))
21445 /* D has already been instantiated or explicitly specialized, so
21446 there's nothing for us to do here.
21448 It might seem reasonable to check whether or not D is an explicit
21449 instantiation, and, if so, stop here. But when an explicit
21450 instantiation is deferred until the end of the compilation,
21451 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
21452 the instantiation. */
21455 /* Check to see whether we know that this template will be
21456 instantiated in some other file, as with "extern template"
21458 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
21460 /* In general, we do not instantiate such templates. */
21461 if (external_p
&& !always_instantiate_p (d
))
21464 gen_tmpl
= most_general_template (tmpl
);
21465 gen_args
= DECL_TI_ARGS (d
);
21467 if (tmpl
!= gen_tmpl
)
21468 /* We should already have the extra args. */
21469 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
21470 == TMPL_ARGS_DEPTH (gen_args
));
21471 /* And what's in the hash table should match D. */
21472 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
21473 || spec
== NULL_TREE
);
21475 /* This needs to happen before any tsubsting. */
21476 if (! push_tinst_level (d
))
21479 timevar_push (TV_TEMPLATE_INST
);
21481 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
21482 for the instantiation. */
21483 td
= template_for_substitution (d
);
21484 code_pattern
= DECL_TEMPLATE_RESULT (td
);
21486 /* We should never be trying to instantiate a member of a class
21487 template or partial specialization. */
21488 gcc_assert (d
!= code_pattern
);
21490 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
21491 || DECL_TEMPLATE_SPECIALIZATION (td
))
21492 /* In the case of a friend template whose definition is provided
21493 outside the class, we may have too many arguments. Drop the
21494 ones we don't need. The same is true for specializations. */
21495 args
= get_innermost_template_args
21496 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
21500 if (TREE_CODE (d
) == FUNCTION_DECL
)
21502 deleted_p
= DECL_DELETED_FN (code_pattern
);
21503 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
21504 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
21510 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
21513 /* We may be in the middle of deferred access check. Disable it now. */
21514 push_deferring_access_checks (dk_no_deferred
);
21516 /* Unless an explicit instantiation directive has already determined
21517 the linkage of D, remember that a definition is available for
21519 if (pattern_defined
21520 && !DECL_INTERFACE_KNOWN (d
)
21521 && !DECL_NOT_REALLY_EXTERN (d
))
21522 mark_definable (d
);
21524 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
21525 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
21526 input_location
= DECL_SOURCE_LOCATION (d
);
21528 /* If D is a member of an explicitly instantiated class template,
21529 and no definition is available, treat it like an implicit
21531 if (!pattern_defined
&& expl_inst_class_mem_p
21532 && DECL_EXPLICIT_INSTANTIATION (d
))
21534 /* Leave linkage flags alone on instantiations with anonymous
21536 if (TREE_PUBLIC (d
))
21538 DECL_NOT_REALLY_EXTERN (d
) = 0;
21539 DECL_INTERFACE_KNOWN (d
) = 0;
21541 SET_DECL_IMPLICIT_INSTANTIATION (d
);
21544 /* Defer all other templates, unless we have been explicitly
21545 forbidden from doing so. */
21546 if (/* If there is no definition, we cannot instantiate the
21549 /* If it's OK to postpone instantiation, do so. */
21551 /* If this is a static data member that will be defined
21552 elsewhere, we don't want to instantiate the entire data
21553 member, but we do want to instantiate the initializer so that
21554 we can substitute that elsewhere. */
21555 || (external_p
&& VAR_P (d
))
21556 /* Handle here a deleted function too, avoid generating
21557 its body (c++/61080). */
21560 /* The definition of the static data member is now required so
21561 we must substitute the initializer. */
21563 && !DECL_INITIAL (d
)
21564 && DECL_INITIAL (code_pattern
))
21568 bool const_init
= false;
21569 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
21571 ns
= decl_namespace_context (d
);
21572 push_nested_namespace (ns
);
21574 push_nested_class (DECL_CONTEXT (d
));
21575 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
21577 tf_warning_or_error
, NULL_TREE
,
21578 /*integral_constant_expression_p=*/false);
21579 /* If instantiating the initializer involved instantiating this
21580 again, don't call cp_finish_decl twice. */
21581 if (!DECL_INITIAL (d
))
21583 /* Make sure the initializer is still constant, in case of
21584 circular dependency (template/instantiate6.C). */
21586 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
21587 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
21588 /*asmspec_tree=*/NULL_TREE
,
21589 LOOKUP_ONLYCONVERTING
);
21592 pop_nested_class ();
21593 pop_nested_namespace (ns
);
21596 /* We restore the source position here because it's used by
21597 add_pending_template. */
21598 input_location
= saved_loc
;
21600 if (at_eof
&& !pattern_defined
21601 && DECL_EXPLICIT_INSTANTIATION (d
)
21602 && DECL_NOT_REALLY_EXTERN (d
))
21605 The definition of a non-exported function template, a
21606 non-exported member function template, or a non-exported
21607 member function or static data member of a class template
21608 shall be present in every translation unit in which it is
21609 explicitly instantiated. */
21610 permerror (input_location
, "explicit instantiation of %qD "
21611 "but no definition available", d
);
21613 /* If we're in unevaluated context, we just wanted to get the
21614 constant value; this isn't an odr use, so don't queue
21615 a full instantiation. */
21616 if (cp_unevaluated_operand
!= 0)
21618 /* ??? Historically, we have instantiated inline functions, even
21619 when marked as "extern template". */
21620 if (!(external_p
&& VAR_P (d
)))
21621 add_pending_template (d
);
21624 /* Tell the repository that D is available in this translation unit
21625 -- and see if it is supposed to be instantiated here. */
21626 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
21628 /* In a PCH file, despite the fact that the repository hasn't
21629 requested instantiation in the PCH it is still possible that
21630 an instantiation will be required in a file that includes the
21633 add_pending_template (d
);
21634 /* Instantiate inline functions so that the inliner can do its
21635 job, even though we'll not be emitting a copy of this
21637 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
21641 fn_context
= decl_function_context (d
);
21642 nested
= (current_function_decl
!= NULL_TREE
);
21643 vec
<tree
> omp_privatization_save
;
21645 save_omp_privatization_clauses (omp_privatization_save
);
21648 push_to_top_level ();
21652 push_function_context ();
21653 cp_unevaluated_operand
= 0;
21654 c_inhibit_evaluation_warnings
= 0;
21657 /* Mark D as instantiated so that recursive calls to
21658 instantiate_decl do not try to instantiate it again. */
21659 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
21661 /* Regenerate the declaration in case the template has been modified
21662 by a subsequent redeclaration. */
21663 regenerate_decl_from_template (d
, td
);
21665 /* We already set the file and line above. Reset them now in case
21666 they changed as a result of calling regenerate_decl_from_template. */
21667 input_location
= DECL_SOURCE_LOCATION (d
);
21672 bool const_init
= false;
21674 /* Clear out DECL_RTL; whatever was there before may not be right
21675 since we've reset the type of the declaration. */
21676 SET_DECL_RTL (d
, NULL
);
21677 DECL_IN_AGGR_P (d
) = 0;
21679 /* The initializer is placed in DECL_INITIAL by
21680 regenerate_decl_from_template so we don't need to
21681 push/pop_access_scope again here. Pull it out so that
21682 cp_finish_decl can process it. */
21683 init
= DECL_INITIAL (d
);
21684 DECL_INITIAL (d
) = NULL_TREE
;
21685 DECL_INITIALIZED_P (d
) = 0;
21687 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
21688 initializer. That function will defer actual emission until
21689 we have a chance to determine linkage. */
21690 DECL_EXTERNAL (d
) = 0;
21692 /* Enter the scope of D so that access-checking works correctly. */
21693 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
21695 push_nested_class (DECL_CONTEXT (d
));
21697 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
21698 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
21701 pop_nested_class ();
21703 if (variable_template_p (td
))
21704 note_variable_template_instantiation (d
);
21706 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
21707 synthesize_method (d
);
21708 else if (TREE_CODE (d
) == FUNCTION_DECL
)
21710 hash_map
<tree
, tree
> *saved_local_specializations
;
21714 tree block
= NULL_TREE
;
21716 /* Save away the current list, in case we are instantiating one
21717 template from within the body of another. */
21718 saved_local_specializations
= local_specializations
;
21720 /* Set up the list of local specializations. */
21721 local_specializations
= new hash_map
<tree
, tree
>;
21723 /* Set up context. */
21724 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
21725 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
21726 block
= push_stmt_list ();
21728 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
21730 /* Some typedefs referenced from within the template code need to be
21731 access checked at template instantiation time, i.e now. These
21732 types were added to the template at parsing time. Let's get those
21733 and perform the access checks then. */
21734 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
21737 /* Create substitution entries for the parameters. */
21738 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
21739 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
21740 spec_parm
= DECL_ARGUMENTS (d
);
21741 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
21743 register_local_specialization (spec_parm
, tmpl_parm
);
21744 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
21745 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
21747 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
21749 if (!DECL_PACK_P (tmpl_parm
))
21751 register_local_specialization (spec_parm
, tmpl_parm
);
21752 spec_parm
= DECL_CHAIN (spec_parm
);
21756 /* Register the (value) argument pack as a specialization of
21757 TMPL_PARM, then move on. */
21758 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
21759 register_local_specialization (argpack
, tmpl_parm
);
21762 gcc_assert (!spec_parm
);
21764 /* Substitute into the body of the function. */
21765 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
21766 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
21767 tf_warning_or_error
, tmpl
);
21770 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
21771 tf_warning_or_error
, tmpl
,
21772 /*integral_constant_expression_p=*/false);
21774 /* Set the current input_location to the end of the function
21775 so that finish_function knows where we are. */
21777 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
21779 /* Remember if we saw an infinite loop in the template. */
21780 current_function_infinite_loop
21781 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
21784 /* We don't need the local specializations any more. */
21785 delete local_specializations
;
21786 local_specializations
= saved_local_specializations
;
21788 /* Finish the function. */
21789 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
21790 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
21791 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
21794 d
= finish_function (0);
21795 expand_or_defer_fn (d
);
21798 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
21799 cp_check_omp_declare_reduction (d
);
21802 /* We're not deferring instantiation any more. */
21803 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
21806 pop_from_top_level ();
21808 pop_function_context ();
21811 input_location
= saved_loc
;
21812 cp_unevaluated_operand
= saved_unevaluated_operand
;
21813 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
21814 pop_deferring_access_checks ();
21815 pop_tinst_level ();
21817 restore_omp_privatization_clauses (omp_privatization_save
);
21819 timevar_pop (TV_TEMPLATE_INST
);
21824 /* Run through the list of templates that we wish we could
21825 instantiate, and instantiate any we can. RETRIES is the
21826 number of times we retry pending template instantiation. */
21829 instantiate_pending_templates (int retries
)
21832 location_t saved_loc
= input_location
;
21834 /* Instantiating templates may trigger vtable generation. This in turn
21835 may require further template instantiations. We place a limit here
21836 to avoid infinite loop. */
21837 if (pending_templates
&& retries
>= max_tinst_depth
)
21839 tree decl
= pending_templates
->tinst
->decl
;
21841 fatal_error (input_location
,
21842 "template instantiation depth exceeds maximum of %d"
21843 " instantiating %q+D, possibly from virtual table generation"
21844 " (use -ftemplate-depth= to increase the maximum)",
21845 max_tinst_depth
, decl
);
21846 if (TREE_CODE (decl
) == FUNCTION_DECL
)
21847 /* Pretend that we defined it. */
21848 DECL_INITIAL (decl
) = error_mark_node
;
21854 struct pending_template
**t
= &pending_templates
;
21855 struct pending_template
*last
= NULL
;
21859 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
21860 bool complete
= false;
21862 if (TYPE_P (instantiation
))
21866 if (!COMPLETE_TYPE_P (instantiation
))
21868 instantiate_class_template (instantiation
);
21869 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
21870 for (fn
= TYPE_METHODS (instantiation
);
21872 fn
= TREE_CHAIN (fn
))
21873 if (! DECL_ARTIFICIAL (fn
))
21874 instantiate_decl (fn
,
21876 /*expl_inst_class_mem_p=*/false);
21877 if (COMPLETE_TYPE_P (instantiation
))
21881 complete
= COMPLETE_TYPE_P (instantiation
);
21885 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
21886 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
21889 = instantiate_decl (instantiation
,
21891 /*expl_inst_class_mem_p=*/false);
21892 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
21896 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
21897 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
21901 /* If INSTANTIATION has been instantiated, then we don't
21902 need to consider it again in the future. */
21910 current_tinst_level
= NULL
;
21912 last_pending_template
= last
;
21914 while (reconsider
);
21916 input_location
= saved_loc
;
21919 /* Substitute ARGVEC into T, which is a list of initializers for
21920 either base class or a non-static data member. The TREE_PURPOSEs
21921 are DECLs, and the TREE_VALUEs are the initializer values. Used by
21922 instantiate_decl. */
21925 tsubst_initializer_list (tree t
, tree argvec
)
21927 tree inits
= NULL_TREE
;
21929 for (; t
; t
= TREE_CHAIN (t
))
21933 tree expanded_bases
= NULL_TREE
;
21934 tree expanded_arguments
= NULL_TREE
;
21937 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
21942 /* Expand the base class expansion type into separate base
21944 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
21945 tf_warning_or_error
,
21947 if (expanded_bases
== error_mark_node
)
21950 /* We'll be building separate TREE_LISTs of arguments for
21952 len
= TREE_VEC_LENGTH (expanded_bases
);
21953 expanded_arguments
= make_tree_vec (len
);
21954 for (i
= 0; i
< len
; i
++)
21955 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
21957 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
21958 expand each argument in the TREE_VALUE of t. */
21959 expr
= make_node (EXPR_PACK_EXPANSION
);
21960 PACK_EXPANSION_LOCAL_P (expr
) = true;
21961 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
21962 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
21964 if (TREE_VALUE (t
) == void_type_node
)
21965 /* VOID_TYPE_NODE is used to indicate
21966 value-initialization. */
21968 for (i
= 0; i
< len
; i
++)
21969 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
21973 /* Substitute parameter packs into each argument in the
21975 in_base_initializer
= 1;
21976 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
21978 tree expanded_exprs
;
21980 /* Expand the argument. */
21981 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
21983 = tsubst_pack_expansion (expr
, argvec
,
21984 tf_warning_or_error
,
21986 if (expanded_exprs
== error_mark_node
)
21989 /* Prepend each of the expanded expressions to the
21990 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
21991 for (i
= 0; i
< len
; i
++)
21993 TREE_VEC_ELT (expanded_arguments
, i
) =
21994 tree_cons (NULL_TREE
,
21995 TREE_VEC_ELT (expanded_exprs
, i
),
21996 TREE_VEC_ELT (expanded_arguments
, i
));
21999 in_base_initializer
= 0;
22001 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
22002 since we built them backwards. */
22003 for (i
= 0; i
< len
; i
++)
22005 TREE_VEC_ELT (expanded_arguments
, i
) =
22006 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
22011 for (i
= 0; i
< len
; ++i
)
22013 if (expanded_bases
)
22015 decl
= TREE_VEC_ELT (expanded_bases
, i
);
22016 decl
= expand_member_init (decl
);
22017 init
= TREE_VEC_ELT (expanded_arguments
, i
);
22022 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
22023 tf_warning_or_error
, NULL_TREE
);
22025 decl
= expand_member_init (decl
);
22026 if (decl
&& !DECL_P (decl
))
22027 in_base_initializer
= 1;
22029 init
= TREE_VALUE (t
);
22031 if (init
!= void_type_node
)
22032 init
= tsubst_expr (init
, argvec
,
22033 tf_warning_or_error
, NULL_TREE
,
22034 /*integral_constant_expression_p=*/false);
22035 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
22036 /* If we had an initializer but it instantiated to nothing,
22037 value-initialize the object. This will only occur when
22038 the initializer was a pack expansion where the parameter
22039 packs used in that expansion were of length zero. */
22040 init
= void_type_node
;
22041 in_base_initializer
= 0;
22046 init
= build_tree_list (decl
, init
);
22047 TREE_CHAIN (init
) = inits
;
22055 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
22058 set_current_access_from_decl (tree decl
)
22060 if (TREE_PRIVATE (decl
))
22061 current_access_specifier
= access_private_node
;
22062 else if (TREE_PROTECTED (decl
))
22063 current_access_specifier
= access_protected_node
;
22065 current_access_specifier
= access_public_node
;
22068 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
22069 is the instantiation (which should have been created with
22070 start_enum) and ARGS are the template arguments to use. */
22073 tsubst_enum (tree tag
, tree newtag
, tree args
)
22077 if (SCOPED_ENUM_P (newtag
))
22078 begin_scope (sk_scoped_enum
, newtag
);
22080 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
22085 decl
= TREE_VALUE (e
);
22086 /* Note that in a template enum, the TREE_VALUE is the
22087 CONST_DECL, not the corresponding INTEGER_CST. */
22088 value
= tsubst_expr (DECL_INITIAL (decl
),
22089 args
, tf_warning_or_error
, NULL_TREE
,
22090 /*integral_constant_expression_p=*/true);
22092 /* Give this enumeration constant the correct access. */
22093 set_current_access_from_decl (decl
);
22095 /* Actually build the enumerator itself. Here we're assuming that
22096 enumerators can't have dependent attributes. */
22097 build_enumerator (DECL_NAME (decl
), value
, newtag
,
22098 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
22101 if (SCOPED_ENUM_P (newtag
))
22104 finish_enum_value_list (newtag
);
22105 finish_enum (newtag
);
22107 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
22108 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
22111 /* DECL is a FUNCTION_DECL that is a template specialization. Return
22112 its type -- but without substituting the innermost set of template
22113 arguments. So, innermost set of template parameters will appear in
22117 get_mostly_instantiated_function_type (tree decl
)
22119 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
22120 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
22123 /* Return truthvalue if we're processing a template different from
22124 the last one involved in diagnostics. */
22126 problematic_instantiation_changed (void)
22128 return current_tinst_level
!= last_error_tinst_level
;
22131 /* Remember current template involved in diagnostics. */
22133 record_last_problematic_instantiation (void)
22135 last_error_tinst_level
= current_tinst_level
;
22138 struct tinst_level
*
22139 current_instantiation (void)
22141 return current_tinst_level
;
22144 /* Return TRUE if current_function_decl is being instantiated, false
22148 instantiating_current_function_p (void)
22150 return (current_instantiation ()
22151 && current_instantiation ()->decl
== current_function_decl
);
22154 /* [temp.param] Check that template non-type parm TYPE is of an allowable
22155 type. Return zero for ok, nonzero for disallowed. Issue error and
22156 warning messages under control of COMPLAIN. */
22159 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
22161 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
22163 else if (POINTER_TYPE_P (type
))
22165 else if (TYPE_PTRMEM_P (type
))
22167 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
22169 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
22171 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
22173 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
22175 /* A bound template template parm could later be instantiated to have a valid
22176 nontype parm type via an alias template. */
22177 else if (cxx_dialect
>= cxx11
22178 && TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22181 if (complain
& tf_error
)
22183 if (type
== error_mark_node
)
22184 inform (input_location
, "invalid template non-type parameter");
22186 error ("%q#T is not a valid type for a template non-type parameter",
22192 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
22193 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
22196 dependent_type_p_r (tree type
)
22202 A type is dependent if it is:
22204 -- a template parameter. Template template parameters are types
22205 for us (since TYPE_P holds true for them) so we handle
22207 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
22208 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
22210 /* -- a qualified-id with a nested-name-specifier which contains a
22211 class-name that names a dependent type or whose unqualified-id
22212 names a dependent type. */
22213 if (TREE_CODE (type
) == TYPENAME_TYPE
)
22216 /* An alias template specialization can be dependent even if the
22217 resulting type is not. */
22218 if (dependent_alias_template_spec_p (type
))
22221 /* -- a cv-qualified type where the cv-unqualified type is
22223 No code is necessary for this bullet; the code below handles
22224 cv-qualified types, and we don't want to strip aliases with
22225 TYPE_MAIN_VARIANT because of DR 1558. */
22226 /* -- a compound type constructed from any dependent type. */
22227 if (TYPE_PTRMEM_P (type
))
22228 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
22229 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
22231 else if (TYPE_PTR_P (type
)
22232 || TREE_CODE (type
) == REFERENCE_TYPE
)
22233 return dependent_type_p (TREE_TYPE (type
));
22234 else if (TREE_CODE (type
) == FUNCTION_TYPE
22235 || TREE_CODE (type
) == METHOD_TYPE
)
22239 if (dependent_type_p (TREE_TYPE (type
)))
22241 for (arg_type
= TYPE_ARG_TYPES (type
);
22243 arg_type
= TREE_CHAIN (arg_type
))
22244 if (dependent_type_p (TREE_VALUE (arg_type
)))
22248 /* -- an array type constructed from any dependent type or whose
22249 size is specified by a constant expression that is
22252 We checked for type- and value-dependence of the bounds in
22253 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
22254 if (TREE_CODE (type
) == ARRAY_TYPE
)
22256 if (TYPE_DOMAIN (type
)
22257 && dependent_type_p (TYPE_DOMAIN (type
)))
22259 return dependent_type_p (TREE_TYPE (type
));
22262 /* -- a template-id in which either the template name is a template
22264 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22266 /* ... or any of the template arguments is a dependent type or
22267 an expression that is type-dependent or value-dependent. */
22268 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
22269 && (any_dependent_template_arguments_p
22270 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
22273 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
22274 dependent; if the argument of the `typeof' expression is not
22275 type-dependent, then it should already been have resolved. */
22276 if (TREE_CODE (type
) == TYPEOF_TYPE
22277 || TREE_CODE (type
) == DECLTYPE_TYPE
22278 || TREE_CODE (type
) == UNDERLYING_TYPE
)
22281 /* A template argument pack is dependent if any of its packed
22283 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
22285 tree args
= ARGUMENT_PACK_ARGS (type
);
22286 int i
, len
= TREE_VEC_LENGTH (args
);
22287 for (i
= 0; i
< len
; ++i
)
22288 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
22292 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
22293 be template parameters. */
22294 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
22297 /* The standard does not specifically mention types that are local
22298 to template functions or local classes, but they should be
22299 considered dependent too. For example:
22301 template <int I> void f() {
22306 The size of `E' cannot be known until the value of `I' has been
22307 determined. Therefore, `E' must be considered dependent. */
22308 scope
= TYPE_CONTEXT (type
);
22309 if (scope
&& TYPE_P (scope
))
22310 return dependent_type_p (scope
);
22311 /* Don't use type_dependent_expression_p here, as it can lead
22312 to infinite recursion trying to determine whether a lambda
22313 nested in a lambda is dependent (c++/47687). */
22314 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
22315 && DECL_LANG_SPECIFIC (scope
)
22316 && DECL_TEMPLATE_INFO (scope
)
22317 && (any_dependent_template_arguments_p
22318 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
22321 /* Other types are non-dependent. */
22325 /* Returns TRUE if TYPE is dependent, in the sense of
22326 [temp.dep.type]. Note that a NULL type is considered dependent. */
22329 dependent_type_p (tree type
)
22331 /* If there are no template parameters in scope, then there can't be
22332 any dependent types. */
22333 if (!processing_template_decl
)
22335 /* If we are not processing a template, then nobody should be
22336 providing us with a dependent type. */
22338 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
22342 /* If the type is NULL, we have not computed a type for the entity
22343 in question; in that case, the type is dependent. */
22347 /* Erroneous types can be considered non-dependent. */
22348 if (type
== error_mark_node
)
22351 /* If we have not already computed the appropriate value for TYPE,
22353 if (!TYPE_DEPENDENT_P_VALID (type
))
22355 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
22356 TYPE_DEPENDENT_P_VALID (type
) = 1;
22359 return TYPE_DEPENDENT_P (type
);
22362 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
22363 lookup. In other words, a dependent type that is not the current
22367 dependent_scope_p (tree scope
)
22369 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
22370 && !currently_open_class (scope
));
22373 /* T is a SCOPE_REF; return whether we need to consider it
22374 instantiation-dependent so that we can check access at instantiation
22375 time even though we know which member it resolves to. */
22378 instantiation_dependent_scope_ref_p (tree t
)
22380 if (DECL_P (TREE_OPERAND (t
, 1))
22381 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
22382 && accessible_in_template_p (TREE_OPERAND (t
, 0),
22383 TREE_OPERAND (t
, 1)))
22389 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
22390 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
22393 /* Note that this predicate is not appropriate for general expressions;
22394 only constant expressions (that satisfy potential_constant_expression)
22395 can be tested for value dependence. */
22398 value_dependent_expression_p (tree expression
)
22400 if (!processing_template_decl
)
22403 /* A name declared with a dependent type. */
22404 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
22407 switch (TREE_CODE (expression
))
22409 case IDENTIFIER_NODE
:
22410 /* A name that has not been looked up -- must be dependent. */
22413 case TEMPLATE_PARM_INDEX
:
22414 /* A non-type template parm. */
22418 /* A non-type template parm. */
22419 if (DECL_TEMPLATE_PARM_P (expression
))
22421 return value_dependent_expression_p (DECL_INITIAL (expression
));
22424 /* A constant with literal type and is initialized
22425 with an expression that is value-dependent.
22427 Note that a non-dependent parenthesized initializer will have
22428 already been replaced with its constant value, so if we see
22429 a TREE_LIST it must be dependent. */
22430 if (DECL_INITIAL (expression
)
22431 && decl_constant_var_p (expression
)
22432 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
22433 /* cp_finish_decl doesn't fold reference initializers. */
22434 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
22435 || value_dependent_expression_p (DECL_INITIAL (expression
))))
22439 case DYNAMIC_CAST_EXPR
:
22440 case STATIC_CAST_EXPR
:
22441 case CONST_CAST_EXPR
:
22442 case REINTERPRET_CAST_EXPR
:
22444 /* These expressions are value-dependent if the type to which
22445 the cast occurs is dependent or the expression being casted
22446 is value-dependent. */
22448 tree type
= TREE_TYPE (expression
);
22450 if (dependent_type_p (type
))
22453 /* A functional cast has a list of operands. */
22454 expression
= TREE_OPERAND (expression
, 0);
22457 /* If there are no operands, it must be an expression such
22458 as "int()". This should not happen for aggregate types
22459 because it would form non-constant expressions. */
22460 gcc_assert (cxx_dialect
>= cxx11
22461 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
22466 if (TREE_CODE (expression
) == TREE_LIST
)
22467 return any_value_dependent_elements_p (expression
);
22469 return value_dependent_expression_p (expression
);
22473 if (SIZEOF_EXPR_TYPE_P (expression
))
22474 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
22478 /* A `sizeof' expression is value-dependent if the operand is
22479 type-dependent or is a pack expansion. */
22480 expression
= TREE_OPERAND (expression
, 0);
22481 if (PACK_EXPANSION_P (expression
))
22483 else if (TYPE_P (expression
))
22484 return dependent_type_p (expression
);
22485 return instantiation_dependent_expression_p (expression
);
22487 case AT_ENCODE_EXPR
:
22488 /* An 'encode' expression is value-dependent if the operand is
22490 expression
= TREE_OPERAND (expression
, 0);
22491 return dependent_type_p (expression
);
22493 case NOEXCEPT_EXPR
:
22494 expression
= TREE_OPERAND (expression
, 0);
22495 return instantiation_dependent_expression_p (expression
);
22498 /* All instantiation-dependent expressions should also be considered
22499 value-dependent. */
22500 return instantiation_dependent_scope_ref_p (expression
);
22502 case COMPONENT_REF
:
22503 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
22504 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
22506 case NONTYPE_ARGUMENT_PACK
:
22507 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
22508 is value-dependent. */
22510 tree values
= ARGUMENT_PACK_ARGS (expression
);
22511 int i
, len
= TREE_VEC_LENGTH (values
);
22513 for (i
= 0; i
< len
; ++i
)
22514 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
22522 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
22523 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
22524 || (type2
? dependent_type_p (type2
) : false));
22528 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
22529 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
22532 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
22533 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
22537 tree op
= TREE_OPERAND (expression
, 0);
22538 return (value_dependent_expression_p (op
)
22539 || has_value_dependent_address (op
));
22542 case REQUIRES_EXPR
:
22543 /* Treat all requires-expressions as value-dependent so
22544 we don't try to fold them. */
22548 return dependent_type_p (TREE_OPERAND (expression
, 0));
22552 tree fn
= get_callee_fndecl (expression
);
22554 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
22556 nargs
= call_expr_nargs (expression
);
22557 for (i
= 0; i
< nargs
; ++i
)
22559 tree op
= CALL_EXPR_ARG (expression
, i
);
22560 /* In a call to a constexpr member function, look through the
22561 implicit ADDR_EXPR on the object argument so that it doesn't
22562 cause the call to be considered value-dependent. We also
22563 look through it in potential_constant_expression. */
22564 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
22565 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
22566 && TREE_CODE (op
) == ADDR_EXPR
)
22567 op
= TREE_OPERAND (op
, 0);
22568 if (value_dependent_expression_p (op
))
22574 case TEMPLATE_ID_EXPR
:
22575 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
22577 return type_dependent_expression_p (expression
)
22578 || variable_concept_p (TREE_OPERAND (expression
, 0));
22584 if (dependent_type_p (TREE_TYPE (expression
)))
22586 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
22587 if (value_dependent_expression_p (val
))
22593 /* Treat a GNU statement expression as dependent to avoid crashing
22594 under instantiate_non_dependent_expr; it can't be constant. */
22598 /* A constant expression is value-dependent if any subexpression is
22599 value-dependent. */
22600 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
22602 case tcc_reference
:
22604 case tcc_comparison
:
22606 case tcc_expression
:
22609 int i
, len
= cp_tree_operand_length (expression
);
22611 for (i
= 0; i
< len
; i
++)
22613 tree t
= TREE_OPERAND (expression
, i
);
22615 /* In some cases, some of the operands may be missing.l
22616 (For example, in the case of PREDECREMENT_EXPR, the
22617 amount to increment by may be missing.) That doesn't
22618 make the expression dependent. */
22619 if (t
&& value_dependent_expression_p (t
))
22630 /* The expression is not value-dependent. */
22634 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
22635 [temp.dep.expr]. Note that an expression with no type is
22636 considered dependent. Other parts of the compiler arrange for an
22637 expression with type-dependent subexpressions to have no type, so
22638 this function doesn't have to be fully recursive. */
22641 type_dependent_expression_p (tree expression
)
22643 if (!processing_template_decl
)
22646 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
22649 /* An unresolved name is always dependent. */
22650 if (identifier_p (expression
)
22651 || TREE_CODE (expression
) == USING_DECL
22652 || TREE_CODE (expression
) == WILDCARD_DECL
)
22655 /* A fold expression is type-dependent. */
22656 if (TREE_CODE (expression
) == UNARY_LEFT_FOLD_EXPR
22657 || TREE_CODE (expression
) == UNARY_RIGHT_FOLD_EXPR
22658 || TREE_CODE (expression
) == BINARY_LEFT_FOLD_EXPR
22659 || TREE_CODE (expression
) == BINARY_RIGHT_FOLD_EXPR
)
22662 /* Some expression forms are never type-dependent. */
22663 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
22664 || TREE_CODE (expression
) == SIZEOF_EXPR
22665 || TREE_CODE (expression
) == ALIGNOF_EXPR
22666 || TREE_CODE (expression
) == AT_ENCODE_EXPR
22667 || TREE_CODE (expression
) == NOEXCEPT_EXPR
22668 || TREE_CODE (expression
) == TRAIT_EXPR
22669 || TREE_CODE (expression
) == TYPEID_EXPR
22670 || TREE_CODE (expression
) == DELETE_EXPR
22671 || TREE_CODE (expression
) == VEC_DELETE_EXPR
22672 || TREE_CODE (expression
) == THROW_EXPR
22673 || TREE_CODE (expression
) == REQUIRES_EXPR
)
22676 /* The types of these expressions depends only on the type to which
22677 the cast occurs. */
22678 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
22679 || TREE_CODE (expression
) == STATIC_CAST_EXPR
22680 || TREE_CODE (expression
) == CONST_CAST_EXPR
22681 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
22682 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
22683 || TREE_CODE (expression
) == CAST_EXPR
)
22684 return dependent_type_p (TREE_TYPE (expression
));
22686 /* The types of these expressions depends only on the type created
22687 by the expression. */
22688 if (TREE_CODE (expression
) == NEW_EXPR
22689 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
22691 /* For NEW_EXPR tree nodes created inside a template, either
22692 the object type itself or a TREE_LIST may appear as the
22694 tree type
= TREE_OPERAND (expression
, 1);
22695 if (TREE_CODE (type
) == TREE_LIST
)
22696 /* This is an array type. We need to check array dimensions
22698 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
22699 || value_dependent_expression_p
22700 (TREE_OPERAND (TREE_VALUE (type
), 1));
22702 return dependent_type_p (type
);
22705 if (TREE_CODE (expression
) == SCOPE_REF
)
22707 tree scope
= TREE_OPERAND (expression
, 0);
22708 tree name
= TREE_OPERAND (expression
, 1);
22710 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
22711 contains an identifier associated by name lookup with one or more
22712 declarations declared with a dependent type, or...a
22713 nested-name-specifier or qualified-id that names a member of an
22714 unknown specialization. */
22715 return (type_dependent_expression_p (name
)
22716 || dependent_scope_p (scope
));
22719 if (TREE_CODE (expression
) == FUNCTION_DECL
22720 && DECL_LANG_SPECIFIC (expression
)
22721 && DECL_TEMPLATE_INFO (expression
)
22722 && (any_dependent_template_arguments_p
22723 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
22726 if (TREE_CODE (expression
) == TEMPLATE_DECL
22727 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
22730 if (TREE_CODE (expression
) == STMT_EXPR
)
22731 expression
= stmt_expr_value_expr (expression
);
22733 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
22738 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
22740 if (type_dependent_expression_p (elt
))
22746 /* A static data member of the current instantiation with incomplete
22747 array type is type-dependent, as the definition and specializations
22748 can have different bounds. */
22749 if (VAR_P (expression
)
22750 && DECL_CLASS_SCOPE_P (expression
)
22751 && dependent_type_p (DECL_CONTEXT (expression
))
22752 && VAR_HAD_UNKNOWN_BOUND (expression
))
22755 /* An array of unknown bound depending on a variadic parameter, eg:
22757 template<typename... Args>
22758 void foo (Args... args)
22760 int arr[] = { args... };
22763 template<int... vals>
22766 int arr[] = { vals... };
22769 If the array has no length and has an initializer, it must be that
22770 we couldn't determine its length in cp_complete_array_type because
22771 it is dependent. */
22772 if (VAR_P (expression
)
22773 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
22774 && !TYPE_DOMAIN (TREE_TYPE (expression
))
22775 && DECL_INITIAL (expression
))
22778 /* A variable template specialization is type-dependent if it has any
22779 dependent template arguments. */
22780 if (VAR_P (expression
)
22781 && DECL_LANG_SPECIFIC (expression
)
22782 && DECL_TEMPLATE_INFO (expression
)
22783 && variable_template_p (DECL_TI_TEMPLATE (expression
)))
22784 return any_dependent_template_arguments_p (DECL_TI_ARGS (expression
));
22786 /* Always dependent, on the number of arguments if nothing else. */
22787 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
22790 if (TREE_TYPE (expression
) == unknown_type_node
)
22792 if (TREE_CODE (expression
) == ADDR_EXPR
)
22793 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
22794 if (TREE_CODE (expression
) == COMPONENT_REF
22795 || TREE_CODE (expression
) == OFFSET_REF
)
22797 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
22799 expression
= TREE_OPERAND (expression
, 1);
22800 if (identifier_p (expression
))
22803 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
22804 if (TREE_CODE (expression
) == SCOPE_REF
)
22807 if (BASELINK_P (expression
))
22809 if (BASELINK_OPTYPE (expression
)
22810 && dependent_type_p (BASELINK_OPTYPE (expression
)))
22812 expression
= BASELINK_FUNCTIONS (expression
);
22815 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
22817 if (any_dependent_template_arguments_p
22818 (TREE_OPERAND (expression
, 1)))
22820 expression
= TREE_OPERAND (expression
, 0);
22821 if (identifier_p (expression
))
22825 gcc_assert (TREE_CODE (expression
) == OVERLOAD
22826 || TREE_CODE (expression
) == FUNCTION_DECL
);
22830 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
22832 expression
= OVL_NEXT (expression
);
22837 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
22839 return (dependent_type_p (TREE_TYPE (expression
)));
22842 /* walk_tree callback function for instantiation_dependent_expression_p,
22843 below. Returns non-zero if a dependent subexpression is found. */
22846 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
22851 /* We don't have to worry about decltype currently because decltype
22852 of an instantiation-dependent expr is a dependent type. This
22853 might change depending on the resolution of DR 1172. */
22854 *walk_subtrees
= false;
22857 enum tree_code code
= TREE_CODE (*tp
);
22860 /* Don't treat an argument list as dependent just because it has no
22868 /* A constant with a dependent initializer is dependent. */
22869 if (value_dependent_expression_p (*tp
))
22873 case TEMPLATE_PARM_INDEX
:
22876 /* Handle expressions with type operands. */
22880 case AT_ENCODE_EXPR
:
22882 tree op
= TREE_OPERAND (*tp
, 0);
22883 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
22884 op
= TREE_TYPE (op
);
22887 if (dependent_type_p (op
))
22891 *walk_subtrees
= false;
22899 if (value_dependent_expression_p (*tp
))
22901 *walk_subtrees
= false;
22904 case COMPONENT_REF
:
22905 if (identifier_p (TREE_OPERAND (*tp
, 1)))
22906 /* In a template, finish_class_member_access_expr creates a
22907 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
22908 type-dependent, so that we can check access control at
22909 instantiation time (PR 42277). See also Core issue 1273. */
22914 if (instantiation_dependent_scope_ref_p (*tp
))
22919 /* Treat statement-expressions as dependent. */
22923 /* Treat requires-expressions as dependent. */
22924 case REQUIRES_EXPR
:
22928 /* Treat calls to function concepts as dependent. */
22929 if (function_concept_check_p (*tp
))
22933 case TEMPLATE_ID_EXPR
:
22934 /* And variable concepts. */
22935 if (variable_concept_p (TREE_OPERAND (*tp
, 0)))
22943 if (type_dependent_expression_p (*tp
))
22949 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
22950 sense defined by the ABI:
22952 "An expression is instantiation-dependent if it is type-dependent
22953 or value-dependent, or it has a subexpression that is type-dependent
22954 or value-dependent." */
22957 instantiation_dependent_expression_p (tree expression
)
22961 if (!processing_template_decl
)
22964 if (expression
== error_mark_node
)
22967 result
= cp_walk_tree_without_duplicates (&expression
,
22968 instantiation_dependent_r
, NULL
);
22969 return result
!= NULL_TREE
;
22972 /* Like type_dependent_expression_p, but it also works while not processing
22973 a template definition, i.e. during substitution or mangling. */
22976 type_dependent_expression_p_push (tree expr
)
22979 ++processing_template_decl
;
22980 b
= type_dependent_expression_p (expr
);
22981 --processing_template_decl
;
22985 /* Returns TRUE if ARGS contains a type-dependent expression. */
22988 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
22993 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
22995 if (type_dependent_expression_p (arg
))
23001 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
23002 expressions) contains any type-dependent expressions. */
23005 any_type_dependent_elements_p (const_tree list
)
23007 for (; list
; list
= TREE_CHAIN (list
))
23008 if (type_dependent_expression_p (TREE_VALUE (list
)))
23014 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
23015 expressions) contains any value-dependent expressions. */
23018 any_value_dependent_elements_p (const_tree list
)
23020 for (; list
; list
= TREE_CHAIN (list
))
23021 if (value_dependent_expression_p (TREE_VALUE (list
)))
23027 /* Returns TRUE if the ARG (a template argument) is dependent. */
23030 dependent_template_arg_p (tree arg
)
23032 if (!processing_template_decl
)
23035 /* Assume a template argument that was wrongly written by the user
23036 is dependent. This is consistent with what
23037 any_dependent_template_arguments_p [that calls this function]
23039 if (!arg
|| arg
== error_mark_node
)
23042 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
23043 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
23045 if (TREE_CODE (arg
) == TEMPLATE_DECL
23046 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
23047 return dependent_template_p (arg
);
23048 else if (ARGUMENT_PACK_P (arg
))
23050 tree args
= ARGUMENT_PACK_ARGS (arg
);
23051 int i
, len
= TREE_VEC_LENGTH (args
);
23052 for (i
= 0; i
< len
; ++i
)
23054 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
23060 else if (TYPE_P (arg
))
23061 return dependent_type_p (arg
);
23063 return (type_dependent_expression_p (arg
)
23064 || value_dependent_expression_p (arg
));
23067 /* Returns true if ARGS (a collection of template arguments) contains
23068 any types that require structural equality testing. */
23071 any_template_arguments_need_structural_equality_p (tree args
)
23078 if (args
== error_mark_node
)
23081 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
23083 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
23084 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
23086 tree arg
= TREE_VEC_ELT (level
, j
);
23087 tree packed_args
= NULL_TREE
;
23090 if (ARGUMENT_PACK_P (arg
))
23092 /* Look inside the argument pack. */
23093 packed_args
= ARGUMENT_PACK_ARGS (arg
);
23094 len
= TREE_VEC_LENGTH (packed_args
);
23097 for (k
= 0; k
< len
; ++k
)
23100 arg
= TREE_VEC_ELT (packed_args
, k
);
23102 if (error_operand_p (arg
))
23104 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
23106 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
23108 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
23109 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
23118 /* Returns true if ARGS (a collection of template arguments) contains
23119 any dependent arguments. */
23122 any_dependent_template_arguments_p (const_tree args
)
23129 if (args
== error_mark_node
)
23132 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
23134 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
23135 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
23136 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
23143 /* Returns TRUE if the template TMPL is dependent. */
23146 dependent_template_p (tree tmpl
)
23148 if (TREE_CODE (tmpl
) == OVERLOAD
)
23152 if (dependent_template_p (OVL_CURRENT (tmpl
)))
23154 tmpl
= OVL_NEXT (tmpl
);
23159 /* Template template parameters are dependent. */
23160 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
23161 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
23163 /* So are names that have not been looked up. */
23164 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
23166 /* So are member templates of dependent classes. */
23167 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
23168 return dependent_type_p (DECL_CONTEXT (tmpl
));
23172 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
23175 dependent_template_id_p (tree tmpl
, tree args
)
23177 return (dependent_template_p (tmpl
)
23178 || any_dependent_template_arguments_p (args
));
23181 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
23185 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
23189 if (!processing_template_decl
)
23192 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
23194 tree decl
= TREE_VEC_ELT (declv
, i
);
23195 tree init
= TREE_VEC_ELT (initv
, i
);
23196 tree cond
= TREE_VEC_ELT (condv
, i
);
23197 tree incr
= TREE_VEC_ELT (incrv
, i
);
23199 if (type_dependent_expression_p (decl
)
23200 || TREE_CODE (decl
) == SCOPE_REF
)
23203 if (init
&& type_dependent_expression_p (init
))
23206 if (type_dependent_expression_p (cond
))
23209 if (COMPARISON_CLASS_P (cond
)
23210 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
23211 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
23214 if (TREE_CODE (incr
) == MODOP_EXPR
)
23216 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
23217 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
23220 else if (type_dependent_expression_p (incr
))
23222 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
23224 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
23226 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
23228 tree t
= TREE_OPERAND (incr
, 1);
23229 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
23230 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
23239 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
23240 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
23241 no such TYPE can be found. Note that this function peers inside
23242 uninstantiated templates and therefore should be used only in
23243 extremely limited situations. ONLY_CURRENT_P restricts this
23244 peering to the currently open classes hierarchy (which is required
23245 when comparing types). */
23248 resolve_typename_type (tree type
, bool only_current_p
)
23257 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
23259 scope
= TYPE_CONTEXT (type
);
23260 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
23261 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
23262 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
23263 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
23264 identifier of the TYPENAME_TYPE anymore.
23265 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
23266 TYPENAME_TYPE instead, we avoid messing up with a possible
23267 typedef variant case. */
23268 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
23270 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
23271 it first before we can figure out what NAME refers to. */
23272 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
23274 if (TYPENAME_IS_RESOLVING_P (scope
))
23275 /* Given a class template A with a dependent base with nested type C,
23276 typedef typename A::C::C C will land us here, as trying to resolve
23277 the initial A::C leads to the local C typedef, which leads back to
23278 A::C::C. So we break the recursion now. */
23281 scope
= resolve_typename_type (scope
, only_current_p
);
23283 /* If we don't know what SCOPE refers to, then we cannot resolve the
23285 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
23287 /* If the SCOPE is a template type parameter, we have no way of
23288 resolving the name. */
23289 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
23291 /* If the SCOPE is not the current instantiation, there's no reason
23292 to look inside it. */
23293 if (only_current_p
&& !currently_open_class (scope
))
23295 /* If this is a typedef, we don't want to look inside (c++/11987). */
23296 if (typedef_variant_p (type
))
23298 /* If SCOPE isn't the template itself, it will not have a valid
23299 TYPE_FIELDS list. */
23300 if (CLASS_TYPE_P (scope
)
23301 && same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
23302 /* scope is either the template itself or a compatible instantiation
23303 like X<T>, so look up the name in the original template. */
23304 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
23306 /* scope is a partial instantiation, so we can't do the lookup or we
23307 will lose the template arguments. */
23309 /* Enter the SCOPE so that name lookup will be resolved as if we
23310 were in the class definition. In particular, SCOPE will no
23311 longer be considered a dependent type. */
23312 pushed_scope
= push_scope (scope
);
23313 /* Look up the declaration. */
23314 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
23315 tf_warning_or_error
);
23317 result
= NULL_TREE
;
23319 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
23320 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
23323 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
23324 && TREE_CODE (decl
) == TYPE_DECL
)
23326 result
= TREE_TYPE (decl
);
23327 if (result
== error_mark_node
)
23328 result
= NULL_TREE
;
23330 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
23331 && DECL_CLASS_TEMPLATE_P (decl
))
23335 /* Obtain the template and the arguments. */
23336 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
23337 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
23338 /* Instantiate the template. */
23339 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
23340 /*entering_scope=*/0,
23341 tf_error
| tf_user
);
23342 if (result
== error_mark_node
)
23343 result
= NULL_TREE
;
23346 /* Leave the SCOPE. */
23348 pop_scope (pushed_scope
);
23350 /* If we failed to resolve it, return the original typename. */
23354 /* If lookup found a typename type, resolve that too. */
23355 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
23357 /* Ill-formed programs can cause infinite recursion here, so we
23358 must catch that. */
23359 TYPENAME_IS_RESOLVING_P (type
) = 1;
23360 result
= resolve_typename_type (result
, only_current_p
);
23361 TYPENAME_IS_RESOLVING_P (type
) = 0;
23364 /* Qualify the resulting type. */
23365 quals
= cp_type_quals (type
);
23367 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
23372 /* EXPR is an expression which is not type-dependent. Return a proxy
23373 for EXPR that can be used to compute the types of larger
23374 expressions containing EXPR. */
23377 build_non_dependent_expr (tree expr
)
23381 /* Try to get a constant value for all non-dependent expressions in
23382 order to expose bugs in *_dependent_expression_p and constexpr. */
23383 if (flag_checking
&& cxx_dialect
>= cxx11
)
23384 fold_non_dependent_expr (expr
);
23386 /* Preserve OVERLOADs; the functions must be available to resolve
23389 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
23390 inner_expr
= stmt_expr_value_expr (inner_expr
);
23391 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
23392 inner_expr
= TREE_OPERAND (inner_expr
, 0);
23393 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
23394 inner_expr
= TREE_OPERAND (inner_expr
, 1);
23395 if (is_overloaded_fn (inner_expr
)
23396 || TREE_CODE (inner_expr
) == OFFSET_REF
)
23398 /* There is no need to return a proxy for a variable. */
23401 /* Preserve string constants; conversions from string constants to
23402 "char *" are allowed, even though normally a "const char *"
23403 cannot be used to initialize a "char *". */
23404 if (TREE_CODE (expr
) == STRING_CST
)
23406 /* Preserve void and arithmetic constants, as an optimization -- there is no
23407 reason to create a new node. */
23408 if (TREE_CODE (expr
) == VOID_CST
23409 || TREE_CODE (expr
) == INTEGER_CST
23410 || TREE_CODE (expr
) == REAL_CST
)
23412 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
23413 There is at least one place where we want to know that a
23414 particular expression is a throw-expression: when checking a ?:
23415 expression, there are special rules if the second or third
23416 argument is a throw-expression. */
23417 if (TREE_CODE (expr
) == THROW_EXPR
)
23420 /* Don't wrap an initializer list, we need to be able to look inside. */
23421 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
23424 /* Don't wrap a dummy object, we need to be able to test for it. */
23425 if (is_dummy_object (expr
))
23428 if (TREE_CODE (expr
) == COND_EXPR
)
23429 return build3 (COND_EXPR
,
23431 TREE_OPERAND (expr
, 0),
23432 (TREE_OPERAND (expr
, 1)
23433 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
23434 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
23435 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
23436 if (TREE_CODE (expr
) == COMPOUND_EXPR
23437 && !COMPOUND_EXPR_OVERLOADED (expr
))
23438 return build2 (COMPOUND_EXPR
,
23440 TREE_OPERAND (expr
, 0),
23441 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
23443 /* If the type is unknown, it can't really be non-dependent */
23444 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
23446 /* Otherwise, build a NON_DEPENDENT_EXPR. */
23447 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
23450 /* ARGS is a vector of expressions as arguments to a function call.
23451 Replace the arguments with equivalent non-dependent expressions.
23452 This modifies ARGS in place. */
23455 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
23460 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
23462 tree newarg
= build_non_dependent_expr (arg
);
23464 (*args
)[ix
] = newarg
;
23468 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
23469 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
23473 make_auto_1 (tree name
)
23475 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
23476 TYPE_NAME (au
) = build_decl (input_location
,
23477 TYPE_DECL
, name
, au
);
23478 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
23479 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
23480 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
23481 TYPE_NAME (au
), NULL_TREE
);
23482 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
23483 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
23484 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
23490 make_decltype_auto (void)
23492 return make_auto_1 (get_identifier ("decltype(auto)"));
23498 return make_auto_1 (get_identifier ("auto"));
23501 /* Given type ARG, return std::initializer_list<ARG>. */
23506 tree std_init_list
= namespace_binding
23507 (get_identifier ("initializer_list"), std_node
);
23509 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
23511 error ("deducing from brace-enclosed initializer list requires "
23512 "#include <initializer_list>");
23513 return error_mark_node
;
23515 argvec
= make_tree_vec (1);
23516 TREE_VEC_ELT (argvec
, 0) = arg
;
23517 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
23518 NULL_TREE
, 0, tf_warning_or_error
);
23521 /* Replace auto in TYPE with std::initializer_list<auto>. */
23524 listify_autos (tree type
, tree auto_node
)
23526 tree init_auto
= listify (auto_node
);
23527 tree argvec
= make_tree_vec (1);
23528 TREE_VEC_ELT (argvec
, 0) = init_auto
;
23529 if (processing_template_decl
)
23530 argvec
= add_to_template_args (current_template_args (), argvec
);
23531 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
23534 /* Hash traits for hashing possibly constrained 'auto'
23535 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
23537 struct auto_hash
: default_hash_traits
<tree
>
23539 static inline hashval_t
hash (tree
);
23540 static inline bool equal (tree
, tree
);
23543 /* Hash the 'auto' T. */
23546 auto_hash::hash (tree t
)
23548 if (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
23549 /* Matching constrained-type-specifiers denote the same template
23550 parameter, so hash the constraint. */
23551 return hash_placeholder_constraint (c
);
23553 /* But unconstrained autos are all separate, so just hash the pointer. */
23554 return iterative_hash_object (t
, 0);
23557 /* Compare two 'auto's. */
23560 auto_hash::equal (tree t1
, tree t2
)
23565 tree c1
= PLACEHOLDER_TYPE_CONSTRAINTS (t1
);
23566 tree c2
= PLACEHOLDER_TYPE_CONSTRAINTS (t2
);
23568 /* Two unconstrained autos are distinct. */
23572 return equivalent_placeholder_constraints (c1
, c2
);
23575 /* for_each_template_parm callback for extract_autos: if t is a (possibly
23576 constrained) auto, add it to the vector. */
23579 extract_autos_r (tree t
, void *data
)
23581 hash_table
<auto_hash
> &hash
= *(hash_table
<auto_hash
>*)data
;
23582 if (is_auto_or_concept (t
))
23584 /* All the autos were built with index 0; fix that up now. */
23585 tree
*p
= hash
.find_slot (t
, INSERT
);
23588 /* If this is a repeated constrained-type-specifier, use the index we
23590 idx
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (*p
));
23593 /* Otherwise this is new, so use the current count. */
23595 idx
= hash
.elements () - 1;
23597 TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (t
)) = idx
;
23600 /* Always keep walking. */
23604 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
23605 says they can appear anywhere in the type. */
23608 extract_autos (tree type
)
23610 hash_set
<tree
> visited
;
23611 hash_table
<auto_hash
> hash (2);
23613 for_each_template_parm (type
, extract_autos_r
, &hash
, &visited
, true);
23615 tree tree_vec
= make_tree_vec (hash
.elements());
23616 for (hash_table
<auto_hash
>::iterator iter
= hash
.begin();
23617 iter
!= hash
.end(); ++iter
)
23620 unsigned i
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (elt
));
23621 TREE_VEC_ELT (tree_vec
, i
)
23622 = build_tree_list (NULL_TREE
, TYPE_NAME (elt
));
23628 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
23629 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
23632 do_auto_deduction (tree type
, tree init
, tree auto_node
)
23634 return do_auto_deduction (type
, init
, auto_node
,
23635 tf_warning_or_error
,
23639 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
23640 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
23641 The CONTEXT determines the context in which auto deduction is performed
23642 and is used to control error diagnostics. */
23645 do_auto_deduction (tree type
, tree init
, tree auto_node
,
23646 tsubst_flags_t complain
, auto_deduction_context context
)
23650 if (init
== error_mark_node
)
23651 return error_mark_node
;
23653 if (type_dependent_expression_p (init
))
23654 /* Defining a subset of type-dependent expressions that we can deduce
23655 from ahead of time isn't worth the trouble. */
23658 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
23659 with either a new invented type template parameter U or, if the
23660 initializer is a braced-init-list (8.5.4), with
23661 std::initializer_list<U>. */
23662 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
23664 if (!DIRECT_LIST_INIT_P (init
))
23665 type
= listify_autos (type
, auto_node
);
23666 else if (CONSTRUCTOR_NELTS (init
) == 1)
23667 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
23670 if (complain
& tf_warning_or_error
)
23672 if (permerror (input_location
, "direct-list-initialization of "
23673 "%<auto%> requires exactly one element"))
23674 inform (input_location
,
23675 "for deduction to %<std::initializer_list%>, use copy-"
23676 "list-initialization (i.e. add %<=%> before the %<{%>)");
23678 type
= listify_autos (type
, auto_node
);
23682 init
= resolve_nondeduced_context (init
);
23684 if (AUTO_IS_DECLTYPE (auto_node
))
23686 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
23687 && !REF_PARENTHESIZED_P (init
)));
23688 targs
= make_tree_vec (1);
23689 TREE_VEC_ELT (targs
, 0)
23690 = finish_decltype_type (init
, id
, tf_warning_or_error
);
23691 if (type
!= auto_node
)
23693 if (complain
& tf_error
)
23694 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
23695 return error_mark_node
;
23700 tree parms
= build_tree_list (NULL_TREE
, type
);
23704 tparms
= extract_autos (type
);
23707 tparms
= make_tree_vec (1);
23708 TREE_VEC_ELT (tparms
, 0)
23709 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
23712 targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
23713 int val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
23714 DEDUCE_CALL
, LOOKUP_NORMAL
,
23715 NULL
, /*explain_p=*/false);
23718 if (processing_template_decl
)
23719 /* Try again at instantiation time. */
23721 if (type
&& type
!= error_mark_node
23722 && (complain
& tf_error
))
23723 /* If type is error_mark_node a diagnostic must have been
23724 emitted by now. Also, having a mention to '<type error>'
23725 in the diagnostic is not really useful to the user. */
23727 if (cfun
&& auto_node
== current_function_auto_return_pattern
23728 && LAMBDA_FUNCTION_P (current_function_decl
))
23729 error ("unable to deduce lambda return type from %qE", init
);
23731 error ("unable to deduce %qT from %qE", type
, init
);
23732 type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
23733 DEDUCE_CALL
, LOOKUP_NORMAL
,
23734 NULL
, /*explain_p=*/true);
23736 return error_mark_node
;
23740 /* If the list of declarators contains more than one declarator, the type
23741 of each declared variable is determined as described above. If the
23742 type deduced for the template parameter U is not the same in each
23743 deduction, the program is ill-formed. */
23744 if (!flag_concepts
&& TREE_TYPE (auto_node
)
23745 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
23747 if (cfun
&& auto_node
== current_function_auto_return_pattern
23748 && LAMBDA_FUNCTION_P (current_function_decl
))
23749 error ("inconsistent types %qT and %qT deduced for "
23750 "lambda return type", TREE_TYPE (auto_node
),
23751 TREE_VEC_ELT (targs
, 0));
23753 error ("inconsistent deduction for %qT: %qT and then %qT",
23754 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
23755 return error_mark_node
;
23757 if (!flag_concepts
)
23758 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
23760 /* Check any placeholder constraints against the deduced type. */
23761 if (flag_concepts
&& !processing_template_decl
)
23762 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (auto_node
))
23764 /* Use the deduced type to check the associated constraints. */
23765 if (!constraints_satisfied_p (constr
, targs
))
23767 if (complain
& tf_warning_or_error
)
23771 case adc_unspecified
:
23772 error("placeholder constraints not satisfied");
23774 case adc_variable_type
:
23775 error ("deduced initializer does not satisfy "
23776 "placeholder constraints");
23778 case adc_return_type
:
23779 error ("deduced return type does not satisfy "
23780 "placeholder constraints");
23782 case adc_requirement
:
23783 error ("deduced expression type does not saatisy "
23784 "placeholder constraints");
23787 diagnose_constraints (input_location
, constr
, targs
);
23789 return error_mark_node
;
23793 if (processing_template_decl
)
23794 targs
= add_to_template_args (current_template_args (), targs
);
23795 return tsubst (type
, targs
, complain
, NULL_TREE
);
23798 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
23802 splice_late_return_type (tree type
, tree late_return_type
)
23804 if (is_auto (type
))
23806 if (late_return_type
)
23807 return late_return_type
;
23809 tree idx
= get_template_parm_index (type
);
23810 if (TEMPLATE_PARM_LEVEL (idx
) <= processing_template_decl
)
23811 /* In an abbreviated function template we didn't know we were dealing
23812 with a function template when we saw the auto return type, so update
23813 it to have the correct level. */
23814 return make_auto_1 (TYPE_IDENTIFIER (type
));
23819 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
23820 'decltype(auto)'. */
23823 is_auto (const_tree type
)
23825 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
23826 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
23827 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
23833 /* for_each_template_parm callback for type_uses_auto. */
23836 is_auto_r (tree tp
, void */
*data*/
)
23838 return is_auto_or_concept (tp
);
23841 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
23842 a use of `auto'. Returns NULL_TREE otherwise. */
23845 type_uses_auto (tree type
)
23849 /* The Concepts TS allows multiple autos in one type-specifier; just
23850 return the first one we find, do_auto_deduction will collect all of
23852 if (uses_template_parms (type
))
23853 return for_each_template_parm (type
, is_auto_r
, /*data*/NULL
,
23854 /*visited*/NULL
, /*nondeduced*/true);
23859 return find_type_usage (type
, is_auto
);
23862 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
23863 'decltype(auto)' or a concept. */
23866 is_auto_or_concept (const_tree type
)
23868 return is_auto (type
); // or concept
23871 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
23872 a concept identifier) iff TYPE contains a use of a generic type. Returns
23873 NULL_TREE otherwise. */
23876 type_uses_auto_or_concept (tree type
)
23878 return find_type_usage (type
, is_auto_or_concept
);
23882 /* For a given template T, return the vector of typedefs referenced
23883 in T for which access check is needed at T instantiation time.
23884 T is either a FUNCTION_DECL or a RECORD_TYPE.
23885 Those typedefs were added to T by the function
23886 append_type_to_template_for_access_check. */
23888 vec
<qualified_typedef_usage_t
, va_gc
> *
23889 get_types_needing_access_check (tree t
)
23892 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
23894 if (!t
|| t
== error_mark_node
)
23897 if (!(ti
= get_template_info (t
)))
23900 if (CLASS_TYPE_P (t
)
23901 || TREE_CODE (t
) == FUNCTION_DECL
)
23903 if (!TI_TEMPLATE (ti
))
23906 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
23912 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
23913 tied to T. That list of typedefs will be access checked at
23914 T instantiation time.
23915 T is either a FUNCTION_DECL or a RECORD_TYPE.
23916 TYPE_DECL is a TYPE_DECL node representing a typedef.
23917 SCOPE is the scope through which TYPE_DECL is accessed.
23918 LOCATION is the location of the usage point of TYPE_DECL.
23920 This function is a subroutine of
23921 append_type_to_template_for_access_check. */
23924 append_type_to_template_for_access_check_1 (tree t
,
23927 location_t location
)
23929 qualified_typedef_usage_t typedef_usage
;
23932 if (!t
|| t
== error_mark_node
)
23935 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
23936 || CLASS_TYPE_P (t
))
23938 && TREE_CODE (type_decl
) == TYPE_DECL
23941 if (!(ti
= get_template_info (t
)))
23944 gcc_assert (TI_TEMPLATE (ti
));
23946 typedef_usage
.typedef_decl
= type_decl
;
23947 typedef_usage
.context
= scope
;
23948 typedef_usage
.locus
= location
;
23950 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
23953 /* Append TYPE_DECL to the template TEMPL.
23954 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
23955 At TEMPL instanciation time, TYPE_DECL will be checked to see
23956 if it can be accessed through SCOPE.
23957 LOCATION is the location of the usage point of TYPE_DECL.
23959 e.g. consider the following code snippet:
23966 template<class U> struct S
23968 C::myint mi; // <-- usage point of the typedef C::myint
23973 At S<char> instantiation time, we need to check the access of C::myint
23974 In other words, we need to check the access of the myint typedef through
23975 the C scope. For that purpose, this function will add the myint typedef
23976 and the scope C through which its being accessed to a list of typedefs
23977 tied to the template S. That list will be walked at template instantiation
23978 time and access check performed on each typedefs it contains.
23979 Note that this particular code snippet should yield an error because
23980 myint is private to C. */
23983 append_type_to_template_for_access_check (tree templ
,
23986 location_t location
)
23988 qualified_typedef_usage_t
*iter
;
23991 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
23993 /* Make sure we don't append the type to the template twice. */
23994 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
23995 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
23998 append_type_to_template_for_access_check_1 (templ
, type_decl
,
24002 /* Convert the generic type parameters in PARM that match the types given in the
24003 range [START_IDX, END_IDX) from the current_template_parms into generic type
24007 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
24009 tree current
= current_template_parms
;
24010 int depth
= TMPL_PARMS_DEPTH (current
);
24011 current
= INNERMOST_TEMPLATE_PARMS (current
);
24012 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
24014 for (int i
= 0; i
< start_idx
; ++i
)
24015 TREE_VEC_ELT (replacement
, i
)
24016 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
24018 for (int i
= start_idx
; i
< end_idx
; ++i
)
24020 /* Create a distinct parameter pack type from the current parm and add it
24021 to the replacement args to tsubst below into the generic function
24024 tree o
= TREE_TYPE (TREE_VALUE
24025 (TREE_VEC_ELT (current
, i
)));
24026 tree t
= copy_type (o
);
24027 TEMPLATE_TYPE_PARM_INDEX (t
)
24028 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
24030 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
24031 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
24032 TYPE_MAIN_VARIANT (t
) = t
;
24033 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
24034 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
24035 TREE_VEC_ELT (replacement
, i
) = t
;
24036 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
24039 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
24040 TREE_VEC_ELT (replacement
, i
)
24041 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
24043 /* If there are more levels then build up the replacement with the outer
24046 replacement
= add_to_template_args (template_parms_to_args
24047 (TREE_CHAIN (current_template_parms
)),
24050 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
24053 /* Entries in the decl_constraint hash table. */
24054 struct GTY((for_user
)) constr_entry
24060 /* Hashing function and equality for constraint entries. */
24061 struct constr_hasher
: ggc_ptr_hash
<constr_entry
>
24063 static hashval_t
hash (constr_entry
*e
)
24065 return (hashval_t
)DECL_UID (e
->decl
);
24068 static bool equal (constr_entry
*e1
, constr_entry
*e2
)
24070 return e1
->decl
== e2
->decl
;
24074 /* A mapping from declarations to constraint information. Note that
24075 both templates and their underlying declarations are mapped to the
24076 same constraint information.
24078 FIXME: This is defined in pt.c because garbage collection
24079 code is not being generated for constraint.cc. */
24081 static GTY (()) hash_table
<constr_hasher
> *decl_constraints
;
24083 /* Returns true iff cinfo contains a valid set of constraints.
24084 This is the case when the associated requirements have been
24085 successfully decomposed into lists of atomic constraints.
24086 That is, when the saved assumptions are not error_mark_node. */
24089 valid_constraints_p (tree cinfo
)
24091 gcc_assert (cinfo
);
24092 return CI_ASSUMPTIONS (cinfo
) != error_mark_node
;
24095 /* Returns the template constraints of declaration T. If T is not
24096 constrained, return NULL_TREE. Note that T must be non-null. */
24099 get_constraints (tree t
)
24101 gcc_assert (DECL_P (t
));
24102 if (TREE_CODE (t
) == TEMPLATE_DECL
)
24103 t
= DECL_TEMPLATE_RESULT (t
);
24104 constr_entry elt
= { t
, NULL_TREE
};
24105 constr_entry
* found
= decl_constraints
->find (&elt
);
24112 /* Associate the given constraint information CI with the declaration
24113 T. If T is a template, then the constraints are associated with
24114 its underlying declaration. Don't build associations if CI is
24118 set_constraints (tree t
, tree ci
)
24123 if (TREE_CODE (t
) == TEMPLATE_DECL
)
24124 t
= DECL_TEMPLATE_RESULT (t
);
24125 gcc_assert (!get_constraints (t
));
24126 constr_entry elt
= {t
, ci
};
24127 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, INSERT
);
24128 constr_entry
* entry
= ggc_alloc
<constr_entry
> ();
24133 /* Remove the associated constraints of the declaration T. */
24136 remove_constraints (tree t
)
24138 gcc_assert (DECL_P (t
));
24139 if (TREE_CODE (t
) == TEMPLATE_DECL
)
24140 t
= DECL_TEMPLATE_RESULT (t
);
24142 constr_entry elt
= {t
, NULL_TREE
};
24143 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, NO_INSERT
);
24145 decl_constraints
->clear_slot (slot
);
24148 /* Set up the hash table for constraint association. */
24151 init_constraint_processing (void)
24153 decl_constraints
= hash_table
<constr_hasher
>::create_ggc(37);
24156 /* Set up the hash tables for template instantiations. */
24159 init_template_processing (void)
24161 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
24162 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
24165 /* Print stats about the template hash tables for -fstats. */
24168 print_template_statistics (void)
24170 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
24171 "%f collisions\n", (long) decl_specializations
->size (),
24172 (long) decl_specializations
->elements (),
24173 decl_specializations
->collisions ());
24174 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
24175 "%f collisions\n", (long) type_specializations
->size (),
24176 (long) type_specializations
->elements (),
24177 type_specializations
->collisions ());
24180 #include "gt-cp-pt.h"