1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2014 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 "pointer-set.h"
40 #include "c-family/c-common.h"
41 #include "c-family/c-objc.h"
42 #include "cp-objcp-common.h"
43 #include "tree-inline.h"
47 #include "tree-iterator.h"
48 #include "type-utils.h"
51 /* The type of functions taking a tree, and some additional data, and
53 typedef int (*tree_fn_t
) (tree
, void*);
55 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
56 instantiations have been deferred, either because their definitions
57 were not yet available, or because we were putting off doing the work. */
58 struct GTY ((chain_next ("%h.next"))) pending_template
{
59 struct pending_template
*next
;
60 struct tinst_level
*tinst
;
63 static GTY(()) struct pending_template
*pending_templates
;
64 static GTY(()) struct pending_template
*last_pending_template
;
66 int processing_template_parmlist
;
67 static int template_header_count
;
69 static GTY(()) tree saved_trees
;
70 static vec
<int> inline_parm_levels
;
72 static GTY(()) struct tinst_level
*current_tinst_level
;
74 static GTY(()) tree saved_access_scope
;
76 /* Live only within one (recursive) call to tsubst_expr. We use
77 this to pass the statement expression node from the STMT_EXPR
78 to the EXPR_STMT that is its result. */
79 static tree cur_stmt_expr
;
81 /* True if we've recursed into fn_type_unification too many times. */
82 static bool excessive_deduction_depth
;
84 typedef struct GTY(()) spec_entry
91 static GTY ((param_is (spec_entry
)))
92 htab_t decl_specializations
;
94 static GTY ((param_is (spec_entry
)))
95 htab_t type_specializations
;
97 /* Contains canonical template parameter types. The vector is indexed by
98 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
99 TREE_LIST, whose TREE_VALUEs contain the canonical template
100 parameters of various types and levels. */
101 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
103 #define UNIFY_ALLOW_NONE 0
104 #define UNIFY_ALLOW_MORE_CV_QUAL 1
105 #define UNIFY_ALLOW_LESS_CV_QUAL 2
106 #define UNIFY_ALLOW_DERIVED 4
107 #define UNIFY_ALLOW_INTEGER 8
108 #define UNIFY_ALLOW_OUTER_LEVEL 16
109 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
110 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
112 enum template_base_result
{
114 tbr_ambiguous_baseclass
,
118 static void push_access_scope (tree
);
119 static void pop_access_scope (tree
);
120 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
121 unification_kind_t
, int,
123 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
124 unification_kind_t
, int, bool, bool);
125 static int unify (tree
, tree
, tree
, tree
, int, bool);
126 static void add_pending_template (tree
);
127 static tree
reopen_tinst_level (struct tinst_level
*);
128 static tree
tsubst_initializer_list (tree
, tree
);
129 static tree
get_class_bindings (tree
, tree
, tree
, tree
);
130 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
132 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
134 static void tsubst_enum (tree
, tree
, tree
);
135 static tree
add_to_template_args (tree
, tree
);
136 static tree
add_outermost_template_args (tree
, tree
);
137 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
138 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
140 static int type_unification_real (tree
, tree
, tree
, const tree
*,
141 unsigned int, int, unification_kind_t
, int,
142 vec
<deferred_access_check
, va_gc
> **,
144 static void note_template_header (int);
145 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
146 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
147 static tree
convert_template_argument (tree
, tree
, tree
,
148 tsubst_flags_t
, int, tree
);
149 static int for_each_template_parm (tree
, tree_fn_t
, void*,
150 hash_set
<tree
> *, bool);
151 static tree
expand_template_argument_pack (tree
);
152 static tree
build_template_parm_index (int, int, int, tree
, tree
);
153 static bool inline_needs_template_parms (tree
, bool);
154 static void push_inline_template_parms_recursive (tree
, int);
155 static tree
retrieve_local_specialization (tree
);
156 static void register_local_specialization (tree
, tree
);
157 static hashval_t
hash_specialization (const void *p
);
158 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
159 static int mark_template_parm (tree
, void *);
160 static int template_parm_this_level_p (tree
, void *);
161 static tree
tsubst_friend_function (tree
, tree
);
162 static tree
tsubst_friend_class (tree
, tree
);
163 static int can_complete_type_without_circularity (tree
);
164 static tree
get_bindings (tree
, tree
, tree
, bool);
165 static int template_decl_level (tree
);
166 static int check_cv_quals_for_unify (int, tree
, tree
);
167 static void template_parm_level_and_index (tree
, int*, int*);
168 static int unify_pack_expansion (tree
, tree
, tree
,
169 tree
, unification_kind_t
, bool, bool);
170 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
171 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
172 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
173 static void regenerate_decl_from_template (tree
, tree
);
174 static tree
most_specialized_class (tree
, tsubst_flags_t
);
175 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
176 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
177 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
178 static bool check_specialization_scope (void);
179 static tree
process_partial_specialization (tree
);
180 static void set_current_access_from_decl (tree
);
181 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
183 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
184 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
186 static bool template_template_parm_bindings_ok_p (tree
, tree
);
187 static int template_args_equal (tree
, tree
);
188 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
189 static tree
for_each_template_parm_r (tree
*, int *, void *);
190 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
191 static void copy_default_args_to_explicit_spec (tree
);
192 static int invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
193 static bool dependent_template_arg_p (tree
);
194 static bool any_template_arguments_need_structural_equality_p (tree
);
195 static bool dependent_type_p_r (tree
);
196 static tree
tsubst_expr (tree
, tree
, tsubst_flags_t
, tree
, bool);
197 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
198 static tree
tsubst_pack_expansion (tree
, tree
, tsubst_flags_t
, tree
);
199 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
200 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
201 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
203 static tree
listify (tree
);
204 static tree
listify_autos (tree
, tree
);
205 static tree
template_parm_to_arg (tree t
);
206 static tree
current_template_args (void);
207 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
208 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
210 /* Make the current scope suitable for access checking when we are
211 processing T. T can be FUNCTION_DECL for instantiated function
212 template, VAR_DECL for static member variable, or TYPE_DECL for
213 alias template (needed by instantiate_decl). */
216 push_access_scope (tree t
)
218 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
219 || TREE_CODE (t
) == TYPE_DECL
);
221 if (DECL_FRIEND_CONTEXT (t
))
222 push_nested_class (DECL_FRIEND_CONTEXT (t
));
223 else if (DECL_CLASS_SCOPE_P (t
))
224 push_nested_class (DECL_CONTEXT (t
));
226 push_to_top_level ();
228 if (TREE_CODE (t
) == FUNCTION_DECL
)
230 saved_access_scope
= tree_cons
231 (NULL_TREE
, current_function_decl
, saved_access_scope
);
232 current_function_decl
= t
;
236 /* Restore the scope set up by push_access_scope. T is the node we
240 pop_access_scope (tree t
)
242 if (TREE_CODE (t
) == FUNCTION_DECL
)
244 current_function_decl
= TREE_VALUE (saved_access_scope
);
245 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
248 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
251 pop_from_top_level ();
254 /* Do any processing required when DECL (a member template
255 declaration) is finished. Returns the TEMPLATE_DECL corresponding
256 to DECL, unless it is a specialization, in which case the DECL
257 itself is returned. */
260 finish_member_template_decl (tree decl
)
262 if (decl
== error_mark_node
)
263 return error_mark_node
;
265 gcc_assert (DECL_P (decl
));
267 if (TREE_CODE (decl
) == TYPE_DECL
)
271 type
= TREE_TYPE (decl
);
272 if (type
== error_mark_node
)
273 return error_mark_node
;
274 if (MAYBE_CLASS_TYPE_P (type
)
275 && CLASSTYPE_TEMPLATE_INFO (type
)
276 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
278 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
279 check_member_template (tmpl
);
284 else if (TREE_CODE (decl
) == FIELD_DECL
)
285 error ("data member %qD cannot be a member template", decl
);
286 else if (DECL_TEMPLATE_INFO (decl
))
288 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
290 check_member_template (DECL_TI_TEMPLATE (decl
));
291 return DECL_TI_TEMPLATE (decl
);
297 error ("invalid member template declaration %qD", decl
);
299 return error_mark_node
;
302 /* Create a template info node. */
305 build_template_info (tree template_decl
, tree template_args
)
307 tree result
= make_node (TEMPLATE_INFO
);
308 TI_TEMPLATE (result
) = template_decl
;
309 TI_ARGS (result
) = template_args
;
313 /* Return the template info node corresponding to T, whatever T is. */
316 get_template_info (const_tree t
)
318 tree tinfo
= NULL_TREE
;
320 if (!t
|| t
== error_mark_node
)
323 if (TREE_CODE (t
) == NAMESPACE_DECL
)
326 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
327 tinfo
= DECL_TEMPLATE_INFO (t
);
329 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
332 if (OVERLOAD_TYPE_P (t
))
333 tinfo
= TYPE_TEMPLATE_INFO (t
);
334 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
335 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
340 /* Returns the template nesting level of the indicated class TYPE.
350 A<T>::B<U> has depth two, while A<T> has depth one.
351 Both A<T>::B<int> and A<int>::B<U> have depth one, if
352 they are instantiations, not specializations.
354 This function is guaranteed to return 0 if passed NULL_TREE so
355 that, for example, `template_class_depth (current_class_type)' is
359 template_class_depth (tree type
)
364 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
365 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
366 ? CP_DECL_CONTEXT (type
) : CP_TYPE_CONTEXT (type
))
368 tree tinfo
= get_template_info (type
);
370 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
371 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
378 /* Subroutine of maybe_begin_member_template_processing.
379 Returns true if processing DECL needs us to push template parms. */
382 inline_needs_template_parms (tree decl
, bool nsdmi
)
384 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
387 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
388 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
391 /* Subroutine of maybe_begin_member_template_processing.
392 Push the template parms in PARMS, starting from LEVELS steps into the
393 chain, and ending at the beginning, since template parms are listed
397 push_inline_template_parms_recursive (tree parmlist
, int levels
)
399 tree parms
= TREE_VALUE (parmlist
);
403 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
405 ++processing_template_decl
;
406 current_template_parms
407 = tree_cons (size_int (processing_template_decl
),
408 parms
, current_template_parms
);
409 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
411 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
413 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
415 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
417 if (error_operand_p (parm
))
420 gcc_assert (DECL_P (parm
));
422 switch (TREE_CODE (parm
))
431 /* Make a CONST_DECL as is done in process_template_parm.
432 It is ugly that we recreate this here; the original
433 version built in process_template_parm is no longer
435 tree decl
= build_decl (DECL_SOURCE_LOCATION (parm
),
436 CONST_DECL
, DECL_NAME (parm
),
438 DECL_ARTIFICIAL (decl
) = 1;
439 TREE_CONSTANT (decl
) = 1;
440 TREE_READONLY (decl
) = 1;
441 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
442 SET_DECL_TEMPLATE_PARM_P (decl
);
453 /* Restore the template parameter context for a member template, a
454 friend template defined in a class definition, or a non-template
455 member of template class. */
458 maybe_begin_member_template_processing (tree decl
)
462 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
466 tree ctx
= DECL_CONTEXT (decl
);
467 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
468 /* Disregard full specializations (c++/60999). */
469 && uses_template_parms (ctx
)
470 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
473 if (inline_needs_template_parms (decl
, nsdmi
))
475 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
476 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
478 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
481 parms
= TREE_CHAIN (parms
);
484 push_inline_template_parms_recursive (parms
, levels
);
487 /* Remember how many levels of template parameters we pushed so that
488 we can pop them later. */
489 inline_parm_levels
.safe_push (levels
);
492 /* Undo the effects of maybe_begin_member_template_processing. */
495 maybe_end_member_template_processing (void)
500 if (inline_parm_levels
.length () == 0)
503 last
= inline_parm_levels
.pop ();
504 for (i
= 0; i
< last
; ++i
)
506 --processing_template_decl
;
507 current_template_parms
= TREE_CHAIN (current_template_parms
);
512 /* Return a new template argument vector which contains all of ARGS,
513 but has as its innermost set of arguments the EXTRA_ARGS. */
516 add_to_template_args (tree args
, tree extra_args
)
523 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
526 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
527 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
529 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
530 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
532 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
533 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
538 /* Like add_to_template_args, but only the outermost ARGS are added to
539 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
540 (EXTRA_ARGS) levels are added. This function is used to combine
541 the template arguments from a partial instantiation with the
542 template arguments used to attain the full instantiation from the
543 partial instantiation. */
546 add_outermost_template_args (tree args
, tree extra_args
)
550 /* If there are more levels of EXTRA_ARGS than there are ARGS,
551 something very fishy is going on. */
552 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
554 /* If *all* the new arguments will be the EXTRA_ARGS, just return
556 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
559 /* For the moment, we make ARGS look like it contains fewer levels. */
560 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
562 new_args
= add_to_template_args (args
, extra_args
);
564 /* Now, we restore ARGS to its full dimensions. */
565 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
570 /* Return the N levels of innermost template arguments from the ARGS. */
573 get_innermost_template_args (tree args
, int n
)
581 /* If N is 1, just return the innermost set of template arguments. */
583 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
585 /* If we're not removing anything, just return the arguments we were
587 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
588 gcc_assert (extra_levels
>= 0);
589 if (extra_levels
== 0)
592 /* Make a new set of arguments, not containing the outer arguments. */
593 new_args
= make_tree_vec (n
);
594 for (i
= 1; i
<= n
; ++i
)
595 SET_TMPL_ARGS_LEVEL (new_args
, i
,
596 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
601 /* The inverse of get_innermost_template_args: Return all but the innermost
602 EXTRA_LEVELS levels of template arguments from the ARGS. */
605 strip_innermost_template_args (tree args
, int extra_levels
)
608 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
613 /* If N is 1, just return the outermost set of template arguments. */
615 return TMPL_ARGS_LEVEL (args
, 1);
617 /* If we're not removing anything, just return the arguments we were
619 gcc_assert (extra_levels
>= 0);
620 if (extra_levels
== 0)
623 /* Make a new set of arguments, not containing the inner arguments. */
624 new_args
= make_tree_vec (n
);
625 for (i
= 1; i
<= n
; ++i
)
626 SET_TMPL_ARGS_LEVEL (new_args
, i
,
627 TMPL_ARGS_LEVEL (args
, i
));
632 /* We've got a template header coming up; push to a new level for storing
636 begin_template_parm_list (void)
638 /* We use a non-tag-transparent scope here, which causes pushtag to
639 put tags in this scope, rather than in the enclosing class or
640 namespace scope. This is the right thing, since we want
641 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
642 global template class, push_template_decl handles putting the
643 TEMPLATE_DECL into top-level scope. For a nested template class,
646 template <class T> struct S1 {
647 template <class T> struct S2 {};
650 pushtag contains special code to call pushdecl_with_scope on the
651 TEMPLATE_DECL for S2. */
652 begin_scope (sk_template_parms
, NULL
);
653 ++processing_template_decl
;
654 ++processing_template_parmlist
;
655 note_template_header (0);
658 /* This routine is called when a specialization is declared. If it is
659 invalid to declare a specialization here, an error is reported and
660 false is returned, otherwise this routine will return true. */
663 check_specialization_scope (void)
665 tree scope
= current_scope ();
669 An explicit specialization shall be declared in the namespace of
670 which the template is a member, or, for member templates, in the
671 namespace of which the enclosing class or enclosing class
672 template is a member. An explicit specialization of a member
673 function, member class or static data member of a class template
674 shall be declared in the namespace of which the class template
676 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
678 error ("explicit specialization in non-namespace scope %qD", scope
);
684 In an explicit specialization declaration for a member of a class
685 template or a member template that appears in namespace scope,
686 the member template and some of its enclosing class templates may
687 remain unspecialized, except that the declaration shall not
688 explicitly specialize a class member template if its enclosing
689 class templates are not explicitly specialized as well. */
690 if (current_template_parms
)
692 error ("enclosing class templates are not explicitly specialized");
699 /* We've just seen template <>. */
702 begin_specialization (void)
704 begin_scope (sk_template_spec
, NULL
);
705 note_template_header (1);
706 return check_specialization_scope ();
709 /* Called at then end of processing a declaration preceded by
713 end_specialization (void)
716 reset_specialization ();
719 /* Any template <>'s that we have seen thus far are not referring to a
720 function specialization. */
723 reset_specialization (void)
725 processing_specialization
= 0;
726 template_header_count
= 0;
729 /* We've just seen a template header. If SPECIALIZATION is nonzero,
730 it was of the form template <>. */
733 note_template_header (int specialization
)
735 processing_specialization
= specialization
;
736 template_header_count
++;
739 /* We're beginning an explicit instantiation. */
742 begin_explicit_instantiation (void)
744 gcc_assert (!processing_explicit_instantiation
);
745 processing_explicit_instantiation
= true;
750 end_explicit_instantiation (void)
752 gcc_assert (processing_explicit_instantiation
);
753 processing_explicit_instantiation
= false;
756 /* An explicit specialization or partial specialization of TMPL is being
757 declared. Check that the namespace in which the specialization is
758 occurring is permissible. Returns false iff it is invalid to
759 specialize TMPL in the current namespace. */
762 check_specialization_namespace (tree tmpl
)
764 tree tpl_ns
= decl_namespace_context (tmpl
);
768 An explicit specialization shall be declared in the namespace of
769 which the template is a member, or, for member templates, in the
770 namespace of which the enclosing class or enclosing class
771 template is a member. An explicit specialization of a member
772 function, member class or static data member of a class template
773 shall be declared in the namespace of which the class template is
775 if (current_scope() != DECL_CONTEXT (tmpl
)
776 && !at_namespace_scope_p ())
778 error ("specialization of %qD must appear at namespace scope", tmpl
);
781 if (is_associated_namespace (current_namespace
, tpl_ns
))
782 /* Same or super-using namespace. */
786 permerror (input_location
, "specialization of %qD in different namespace", tmpl
);
787 permerror (input_location
, " from definition of %q+#D", tmpl
);
792 /* SPEC is an explicit instantiation. Check that it is valid to
793 perform this explicit instantiation in the current namespace. */
796 check_explicit_instantiation_namespace (tree spec
)
800 /* DR 275: An explicit instantiation shall appear in an enclosing
801 namespace of its template. */
802 ns
= decl_namespace_context (spec
);
803 if (!is_ancestor (current_namespace
, ns
))
804 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
805 "(which does not enclose namespace %qD)",
806 spec
, current_namespace
, ns
);
809 /* The TYPE is being declared. If it is a template type, that means it
810 is a partial specialization. Do appropriate error-checking. */
813 maybe_process_partial_specialization (tree type
)
817 if (type
== error_mark_node
)
818 return error_mark_node
;
820 /* A lambda that appears in specialization context is not itself a
822 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
825 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
827 error ("name of class shadows template template parameter %qD",
829 return error_mark_node
;
832 context
= TYPE_CONTEXT (type
);
834 if (TYPE_ALIAS_P (type
))
836 if (TYPE_TEMPLATE_INFO (type
)
837 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type
)))
838 error ("specialization of alias template %qD",
839 TYPE_TI_TEMPLATE (type
));
841 error ("explicit specialization of non-template %qT", type
);
842 return error_mark_node
;
844 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
846 /* This is for ordinary explicit specialization and partial
847 specialization of a template class such as:
849 template <> class C<int>;
853 template <class T> class C<T*>;
855 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
857 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
858 && !COMPLETE_TYPE_P (type
))
860 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type
))
861 && !at_namespace_scope_p ())
862 return error_mark_node
;
863 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
864 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
865 if (processing_template_decl
)
867 if (push_template_decl (TYPE_MAIN_DECL (type
))
869 return error_mark_node
;
872 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
873 error ("specialization of %qT after instantiation", type
);
874 else if (errorcount
&& !processing_specialization
875 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
876 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
877 /* Trying to define a specialization either without a template<> header
878 or in an inappropriate place. We've already given an error, so just
879 bail now so we don't actually define the specialization. */
880 return error_mark_node
;
882 else if (CLASS_TYPE_P (type
)
883 && !CLASSTYPE_USE_TEMPLATE (type
)
884 && CLASSTYPE_TEMPLATE_INFO (type
)
885 && context
&& CLASS_TYPE_P (context
)
886 && CLASSTYPE_TEMPLATE_INFO (context
))
888 /* This is for an explicit specialization of member class
889 template according to [temp.expl.spec/18]:
891 template <> template <class U> class C<int>::D;
893 The context `C<int>' must be an implicit instantiation.
894 Otherwise this is just a member class template declared
897 template <> class C<int> { template <class U> class D; };
898 template <> template <class U> class C<int>::D;
900 In the first case, `C<int>::D' is a specialization of `C<T>::D'
901 while in the second case, `C<int>::D' is a primary template
902 and `C<T>::D' may not exist. */
904 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
905 && !COMPLETE_TYPE_P (type
))
908 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
910 if (current_namespace
911 != decl_namespace_context (tmpl
))
913 permerror (input_location
, "specializing %q#T in different namespace", type
);
914 permerror (input_location
, " from definition of %q+#D", tmpl
);
917 /* Check for invalid specialization after instantiation:
919 template <> template <> class C<int>::D<int>;
920 template <> template <class U> class C<int>::D; */
922 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
923 t
; t
= TREE_CHAIN (t
))
925 tree inst
= TREE_VALUE (t
);
926 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
927 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
929 /* We already have a full specialization of this partial
930 instantiation, or a full specialization has been
931 looked up but not instantiated. Reassign it to the
932 new member specialization template. */
937 elt
.tmpl
= most_general_template (tmpl
);
938 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
941 htab_remove_elt (type_specializations
, &elt
);
944 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
946 slot
= htab_find_slot (type_specializations
, &elt
, INSERT
);
947 entry
= ggc_alloc
<spec_entry
> ();
952 /* But if we've had an implicit instantiation, that's a
953 problem ([temp.expl.spec]/6). */
954 error ("specialization %qT after instantiation %qT",
958 /* Mark TYPE as a specialization. And as a result, we only
959 have one level of template argument for the innermost
961 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
962 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
963 CLASSTYPE_TI_ARGS (type
)
964 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
967 else if (processing_specialization
)
969 /* Someday C++0x may allow for enum template specialization. */
970 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
971 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
972 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
973 "of %qD not allowed by ISO C++", type
);
976 error ("explicit specialization of non-template %qT", type
);
977 return error_mark_node
;
984 /* Returns nonzero if we can optimize the retrieval of specializations
985 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
986 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
989 optimize_specialization_lookup_p (tree tmpl
)
991 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
992 && DECL_CLASS_SCOPE_P (tmpl
)
993 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
995 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
996 /* The optimized lookup depends on the fact that the
997 template arguments for the member function template apply
998 purely to the containing class, which is not true if the
999 containing class is an explicit or partial
1001 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1002 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1003 && !DECL_CONV_FN_P (tmpl
)
1004 /* It is possible to have a template that is not a member
1005 template and is not a member of a template class:
1007 template <typename T>
1008 struct S { friend A::f(); };
1010 Here, the friend function is a template, but the context does
1011 not have template information. The optimized lookup relies
1012 on having ARGS be the template arguments for both the class
1013 and the function template. */
1014 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1017 /* Retrieve the specialization (in the sense of [temp.spec] - a
1018 specialization is either an instantiation or an explicit
1019 specialization) of TMPL for the given template ARGS. If there is
1020 no such specialization, return NULL_TREE. The ARGS are a vector of
1021 arguments, or a vector of vectors of arguments, in the case of
1022 templates with more than one level of parameters.
1024 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1025 then we search for a partial specialization matching ARGS. This
1026 parameter is ignored if TMPL is not a class template.
1028 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1029 result is a NONTYPE_ARGUMENT_PACK. */
1032 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1034 if (tmpl
== NULL_TREE
)
1037 if (args
== error_mark_node
)
1040 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1041 || TREE_CODE (tmpl
) == FIELD_DECL
);
1043 /* There should be as many levels of arguments as there are
1044 levels of parameters. */
1045 gcc_assert (TMPL_ARGS_DEPTH (args
)
1046 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1047 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1048 : template_class_depth (DECL_CONTEXT (tmpl
))));
1050 if (optimize_specialization_lookup_p (tmpl
))
1052 tree class_template
;
1053 tree class_specialization
;
1054 vec
<tree
, va_gc
> *methods
;
1058 /* The template arguments actually apply to the containing
1059 class. Find the class specialization with those
1061 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1062 class_specialization
1063 = retrieve_specialization (class_template
, args
, 0);
1064 if (!class_specialization
)
1066 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1067 for the specialization. */
1068 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
1071 /* Iterate through the methods with the indicated name, looking
1072 for the one that has an instance of TMPL. */
1073 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
1074 for (fns
= (*methods
)[idx
]; fns
; fns
= OVL_NEXT (fns
))
1076 tree fn
= OVL_CURRENT (fns
);
1077 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1078 /* using-declarations can add base methods to the method vec,
1079 and we don't want those here. */
1080 && DECL_CONTEXT (fn
) == class_specialization
)
1089 htab_t specializations
;
1093 elt
.spec
= NULL_TREE
;
1095 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1096 specializations
= type_specializations
;
1098 specializations
= decl_specializations
;
1101 hash
= hash_specialization (&elt
);
1102 found
= (spec_entry
*) htab_find_with_hash (specializations
, &elt
, hash
);
1110 /* Like retrieve_specialization, but for local declarations. */
1113 retrieve_local_specialization (tree tmpl
)
1117 if (local_specializations
== NULL
)
1120 slot
= pointer_map_contains (local_specializations
, tmpl
);
1121 return slot
? (tree
) *slot
: NULL_TREE
;
1124 /* Returns nonzero iff DECL is a specialization of TMPL. */
1127 is_specialization_of (tree decl
, tree tmpl
)
1131 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1135 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1141 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1143 for (t
= TREE_TYPE (decl
);
1145 t
= CLASSTYPE_USE_TEMPLATE (t
)
1146 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1147 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1154 /* Returns nonzero iff DECL is a specialization of friend declaration
1155 FRIEND_DECL according to [temp.friend]. */
1158 is_specialization_of_friend (tree decl
, tree friend_decl
)
1160 bool need_template
= true;
1163 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1164 || TREE_CODE (decl
) == TYPE_DECL
);
1166 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1167 of a template class, we want to check if DECL is a specialization
1169 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1170 && DECL_TEMPLATE_INFO (friend_decl
)
1171 && !DECL_USE_TEMPLATE (friend_decl
))
1173 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1174 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1175 need_template
= false;
1177 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1178 && !PRIMARY_TEMPLATE_P (friend_decl
))
1179 need_template
= false;
1181 /* There is nothing to do if this is not a template friend. */
1182 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1185 if (is_specialization_of (decl
, friend_decl
))
1189 A member of a class template may be declared to be a friend of a
1190 non-template class. In this case, the corresponding member of
1191 every specialization of the class template is a friend of the
1192 class granting friendship.
1194 For example, given a template friend declaration
1196 template <class T> friend void A<T>::f();
1198 the member function below is considered a friend
1200 template <> struct A<int> {
1204 For this type of template friend, TEMPLATE_DEPTH below will be
1205 nonzero. To determine if DECL is a friend of FRIEND, we first
1206 check if the enclosing class is a specialization of another. */
1208 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1210 && DECL_CLASS_SCOPE_P (decl
)
1211 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1212 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1214 /* Next, we check the members themselves. In order to handle
1215 a few tricky cases, such as when FRIEND_DECL's are
1217 template <class T> friend void A<T>::g(T t);
1218 template <class T> template <T t> friend void A<T>::h();
1222 void A<int>::g(int);
1223 template <int> void A<int>::h();
1225 we need to figure out ARGS, the template arguments from
1226 the context of DECL. This is required for template substitution
1227 of `T' in the function parameter of `g' and template parameter
1228 of `h' in the above examples. Here ARGS corresponds to `int'. */
1230 tree context
= DECL_CONTEXT (decl
);
1231 tree args
= NULL_TREE
;
1232 int current_depth
= 0;
1234 while (current_depth
< template_depth
)
1236 if (CLASSTYPE_TEMPLATE_INFO (context
))
1238 if (current_depth
== 0)
1239 args
= TYPE_TI_ARGS (context
);
1241 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1244 context
= TYPE_CONTEXT (context
);
1247 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1252 tree friend_args_type
;
1253 tree decl_args_type
;
1255 /* Make sure that both DECL and FRIEND_DECL are templates or
1257 is_template
= DECL_TEMPLATE_INFO (decl
)
1258 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1259 if (need_template
^ is_template
)
1261 else if (is_template
)
1263 /* If both are templates, check template parameter list. */
1265 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1267 if (!comp_template_parms
1268 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1272 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1275 decl_type
= TREE_TYPE (decl
);
1277 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1278 tf_none
, NULL_TREE
);
1279 if (friend_type
== error_mark_node
)
1282 /* Check if return types match. */
1283 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1286 /* Check if function parameter types match, ignoring the
1287 `this' parameter. */
1288 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1289 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1290 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1291 friend_args_type
= TREE_CHAIN (friend_args_type
);
1292 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1293 decl_args_type
= TREE_CHAIN (decl_args_type
);
1295 return compparms (decl_args_type
, friend_args_type
);
1299 /* DECL is a TYPE_DECL */
1301 tree decl_type
= TREE_TYPE (decl
);
1303 /* Make sure that both DECL and FRIEND_DECL are templates or
1306 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1307 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1309 if (need_template
^ is_template
)
1311 else if (is_template
)
1314 /* If both are templates, check the name of the two
1315 TEMPLATE_DECL's first because is_friend didn't. */
1316 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1317 != DECL_NAME (friend_decl
))
1320 /* Now check template parameter list. */
1322 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1324 return comp_template_parms
1325 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1329 return (DECL_NAME (decl
)
1330 == DECL_NAME (friend_decl
));
1336 /* Register the specialization SPEC as a specialization of TMPL with
1337 the indicated ARGS. IS_FRIEND indicates whether the specialization
1338 is actually just a friend declaration. Returns SPEC, or an
1339 equivalent prior declaration, if available.
1341 We also store instantiations of field packs in the hash table, even
1342 though they are not themselves templates, to make lookup easier. */
1345 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1352 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1353 || (TREE_CODE (tmpl
) == FIELD_DECL
1354 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1356 if (TREE_CODE (spec
) == FUNCTION_DECL
1357 && uses_template_parms (DECL_TI_ARGS (spec
)))
1358 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1359 register it; we want the corresponding TEMPLATE_DECL instead.
1360 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1361 the more obvious `uses_template_parms (spec)' to avoid problems
1362 with default function arguments. In particular, given
1363 something like this:
1365 template <class T> void f(T t1, T t = T())
1367 the default argument expression is not substituted for in an
1368 instantiation unless and until it is actually needed. */
1371 if (optimize_specialization_lookup_p (tmpl
))
1372 /* We don't put these specializations in the hash table, but we might
1373 want to give an error about a mismatch. */
1374 fn
= retrieve_specialization (tmpl
, args
, 0);
1382 hash
= hash_specialization (&elt
);
1385 htab_find_slot_with_hash (decl_specializations
, &elt
, hash
, INSERT
);
1387 fn
= ((spec_entry
*) *slot
)->spec
;
1392 /* We can sometimes try to re-register a specialization that we've
1393 already got. In particular, regenerate_decl_from_template calls
1394 duplicate_decls which will update the specialization list. But,
1395 we'll still get called again here anyhow. It's more convenient
1396 to simply allow this than to try to prevent it. */
1399 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1401 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1403 if (DECL_ODR_USED (fn
)
1404 || DECL_EXPLICIT_INSTANTIATION (fn
))
1406 error ("specialization of %qD after instantiation",
1408 return error_mark_node
;
1413 /* This situation should occur only if the first
1414 specialization is an implicit instantiation, the
1415 second is an explicit specialization, and the
1416 implicit instantiation has not yet been used. That
1417 situation can occur if we have implicitly
1418 instantiated a member function and then specialized
1421 We can also wind up here if a friend declaration that
1422 looked like an instantiation turns out to be a
1425 template <class T> void foo(T);
1426 class S { friend void foo<>(int) };
1427 template <> void foo(int);
1429 We transform the existing DECL in place so that any
1430 pointers to it become pointers to the updated
1433 If there was a definition for the template, but not
1434 for the specialization, we want this to look as if
1435 there were no definition, and vice versa. */
1436 DECL_INITIAL (fn
) = NULL_TREE
;
1437 duplicate_decls (spec
, fn
, is_friend
);
1438 /* The call to duplicate_decls will have applied
1441 An explicit specialization of a function template
1442 is inline only if it is explicitly declared to be,
1443 and independently of whether its function template
1446 to the primary function; now copy the inline bits to
1447 the various clones. */
1448 FOR_EACH_CLONE (clone
, fn
)
1450 DECL_DECLARED_INLINE_P (clone
)
1451 = DECL_DECLARED_INLINE_P (fn
);
1452 DECL_SOURCE_LOCATION (clone
)
1453 = DECL_SOURCE_LOCATION (fn
);
1454 DECL_DELETED_FN (clone
)
1455 = DECL_DELETED_FN (fn
);
1457 check_specialization_namespace (tmpl
);
1462 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1464 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1465 /* Dup decl failed, but this is a new definition. Set the
1466 line number so any errors match this new
1468 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1474 return duplicate_decls (spec
, fn
, is_friend
);
1476 /* A specialization must be declared in the same namespace as the
1477 template it is specializing. */
1478 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1479 && !check_specialization_namespace (tmpl
))
1480 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1482 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1484 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1485 gcc_assert (tmpl
&& args
&& spec
);
1488 if (TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1489 && PRIMARY_TEMPLATE_P (tmpl
)
1490 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1491 /* TMPL is a forward declaration of a template function; keep a list
1492 of all specializations in case we need to reassign them to a friend
1493 template later in tsubst_friend_function. */
1494 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1495 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1501 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1502 TMPL and ARGS members, ignores SPEC. */
1504 int comparing_specializations
;
1507 eq_specializations (const void *p1
, const void *p2
)
1509 const spec_entry
*e1
= (const spec_entry
*)p1
;
1510 const spec_entry
*e2
= (const spec_entry
*)p2
;
1513 ++comparing_specializations
;
1514 equal
= (e1
->tmpl
== e2
->tmpl
1515 && comp_template_args (e1
->args
, e2
->args
));
1516 --comparing_specializations
;
1521 /* Returns a hash for a template TMPL and template arguments ARGS. */
1524 hash_tmpl_and_args (tree tmpl
, tree args
)
1526 hashval_t val
= DECL_UID (tmpl
);
1527 return iterative_hash_template_arg (args
, val
);
1530 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1534 hash_specialization (const void *p
)
1536 const spec_entry
*e
= (const spec_entry
*)p
;
1537 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1540 /* Recursively calculate a hash value for a template argument ARG, for use
1541 in the hash tables of template specializations. */
1544 iterative_hash_template_arg (tree arg
, hashval_t val
)
1546 unsigned HOST_WIDE_INT i
;
1547 enum tree_code code
;
1550 if (arg
== NULL_TREE
)
1551 return iterative_hash_object (arg
, val
);
1556 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1557 /* We can get one of these when re-hashing a previous entry in the middle
1558 of substituting into a pack expansion. Just look through it. */
1559 arg
= ARGUMENT_PACK_SELECT_FROM_PACK (arg
);
1561 code
= TREE_CODE (arg
);
1562 tclass
= TREE_CODE_CLASS (code
);
1564 val
= iterative_hash_object (code
, val
);
1571 case IDENTIFIER_NODE
:
1572 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1576 int i
, len
= TREE_VEC_LENGTH (arg
);
1577 for (i
= 0; i
< len
; ++i
)
1578 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1582 case TYPE_PACK_EXPANSION
:
1583 case EXPR_PACK_EXPANSION
:
1584 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1585 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1587 case TYPE_ARGUMENT_PACK
:
1588 case NONTYPE_ARGUMENT_PACK
:
1589 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1592 for (; arg
; arg
= TREE_CHAIN (arg
))
1593 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1597 for (; arg
; arg
= OVL_NEXT (arg
))
1598 val
= iterative_hash_template_arg (OVL_CURRENT (arg
), val
);
1604 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1606 val
= iterative_hash_template_arg (field
, val
);
1607 val
= iterative_hash_template_arg (value
, val
);
1613 if (!DECL_ARTIFICIAL (arg
))
1615 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1616 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1618 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1621 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1624 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1625 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1627 case TEMPLATE_PARM_INDEX
:
1628 val
= iterative_hash_template_arg
1629 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1630 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1631 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1634 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1635 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1636 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1639 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1641 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1645 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1646 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1647 val
= iterative_hash_object (code
, val
);
1648 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1651 /* A lambda can't appear in a template arg, but don't crash on
1653 gcc_assert (seen_error ());
1657 case IMPLICIT_CONV_EXPR
:
1658 case STATIC_CAST_EXPR
:
1659 case REINTERPRET_CAST_EXPR
:
1660 case CONST_CAST_EXPR
:
1661 case DYNAMIC_CAST_EXPR
:
1663 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1664 /* Now hash operands as usual. */
1674 if (TYPE_CANONICAL (arg
))
1675 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1677 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1678 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1679 /* Otherwise just compare the types during lookup. */
1682 case tcc_declaration
:
1684 return iterative_hash_expr (arg
, val
);
1687 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1689 unsigned n
= cp_tree_operand_length (arg
);
1690 for (i
= 0; i
< n
; ++i
)
1691 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1699 /* Unregister the specialization SPEC as a specialization of TMPL.
1700 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1701 if the SPEC was listed as a specialization of TMPL.
1703 Note that SPEC has been ggc_freed, so we can't look inside it. */
1706 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1711 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1712 elt
.args
= TI_ARGS (tinfo
);
1713 elt
.spec
= NULL_TREE
;
1715 entry
= (spec_entry
*) htab_find (decl_specializations
, &elt
);
1718 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1719 gcc_assert (new_spec
!= NULL_TREE
);
1720 entry
->spec
= new_spec
;
1727 /* Like register_specialization, but for local declarations. We are
1728 registering SPEC, an instantiation of TMPL. */
1731 register_local_specialization (tree spec
, tree tmpl
)
1735 slot
= pointer_map_insert (local_specializations
, tmpl
);
1739 /* TYPE is a class type. Returns true if TYPE is an explicitly
1740 specialized class. */
1743 explicit_class_specialization_p (tree type
)
1745 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1747 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1750 /* Print the list of functions at FNS, going through all the overloads
1751 for each element of the list. Alternatively, FNS can not be a
1752 TREE_LIST, in which case it will be printed together with all the
1755 MORE and *STR should respectively be FALSE and NULL when the function
1756 is called from the outside. They are used internally on recursive
1757 calls. print_candidates manages the two parameters and leaves NULL
1758 in *STR when it ends. */
1761 print_candidates_1 (tree fns
, bool more
, const char **str
)
1764 char *spaces
= NULL
;
1766 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
1767 if (TREE_CODE (fn
) == TREE_LIST
)
1769 for (fn2
= fn
; fn2
!= NULL_TREE
; fn2
= TREE_CHAIN (fn2
))
1770 print_candidates_1 (TREE_VALUE (fn2
),
1771 TREE_CHAIN (fn2
) || more
, str
);
1775 tree cand
= OVL_CURRENT (fn
);
1778 /* Pick the prefix string. */
1779 if (!more
&& !OVL_NEXT (fns
))
1781 inform (DECL_SOURCE_LOCATION (cand
),
1782 "candidate is: %#D", cand
);
1786 *str
= _("candidates are:");
1787 spaces
= get_spaces (*str
);
1789 inform (DECL_SOURCE_LOCATION (cand
), "%s %#D", *str
, cand
);
1790 *str
= spaces
? spaces
: *str
;
1800 /* Print the list of candidate FNS in an error message. FNS can also
1801 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1804 print_candidates (tree fns
)
1806 const char *str
= NULL
;
1807 print_candidates_1 (fns
, false, &str
);
1808 gcc_assert (str
== NULL
);
1811 /* Returns the template (one of the functions given by TEMPLATE_ID)
1812 which can be specialized to match the indicated DECL with the
1813 explicit template args given in TEMPLATE_ID. The DECL may be
1814 NULL_TREE if none is available. In that case, the functions in
1815 TEMPLATE_ID are non-members.
1817 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1818 specialization of a member template.
1820 The TEMPLATE_COUNT is the number of references to qualifying
1821 template classes that appeared in the name of the function. See
1822 check_explicit_specialization for a more accurate description.
1824 TSK indicates what kind of template declaration (if any) is being
1825 declared. TSK_TEMPLATE indicates that the declaration given by
1826 DECL, though a FUNCTION_DECL, has template parameters, and is
1827 therefore a template function.
1829 The template args (those explicitly specified and those deduced)
1830 are output in a newly created vector *TARGS_OUT.
1832 If it is impossible to determine the result, an error message is
1833 issued. The error_mark_node is returned to indicate failure. */
1836 determine_specialization (tree template_id
,
1839 int need_member_template
,
1845 tree explicit_targs
;
1846 tree candidates
= NULL_TREE
;
1847 /* A TREE_LIST of templates of which DECL may be a specialization.
1848 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1849 corresponding TREE_PURPOSE is the set of template arguments that,
1850 when used to instantiate the template, would produce a function
1851 with the signature of DECL. */
1852 tree templates
= NULL_TREE
;
1854 cp_binding_level
*b
;
1856 *targs_out
= NULL_TREE
;
1858 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
1859 return error_mark_node
;
1861 /* We shouldn't be specializing a member template of an
1862 unspecialized class template; we already gave an error in
1863 check_specialization_scope, now avoid crashing. */
1864 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
1865 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
1867 gcc_assert (errorcount
);
1868 return error_mark_node
;
1871 fns
= TREE_OPERAND (template_id
, 0);
1872 explicit_targs
= TREE_OPERAND (template_id
, 1);
1874 if (fns
== error_mark_node
)
1875 return error_mark_node
;
1877 /* Check for baselinks. */
1878 if (BASELINK_P (fns
))
1879 fns
= BASELINK_FUNCTIONS (fns
);
1881 if (!is_overloaded_fn (fns
))
1883 error ("%qD is not a function template", fns
);
1884 return error_mark_node
;
1887 /* Count the number of template headers specified for this
1890 for (b
= current_binding_level
;
1891 b
->kind
== sk_template_parms
;
1895 for (; fns
; fns
= OVL_NEXT (fns
))
1897 tree fn
= OVL_CURRENT (fns
);
1899 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1901 tree decl_arg_types
;
1905 /* In case of explicit specialization, we need to check if
1906 the number of template headers appearing in the specialization
1907 is correct. This is usually done in check_explicit_specialization,
1908 but the check done there cannot be exhaustive when specializing
1909 member functions. Consider the following code:
1911 template <> void A<int>::f(int);
1912 template <> template <> void A<int>::f(int);
1914 Assuming that A<int> is not itself an explicit specialization
1915 already, the first line specializes "f" which is a non-template
1916 member function, whilst the second line specializes "f" which
1917 is a template member function. So both lines are syntactically
1918 correct, and check_explicit_specialization does not reject
1921 Here, we can do better, as we are matching the specialization
1922 against the declarations. We count the number of template
1923 headers, and we check if they match TEMPLATE_COUNT + 1
1924 (TEMPLATE_COUNT is the number of qualifying template classes,
1925 plus there must be another header for the member template
1928 Notice that if header_count is zero, this is not a
1929 specialization but rather a template instantiation, so there
1930 is no check we can perform here. */
1931 if (header_count
&& header_count
!= template_count
+ 1)
1934 /* Check that the number of template arguments at the
1935 innermost level for DECL is the same as for FN. */
1936 if (current_binding_level
->kind
== sk_template_parms
1937 && !current_binding_level
->explicit_spec_p
1938 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
1939 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1940 (current_template_parms
))))
1943 /* DECL might be a specialization of FN. */
1944 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1945 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1947 /* For a non-static member function, we need to make sure
1948 that the const qualification is the same. Since
1949 get_bindings does not try to merge the "this" parameter,
1950 we must do the comparison explicitly. */
1951 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1952 && !same_type_p (TREE_VALUE (fn_arg_types
),
1953 TREE_VALUE (decl_arg_types
)))
1956 /* Skip the "this" parameter and, for constructors of
1957 classes with virtual bases, the VTT parameter. A
1958 full specialization of a constructor will have a VTT
1959 parameter, but a template never will. */
1961 = skip_artificial_parms_for (decl
, decl_arg_types
);
1963 = skip_artificial_parms_for (fn
, fn_arg_types
);
1965 /* Function templates cannot be specializations; there are
1966 no partial specializations of functions. Therefore, if
1967 the type of DECL does not match FN, there is no
1969 if (tsk
== tsk_template
)
1971 if (compparms (fn_arg_types
, decl_arg_types
))
1972 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1976 /* See whether this function might be a specialization of this
1977 template. Suppress access control because we might be trying
1978 to make this specialization a friend, and we have already done
1979 access control for the declaration of the specialization. */
1980 push_deferring_access_checks (dk_no_check
);
1981 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
1982 pop_deferring_access_checks ();
1985 /* We cannot deduce template arguments that when used to
1986 specialize TMPL will produce DECL. */
1989 /* Make sure that the deduced arguments actually work. */
1990 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
);
1991 if (insttype
== error_mark_node
)
1994 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
1995 if (!compparms (fn_arg_types
, decl_arg_types
))
1998 /* Save this template, and the arguments deduced. */
1999 templates
= tree_cons (targs
, fn
, templates
);
2001 else if (need_member_template
)
2002 /* FN is an ordinary member function, and we need a
2003 specialization of a member template. */
2005 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2006 /* We can get IDENTIFIER_NODEs here in certain erroneous
2009 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2010 /* This is just an ordinary non-member function. Nothing can
2011 be a specialization of that. */
2013 else if (DECL_ARTIFICIAL (fn
))
2014 /* Cannot specialize functions that are created implicitly. */
2018 tree decl_arg_types
;
2020 /* This is an ordinary member function. However, since
2021 we're here, we can assume its enclosing class is a
2022 template class. For example,
2024 template <typename T> struct S { void f(); };
2025 template <> void S<int>::f() {}
2027 Here, S<int>::f is a non-template, but S<int> is a
2028 template class. If FN has the same type as DECL, we
2029 might be in business. */
2031 if (!DECL_TEMPLATE_INFO (fn
))
2032 /* Its enclosing class is an explicit specialization
2033 of a template class. This is not a candidate. */
2036 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2037 TREE_TYPE (TREE_TYPE (fn
))))
2038 /* The return types differ. */
2041 /* Adjust the type of DECL in case FN is a static member. */
2042 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2043 if (DECL_STATIC_FUNCTION_P (fn
)
2044 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2045 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2047 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2050 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2054 if (templates
&& TREE_CHAIN (templates
))
2060 It is possible for a specialization with a given function
2061 signature to be instantiated from more than one function
2062 template. In such cases, explicit specification of the
2063 template arguments must be used to uniquely identify the
2064 function template specialization being specialized.
2066 Note that here, there's no suggestion that we're supposed to
2067 determine which of the candidate templates is most
2068 specialized. However, we, also have:
2072 Partial ordering of overloaded function template
2073 declarations is used in the following contexts to select
2074 the function template to which a function template
2075 specialization refers:
2077 -- when an explicit specialization refers to a function
2080 So, we do use the partial ordering rules, at least for now.
2081 This extension can only serve to make invalid programs valid,
2082 so it's safe. And, there is strong anecdotal evidence that
2083 the committee intended the partial ordering rules to apply;
2084 the EDG front end has that behavior, and John Spicer claims
2085 that the committee simply forgot to delete the wording in
2086 [temp.expl.spec]. */
2087 tree tmpl
= most_specialized_instantiation (templates
);
2088 if (tmpl
!= error_mark_node
)
2091 TREE_CHAIN (templates
) = NULL_TREE
;
2095 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2097 error ("template-id %qD for %q+D does not match any template "
2098 "declaration", template_id
, decl
);
2099 if (header_count
&& header_count
!= template_count
+ 1)
2100 inform (input_location
, "saw %d %<template<>%>, need %d for "
2101 "specializing a member function template",
2102 header_count
, template_count
+ 1);
2103 return error_mark_node
;
2105 else if ((templates
&& TREE_CHAIN (templates
))
2106 || (candidates
&& TREE_CHAIN (candidates
))
2107 || (templates
&& candidates
))
2109 error ("ambiguous template specialization %qD for %q+D",
2111 candidates
= chainon (candidates
, templates
);
2112 print_candidates (candidates
);
2113 return error_mark_node
;
2116 /* We have one, and exactly one, match. */
2119 tree fn
= TREE_VALUE (candidates
);
2120 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2121 /* DECL is a re-declaration or partial instantiation of a template
2123 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2125 /* It was a specialization of an ordinary member function in a
2127 return DECL_TI_TEMPLATE (fn
);
2130 /* It was a specialization of a template. */
2131 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2132 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2134 *targs_out
= copy_node (targs
);
2135 SET_TMPL_ARGS_LEVEL (*targs_out
,
2136 TMPL_ARGS_DEPTH (*targs_out
),
2137 TREE_PURPOSE (templates
));
2140 *targs_out
= TREE_PURPOSE (templates
);
2141 return TREE_VALUE (templates
);
2144 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2145 but with the default argument values filled in from those in the
2149 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2152 tree new_spec_types
;
2157 if (spec_types
== void_list_node
)
2158 return void_list_node
;
2160 /* Substitute into the rest of the list. */
2162 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2163 TREE_CHAIN (tmpl_types
));
2165 /* Add the default argument for this parameter. */
2166 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2167 TREE_VALUE (spec_types
),
2171 /* DECL is an explicit specialization. Replicate default arguments
2172 from the template it specializes. (That way, code like:
2174 template <class T> void f(T = 3);
2175 template <> void f(double);
2178 works, as required.) An alternative approach would be to look up
2179 the correct default arguments at the call-site, but this approach
2180 is consistent with how implicit instantiations are handled. */
2183 copy_default_args_to_explicit_spec (tree decl
)
2188 tree new_spec_types
;
2192 tree object_type
= NULL_TREE
;
2193 tree in_charge
= NULL_TREE
;
2194 tree vtt
= NULL_TREE
;
2196 /* See if there's anything we need to do. */
2197 tmpl
= DECL_TI_TEMPLATE (decl
);
2198 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2199 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2200 if (TREE_PURPOSE (t
))
2205 old_type
= TREE_TYPE (decl
);
2206 spec_types
= TYPE_ARG_TYPES (old_type
);
2208 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2210 /* Remove the this pointer, but remember the object's type for
2212 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2213 spec_types
= TREE_CHAIN (spec_types
);
2214 tmpl_types
= TREE_CHAIN (tmpl_types
);
2216 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2218 /* DECL may contain more parameters than TMPL due to the extra
2219 in-charge parameter in constructors and destructors. */
2220 in_charge
= spec_types
;
2221 spec_types
= TREE_CHAIN (spec_types
);
2223 if (DECL_HAS_VTT_PARM_P (decl
))
2226 spec_types
= TREE_CHAIN (spec_types
);
2230 /* Compute the merged default arguments. */
2232 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2234 /* Compute the new FUNCTION_TYPE. */
2238 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2243 /* Put the in-charge parameter back. */
2244 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2245 TREE_VALUE (in_charge
),
2248 new_type
= build_method_type_directly (object_type
,
2249 TREE_TYPE (old_type
),
2253 new_type
= build_function_type (TREE_TYPE (old_type
),
2255 new_type
= cp_build_type_attribute_variant (new_type
,
2256 TYPE_ATTRIBUTES (old_type
));
2257 new_type
= build_exception_variant (new_type
,
2258 TYPE_RAISES_EXCEPTIONS (old_type
));
2260 if (TYPE_HAS_LATE_RETURN_TYPE (old_type
))
2261 TYPE_HAS_LATE_RETURN_TYPE (new_type
) = 1;
2263 TREE_TYPE (decl
) = new_type
;
2266 /* Return the number of template headers we expect to see for a definition
2267 or specialization of CTYPE or one of its non-template members. */
2270 num_template_headers_for_class (tree ctype
)
2272 int num_templates
= 0;
2274 while (ctype
&& CLASS_TYPE_P (ctype
))
2276 /* You're supposed to have one `template <...>' for every
2277 template class, but you don't need one for a full
2278 specialization. For example:
2280 template <class T> struct S{};
2281 template <> struct S<int> { void f(); };
2282 void S<int>::f () {}
2284 is correct; there shouldn't be a `template <>' for the
2285 definition of `S<int>::f'. */
2286 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2287 /* If CTYPE does not have template information of any
2288 kind, then it is not a template, nor is it nested
2289 within a template. */
2291 if (explicit_class_specialization_p (ctype
))
2293 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2296 ctype
= TYPE_CONTEXT (ctype
);
2299 return num_templates
;
2302 /* Do a simple sanity check on the template headers that precede the
2303 variable declaration DECL. */
2306 check_template_variable (tree decl
)
2308 tree ctx
= CP_DECL_CONTEXT (decl
);
2309 int wanted
= num_template_headers_for_class (ctx
);
2310 if (!TYPE_P (ctx
) || !CLASSTYPE_TEMPLATE_INFO (ctx
))
2311 permerror (DECL_SOURCE_LOCATION (decl
),
2312 "%qD is not a static data member of a class template", decl
);
2313 else if (template_header_count
> wanted
)
2315 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2316 "too many template headers for %D (should be %d)",
2318 if (warned
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2319 inform (DECL_SOURCE_LOCATION (decl
),
2320 "members of an explicitly specialized class are defined "
2321 "without a template header");
2325 /* Check to see if the function just declared, as indicated in
2326 DECLARATOR, and in DECL, is a specialization of a function
2327 template. We may also discover that the declaration is an explicit
2328 instantiation at this point.
2330 Returns DECL, or an equivalent declaration that should be used
2331 instead if all goes well. Issues an error message if something is
2332 amiss. Returns error_mark_node if the error is not easily
2335 FLAGS is a bitmask consisting of the following flags:
2337 2: The function has a definition.
2338 4: The function is a friend.
2340 The TEMPLATE_COUNT is the number of references to qualifying
2341 template classes that appeared in the name of the function. For
2344 template <class T> struct S { void f(); };
2347 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2348 classes are not counted in the TEMPLATE_COUNT, so that in
2350 template <class T> struct S {};
2351 template <> struct S<int> { void f(); }
2352 template <> void S<int>::f();
2354 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2355 invalid; there should be no template <>.)
2357 If the function is a specialization, it is marked as such via
2358 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2359 is set up correctly, and it is added to the list of specializations
2360 for that template. */
2363 check_explicit_specialization (tree declarator
,
2368 int have_def
= flags
& 2;
2369 int is_friend
= flags
& 4;
2370 int specialization
= 0;
2371 int explicit_instantiation
= 0;
2372 int member_specialization
= 0;
2373 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2374 tree dname
= DECL_NAME (decl
);
2379 if (!processing_specialization
)
2382 tsk
= tsk_excessive_parms
;
2385 tsk
= current_tmpl_spec_kind (template_count
);
2390 if (processing_specialization
)
2393 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2395 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2398 /* This could be something like:
2400 template <class T> void f(T);
2401 class S { friend void f<>(int); } */
2405 /* This case handles bogus declarations like template <>
2406 template <class T> void f<int>(); */
2408 error ("template-id %qD in declaration of primary template",
2415 case tsk_invalid_member_spec
:
2416 /* The error has already been reported in
2417 check_specialization_scope. */
2418 return error_mark_node
;
2420 case tsk_invalid_expl_inst
:
2421 error ("template parameter list used in explicit instantiation");
2427 error ("definition provided for explicit instantiation");
2429 explicit_instantiation
= 1;
2432 case tsk_excessive_parms
:
2433 case tsk_insufficient_parms
:
2434 if (tsk
== tsk_excessive_parms
)
2435 error ("too many template parameter lists in declaration of %qD",
2437 else if (template_header_count
)
2438 error("too few template parameter lists in declaration of %qD", decl
);
2440 error("explicit specialization of %qD must be introduced by "
2441 "%<template <>%>", decl
);
2445 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2447 member_specialization
= 1;
2453 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2455 /* This case handles bogus declarations like template <>
2456 template <class T> void f<int>(); */
2458 if (uses_template_parms (declarator
))
2459 error ("function template partial specialization %qD "
2460 "is not allowed", declarator
);
2462 error ("template-id %qD in declaration of primary template",
2467 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2468 /* This is a specialization of a member template, without
2469 specialization the containing class. Something like:
2471 template <class T> struct S {
2472 template <class U> void f (U);
2474 template <> template <class U> void S<int>::f(U) {}
2476 That's a specialization -- but of the entire template. */
2484 if (specialization
|| member_specialization
)
2486 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2487 for (; t
; t
= TREE_CHAIN (t
))
2488 if (TREE_PURPOSE (t
))
2490 permerror (input_location
,
2491 "default argument specified in explicit specialization");
2496 if (specialization
|| member_specialization
|| explicit_instantiation
)
2498 tree tmpl
= NULL_TREE
;
2499 tree targs
= NULL_TREE
;
2501 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2502 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2506 gcc_assert (identifier_p (declarator
));
2511 /* If there is no class context, the explicit instantiation
2512 must be at namespace scope. */
2513 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2515 /* Find the namespace binding, using the declaration
2517 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2519 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2521 error ("%qD is not a template function", dname
);
2522 fns
= error_mark_node
;
2526 tree fn
= OVL_CURRENT (fns
);
2527 if (!is_associated_namespace (CP_DECL_CONTEXT (decl
),
2528 CP_DECL_CONTEXT (fn
)))
2529 error ("%qD is not declared in %qD",
2530 decl
, current_namespace
);
2534 declarator
= lookup_template_function (fns
, NULL_TREE
);
2537 if (declarator
== error_mark_node
)
2538 return error_mark_node
;
2540 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2542 if (!explicit_instantiation
)
2543 /* A specialization in class scope. This is invalid,
2544 but the error will already have been flagged by
2545 check_specialization_scope. */
2546 return error_mark_node
;
2549 /* It's not valid to write an explicit instantiation in
2552 class C { template void f(); }
2554 This case is caught by the parser. However, on
2557 template class C { void f(); };
2559 (which is invalid) we can get here. The error will be
2566 else if (ctype
!= NULL_TREE
2567 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2569 /* Find the list of functions in ctype that have the same
2570 name as the declared function. */
2571 tree name
= TREE_OPERAND (declarator
, 0);
2572 tree fns
= NULL_TREE
;
2575 if (constructor_name_p (name
, ctype
))
2577 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2579 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2580 : !CLASSTYPE_DESTRUCTORS (ctype
))
2582 /* From [temp.expl.spec]:
2584 If such an explicit specialization for the member
2585 of a class template names an implicitly-declared
2586 special member function (clause _special_), the
2587 program is ill-formed.
2589 Similar language is found in [temp.explicit]. */
2590 error ("specialization of implicitly-declared special member function");
2591 return error_mark_node
;
2594 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2597 if (!DECL_CONV_FN_P (decl
))
2599 idx
= lookup_fnfields_1 (ctype
, name
);
2601 fns
= (*CLASSTYPE_METHOD_VEC (ctype
))[idx
];
2605 vec
<tree
, va_gc
> *methods
;
2608 /* For a type-conversion operator, we cannot do a
2609 name-based lookup. We might be looking for `operator
2610 int' which will be a specialization of `operator T'.
2611 So, we find *all* the conversion operators, and then
2612 select from them. */
2615 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2617 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2618 methods
->iterate (idx
, &ovl
);
2621 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2622 /* There are no more conversion functions. */
2625 /* Glue all these conversion functions together
2626 with those we already have. */
2627 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2628 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2632 if (fns
== NULL_TREE
)
2634 error ("no member function %qD declared in %qT", name
, ctype
);
2635 return error_mark_node
;
2638 TREE_OPERAND (declarator
, 0) = fns
;
2641 /* Figure out what exactly is being specialized at this point.
2642 Note that for an explicit instantiation, even one for a
2643 member function, we cannot tell apriori whether the
2644 instantiation is for a member template, or just a member
2645 function of a template class. Even if a member template is
2646 being instantiated, the member template arguments may be
2647 elided if they can be deduced from the rest of the
2649 tmpl
= determine_specialization (declarator
, decl
,
2651 member_specialization
,
2655 if (!tmpl
|| tmpl
== error_mark_node
)
2656 /* We couldn't figure out what this declaration was
2658 return error_mark_node
;
2661 tree gen_tmpl
= most_general_template (tmpl
);
2663 if (explicit_instantiation
)
2665 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2666 is done by do_decl_instantiation later. */
2668 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2669 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2671 if (arg_depth
> parm_depth
)
2673 /* If TMPL is not the most general template (for
2674 example, if TMPL is a friend template that is
2675 injected into namespace scope), then there will
2676 be too many levels of TARGS. Remove some of them
2681 new_targs
= make_tree_vec (parm_depth
);
2682 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2683 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2684 = TREE_VEC_ELT (targs
, i
);
2688 return instantiate_template (tmpl
, targs
, tf_error
);
2691 /* If we thought that the DECL was a member function, but it
2692 turns out to be specializing a static member function,
2693 make DECL a static member function as well. */
2694 if (DECL_STATIC_FUNCTION_P (tmpl
)
2695 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2696 revert_static_member_fn (decl
);
2698 /* If this is a specialization of a member template of a
2699 template class, we want to return the TEMPLATE_DECL, not
2700 the specialization of it. */
2701 if (tsk
== tsk_template
)
2703 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
2704 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2705 DECL_INITIAL (result
) = NULL_TREE
;
2709 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2710 DECL_SOURCE_LOCATION (result
)
2711 = DECL_SOURCE_LOCATION (decl
);
2712 /* We want to use the argument list specified in the
2713 definition, not in the original declaration. */
2714 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
2715 for (parm
= DECL_ARGUMENTS (result
); parm
;
2716 parm
= DECL_CHAIN (parm
))
2717 DECL_CONTEXT (parm
) = result
;
2719 return register_specialization (tmpl
, gen_tmpl
, targs
,
2723 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2724 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
2726 /* Inherit default function arguments from the template
2727 DECL is specializing. */
2728 copy_default_args_to_explicit_spec (decl
);
2730 /* This specialization has the same protection as the
2731 template it specializes. */
2732 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
2733 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
2735 /* 7.1.1-1 [dcl.stc]
2737 A storage-class-specifier shall not be specified in an
2738 explicit specialization...
2740 The parser rejects these, so unless action is taken here,
2741 explicit function specializations will always appear with
2744 The action recommended by the C++ CWG in response to C++
2745 defect report 605 is to make the storage class and linkage
2746 of the explicit specialization match the templated function:
2748 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2750 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
2752 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
2753 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
2755 /* This specialization has the same linkage and visibility as
2756 the function template it specializes. */
2757 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
2758 if (! TREE_PUBLIC (decl
))
2760 DECL_INTERFACE_KNOWN (decl
) = 1;
2761 DECL_NOT_REALLY_EXTERN (decl
) = 1;
2763 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
2764 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
2766 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
2767 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
2771 /* If DECL is a friend declaration, declared using an
2772 unqualified name, the namespace associated with DECL may
2773 have been set incorrectly. For example, in:
2775 template <typename T> void f(T);
2777 struct S { friend void f<int>(int); }
2780 we will have set the DECL_CONTEXT for the friend
2781 declaration to N, rather than to the global namespace. */
2782 if (DECL_NAMESPACE_SCOPE_P (decl
))
2783 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
2785 if (is_friend
&& !have_def
)
2786 /* This is not really a declaration of a specialization.
2787 It's just the name of an instantiation. But, it's not
2788 a request for an instantiation, either. */
2789 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
2791 /* A specialization is not necessarily COMDAT. */
2792 DECL_COMDAT (decl
) = DECL_DECLARED_INLINE_P (decl
);
2794 /* Register this specialization so that we can find it
2796 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
, 0);
2798 /* A 'structor should already have clones. */
2799 gcc_assert (decl
== error_mark_node
2800 || !(DECL_CONSTRUCTOR_P (decl
)
2801 || DECL_DESTRUCTOR_P (decl
))
2802 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
2809 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2810 parameters. These are represented in the same format used for
2811 DECL_TEMPLATE_PARMS. */
2814 comp_template_parms (const_tree parms1
, const_tree parms2
)
2819 if (parms1
== parms2
)
2822 for (p1
= parms1
, p2
= parms2
;
2823 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2824 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2826 tree t1
= TREE_VALUE (p1
);
2827 tree t2
= TREE_VALUE (p2
);
2830 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2831 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2833 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2836 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2838 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2839 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2841 /* If either of the template parameters are invalid, assume
2842 they match for the sake of error recovery. */
2843 if (error_operand_p (parm1
) || error_operand_p (parm2
))
2846 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2849 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2850 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2851 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2853 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2858 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2859 /* One set of parameters has more parameters lists than the
2866 /* Determine whether PARM is a parameter pack. */
2869 template_parameter_pack_p (const_tree parm
)
2871 /* Determine if we have a non-type template parameter pack. */
2872 if (TREE_CODE (parm
) == PARM_DECL
)
2873 return (DECL_TEMPLATE_PARM_P (parm
)
2874 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2875 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
2876 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
2878 /* If this is a list of template parameters, we could get a
2879 TYPE_DECL or a TEMPLATE_DECL. */
2880 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2881 parm
= TREE_TYPE (parm
);
2883 /* Otherwise it must be a type template parameter. */
2884 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2885 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2886 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2889 /* Determine if T is a function parameter pack. */
2892 function_parameter_pack_p (const_tree t
)
2894 if (t
&& TREE_CODE (t
) == PARM_DECL
)
2895 return DECL_PACK_P (t
);
2899 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2900 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2903 get_function_template_decl (const_tree primary_func_tmpl_inst
)
2905 if (! primary_func_tmpl_inst
2906 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
2907 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
2910 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
2913 /* Return true iff the function parameter PARAM_DECL was expanded
2914 from the function parameter pack PACK. */
2917 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
2919 if (DECL_ARTIFICIAL (param_decl
)
2920 || !function_parameter_pack_p (pack
))
2923 /* The parameter pack and its pack arguments have the same
2925 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
2928 /* Determine whether ARGS describes a variadic template args list,
2929 i.e., one that is terminated by a template argument pack. */
2932 template_args_variadic_p (tree args
)
2937 if (args
== NULL_TREE
)
2940 args
= INNERMOST_TEMPLATE_ARGS (args
);
2941 nargs
= TREE_VEC_LENGTH (args
);
2946 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
2948 return ARGUMENT_PACK_P (last_parm
);
2951 /* Generate a new name for the parameter pack name NAME (an
2952 IDENTIFIER_NODE) that incorporates its */
2955 make_ith_pack_parameter_name (tree name
, int i
)
2957 /* Munge the name to include the parameter index. */
2958 #define NUMBUF_LEN 128
2959 char numbuf
[NUMBUF_LEN
];
2963 if (name
== NULL_TREE
)
2965 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
2966 newname_len
= IDENTIFIER_LENGTH (name
)
2967 + strlen (numbuf
) + 2;
2968 newname
= (char*)alloca (newname_len
);
2969 snprintf (newname
, newname_len
,
2970 "%s#%i", IDENTIFIER_POINTER (name
), i
);
2971 return get_identifier (newname
);
2974 /* Return true if T is a primary function, class or alias template
2978 primary_template_instantiation_p (const_tree t
)
2983 if (TREE_CODE (t
) == FUNCTION_DECL
)
2984 return DECL_LANG_SPECIFIC (t
)
2985 && DECL_TEMPLATE_INSTANTIATION (t
)
2986 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
2987 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
2988 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
2989 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
2990 else if (alias_template_specialization_p (t
))
2995 /* Return true if PARM is a template template parameter. */
2998 template_template_parameter_p (const_tree parm
)
3000 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3003 /* Return true iff PARM is a DECL representing a type template
3007 template_type_parameter_p (const_tree parm
)
3010 && (TREE_CODE (parm
) == TYPE_DECL
3011 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3012 && DECL_TEMPLATE_PARM_P (parm
));
3015 /* Return the template parameters of T if T is a
3016 primary template instantiation, NULL otherwise. */
3019 get_primary_template_innermost_parameters (const_tree t
)
3021 tree parms
= NULL
, template_info
= NULL
;
3023 if ((template_info
= get_template_info (t
))
3024 && primary_template_instantiation_p (t
))
3025 parms
= INNERMOST_TEMPLATE_PARMS
3026 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3031 /* Return the template parameters of the LEVELth level from the full list
3032 of template parameters PARMS. */
3035 get_template_parms_at_level (tree parms
, int level
)
3039 || TREE_CODE (parms
) != TREE_LIST
3040 || level
> TMPL_PARMS_DEPTH (parms
))
3043 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3044 if (TMPL_PARMS_DEPTH (p
) == level
)
3050 /* Returns the template arguments of T if T is a template instantiation,
3054 get_template_innermost_arguments (const_tree t
)
3056 tree args
= NULL
, template_info
= NULL
;
3058 if ((template_info
= get_template_info (t
))
3059 && TI_ARGS (template_info
))
3060 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3065 /* Return the argument pack elements of T if T is a template argument pack,
3069 get_template_argument_pack_elems (const_tree t
)
3071 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3072 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3075 return ARGUMENT_PACK_ARGS (t
);
3078 /* Structure used to track the progress of find_parameter_packs_r. */
3079 struct find_parameter_pack_data
3081 /* TREE_LIST that will contain all of the parameter packs found by
3083 tree
* parameter_packs
;
3085 /* Set of AST nodes that have been visited by the traversal. */
3086 hash_set
<tree
> *visited
;
3089 /* Identifies all of the argument packs that occur in a template
3090 argument and appends them to the TREE_LIST inside DATA, which is a
3091 find_parameter_pack_data structure. This is a subroutine of
3092 make_pack_expansion and uses_parameter_packs. */
3094 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3097 struct find_parameter_pack_data
* ppd
=
3098 (struct find_parameter_pack_data
*)data
;
3099 bool parameter_pack_p
= false;
3101 /* Handle type aliases/typedefs. */
3102 if (TYPE_ALIAS_P (t
))
3104 if (TYPE_TEMPLATE_INFO (t
))
3105 cp_walk_tree (&TYPE_TI_ARGS (t
),
3106 &find_parameter_packs_r
,
3112 /* Identify whether this is a parameter pack or not. */
3113 switch (TREE_CODE (t
))
3115 case TEMPLATE_PARM_INDEX
:
3116 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3117 parameter_pack_p
= true;
3120 case TEMPLATE_TYPE_PARM
:
3121 t
= TYPE_MAIN_VARIANT (t
);
3122 case TEMPLATE_TEMPLATE_PARM
:
3123 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3124 parameter_pack_p
= true;
3129 if (DECL_PACK_P (t
))
3131 /* We don't want to walk into the type of a PARM_DECL,
3132 because we don't want to see the type parameter pack. */
3134 parameter_pack_p
= true;
3138 /* Look through a lambda capture proxy to the field pack. */
3140 if (DECL_HAS_VALUE_EXPR_P (t
))
3142 tree v
= DECL_VALUE_EXPR (t
);
3144 &find_parameter_packs_r
,
3151 parameter_pack_p
= true;
3154 /* Not a parameter pack. */
3158 if (parameter_pack_p
)
3160 /* Add this parameter pack to the list. */
3161 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3165 cp_walk_tree (&TYPE_CONTEXT (t
),
3166 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3168 /* This switch statement will return immediately if we don't find a
3170 switch (TREE_CODE (t
))
3172 case TEMPLATE_PARM_INDEX
:
3175 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3176 /* Check the template itself. */
3177 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3178 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3179 /* Check the template arguments. */
3180 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3185 case TEMPLATE_TYPE_PARM
:
3186 case TEMPLATE_TEMPLATE_PARM
:
3193 if (TYPE_PTRMEMFUNC_P (t
))
3199 if (TYPE_TEMPLATE_INFO (t
))
3200 cp_walk_tree (&TYPE_TI_ARGS (t
),
3201 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3208 cp_walk_tree (&TREE_TYPE (t
),
3209 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3213 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3218 case TYPE_PACK_EXPANSION
:
3219 case EXPR_PACK_EXPANSION
:
3224 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3229 case IDENTIFIER_NODE
:
3230 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3242 /* Determines if the expression or type T uses any parameter packs. */
3244 uses_parameter_packs (tree t
)
3246 tree parameter_packs
= NULL_TREE
;
3247 struct find_parameter_pack_data ppd
;
3248 ppd
.parameter_packs
= ¶meter_packs
;
3249 ppd
.visited
= new hash_set
<tree
>;
3250 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3252 return parameter_packs
!= NULL_TREE
;
3255 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3256 representation a base-class initializer into a parameter pack
3257 expansion. If all goes well, the resulting node will be an
3258 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3261 make_pack_expansion (tree arg
)
3264 tree parameter_packs
= NULL_TREE
;
3265 bool for_types
= false;
3266 struct find_parameter_pack_data ppd
;
3268 if (!arg
|| arg
== error_mark_node
)
3271 if (TREE_CODE (arg
) == TREE_LIST
)
3273 /* The only time we will see a TREE_LIST here is for a base
3274 class initializer. In this case, the TREE_PURPOSE will be a
3275 _TYPE node (representing the base class expansion we're
3276 initializing) and the TREE_VALUE will be a TREE_LIST
3277 containing the initialization arguments.
3279 The resulting expansion looks somewhat different from most
3280 expansions. Rather than returning just one _EXPANSION, we
3281 return a TREE_LIST whose TREE_PURPOSE is a
3282 TYPE_PACK_EXPANSION containing the bases that will be
3283 initialized. The TREE_VALUE will be identical to the
3284 original TREE_VALUE, which is a list of arguments that will
3285 be passed to each base. We do not introduce any new pack
3286 expansion nodes into the TREE_VALUE (although it is possible
3287 that some already exist), because the TREE_PURPOSE and
3288 TREE_VALUE all need to be expanded together with the same
3289 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3290 resulting TREE_PURPOSE will mention the parameter packs in
3291 both the bases and the arguments to the bases. */
3294 tree parameter_packs
= NULL_TREE
;
3296 /* Determine which parameter packs will be used by the base
3298 ppd
.visited
= new hash_set
<tree
>;
3299 ppd
.parameter_packs
= ¶meter_packs
;
3300 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3303 if (parameter_packs
== NULL_TREE
)
3305 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3307 return error_mark_node
;
3310 if (TREE_VALUE (arg
) != void_type_node
)
3312 /* Collect the sets of parameter packs used in each of the
3313 initialization arguments. */
3314 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3316 /* Determine which parameter packs will be expanded in this
3318 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3325 /* Create the pack expansion type for the base type. */
3326 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3327 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3328 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3330 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3331 they will rarely be compared to anything. */
3332 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3334 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3337 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3340 /* Build the PACK_EXPANSION_* node. */
3342 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3343 : make_node (EXPR_PACK_EXPANSION
);
3344 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3345 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3347 /* Propagate type and const-expression information. */
3348 TREE_TYPE (result
) = TREE_TYPE (arg
);
3349 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3352 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3353 they will rarely be compared to anything. */
3354 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3356 /* Determine which parameter packs will be expanded. */
3357 ppd
.parameter_packs
= ¶meter_packs
;
3358 ppd
.visited
= new hash_set
<tree
>;
3359 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3362 /* Make sure we found some parameter packs. */
3363 if (parameter_packs
== NULL_TREE
)
3366 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3368 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3369 return error_mark_node
;
3371 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3373 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3378 /* Checks T for any "bare" parameter packs, which have not yet been
3379 expanded, and issues an error if any are found. This operation can
3380 only be done on full expressions or types (e.g., an expression
3381 statement, "if" condition, etc.), because we could have expressions like:
3383 foo(f(g(h(args)))...)
3385 where "args" is a parameter pack. check_for_bare_parameter_packs
3386 should not be called for the subexpressions args, h(args),
3387 g(h(args)), or f(g(h(args))), because we would produce erroneous
3390 Returns TRUE and emits an error if there were bare parameter packs,
3391 returns FALSE otherwise. */
3393 check_for_bare_parameter_packs (tree t
)
3395 tree parameter_packs
= NULL_TREE
;
3396 struct find_parameter_pack_data ppd
;
3398 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3401 if (TREE_CODE (t
) == TYPE_DECL
)
3404 ppd
.parameter_packs
= ¶meter_packs
;
3405 ppd
.visited
= new hash_set
<tree
>;
3406 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3409 if (parameter_packs
)
3411 error ("parameter packs not expanded with %<...%>:");
3412 while (parameter_packs
)
3414 tree pack
= TREE_VALUE (parameter_packs
);
3415 tree name
= NULL_TREE
;
3417 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3418 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3419 name
= TYPE_NAME (pack
);
3420 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3421 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3423 name
= DECL_NAME (pack
);
3426 inform (input_location
, " %qD", name
);
3428 inform (input_location
, " <anonymous>");
3430 parameter_packs
= TREE_CHAIN (parameter_packs
);
3439 /* Expand any parameter packs that occur in the template arguments in
3442 expand_template_argument_pack (tree args
)
3444 tree result_args
= NULL_TREE
;
3445 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3446 int num_result_args
= -1;
3447 int non_default_args_count
= -1;
3449 /* First, determine if we need to expand anything, and the number of
3450 slots we'll need. */
3451 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3453 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3454 if (arg
== NULL_TREE
)
3456 if (ARGUMENT_PACK_P (arg
))
3458 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3459 if (num_result_args
< 0)
3460 num_result_args
= in_arg
+ num_packed
;
3462 num_result_args
+= num_packed
;
3466 if (num_result_args
>= 0)
3471 /* If no expansion is necessary, we're done. */
3472 if (num_result_args
< 0)
3475 /* Expand arguments. */
3476 result_args
= make_tree_vec (num_result_args
);
3477 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3478 non_default_args_count
=
3479 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3480 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3482 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3483 if (ARGUMENT_PACK_P (arg
))
3485 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3486 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3487 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3488 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3489 if (non_default_args_count
> 0)
3490 non_default_args_count
+= num_packed
- 1;
3494 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3498 if (non_default_args_count
>= 0)
3499 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3503 /* Checks if DECL shadows a template parameter.
3505 [temp.local]: A template-parameter shall not be redeclared within its
3506 scope (including nested scopes).
3508 Emits an error and returns TRUE if the DECL shadows a parameter,
3509 returns FALSE otherwise. */
3512 check_template_shadow (tree decl
)
3516 /* If we're not in a template, we can't possibly shadow a template
3518 if (!current_template_parms
)
3521 /* Figure out what we're shadowing. */
3522 if (TREE_CODE (decl
) == OVERLOAD
)
3523 decl
= OVL_CURRENT (decl
);
3524 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3526 /* If there's no previous binding for this name, we're not shadowing
3527 anything, let alone a template parameter. */
3531 /* If we're not shadowing a template parameter, we're done. Note
3532 that OLDDECL might be an OVERLOAD (or perhaps even an
3533 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3535 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3538 /* We check for decl != olddecl to avoid bogus errors for using a
3539 name inside a class. We check TPFI to avoid duplicate errors for
3540 inline member templates. */
3542 || (DECL_TEMPLATE_PARM_P (decl
)
3543 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
3546 /* Don't complain about the injected class name, as we've already
3547 complained about the class itself. */
3548 if (DECL_SELF_REFERENCE_P (decl
))
3551 error ("declaration of %q+#D", decl
);
3552 error (" shadows template parm %q+#D", olddecl
);
3556 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3557 ORIG_LEVEL, DECL, and TYPE. */
3560 build_template_parm_index (int index
,
3566 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3567 TEMPLATE_PARM_IDX (t
) = index
;
3568 TEMPLATE_PARM_LEVEL (t
) = level
;
3569 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3570 TEMPLATE_PARM_DECL (t
) = decl
;
3571 TREE_TYPE (t
) = type
;
3572 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3573 TREE_READONLY (t
) = TREE_READONLY (decl
);
3578 /* Find the canonical type parameter for the given template type
3579 parameter. Returns the canonical type parameter, which may be TYPE
3580 if no such parameter existed. */
3583 canonical_type_parameter (tree type
)
3586 int idx
= TEMPLATE_TYPE_IDX (type
);
3587 if (!canonical_template_parms
)
3588 vec_alloc (canonical_template_parms
, idx
+1);
3590 while (canonical_template_parms
->length () <= (unsigned)idx
)
3591 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3593 list
= (*canonical_template_parms
)[idx
];
3594 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3595 list
= TREE_CHAIN (list
);
3598 return TREE_VALUE (list
);
3601 (*canonical_template_parms
)[idx
]
3602 = tree_cons (NULL_TREE
, type
,
3603 (*canonical_template_parms
)[idx
]);
3608 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3609 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3610 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3611 new one is created. */
3614 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3615 tsubst_flags_t complain
)
3617 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3618 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3619 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3620 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3622 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3625 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3626 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3627 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3628 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3629 DECL_ARTIFICIAL (decl
) = 1;
3630 SET_DECL_TEMPLATE_PARM_P (decl
);
3632 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3633 TEMPLATE_PARM_LEVEL (index
) - levels
,
3634 TEMPLATE_PARM_ORIG_LEVEL (index
),
3636 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3637 TEMPLATE_PARM_PARAMETER_PACK (t
)
3638 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3640 /* Template template parameters need this. */
3641 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3642 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3643 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
)),
3647 return TEMPLATE_PARM_DESCENDANTS (index
);
3650 /* Process information from new template parameter PARM and append it
3651 to the LIST being built. This new parameter is a non-type
3652 parameter iff IS_NON_TYPE is true. This new parameter is a
3653 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3657 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
3658 bool is_non_type
, bool is_parameter_pack
)
3664 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
3665 defval
= TREE_PURPOSE (parm
);
3669 tree p
= tree_last (list
);
3671 if (p
&& TREE_VALUE (p
) != error_mark_node
)
3674 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
3675 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
3677 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
3685 parm
= TREE_VALUE (parm
);
3687 SET_DECL_TEMPLATE_PARM_P (parm
);
3689 if (TREE_TYPE (parm
) != error_mark_node
)
3693 The top-level cv-qualifiers on the template-parameter are
3694 ignored when determining its type. */
3695 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
3696 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
3697 TREE_TYPE (parm
) = error_mark_node
;
3698 else if (uses_parameter_packs (TREE_TYPE (parm
))
3699 && !is_parameter_pack
3700 /* If we're in a nested template parameter list, the template
3701 template parameter could be a parameter pack. */
3702 && processing_template_parmlist
== 1)
3704 /* This template parameter is not a parameter pack, but it
3705 should be. Complain about "bare" parameter packs. */
3706 check_for_bare_parameter_packs (TREE_TYPE (parm
));
3708 /* Recover by calling this a parameter pack. */
3709 is_parameter_pack
= true;
3713 /* A template parameter is not modifiable. */
3714 TREE_CONSTANT (parm
) = 1;
3715 TREE_READONLY (parm
) = 1;
3716 decl
= build_decl (parm_loc
,
3717 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
3718 TREE_CONSTANT (decl
) = 1;
3719 TREE_READONLY (decl
) = 1;
3720 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
3721 = build_template_parm_index (idx
, processing_template_decl
,
3722 processing_template_decl
,
3723 decl
, TREE_TYPE (parm
));
3725 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
3726 = is_parameter_pack
;
3731 parm
= TREE_VALUE (TREE_VALUE (parm
));
3733 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
3735 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
3736 /* This is for distinguishing between real templates and template
3737 template parameters */
3738 TREE_TYPE (parm
) = t
;
3739 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
3744 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
3745 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3746 decl
= build_decl (parm_loc
,
3747 TYPE_DECL
, parm
, t
);
3750 TYPE_NAME (t
) = decl
;
3751 TYPE_STUB_DECL (t
) = decl
;
3753 TEMPLATE_TYPE_PARM_INDEX (t
)
3754 = build_template_parm_index (idx
, processing_template_decl
,
3755 processing_template_decl
,
3756 decl
, TREE_TYPE (parm
));
3757 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
3758 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
3760 DECL_ARTIFICIAL (decl
) = 1;
3761 SET_DECL_TEMPLATE_PARM_P (decl
);
3763 parm
= build_tree_list (defval
, parm
);
3764 return chainon (list
, parm
);
3767 /* The end of a template parameter list has been reached. Process the
3768 tree list into a parameter vector, converting each parameter into a more
3769 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3773 end_template_parm_list (tree parms
)
3777 tree saved_parmlist
= make_tree_vec (list_length (parms
));
3779 current_template_parms
3780 = tree_cons (size_int (processing_template_decl
),
3781 saved_parmlist
, current_template_parms
);
3783 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3785 next
= TREE_CHAIN (parm
);
3786 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3787 TREE_CHAIN (parm
) = NULL_TREE
;
3790 --processing_template_parmlist
;
3792 return saved_parmlist
;
3795 /* end_template_decl is called after a template declaration is seen. */
3798 end_template_decl (void)
3800 reset_specialization ();
3802 if (! processing_template_decl
)
3805 /* This matches the pushlevel in begin_template_parm_list. */
3808 --processing_template_decl
;
3809 current_template_parms
= TREE_CHAIN (current_template_parms
);
3812 /* Takes a TREE_LIST representing a template parameter and convert it
3813 into an argument suitable to be passed to the type substitution
3814 functions. Note that If the TREE_LIST contains an error_mark
3815 node, the returned argument is error_mark_node. */
3818 template_parm_to_arg (tree t
)
3822 || TREE_CODE (t
) != TREE_LIST
)
3825 if (error_operand_p (TREE_VALUE (t
)))
3826 return error_mark_node
;
3830 if (TREE_CODE (t
) == TYPE_DECL
3831 || TREE_CODE (t
) == TEMPLATE_DECL
)
3835 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3837 /* Turn this argument into a TYPE_ARGUMENT_PACK
3838 with a single element, which expands T. */
3839 tree vec
= make_tree_vec (1);
3840 #ifdef ENABLE_CHECKING
3841 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3842 (vec
, TREE_VEC_LENGTH (vec
));
3844 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3846 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
3847 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3852 t
= DECL_INITIAL (t
);
3854 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3856 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3857 with a single element, which expands T. */
3858 tree vec
= make_tree_vec (1);
3859 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3860 #ifdef ENABLE_CHECKING
3861 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3862 (vec
, TREE_VEC_LENGTH (vec
));
3864 t
= convert_from_reference (t
);
3865 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3867 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3868 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3869 TREE_TYPE (t
) = type
;
3872 t
= convert_from_reference (t
);
3877 /* Given a set of template parameters, return them as a set of template
3878 arguments. The template parameters are represented as a TREE_VEC, in
3879 the form documented in cp-tree.h for template arguments. */
3882 template_parms_to_args (tree parms
)
3885 tree args
= NULL_TREE
;
3886 int length
= TMPL_PARMS_DEPTH (parms
);
3889 /* If there is only one level of template parameters, we do not
3890 create a TREE_VEC of TREE_VECs. Instead, we return a single
3891 TREE_VEC containing the arguments. */
3893 args
= make_tree_vec (length
);
3895 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
3897 tree a
= copy_node (TREE_VALUE (header
));
3900 TREE_TYPE (a
) = NULL_TREE
;
3901 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
3902 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
3904 #ifdef ENABLE_CHECKING
3905 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
3909 TREE_VEC_ELT (args
, --l
) = a
;
3914 if (length
> 1 && TREE_VEC_ELT (args
, 0) == NULL_TREE
)
3915 /* This can happen for template parms of a template template
3918 template<template<class T, class U> class TT> struct S;
3920 Consider the level of the parms of TT; T and U both have
3921 level 2; TT has no template parm of level 1. So in this case
3922 the first element of full_template_args is NULL_TREE. If we
3923 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
3924 of 2. This will make tsubst wrongly consider that T and U
3925 have level 1. Instead, let's create a dummy vector as the
3926 first element of full_template_args so that TMPL_ARGS_DEPTH
3927 returns the correct depth for args. */
3928 TREE_VEC_ELT (args
, 0) = make_tree_vec (1);
3932 /* Within the declaration of a template, return the currently active
3933 template parameters as an argument TREE_VEC. */
3936 current_template_args (void)
3938 return template_parms_to_args (current_template_parms
);
3941 /* Update the declared TYPE by doing any lookups which were thought to be
3942 dependent, but are not now that we know the SCOPE of the declarator. */
3945 maybe_update_decl_type (tree orig_type
, tree scope
)
3947 tree type
= orig_type
;
3949 if (type
== NULL_TREE
)
3952 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3953 type
= TREE_TYPE (type
);
3955 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
3956 && dependent_type_p (type
)
3957 /* Don't bother building up the args in this case. */
3958 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
3960 /* tsubst in the args corresponding to the template parameters,
3961 including auto if present. Most things will be unchanged, but
3962 make_typename_type and tsubst_qualified_id will resolve
3963 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3964 tree args
= current_template_args ();
3965 tree auto_node
= type_uses_auto (type
);
3969 tree auto_vec
= make_tree_vec (1);
3970 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
3971 args
= add_to_template_args (args
, auto_vec
);
3973 pushed
= push_scope (scope
);
3974 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
3979 if (type
== error_mark_node
)
3982 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3984 if (same_type_p (type
, TREE_TYPE (orig_type
)))
3987 type
= TYPE_NAME (type
);
3992 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3993 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3994 a member template. Used by push_template_decl below. */
3997 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
3999 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4000 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4001 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4002 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4003 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4008 struct template_parm_data
4010 /* The level of the template parameters we are currently
4014 /* The index of the specialization argument we are currently
4018 /* An array whose size is the number of template parameters. The
4019 elements are nonzero if the parameter has been used in any one
4020 of the arguments processed so far. */
4023 /* An array whose size is the number of template arguments. The
4024 elements are nonzero if the argument makes use of template
4025 parameters of this level. */
4026 int* arg_uses_template_parms
;
4029 /* Subroutine of push_template_decl used to see if each template
4030 parameter in a partial specialization is used in the explicit
4031 argument list. If T is of the LEVEL given in DATA (which is
4032 treated as a template_parm_data*), then DATA->PARMS is marked
4036 mark_template_parm (tree t
, void* data
)
4040 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4042 template_parm_level_and_index (t
, &level
, &idx
);
4044 if (level
== tpd
->level
)
4046 tpd
->parms
[idx
] = 1;
4047 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4050 /* Return zero so that for_each_template_parm will continue the
4051 traversal of the tree; we want to mark *every* template parm. */
4055 /* Process the partial specialization DECL. */
4058 process_partial_specialization (tree decl
)
4060 tree type
= TREE_TYPE (decl
);
4061 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
4062 tree specargs
= CLASSTYPE_TI_ARGS (type
);
4063 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4064 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4067 int nargs
= TREE_VEC_LENGTH (inner_args
);
4070 bool did_error_intro
= false;
4071 struct template_parm_data tpd
;
4072 struct template_parm_data tpd2
;
4074 gcc_assert (current_template_parms
);
4076 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4077 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4079 /* We check that each of the template parameters given in the
4080 partial specialization is used in the argument list to the
4081 specialization. For example:
4083 template <class T> struct S;
4084 template <class T> struct S<T*>;
4086 The second declaration is OK because `T*' uses the template
4087 parameter T, whereas
4089 template <class T> struct S<int>;
4091 is no good. Even trickier is:
4102 The S2<T> declaration is actually invalid; it is a
4103 full-specialization. Of course,
4106 struct S2<T (*)(U)>;
4108 or some such would have been OK. */
4109 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4110 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4111 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4113 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4114 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4115 for (i
= 0; i
< nargs
; ++i
)
4117 tpd
.current_arg
= i
;
4118 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4119 &mark_template_parm
,
4122 /*include_nondeduced_p=*/false);
4124 for (i
= 0; i
< ntparms
; ++i
)
4125 if (tpd
.parms
[i
] == 0)
4127 /* One of the template parms was not used in a deduced context in the
4129 if (!did_error_intro
)
4131 error ("template parameters not deducible in "
4132 "partial specialization:");
4133 did_error_intro
= true;
4136 inform (input_location
, " %qD",
4137 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4140 if (did_error_intro
)
4141 return error_mark_node
;
4143 /* [temp.class.spec]
4145 The argument list of the specialization shall not be identical to
4146 the implicit argument list of the primary template. */
4147 if (comp_template_args
4149 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
4151 error ("partial specialization %qT does not specialize any template arguments", type
);
4153 /* A partial specialization that replaces multiple parameters of the
4154 primary template with a pack expansion is less specialized for those
4156 if (nargs
< DECL_NTPARMS (maintmpl
))
4158 error ("partial specialization is not more specialized than the "
4159 "primary template because it replaces multiple parameters "
4160 "with a pack expansion");
4161 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4165 /* [temp.class.spec]
4167 A partially specialized non-type argument expression shall not
4168 involve template parameters of the partial specialization except
4169 when the argument expression is a simple identifier.
4171 The type of a template parameter corresponding to a specialized
4172 non-type argument shall not be dependent on a parameter of the
4175 Also, we verify that pack expansions only occur at the
4176 end of the argument list. */
4177 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4179 for (i
= 0; i
< nargs
; ++i
)
4181 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4182 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4183 tree packed_args
= NULL_TREE
;
4186 if (ARGUMENT_PACK_P (arg
))
4188 /* Extract the arguments from the argument pack. We'll be
4189 iterating over these in the following loop. */
4190 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4191 len
= TREE_VEC_LENGTH (packed_args
);
4194 for (j
= 0; j
< len
; j
++)
4197 /* Get the Jth argument in the parameter pack. */
4198 arg
= TREE_VEC_ELT (packed_args
, j
);
4200 if (PACK_EXPANSION_P (arg
))
4202 /* Pack expansions must come at the end of the
4204 if ((packed_args
&& j
< len
- 1)
4205 || (!packed_args
&& i
< nargs
- 1))
4207 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4208 error ("parameter pack argument %qE must be at the "
4209 "end of the template argument list", arg
);
4211 error ("parameter pack argument %qT must be at the "
4212 "end of the template argument list", arg
);
4216 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4217 /* We only care about the pattern. */
4218 arg
= PACK_EXPANSION_PATTERN (arg
);
4220 if (/* These first two lines are the `non-type' bit. */
4222 && TREE_CODE (arg
) != TEMPLATE_DECL
4223 /* This next two lines are the `argument expression is not just a
4224 simple identifier' condition and also the `specialized
4225 non-type argument' bit. */
4226 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4227 && !(REFERENCE_REF_P (arg
)
4228 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4230 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4231 || (packed_args
&& uses_template_parms (arg
)))
4232 error ("template argument %qE involves template parameter(s)",
4236 /* Look at the corresponding template parameter,
4237 marking which template parameters its type depends
4239 tree type
= TREE_TYPE (parm
);
4243 /* We haven't yet initialized TPD2. Do so now. */
4244 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4245 /* The number of parameters here is the number in the
4246 main template, which, as checked in the assertion
4248 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4250 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4253 /* Mark the template parameters. But this time, we're
4254 looking for the template parameters of the main
4255 template, not in the specialization. */
4256 tpd2
.current_arg
= i
;
4257 tpd2
.arg_uses_template_parms
[i
] = 0;
4258 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4259 for_each_template_parm (type
,
4260 &mark_template_parm
,
4263 /*include_nondeduced_p=*/false);
4265 if (tpd2
.arg_uses_template_parms
[i
])
4267 /* The type depended on some template parameters.
4268 If they are fully specialized in the
4269 specialization, that's OK. */
4272 for (j
= 0; j
< nargs
; ++j
)
4273 if (tpd2
.parms
[j
] != 0
4274 && tpd
.arg_uses_template_parms
[j
])
4277 error_n (input_location
, count
,
4278 "type %qT of template argument %qE depends "
4279 "on a template parameter",
4280 "type %qT of template argument %qE depends "
4281 "on template parameters",
4290 /* We should only get here once. */
4291 gcc_assert (!COMPLETE_TYPE_P (type
));
4293 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4294 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4295 TREE_TYPE (tmpl
) = type
;
4296 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4297 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4298 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4299 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4301 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4302 = tree_cons (specargs
, tmpl
,
4303 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4304 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4306 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4307 inst
= TREE_CHAIN (inst
))
4309 tree inst_type
= TREE_VALUE (inst
);
4310 if (COMPLETE_TYPE_P (inst_type
)
4311 && CLASSTYPE_IMPLICIT_INSTANTIATION (inst_type
))
4313 tree spec
= most_specialized_class (inst_type
, tf_none
);
4314 if (spec
&& TREE_TYPE (spec
) == type
)
4315 permerror (input_location
,
4316 "partial specialization of %qT after instantiation "
4317 "of %qT", type
, inst_type
);
4324 /* PARM is a template parameter of some form; return the corresponding
4325 TEMPLATE_PARM_INDEX. */
4328 get_template_parm_index (tree parm
)
4330 if (TREE_CODE (parm
) == PARM_DECL
4331 || TREE_CODE (parm
) == CONST_DECL
)
4332 parm
= DECL_INITIAL (parm
);
4333 else if (TREE_CODE (parm
) == TYPE_DECL
4334 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4335 parm
= TREE_TYPE (parm
);
4336 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4337 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4338 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4339 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4343 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4344 parameter packs used by the template parameter PARM. */
4347 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4349 /* A type parm can't refer to another parm. */
4350 if (TREE_CODE (parm
) == TYPE_DECL
)
4352 else if (TREE_CODE (parm
) == PARM_DECL
)
4354 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4359 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4361 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4362 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4363 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4366 /* PARM is a template parameter pack. Return any parameter packs used in
4367 its type or the type of any of its template parameters. If there are
4368 any such packs, it will be instantiated into a fixed template parameter
4369 list by partial instantiation rather than be fully deduced. */
4372 fixed_parameter_pack_p (tree parm
)
4374 /* This can only be true in a member template. */
4375 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4377 /* This can only be true for a parameter pack. */
4378 if (!template_parameter_pack_p (parm
))
4380 /* A type parm can't refer to another parm. */
4381 if (TREE_CODE (parm
) == TYPE_DECL
)
4384 tree parameter_packs
= NULL_TREE
;
4385 struct find_parameter_pack_data ppd
;
4386 ppd
.parameter_packs
= ¶meter_packs
;
4387 ppd
.visited
= new hash_set
<tree
>;
4389 fixed_parameter_pack_p_1 (parm
, &ppd
);
4392 return parameter_packs
;
4395 /* Check that a template declaration's use of default arguments and
4396 parameter packs is not invalid. Here, PARMS are the template
4397 parameters. IS_PRIMARY is true if DECL is the thing declared by
4398 a primary template. IS_PARTIAL is true if DECL is a partial
4401 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4402 declaration (but not a definition); 1 indicates a declaration, 2
4403 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4404 emitted for extraneous default arguments.
4406 Returns TRUE if there were no errors found, FALSE otherwise. */
4409 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4410 bool is_partial
, int is_friend_decl
)
4413 int last_level_to_check
;
4415 bool no_errors
= true;
4419 A default template-argument shall not be specified in a
4420 function template declaration or a function template definition, nor
4421 in the template-parameter-list of the definition of a member of a
4424 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
4425 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
4426 /* You can't have a function template declaration in a local
4427 scope, nor you can you define a member of a class template in a
4431 if (TREE_CODE (decl
) == TYPE_DECL
4433 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4434 /* A lambda doesn't have an explicit declaration; don't complain
4435 about the parms of the enclosing class. */
4438 if (current_class_type
4439 && !TYPE_BEING_DEFINED (current_class_type
)
4440 && DECL_LANG_SPECIFIC (decl
)
4441 && DECL_DECLARES_FUNCTION_P (decl
)
4442 /* If this is either a friend defined in the scope of the class
4443 or a member function. */
4444 && (DECL_FUNCTION_MEMBER_P (decl
)
4445 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4446 : DECL_FRIEND_CONTEXT (decl
)
4447 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4449 /* And, if it was a member function, it really was defined in
4450 the scope of the class. */
4451 && (!DECL_FUNCTION_MEMBER_P (decl
)
4452 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4453 /* We already checked these parameters when the template was
4454 declared, so there's no need to do it again now. This function
4455 was defined in class scope, but we're processing its body now
4456 that the class is complete. */
4459 /* Core issue 226 (C++0x only): the following only applies to class
4462 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4466 If a template-parameter has a default template-argument, all
4467 subsequent template-parameters shall have a default
4468 template-argument supplied. */
4469 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4471 tree inner_parms
= TREE_VALUE (parm_level
);
4472 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4473 int seen_def_arg_p
= 0;
4476 for (i
= 0; i
< ntparms
; ++i
)
4478 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4480 if (parm
== error_mark_node
)
4483 if (TREE_PURPOSE (parm
))
4485 else if (seen_def_arg_p
4486 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4488 error ("no default argument for %qD", TREE_VALUE (parm
));
4489 /* For better subsequent error-recovery, we indicate that
4490 there should have been a default argument. */
4491 TREE_PURPOSE (parm
) = error_mark_node
;
4494 else if (!is_partial
4496 /* Don't complain about an enclosing partial
4498 && parm_level
== parms
4499 && TREE_CODE (decl
) == TYPE_DECL
4501 && template_parameter_pack_p (TREE_VALUE (parm
))
4502 /* A fixed parameter pack will be partially
4503 instantiated into a fixed length list. */
4504 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4506 /* A primary class template can only have one
4507 parameter pack, at the end of the template
4510 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
4511 error ("parameter pack %qE must be at the end of the"
4512 " template parameter list", TREE_VALUE (parm
));
4514 error ("parameter pack %qT must be at the end of the"
4515 " template parameter list",
4516 TREE_TYPE (TREE_VALUE (parm
)));
4518 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4526 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4530 /* For an ordinary class template, default template arguments are
4531 allowed at the innermost level, e.g.:
4532 template <class T = int>
4534 but, in a partial specialization, they're not allowed even
4535 there, as we have in [temp.class.spec]:
4537 The template parameter list of a specialization shall not
4538 contain default template argument values.
4540 So, for a partial specialization, or for a function template
4541 (in C++98/C++03), we look at all of them. */
4544 /* But, for a primary class template that is not a partial
4545 specialization we look at all template parameters except the
4547 parms
= TREE_CHAIN (parms
);
4549 /* Figure out what error message to issue. */
4550 if (is_friend_decl
== 2)
4551 msg
= G_("default template arguments may not be used in function template "
4552 "friend re-declaration");
4553 else if (is_friend_decl
)
4554 msg
= G_("default template arguments may not be used in function template "
4555 "friend declarations");
4556 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4557 msg
= G_("default template arguments may not be used in function templates "
4558 "without -std=c++11 or -std=gnu++11");
4559 else if (is_partial
)
4560 msg
= G_("default template arguments may not be used in "
4561 "partial specializations");
4563 msg
= G_("default argument for template parameter for class enclosing %qD");
4565 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4566 /* If we're inside a class definition, there's no need to
4567 examine the parameters to the class itself. On the one
4568 hand, they will be checked when the class is defined, and,
4569 on the other, default arguments are valid in things like:
4570 template <class T = double>
4571 struct S { template <class U> void f(U); };
4572 Here the default argument for `S' has no bearing on the
4573 declaration of `f'. */
4574 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4576 /* Check everything. */
4577 last_level_to_check
= 0;
4579 for (parm_level
= parms
;
4580 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4581 parm_level
= TREE_CHAIN (parm_level
))
4583 tree inner_parms
= TREE_VALUE (parm_level
);
4587 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4588 for (i
= 0; i
< ntparms
; ++i
)
4590 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4593 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4598 if (is_friend_decl
== 2)
4605 /* Clear out the default argument so that we are not
4607 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
4611 /* At this point, if we're still interested in issuing messages,
4612 they must apply to classes surrounding the object declared. */
4614 msg
= G_("default argument for template parameter for class "
4621 /* Worker for push_template_decl_real, called via
4622 for_each_template_parm. DATA is really an int, indicating the
4623 level of the parameters we are interested in. If T is a template
4624 parameter of that level, return nonzero. */
4627 template_parm_this_level_p (tree t
, void* data
)
4629 int this_level
= *(int *)data
;
4632 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4633 level
= TEMPLATE_PARM_LEVEL (t
);
4635 level
= TEMPLATE_TYPE_LEVEL (t
);
4636 return level
== this_level
;
4639 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4640 parameters given by current_template_args, or reuses a
4641 previously existing one, if appropriate. Returns the DECL, or an
4642 equivalent one, if it is replaced via a call to duplicate_decls.
4644 If IS_FRIEND is true, DECL is a friend declaration. */
4647 push_template_decl_real (tree decl
, bool is_friend
)
4655 int new_template_p
= 0;
4656 /* True if the template is a member template, in the sense of
4658 bool member_template_p
= false;
4660 if (decl
== error_mark_node
|| !current_template_parms
)
4661 return error_mark_node
;
4663 /* See if this is a partial specialization. */
4664 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
4665 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
4666 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
4668 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
4672 /* For a friend, we want the context of the friend function, not
4673 the type of which it is a friend. */
4674 ctx
= CP_DECL_CONTEXT (decl
);
4675 else if (CP_DECL_CONTEXT (decl
)
4676 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4677 /* In the case of a virtual function, we want the class in which
4679 ctx
= CP_DECL_CONTEXT (decl
);
4681 /* Otherwise, if we're currently defining some class, the DECL
4682 is assumed to be a member of the class. */
4683 ctx
= current_scope ();
4685 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
4688 if (!DECL_CONTEXT (decl
))
4689 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
4691 /* See if this is a primary template. */
4692 if (is_friend
&& ctx
4693 && uses_template_parms_level (ctx
, processing_template_decl
))
4694 /* A friend template that specifies a class context, i.e.
4695 template <typename T> friend void A<T>::f();
4699 is_primary
= template_parm_scope_p ();
4703 if (DECL_CLASS_SCOPE_P (decl
))
4704 member_template_p
= true;
4705 if (TREE_CODE (decl
) == TYPE_DECL
4706 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
4708 error ("template class without a name");
4709 return error_mark_node
;
4711 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
4713 if (DECL_DESTRUCTOR_P (decl
))
4717 A destructor shall not be a member template. */
4718 error ("destructor %qD declared as member template", decl
);
4719 return error_mark_node
;
4721 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
4722 && (!prototype_p (TREE_TYPE (decl
))
4723 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
4724 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
4725 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
4726 == void_list_node
)))
4728 /* [basic.stc.dynamic.allocation]
4730 An allocation function can be a function
4731 template. ... Template allocation functions shall
4732 have two or more parameters. */
4733 error ("invalid template declaration of %qD", decl
);
4734 return error_mark_node
;
4737 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4738 && CLASS_TYPE_P (TREE_TYPE (decl
)))
4740 else if (TREE_CODE (decl
) == TYPE_DECL
4741 && TYPE_DECL_ALIAS_P (decl
))
4742 /* alias-declaration */
4743 gcc_assert (!DECL_ARTIFICIAL (decl
));
4746 error ("template declaration of %q#D", decl
);
4747 return error_mark_node
;
4751 /* Check to see that the rules regarding the use of default
4752 arguments are not being violated. */
4753 check_default_tmpl_args (decl
, current_template_parms
,
4754 is_primary
, is_partial
, /*is_friend_decl=*/0);
4756 /* Ensure that there are no parameter packs in the type of this
4757 declaration that have not been expanded. */
4758 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4760 /* Check each of the arguments individually to see if there are
4761 any bare parameter packs. */
4762 tree type
= TREE_TYPE (decl
);
4763 tree arg
= DECL_ARGUMENTS (decl
);
4764 tree argtype
= TYPE_ARG_TYPES (type
);
4766 while (arg
&& argtype
)
4768 if (!DECL_PACK_P (arg
)
4769 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
4771 /* This is a PARM_DECL that contains unexpanded parameter
4772 packs. We have already complained about this in the
4773 check_for_bare_parameter_packs call, so just replace
4774 these types with ERROR_MARK_NODE. */
4775 TREE_TYPE (arg
) = error_mark_node
;
4776 TREE_VALUE (argtype
) = error_mark_node
;
4779 arg
= DECL_CHAIN (arg
);
4780 argtype
= TREE_CHAIN (argtype
);
4783 /* Check for bare parameter packs in the return type and the
4784 exception specifiers. */
4785 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
4786 /* Errors were already issued, set return type to int
4787 as the frontend doesn't expect error_mark_node as
4789 TREE_TYPE (type
) = integer_type_node
;
4790 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
4791 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
4793 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
4794 && TYPE_DECL_ALIAS_P (decl
))
4795 ? DECL_ORIGINAL_TYPE (decl
)
4796 : TREE_TYPE (decl
)))
4798 TREE_TYPE (decl
) = error_mark_node
;
4799 return error_mark_node
;
4803 return process_partial_specialization (decl
);
4805 args
= current_template_args ();
4808 || TREE_CODE (ctx
) == FUNCTION_DECL
4809 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
4810 || (TREE_CODE (decl
) == TYPE_DECL
4811 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4812 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
4814 if (DECL_LANG_SPECIFIC (decl
)
4815 && DECL_TEMPLATE_INFO (decl
)
4816 && DECL_TI_TEMPLATE (decl
))
4817 tmpl
= DECL_TI_TEMPLATE (decl
);
4818 /* If DECL is a TYPE_DECL for a class-template, then there won't
4819 be DECL_LANG_SPECIFIC. The information equivalent to
4820 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4821 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4822 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
4823 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
4825 /* Since a template declaration already existed for this
4826 class-type, we must be redeclaring it here. Make sure
4827 that the redeclaration is valid. */
4828 redeclare_class_template (TREE_TYPE (decl
),
4829 current_template_parms
);
4830 /* We don't need to create a new TEMPLATE_DECL; just use the
4831 one we already had. */
4832 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
4836 tmpl
= build_template_decl (decl
, current_template_parms
,
4840 if (DECL_LANG_SPECIFIC (decl
)
4841 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4843 /* A specialization of a member template of a template
4845 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4846 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
4847 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
4853 tree a
, t
, current
, parms
;
4855 tree tinfo
= get_template_info (decl
);
4859 error ("template definition of non-template %q#D", decl
);
4860 return error_mark_node
;
4863 tmpl
= TI_TEMPLATE (tinfo
);
4865 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
4866 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
4867 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4868 && DECL_MEMBER_TEMPLATE_P (tmpl
))
4872 /* The declaration is a specialization of a member
4873 template, declared outside the class. Therefore, the
4874 innermost template arguments will be NULL, so we
4875 replace them with the arguments determined by the
4876 earlier call to check_explicit_specialization. */
4877 args
= DECL_TI_ARGS (decl
);
4880 = build_template_decl (decl
, current_template_parms
,
4882 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
4883 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
4884 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
4885 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
4886 DECL_TEMPLATE_INFO (new_tmpl
)
4887 = build_template_info (tmpl
, args
);
4889 register_specialization (new_tmpl
,
4890 most_general_template (tmpl
),
4896 /* Make sure the template headers we got make sense. */
4898 parms
= DECL_TEMPLATE_PARMS (tmpl
);
4899 i
= TMPL_PARMS_DEPTH (parms
);
4900 if (TMPL_ARGS_DEPTH (args
) != i
)
4902 error ("expected %d levels of template parms for %q#D, got %d",
4903 i
, decl
, TMPL_ARGS_DEPTH (args
));
4904 DECL_INTERFACE_KNOWN (decl
) = 1;
4905 return error_mark_node
;
4908 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
4910 a
= TMPL_ARGS_LEVEL (args
, i
);
4911 t
= INNERMOST_TEMPLATE_PARMS (parms
);
4913 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
4915 if (current
== decl
)
4916 error ("got %d template parameters for %q#D",
4917 TREE_VEC_LENGTH (a
), decl
);
4919 error ("got %d template parameters for %q#T",
4920 TREE_VEC_LENGTH (a
), current
);
4921 error (" but %d required", TREE_VEC_LENGTH (t
));
4922 /* Avoid crash in import_export_decl. */
4923 DECL_INTERFACE_KNOWN (decl
) = 1;
4924 return error_mark_node
;
4927 if (current
== decl
)
4929 else if (current
== NULL_TREE
)
4930 /* Can happen in erroneous input. */
4933 current
= get_containing_scope (current
);
4936 /* Check that the parms are used in the appropriate qualifying scopes
4937 in the declarator. */
4938 if (!comp_template_args
4940 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
4943 template arguments to %qD do not match original template %qD",
4944 decl
, DECL_TEMPLATE_RESULT (tmpl
));
4945 if (!uses_template_parms (TI_ARGS (tinfo
)))
4946 inform (input_location
, "use template<> for an explicit specialization");
4947 /* Avoid crash in import_export_decl. */
4948 DECL_INTERFACE_KNOWN (decl
) = 1;
4949 return error_mark_node
;
4953 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4954 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
4956 /* Push template declarations for global functions and types. Note
4957 that we do not try to push a global template friend declared in a
4958 template class; such a thing may well depend on the template
4959 parameters of the class. */
4960 if (new_template_p
&& !ctx
4961 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
4963 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
4964 if (tmpl
== error_mark_node
)
4965 return error_mark_node
;
4967 /* Hide template friend classes that haven't been declared yet. */
4968 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
4970 DECL_ANTICIPATED (tmpl
) = 1;
4971 DECL_FRIEND_P (tmpl
) = 1;
4977 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
4980 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
4981 if (DECL_CONV_FN_P (tmpl
))
4983 int depth
= TMPL_PARMS_DEPTH (parms
);
4985 /* It is a conversion operator. See if the type converted to
4986 depends on innermost template operands. */
4988 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
4990 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
4993 /* Give template template parms a DECL_CONTEXT of the template
4994 for which they are a parameter. */
4995 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
4996 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
4998 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
4999 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5000 DECL_CONTEXT (parm
) = tmpl
;
5004 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5005 back to its most general template. If TMPL is a specialization,
5006 ARGS may only have the innermost set of arguments. Add the missing
5007 argument levels if necessary. */
5008 if (DECL_TEMPLATE_INFO (tmpl
))
5009 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5011 info
= build_template_info (tmpl
, args
);
5013 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5014 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5017 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5018 retrofit_lang_decl (decl
);
5019 if (DECL_LANG_SPECIFIC (decl
))
5020 DECL_TEMPLATE_INFO (decl
) = info
;
5023 if (flag_implicit_templates
5025 && VAR_OR_FUNCTION_DECL_P (decl
))
5026 /* Set DECL_COMDAT on template instantiations; if we force
5027 them to be emitted by explicit instantiation or -frepo,
5028 mark_needed will tell cgraph to do the right thing. */
5029 DECL_COMDAT (decl
) = true;
5031 return DECL_TEMPLATE_RESULT (tmpl
);
5035 push_template_decl (tree decl
)
5037 return push_template_decl_real (decl
, false);
5040 /* FN is an inheriting constructor that inherits from the constructor
5041 template INHERITED; turn FN into a constructor template with a matching
5045 add_inherited_template_parms (tree fn
, tree inherited
)
5048 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5049 inner_parms
= copy_node (inner_parms
);
5051 = tree_cons (size_int (processing_template_decl
+ 1),
5052 inner_parms
, current_template_parms
);
5053 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5054 tree args
= template_parms_to_args (parms
);
5055 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5056 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5057 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5058 DECL_ARTIFICIAL (tmpl
) = true;
5059 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5063 /* Called when a class template TYPE is redeclared with the indicated
5064 template PARMS, e.g.:
5066 template <class T> struct S;
5067 template <class T> struct S {}; */
5070 redeclare_class_template (tree type
, tree parms
)
5076 if (!TYPE_TEMPLATE_INFO (type
))
5078 error ("%qT is not a template type", type
);
5082 tmpl
= TYPE_TI_TEMPLATE (type
);
5083 if (!PRIMARY_TEMPLATE_P (tmpl
))
5084 /* The type is nested in some template class. Nothing to worry
5085 about here; there are no new template parameters for the nested
5091 error ("template specifiers not specified in declaration of %qD",
5096 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5097 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5099 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5101 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5102 "redeclared with %d template parameter",
5103 "redeclared with %d template parameters",
5104 TREE_VEC_LENGTH (parms
));
5105 inform_n (input_location
, TREE_VEC_LENGTH (tmpl_parms
),
5106 "previous declaration %q+D used %d template parameter",
5107 "previous declaration %q+D used %d template parameters",
5108 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5112 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5119 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5120 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5123 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5124 if (error_operand_p (tmpl_parm
))
5127 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5128 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5129 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5131 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5133 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5134 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5135 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5136 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5137 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5138 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5139 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5140 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5141 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5143 error ("template parameter %q+#D", tmpl_parm
);
5144 error ("redeclared here as %q#D", parm
);
5148 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5150 /* We have in [temp.param]:
5152 A template-parameter may not be given default arguments
5153 by two different declarations in the same scope. */
5154 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5155 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5156 "original definition appeared here");
5160 if (parm_default
!= NULL_TREE
)
5161 /* Update the previous template parameters (which are the ones
5162 that will really count) with the new default value. */
5163 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5164 else if (tmpl_default
!= NULL_TREE
)
5165 /* Update the new parameters, too; they'll be used as the
5166 parameters for any members. */
5167 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5173 /* Simplify EXPR if it is a non-dependent expression. Returns the
5174 (possibly simplified) expression. */
5177 fold_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5179 if (expr
== NULL_TREE
)
5182 /* If we're in a template, but EXPR isn't value dependent, simplify
5183 it. We're supposed to treat:
5185 template <typename T> void f(T[1 + 1]);
5186 template <typename T> void f(T[2]);
5188 as two declarations of the same function, for example. */
5189 if (processing_template_decl
5190 && !instantiation_dependent_expression_p (expr
)
5191 && potential_constant_expression (expr
))
5193 HOST_WIDE_INT saved_processing_template_decl
;
5195 saved_processing_template_decl
= processing_template_decl
;
5196 processing_template_decl
= 0;
5197 expr
= tsubst_copy_and_build (expr
,
5200 /*in_decl=*/NULL_TREE
,
5201 /*function_p=*/false,
5202 /*integral_constant_expression_p=*/true);
5203 processing_template_decl
= saved_processing_template_decl
;
5209 fold_non_dependent_expr (tree expr
)
5211 return fold_non_dependent_expr_sfinae (expr
, tf_error
);
5214 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5215 template declaration, or a TYPE_DECL for an alias declaration. */
5218 alias_type_or_template_p (tree t
)
5222 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5225 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5226 || DECL_ALIAS_TEMPLATE_P (t
));
5229 /* Return TRUE iff is a specialization of an alias template. */
5232 alias_template_specialization_p (const_tree t
)
5238 && TYPE_TEMPLATE_INFO (t
)
5239 && PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (t
))
5240 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (t
)));
5243 /* Return the number of innermost template parameters in TMPL. */
5246 num_innermost_template_parms (tree tmpl
)
5248 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5249 return TREE_VEC_LENGTH (parms
);
5252 /* Return either TMPL or another template that it is equivalent to under DR
5253 1286: An alias that just changes the name of a template is equivalent to
5254 the other template. */
5257 get_underlying_template (tree tmpl
)
5259 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5260 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5262 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5263 if (TYPE_TEMPLATE_INFO (result
))
5265 tree sub
= TYPE_TI_TEMPLATE (result
);
5266 if (PRIMARY_TEMPLATE_P (sub
)
5267 && (num_innermost_template_parms (tmpl
)
5268 == num_innermost_template_parms (sub
)))
5270 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5271 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5272 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5274 /* The alias type is equivalent to the pattern of the
5275 underlying template, so strip the alias. */
5285 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5286 must be a function or a pointer-to-function type, as specified
5287 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5288 and check that the resulting function has external linkage. */
5291 convert_nontype_argument_function (tree type
, tree expr
,
5292 tsubst_flags_t complain
)
5296 linkage_kind linkage
;
5298 fn
= instantiate_type (type
, fns
, tf_none
);
5299 if (fn
== error_mark_node
)
5300 return error_mark_node
;
5303 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5304 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5305 if (BASELINK_P (fn_no_ptr
))
5306 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5308 /* [temp.arg.nontype]/1
5310 A template-argument for a non-type, non-template template-parameter
5313 -- the address of an object or function with external [C++11: or
5314 internal] linkage. */
5316 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5318 if (complain
& tf_error
)
5320 error ("%qE is not a valid template argument for type %qT",
5322 if (TYPE_PTR_P (type
))
5323 error ("it must be the address of a function with "
5324 "external linkage");
5326 error ("it must be the name of a function with "
5327 "external linkage");
5332 linkage
= decl_linkage (fn_no_ptr
);
5333 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5335 if (complain
& tf_error
)
5337 if (cxx_dialect
>= cxx11
)
5338 error ("%qE is not a valid template argument for type %qT "
5339 "because %qD has no linkage",
5340 expr
, type
, fn_no_ptr
);
5342 error ("%qE is not a valid template argument for type %qT "
5343 "because %qD does not have external linkage",
5344 expr
, type
, fn_no_ptr
);
5352 /* Subroutine of convert_nontype_argument.
5353 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5354 Emit an error otherwise. */
5357 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5358 tsubst_flags_t complain
)
5361 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5363 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5365 if (processing_template_decl
5366 && TREE_CODE (expr
) == ADDR_EXPR
5367 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
5369 if (complain
& tf_error
)
5371 error ("%qE is not a valid template argument for type %qT",
5373 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5378 /* Returns TRUE iff the address of OP is value-dependent.
5380 14.6.2.4 [temp.dep.temp]:
5381 A non-integral non-type template-argument is dependent if its type is
5382 dependent or it has either of the following forms
5385 and contains a nested-name-specifier which specifies a class-name that
5386 names a dependent type.
5388 We generalize this to just say that the address of a member of a
5389 dependent class is value-dependent; the above doesn't cover the
5390 address of a static data member named with an unqualified-id. */
5393 has_value_dependent_address (tree op
)
5395 /* We could use get_inner_reference here, but there's no need;
5396 this is only relevant for template non-type arguments, which
5397 can only be expressed as &id-expression. */
5400 tree ctx
= CP_DECL_CONTEXT (op
);
5401 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5408 /* The next set of functions are used for providing helpful explanatory
5409 diagnostics for failed overload resolution. Their messages should be
5410 indented by two spaces for consistency with the messages in
5414 unify_success (bool /*explain_p*/)
5420 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5423 inform (input_location
,
5424 " couldn't deduce template parameter %qD", parm
);
5429 unify_invalid (bool /*explain_p*/)
5435 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5438 inform (input_location
,
5439 " types %qT and %qT have incompatible cv-qualifiers",
5445 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5448 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5453 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5456 inform (input_location
,
5457 " template parameter %qD is not a parameter pack, but "
5464 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5467 inform (input_location
,
5468 " template argument %qE does not match "
5469 "pointer-to-member constant %qE",
5475 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5478 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5483 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5486 inform (input_location
,
5487 " inconsistent parameter pack deduction with %qT and %qT",
5493 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5498 inform (input_location
,
5499 " deduced conflicting types for parameter %qT (%qT and %qT)",
5500 parm
, first
, second
);
5502 inform (input_location
,
5503 " deduced conflicting values for non-type parameter "
5504 "%qE (%qE and %qE)", parm
, first
, second
);
5510 unify_vla_arg (bool explain_p
, tree arg
)
5513 inform (input_location
,
5514 " variable-sized array type %qT is not "
5515 "a valid template argument",
5521 unify_method_type_error (bool explain_p
, tree arg
)
5524 inform (input_location
,
5525 " member function type %qT is not a valid template argument",
5531 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
5536 inform_n (input_location
, wanted
,
5537 " candidate expects at least %d argument, %d provided",
5538 " candidate expects at least %d arguments, %d provided",
5541 inform_n (input_location
, wanted
,
5542 " candidate expects %d argument, %d provided",
5543 " candidate expects %d arguments, %d provided",
5550 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5552 return unify_arity (explain_p
, have
, wanted
);
5556 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
5557 bool least_p
= false)
5559 return unify_arity (explain_p
, have
, wanted
, least_p
);
5563 unify_arg_conversion (bool explain_p
, tree to_type
,
5564 tree from_type
, tree arg
)
5567 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5568 " cannot convert %qE (type %qT) to type %qT",
5569 arg
, from_type
, to_type
);
5574 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5575 tree parm
, tree arg
)
5580 case tbr_ambiguous_baseclass
:
5581 inform (input_location
, " %qT is an ambiguous base class of %qT",
5585 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5592 unify_inconsistent_template_template_parameters (bool explain_p
)
5595 inform (input_location
,
5596 " template parameters of a template template argument are "
5597 "inconsistent with other deduced template arguments");
5602 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5605 inform (input_location
,
5606 " can't deduce a template for %qT from non-template type %qT",
5612 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5615 inform (input_location
,
5616 " template argument %qE does not match %qD", arg
, parm
);
5621 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5624 inform (input_location
,
5625 " could not resolve address from overloaded function %qE",
5630 /* Attempt to convert the non-type template parameter EXPR to the
5631 indicated TYPE. If the conversion is successful, return the
5632 converted value. If the conversion is unsuccessful, return
5633 NULL_TREE if we issued an error message, or error_mark_node if we
5634 did not. We issue error messages for out-and-out bad template
5635 parameters, but not simply because the conversion failed, since we
5636 might be just trying to do argument deduction. Both TYPE and EXPR
5637 must be non-dependent.
5639 The conversion follows the special rules described in
5640 [temp.arg.nontype], and it is much more strict than an implicit
5643 This function is called twice for each template argument (see
5644 lookup_template_class for a more accurate description of this
5645 problem). This means that we need to handle expressions which
5646 are not valid in a C++ source, but can be created from the
5647 first call (for instance, casts to perform conversions). These
5648 hacks can go away after we fix the double coercion problem. */
5651 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5655 /* Detect immediately string literals as invalid non-type argument.
5656 This special-case is not needed for correctness (we would easily
5657 catch this later), but only to provide better diagnostic for this
5658 common user mistake. As suggested by DR 100, we do not mention
5659 linkage issues in the diagnostic as this is not the point. */
5660 /* FIXME we're making this OK. */
5661 if (TREE_CODE (expr
) == STRING_CST
)
5663 if (complain
& tf_error
)
5664 error ("%qE is not a valid template argument for type %qT "
5665 "because string literals can never be used in this context",
5670 /* Add the ADDR_EXPR now for the benefit of
5671 value_dependent_expression_p. */
5672 if (TYPE_PTROBV_P (type
)
5673 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5675 expr
= decay_conversion (expr
, complain
);
5676 if (expr
== error_mark_node
)
5677 return error_mark_node
;
5680 /* If we are in a template, EXPR may be non-dependent, but still
5681 have a syntactic, rather than semantic, form. For example, EXPR
5682 might be a SCOPE_REF, rather than the VAR_DECL to which the
5683 SCOPE_REF refers. Preserving the qualifying scope is necessary
5684 so that access checking can be performed when the template is
5685 instantiated -- but here we need the resolved form so that we can
5686 convert the argument. */
5687 if (TYPE_REF_OBJ_P (type
)
5688 && has_value_dependent_address (expr
))
5689 /* If we want the address and it's value-dependent, don't fold. */;
5690 else if (!type_unknown_p (expr
))
5691 expr
= fold_non_dependent_expr_sfinae (expr
, complain
);
5692 if (error_operand_p (expr
))
5693 return error_mark_node
;
5694 expr_type
= TREE_TYPE (expr
);
5695 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5696 expr
= mark_lvalue_use (expr
);
5698 expr
= mark_rvalue_use (expr
);
5700 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5701 to a non-type argument of "nullptr". */
5702 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5703 expr
= convert (type
, expr
);
5705 /* In C++11, integral or enumeration non-type template arguments can be
5706 arbitrary constant expressions. Pointer and pointer to
5707 member arguments can be general constant expressions that evaluate
5708 to a null value, but otherwise still need to be of a specific form. */
5709 if (cxx_dialect
>= cxx11
)
5711 if (TREE_CODE (expr
) == PTRMEM_CST
)
5712 /* A PTRMEM_CST is already constant, and a valid template
5713 argument for a parameter of pointer to member type, we just want
5714 to leave it in that form rather than lower it to a
5716 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5717 expr
= maybe_constant_value (expr
);
5718 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5720 tree folded
= maybe_constant_value (expr
);
5721 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5722 : null_member_pointer_value_p (folded
))
5727 /* HACK: Due to double coercion, we can get a
5728 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5729 which is the tree that we built on the first call (see
5730 below when coercing to reference to object or to reference to
5731 function). We just strip everything and get to the arg.
5732 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5734 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5736 tree probe_type
, probe
= expr
;
5737 if (REFERENCE_REF_P (probe
))
5738 probe
= TREE_OPERAND (probe
, 0);
5739 probe_type
= TREE_TYPE (probe
);
5740 if (TREE_CODE (probe
) == NOP_EXPR
)
5742 /* ??? Maybe we could use convert_from_reference here, but we
5743 would need to relax its constraints because the NOP_EXPR
5744 could actually change the type to something more cv-qualified,
5745 and this is not folded by convert_from_reference. */
5746 tree addr
= TREE_OPERAND (probe
, 0);
5747 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5748 && TREE_CODE (addr
) == ADDR_EXPR
5749 && TYPE_PTR_P (TREE_TYPE (addr
))
5750 && (same_type_ignoring_top_level_qualifiers_p
5751 (TREE_TYPE (probe_type
),
5752 TREE_TYPE (TREE_TYPE (addr
)))))
5754 expr
= TREE_OPERAND (addr
, 0);
5755 expr_type
= TREE_TYPE (probe_type
);
5760 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5761 parameter is a pointer to object, through decay and
5762 qualification conversion. Let's strip everything. */
5763 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5767 if (TREE_CODE (probe
) == ADDR_EXPR
5768 && TYPE_PTR_P (TREE_TYPE (probe
)))
5770 /* Skip the ADDR_EXPR only if it is part of the decay for
5771 an array. Otherwise, it is part of the original argument
5772 in the source code. */
5773 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5774 probe
= TREE_OPERAND (probe
, 0);
5776 expr_type
= TREE_TYPE (expr
);
5780 /* [temp.arg.nontype]/5, bullet 1
5782 For a non-type template-parameter of integral or enumeration type,
5783 integral promotions (_conv.prom_) and integral conversions
5784 (_conv.integral_) are applied. */
5785 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5787 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5788 t
= maybe_constant_value (t
);
5789 if (t
!= error_mark_node
)
5792 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5793 return error_mark_node
;
5795 /* Notice that there are constant expressions like '4 % 0' which
5796 do not fold into integer constants. */
5797 if (TREE_CODE (expr
) != INTEGER_CST
)
5799 if (complain
& tf_error
)
5801 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
5802 if (processing_template_decl
5803 && !require_potential_constant_expression (expr
))
5805 expr
= cxx_constant_value (expr
);
5806 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
5807 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
5808 "in template argument for type %qT ", type
);
5809 if (expr
== error_mark_node
)
5811 /* else cxx_constant_value complained but gave us
5812 a real constant, so go ahead. */
5813 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
5819 /* Avoid typedef problems. */
5820 if (TREE_TYPE (expr
) != type
)
5821 expr
= fold_convert (type
, expr
);
5823 /* [temp.arg.nontype]/5, bullet 2
5825 For a non-type template-parameter of type pointer to object,
5826 qualification conversions (_conv.qual_) and the array-to-pointer
5827 conversion (_conv.array_) are applied. */
5828 else if (TYPE_PTROBV_P (type
))
5830 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5832 A template-argument for a non-type, non-template template-parameter
5833 shall be one of: [...]
5835 -- the name of a non-type template-parameter;
5836 -- the address of an object or function with external linkage, [...]
5837 expressed as "& id-expression" where the & is optional if the name
5838 refers to a function or array, or if the corresponding
5839 template-parameter is a reference.
5841 Here, we do not care about functions, as they are invalid anyway
5842 for a parameter of type pointer-to-object. */
5844 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
5845 /* Non-type template parameters are OK. */
5847 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5848 /* Null pointer values are OK in C++11. */;
5849 else if (TREE_CODE (expr
) != ADDR_EXPR
5850 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
5854 if (complain
& tf_error
)
5855 error ("%qD is not a valid template argument "
5856 "because %qD is a variable, not the address of "
5857 "a variable", expr
, expr
);
5860 if (POINTER_TYPE_P (expr_type
))
5862 if (complain
& tf_error
)
5863 error ("%qE is not a valid template argument for %qT "
5864 "because it is not the address of a variable",
5868 /* Other values, like integer constants, might be valid
5869 non-type arguments of some other type. */
5870 return error_mark_node
;
5876 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
5877 ? TREE_OPERAND (expr
, 0) : expr
);
5880 if (complain
& tf_error
)
5881 error ("%qE is not a valid template argument of type %qT "
5882 "because %qE is not a variable", expr
, type
, decl
);
5885 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
5887 if (complain
& tf_error
)
5888 error ("%qE is not a valid template argument of type %qT "
5889 "because %qD does not have external linkage",
5893 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
5895 if (complain
& tf_error
)
5896 error ("%qE is not a valid template argument of type %qT "
5897 "because %qD has no linkage", expr
, type
, decl
);
5902 expr
= decay_conversion (expr
, complain
);
5903 if (expr
== error_mark_node
)
5904 return error_mark_node
;
5906 expr
= perform_qualification_conversions (type
, expr
);
5907 if (expr
== error_mark_node
)
5908 return error_mark_node
;
5910 /* [temp.arg.nontype]/5, bullet 3
5912 For a non-type template-parameter of type reference to object, no
5913 conversions apply. The type referred to by the reference may be more
5914 cv-qualified than the (otherwise identical) type of the
5915 template-argument. The template-parameter is bound directly to the
5916 template-argument, which must be an lvalue. */
5917 else if (TYPE_REF_OBJ_P (type
))
5919 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
5921 return error_mark_node
;
5923 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
5925 if (complain
& tf_error
)
5926 error ("%qE is not a valid template argument for type %qT "
5927 "because of conflicts in cv-qualification", expr
, type
);
5931 if (!real_lvalue_p (expr
))
5933 if (complain
& tf_error
)
5934 error ("%qE is not a valid template argument for type %qT "
5935 "because it is not an lvalue", expr
, type
);
5939 /* [temp.arg.nontype]/1
5941 A template-argument for a non-type, non-template template-parameter
5942 shall be one of: [...]
5944 -- the address of an object or function with external linkage. */
5945 if (INDIRECT_REF_P (expr
)
5946 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
5948 expr
= TREE_OPERAND (expr
, 0);
5951 if (complain
& tf_error
)
5952 error ("%q#D is not a valid template argument for type %qT "
5953 "because a reference variable does not have a constant "
5954 "address", expr
, type
);
5961 if (complain
& tf_error
)
5962 error ("%qE is not a valid template argument for type %qT "
5963 "because it is not an object with external linkage",
5968 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
5970 if (complain
& tf_error
)
5971 error ("%qE is not a valid template argument for type %qT "
5972 "because object %qD has not external linkage",
5977 expr
= build_nop (type
, build_address (expr
));
5979 /* [temp.arg.nontype]/5, bullet 4
5981 For a non-type template-parameter of type pointer to function, only
5982 the function-to-pointer conversion (_conv.func_) is applied. If the
5983 template-argument represents a set of overloaded functions (or a
5984 pointer to such), the matching function is selected from the set
5986 else if (TYPE_PTRFN_P (type
))
5988 /* If the argument is a template-id, we might not have enough
5989 context information to decay the pointer. */
5990 if (!type_unknown_p (expr_type
))
5992 expr
= decay_conversion (expr
, complain
);
5993 if (expr
== error_mark_node
)
5994 return error_mark_node
;
5997 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5998 /* Null pointer values are OK in C++11. */
5999 return perform_qualification_conversions (type
, expr
);
6001 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6002 if (!expr
|| expr
== error_mark_node
)
6005 /* [temp.arg.nontype]/5, bullet 5
6007 For a non-type template-parameter of type reference to function, no
6008 conversions apply. If the template-argument represents a set of
6009 overloaded functions, the matching function is selected from the set
6011 else if (TYPE_REFFN_P (type
))
6013 if (TREE_CODE (expr
) == ADDR_EXPR
)
6015 if (complain
& tf_error
)
6017 error ("%qE is not a valid template argument for type %qT "
6018 "because it is a pointer", expr
, type
);
6019 inform (input_location
, "try using %qE instead",
6020 TREE_OPERAND (expr
, 0));
6025 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6026 if (!expr
|| expr
== error_mark_node
)
6029 expr
= build_nop (type
, build_address (expr
));
6031 /* [temp.arg.nontype]/5, bullet 6
6033 For a non-type template-parameter of type pointer to member function,
6034 no conversions apply. If the template-argument represents a set of
6035 overloaded member functions, the matching member function is selected
6036 from the set (_over.over_). */
6037 else if (TYPE_PTRMEMFUNC_P (type
))
6039 expr
= instantiate_type (type
, expr
, tf_none
);
6040 if (expr
== error_mark_node
)
6041 return error_mark_node
;
6043 /* [temp.arg.nontype] bullet 1 says the pointer to member
6044 expression must be a pointer-to-member constant. */
6045 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6046 return error_mark_node
;
6048 /* There is no way to disable standard conversions in
6049 resolve_address_of_overloaded_function (called by
6050 instantiate_type). It is possible that the call succeeded by
6051 converting &B::I to &D::I (where B is a base of D), so we need
6052 to reject this conversion here.
6054 Actually, even if there was a way to disable standard conversions,
6055 it would still be better to reject them here so that we can
6056 provide a superior diagnostic. */
6057 if (!same_type_p (TREE_TYPE (expr
), type
))
6059 if (complain
& tf_error
)
6061 error ("%qE is not a valid template argument for type %qT "
6062 "because it is of type %qT", expr
, type
,
6064 /* If we are just one standard conversion off, explain. */
6065 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6066 inform (input_location
,
6067 "standard conversions are not allowed in this context");
6072 /* [temp.arg.nontype]/5, bullet 7
6074 For a non-type template-parameter of type pointer to data member,
6075 qualification conversions (_conv.qual_) are applied. */
6076 else if (TYPE_PTRDATAMEM_P (type
))
6078 /* [temp.arg.nontype] bullet 1 says the pointer to member
6079 expression must be a pointer-to-member constant. */
6080 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6081 return error_mark_node
;
6083 expr
= perform_qualification_conversions (type
, expr
);
6084 if (expr
== error_mark_node
)
6087 else if (NULLPTR_TYPE_P (type
))
6089 if (expr
!= nullptr_node
)
6091 if (complain
& tf_error
)
6092 error ("%qE is not a valid template argument for type %qT "
6093 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6098 /* A template non-type parameter must be one of the above. */
6102 /* Sanity check: did we actually convert the argument to the
6104 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6105 (type
, TREE_TYPE (expr
)));
6109 /* Subroutine of coerce_template_template_parms, which returns 1 if
6110 PARM_PARM and ARG_PARM match using the rule for the template
6111 parameters of template template parameters. Both PARM and ARG are
6112 template parameters; the rest of the arguments are the same as for
6113 coerce_template_template_parms.
6116 coerce_template_template_parm (tree parm
,
6118 tsubst_flags_t complain
,
6122 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6123 || parm
== NULL_TREE
|| error_operand_p (parm
))
6126 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6129 switch (TREE_CODE (parm
))
6132 /* We encounter instantiations of templates like
6133 template <template <template <class> class> class TT>
6136 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6137 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6139 if (!coerce_template_template_parms
6140 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6146 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6147 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6148 /* Argument is a parameter pack but parameter is not. */
6153 /* The tsubst call is used to handle cases such as
6155 template <int> class C {};
6156 template <class T, template <T> class TT> class D {};
6159 i.e. the parameter list of TT depends on earlier parameters. */
6160 if (!uses_template_parms (TREE_TYPE (arg
))
6162 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6166 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6167 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6168 /* Argument is a parameter pack but parameter is not. */
6181 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6182 template template parameters. Both PARM_PARMS and ARG_PARMS are
6183 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6186 Consider the example:
6187 template <class T> class A;
6188 template<template <class U> class TT> class B;
6190 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6191 the parameters to A, and OUTER_ARGS contains A. */
6194 coerce_template_template_parms (tree parm_parms
,
6196 tsubst_flags_t complain
,
6200 int nparms
, nargs
, i
;
6204 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6205 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6207 nparms
= TREE_VEC_LENGTH (parm_parms
);
6208 nargs
= TREE_VEC_LENGTH (arg_parms
);
6210 /* Determine whether we have a parameter pack at the end of the
6211 template template parameter's template parameter list. */
6212 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6214 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6216 if (error_operand_p (parm
))
6219 switch (TREE_CODE (parm
))
6223 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6228 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6238 && !(variadic_p
&& nargs
>= nparms
- 1))
6241 /* Check all of the template parameters except the parameter pack at
6242 the end (if any). */
6243 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6245 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6246 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6249 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6250 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6252 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6260 /* Check each of the template parameters in the template
6261 argument against the template parameter pack at the end of
6262 the template template parameter. */
6263 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6266 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6268 for (; i
< nargs
; ++i
)
6270 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6273 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6275 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6284 /* Verifies that the deduced template arguments (in TARGS) for the
6285 template template parameters (in TPARMS) represent valid bindings,
6286 by comparing the template parameter list of each template argument
6287 to the template parameter list of its corresponding template
6288 template parameter, in accordance with DR150. This
6289 routine can only be called after all template arguments have been
6290 deduced. It will return TRUE if all of the template template
6291 parameter bindings are okay, FALSE otherwise. */
6293 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6295 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6298 /* We're dealing with template parms in this process. */
6299 ++processing_template_decl
;
6301 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6303 for (i
= 0; i
< ntparms
; ++i
)
6305 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6306 tree targ
= TREE_VEC_ELT (targs
, i
);
6308 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6310 tree packed_args
= NULL_TREE
;
6313 if (ARGUMENT_PACK_P (targ
))
6315 /* Look inside the argument pack. */
6316 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6317 len
= TREE_VEC_LENGTH (packed_args
);
6320 for (idx
= 0; idx
< len
; ++idx
)
6322 tree targ_parms
= NULL_TREE
;
6325 /* Extract the next argument from the argument
6327 targ
= TREE_VEC_ELT (packed_args
, idx
);
6329 if (PACK_EXPANSION_P (targ
))
6330 /* Look at the pattern of the pack expansion. */
6331 targ
= PACK_EXPANSION_PATTERN (targ
);
6333 /* Extract the template parameters from the template
6335 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6336 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6337 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6338 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6340 /* Verify that we can coerce the template template
6341 parameters from the template argument to the template
6342 parameter. This requires an exact match. */
6344 && !coerce_template_template_parms
6345 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6360 --processing_template_decl
;
6364 /* Since type attributes aren't mangled, we need to strip them from
6365 template type arguments. */
6368 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6371 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6373 mv
= TYPE_MAIN_VARIANT (arg
);
6374 arg
= strip_typedefs (arg
);
6375 if (TYPE_ALIGN (arg
) != TYPE_ALIGN (mv
)
6376 || TYPE_ATTRIBUTES (arg
) != TYPE_ATTRIBUTES (mv
))
6378 if (complain
& tf_warning
)
6379 warning (0, "ignoring attributes on template argument %qT", arg
);
6380 arg
= build_aligned_type (arg
, TYPE_ALIGN (mv
));
6381 arg
= cp_build_type_attribute_variant (arg
, TYPE_ATTRIBUTES (mv
));
6386 /* Convert the indicated template ARG as necessary to match the
6387 indicated template PARM. Returns the converted ARG, or
6388 error_mark_node if the conversion was unsuccessful. Error and
6389 warning messages are issued under control of COMPLAIN. This
6390 conversion is for the Ith parameter in the parameter list. ARGS is
6391 the full set of template arguments deduced so far. */
6394 convert_template_argument (tree parm
,
6397 tsubst_flags_t complain
,
6403 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6405 if (TREE_CODE (arg
) == TREE_LIST
6406 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6408 /* The template argument was the name of some
6409 member function. That's usually
6410 invalid, but static members are OK. In any
6411 case, grab the underlying fields/functions
6412 and issue an error later if required. */
6413 orig_arg
= TREE_VALUE (arg
);
6414 TREE_TYPE (arg
) = unknown_type_node
;
6419 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6420 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6421 || requires_tmpl_type
);
6423 /* When determining whether an argument pack expansion is a template,
6424 look at the pattern. */
6425 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6426 arg
= PACK_EXPANSION_PATTERN (arg
);
6428 /* Deal with an injected-class-name used as a template template arg. */
6429 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6431 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6432 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6434 if (cxx_dialect
>= cxx11
)
6435 /* OK under DR 1004. */;
6436 else if (complain
& tf_warning_or_error
)
6437 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6438 " used as template template argument", TYPE_NAME (arg
));
6439 else if (flag_pedantic_errors
)
6447 ((TREE_CODE (arg
) == TEMPLATE_DECL
6448 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6449 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6450 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6451 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6454 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6455 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6456 arg
= TYPE_STUB_DECL (arg
);
6458 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6460 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6461 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6463 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6465 if (complain
& tf_error
)
6466 error ("invalid use of destructor %qE as a type", orig_arg
);
6467 return error_mark_node
;
6470 permerror (input_location
,
6471 "to refer to a type member of a template parameter, "
6472 "use %<typename %E%>", orig_arg
);
6474 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6475 TREE_OPERAND (arg
, 1),
6481 if (is_type
!= requires_type
)
6485 if (complain
& tf_error
)
6487 error ("type/value mismatch at argument %d in template "
6488 "parameter list for %qD",
6491 inform (input_location
,
6492 " expected a constant of type %qT, got %qT",
6494 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6495 else if (requires_tmpl_type
)
6496 inform (input_location
,
6497 " expected a class template, got %qE", orig_arg
);
6499 inform (input_location
,
6500 " expected a type, got %qE", orig_arg
);
6503 return error_mark_node
;
6505 if (is_tmpl_type
^ requires_tmpl_type
)
6507 if (in_decl
&& (complain
& tf_error
))
6509 error ("type/value mismatch at argument %d in template "
6510 "parameter list for %qD",
6513 inform (input_location
,
6514 " expected a type, got %qT", DECL_NAME (arg
));
6516 inform (input_location
,
6517 " expected a class template, got %qT", orig_arg
);
6519 return error_mark_node
;
6524 if (requires_tmpl_type
)
6526 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6528 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6529 /* The number of argument required is not known yet.
6530 Just accept it for now. */
6531 val
= TREE_TYPE (arg
);
6534 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6537 /* Strip alias templates that are equivalent to another
6539 arg
= get_underlying_template (arg
);
6540 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6542 if (coerce_template_template_parms (parmparm
, argparm
,
6548 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6550 if (val
!= error_mark_node
)
6552 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6553 val
= TREE_TYPE (val
);
6554 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6555 val
= make_pack_expansion (val
);
6560 if (in_decl
&& (complain
& tf_error
))
6562 error ("type/value mismatch at argument %d in "
6563 "template parameter list for %qD",
6565 inform (input_location
,
6566 " expected a template of type %qD, got %qT",
6570 val
= error_mark_node
;
6576 /* We only form one instance of each template specialization.
6577 Therefore, if we use a non-canonical variant (i.e., a
6578 typedef), any future messages referring to the type will use
6579 the typedef, which is confusing if those future uses do not
6580 themselves also use the typedef. */
6582 val
= canonicalize_type_argument (val
, complain
);
6586 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6588 if (invalid_nontype_parm_type_p (t
, complain
))
6589 return error_mark_node
;
6591 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6593 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6597 /* Not sure if this is reachable, but it doesn't hurt
6599 error ("type mismatch in nontype parameter pack");
6600 val
= error_mark_node
;
6603 else if (!dependent_template_arg_p (orig_arg
)
6604 && !uses_template_parms (t
))
6605 /* We used to call digest_init here. However, digest_init
6606 will report errors, which we don't want when complain
6607 is zero. More importantly, digest_init will try too
6608 hard to convert things: for example, `0' should not be
6609 converted to pointer type at this point according to
6610 the standard. Accepting this is not merely an
6611 extension, since deciding whether or not these
6612 conversions can occur is part of determining which
6613 function template to call, or whether a given explicit
6614 argument specification is valid. */
6615 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6617 val
= strip_typedefs_expr (orig_arg
);
6619 if (val
== NULL_TREE
)
6620 val
= error_mark_node
;
6621 else if (val
== error_mark_node
&& (complain
& tf_error
))
6622 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6624 if (TREE_CODE (val
) == SCOPE_REF
)
6626 /* Strip typedefs from the SCOPE_REF. */
6627 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6628 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6630 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6631 QUALIFIED_NAME_IS_TEMPLATE (val
));
6638 /* Coerces the remaining template arguments in INNER_ARGS (from
6639 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6640 Returns the coerced argument pack. PARM_IDX is the position of this
6641 parameter in the template parameter list. ARGS is the original
6642 template argument list. */
6644 coerce_template_parameter_pack (tree parms
,
6652 tsubst_flags_t complain
)
6654 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6655 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6658 tree packed_parms
= NULL_TREE
;
6660 if (arg_idx
> nargs
)
6663 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6665 /* When the template parameter is a non-type template parameter pack
6666 or template template parameter pack whose type or template
6667 parameters use parameter packs, we know exactly how many arguments
6668 we are looking for. Build a vector of the instantiated decls for
6669 these template parameters in PACKED_PARMS. */
6670 /* We can't use make_pack_expansion here because it would interpret a
6671 _DECL as a use rather than a declaration. */
6672 tree decl
= TREE_VALUE (parm
);
6673 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6674 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6675 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6676 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6678 TREE_VEC_LENGTH (args
)--;
6679 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6680 TREE_VEC_LENGTH (args
)++;
6682 if (packed_parms
== error_mark_node
)
6683 return error_mark_node
;
6685 /* If we're doing a partial instantiation of a member template,
6686 verify that all of the types used for the non-type
6687 template parameter pack are, in fact, valid for non-type
6688 template parameters. */
6690 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6692 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6693 for (j
= 0; j
< len
; ++j
)
6695 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6696 if (invalid_nontype_parm_type_p (t
, complain
))
6697 return error_mark_node
;
6701 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6704 packed_args
= make_tree_vec (nargs
- arg_idx
);
6706 /* Convert the remaining arguments, which will be a part of the
6707 parameter pack "parm". */
6708 for (; arg_idx
< nargs
; ++arg_idx
)
6710 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6711 tree actual_parm
= TREE_VALUE (parm
);
6712 int pack_idx
= arg_idx
- parm_idx
;
6716 /* Once we've packed as many args as we have types, stop. */
6717 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6719 else if (PACK_EXPANSION_P (arg
))
6720 /* We don't know how many args we have yet, just
6721 use the unconverted ones for now. */
6724 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6727 if (arg
== error_mark_node
)
6729 if (complain
& tf_error
)
6730 error ("template argument %d is invalid", arg_idx
+ 1);
6733 arg
= convert_template_argument (actual_parm
,
6734 arg
, new_args
, complain
, parm_idx
,
6736 if (arg
== error_mark_node
)
6738 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6741 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6742 && TREE_VEC_LENGTH (packed_args
) > 0)
6744 if (complain
& tf_error
)
6745 error ("wrong number of template arguments (%d, should be %d)",
6746 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6747 return error_mark_node
;
6750 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6751 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6752 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6755 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6756 TREE_TYPE (argument_pack
)
6757 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6758 TREE_CONSTANT (argument_pack
) = 1;
6761 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6762 #ifdef ENABLE_CHECKING
6763 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6764 TREE_VEC_LENGTH (packed_args
));
6766 return argument_pack
;
6769 /* Returns the number of pack expansions in the template argument vector
6773 pack_expansion_args_count (tree args
)
6778 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6780 tree elt
= TREE_VEC_ELT (args
, i
);
6781 if (elt
&& PACK_EXPANSION_P (elt
))
6787 /* Convert all template arguments to their appropriate types, and
6788 return a vector containing the innermost resulting template
6789 arguments. If any error occurs, return error_mark_node. Error and
6790 warning messages are issued under control of COMPLAIN.
6792 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6793 for arguments not specified in ARGS. Otherwise, if
6794 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6795 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6796 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6800 coerce_template_parms (tree parms
,
6803 tsubst_flags_t complain
,
6804 bool require_all_args
,
6805 bool use_default_args
)
6807 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6808 tree orig_inner_args
;
6811 tree new_inner_args
;
6812 int saved_unevaluated_operand
;
6813 int saved_inhibit_evaluation_warnings
;
6815 /* When used as a boolean value, indicates whether this is a
6816 variadic template parameter list. Since it's an int, we can also
6817 subtract it from nparms to get the number of non-variadic
6820 int variadic_args_p
= 0;
6821 int post_variadic_parms
= 0;
6823 if (args
== error_mark_node
)
6824 return error_mark_node
;
6826 nparms
= TREE_VEC_LENGTH (parms
);
6828 /* Determine if there are any parameter packs. */
6829 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
6831 tree tparm
= TREE_VALUE (TREE_VEC_ELT (parms
, parm_idx
));
6833 ++post_variadic_parms
;
6834 if (template_parameter_pack_p (tparm
))
6838 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
6839 /* If there are no parameters that follow a parameter pack, we need to
6840 expand any argument packs so that we can deduce a parameter pack from
6841 some non-packed args followed by an argument pack, as in variadic85.C.
6842 If there are such parameters, we need to leave argument packs intact
6843 so the arguments are assigned properly. This can happen when dealing
6844 with a nested class inside a partial specialization of a class
6845 template, as in variadic92.C, or when deducing a template parameter pack
6846 from a sub-declarator, as in variadic114.C. */
6847 if (!post_variadic_parms
)
6848 inner_args
= expand_template_argument_pack (inner_args
);
6850 /* Count any pack expansion args. */
6851 variadic_args_p
= pack_expansion_args_count (inner_args
);
6853 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6854 if ((nargs
> nparms
&& !variadic_p
)
6855 || (nargs
< nparms
- variadic_p
6858 && (!use_default_args
6859 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
6860 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
6862 if (complain
& tf_error
)
6866 nparms
-= variadic_p
;
6867 error ("wrong number of template arguments "
6868 "(%d, should be %d or more)", nargs
, nparms
);
6871 error ("wrong number of template arguments "
6872 "(%d, should be %d)", nargs
, nparms
);
6875 error ("provided for %q+D", in_decl
);
6878 return error_mark_node
;
6880 /* We can't pass a pack expansion to a non-pack parameter of an alias
6881 template (DR 1430). */
6882 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
6884 && nargs
- variadic_args_p
< nparms
- variadic_p
)
6886 if (complain
& tf_error
)
6888 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
6890 tree arg
= TREE_VEC_ELT (inner_args
, i
);
6891 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
6893 if (PACK_EXPANSION_P (arg
)
6894 && !template_parameter_pack_p (parm
))
6896 error ("pack expansion argument for non-pack parameter "
6897 "%qD of alias template %qD", parm
, in_decl
);
6898 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
6905 return error_mark_node
;
6908 /* We need to evaluate the template arguments, even though this
6909 template-id may be nested within a "sizeof". */
6910 saved_unevaluated_operand
= cp_unevaluated_operand
;
6911 cp_unevaluated_operand
= 0;
6912 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6913 c_inhibit_evaluation_warnings
= 0;
6914 new_inner_args
= make_tree_vec (nparms
);
6915 new_args
= add_outermost_template_args (args
, new_inner_args
);
6916 int pack_adjust
= 0;
6917 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
6922 /* Get the Ith template parameter. */
6923 parm
= TREE_VEC_ELT (parms
, parm_idx
);
6925 if (parm
== error_mark_node
)
6927 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
6931 /* Calculate the next argument. */
6932 if (arg_idx
< nargs
)
6933 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6937 if (template_parameter_pack_p (TREE_VALUE (parm
))
6938 && !(arg
&& ARGUMENT_PACK_P (arg
)))
6940 /* Some arguments will be placed in the
6941 template parameter pack PARM. */
6942 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
6943 inner_args
, arg_idx
,
6947 if (arg
== NULL_TREE
)
6949 /* We don't know how many args we have yet, just use the
6950 unconverted (and still packed) ones for now. */
6951 new_inner_args
= orig_inner_args
;
6956 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
6958 /* Store this argument. */
6959 if (arg
== error_mark_node
)
6962 /* We are done with all of the arguments. */
6967 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
6968 arg_idx
+= pack_adjust
;
6975 if (PACK_EXPANSION_P (arg
))
6977 /* "If every valid specialization of a variadic template
6978 requires an empty template parameter pack, the template is
6979 ill-formed, no diagnostic required." So check that the
6980 pattern works with this parameter. */
6981 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
6982 tree conv
= convert_template_argument (TREE_VALUE (parm
),
6986 if (conv
== error_mark_node
)
6988 inform (input_location
, "so any instantiation with a "
6989 "non-empty parameter pack would be ill-formed");
6992 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
6993 /* Recover from missing typename. */
6994 TREE_VEC_ELT (inner_args
, arg_idx
)
6995 = make_pack_expansion (conv
);
6997 /* We don't know how many args we have yet, just
6998 use the unconverted ones for now. */
6999 new_inner_args
= inner_args
;
7004 else if (require_all_args
)
7006 /* There must be a default arg in this case. */
7007 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
7009 /* The position of the first default template argument,
7010 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7012 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7013 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7014 arg_idx
- pack_adjust
);
7019 if (arg
== error_mark_node
)
7021 if (complain
& tf_error
)
7022 error ("template argument %d is invalid", arg_idx
+ 1);
7025 /* This only occurs if there was an error in the template
7026 parameter list itself (which we would already have
7027 reported) that we are trying to recover from, e.g., a class
7028 template with a parameter list such as
7029 template<typename..., typename>. */
7032 arg
= convert_template_argument (TREE_VALUE (parm
),
7033 arg
, new_args
, complain
,
7036 if (arg
== error_mark_node
)
7038 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7040 cp_unevaluated_operand
= saved_unevaluated_operand
;
7041 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7043 if (variadic_p
&& arg_idx
< nargs
)
7045 if (complain
& tf_error
)
7047 error ("wrong number of template arguments "
7048 "(%d, should be %d)", nargs
, arg_idx
);
7050 error ("provided for %q+D", in_decl
);
7052 return error_mark_node
;
7056 return error_mark_node
;
7058 #ifdef ENABLE_CHECKING
7059 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7060 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7061 TREE_VEC_LENGTH (new_inner_args
));
7064 return new_inner_args
;
7067 /* Like coerce_template_parms. If PARMS represents all template
7068 parameters levels, this function returns a vector of vectors
7069 representing all the resulting argument levels. Note that in this
7070 case, only the innermost arguments are coerced because the
7071 outermost ones are supposed to have been coerced already.
7073 Otherwise, if PARMS represents only (the innermost) vector of
7074 parameters, this function returns a vector containing just the
7075 innermost resulting arguments. */
7078 coerce_innermost_template_parms (tree parms
,
7081 tsubst_flags_t complain
,
7082 bool require_all_args
,
7083 bool use_default_args
)
7085 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7086 int args_depth
= TMPL_ARGS_DEPTH (args
);
7089 if (parms_depth
> 1)
7091 coerced_args
= make_tree_vec (parms_depth
);
7095 for (level
= parms
, cur_depth
= parms_depth
;
7096 parms_depth
> 0 && level
!= NULL_TREE
;
7097 level
= TREE_CHAIN (level
), --cur_depth
)
7100 if (cur_depth
== args_depth
)
7101 l
= coerce_template_parms (TREE_VALUE (level
),
7102 args
, in_decl
, complain
,
7106 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7108 if (l
== error_mark_node
)
7109 return error_mark_node
;
7111 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7115 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7116 args
, in_decl
, complain
,
7119 return coerced_args
;
7122 /* Returns 1 if template args OT and NT are equivalent. */
7125 template_args_equal (tree ot
, tree nt
)
7129 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7132 if (TREE_CODE (nt
) == TREE_VEC
)
7133 /* For member templates */
7134 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7135 else if (PACK_EXPANSION_P (ot
))
7136 return (PACK_EXPANSION_P (nt
)
7137 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7138 PACK_EXPANSION_PATTERN (nt
))
7139 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7140 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7141 else if (ARGUMENT_PACK_P (ot
))
7146 if (!ARGUMENT_PACK_P (nt
))
7149 opack
= ARGUMENT_PACK_ARGS (ot
);
7150 npack
= ARGUMENT_PACK_ARGS (nt
);
7151 len
= TREE_VEC_LENGTH (opack
);
7152 if (TREE_VEC_LENGTH (npack
) != len
)
7154 for (i
= 0; i
< len
; ++i
)
7155 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7156 TREE_VEC_ELT (npack
, i
)))
7160 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7162 /* We get here probably because we are in the middle of substituting
7163 into the pattern of a pack expansion. In that case the
7164 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7165 interested in. So we want to use the initial pack argument for
7167 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7168 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7169 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7170 return template_args_equal (ot
, nt
);
7172 else if (TYPE_P (nt
))
7173 return TYPE_P (ot
) && same_type_p (ot
, nt
);
7174 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7177 return cp_tree_equal (ot
, nt
);
7180 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7181 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7182 NEWARG_PTR with the offending arguments if they are non-NULL. */
7185 comp_template_args_with_info (tree oldargs
, tree newargs
,
7186 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7190 if (oldargs
== newargs
)
7193 if (!oldargs
|| !newargs
)
7196 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7199 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7201 tree nt
= TREE_VEC_ELT (newargs
, i
);
7202 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7204 if (! template_args_equal (ot
, nt
))
7206 if (oldarg_ptr
!= NULL
)
7208 if (newarg_ptr
!= NULL
)
7216 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7217 of template arguments. Returns 0 otherwise. */
7220 comp_template_args (tree oldargs
, tree newargs
)
7222 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7226 add_pending_template (tree d
)
7228 tree ti
= (TYPE_P (d
)
7229 ? CLASSTYPE_TEMPLATE_INFO (d
)
7230 : DECL_TEMPLATE_INFO (d
));
7231 struct pending_template
*pt
;
7234 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7237 /* We are called both from instantiate_decl, where we've already had a
7238 tinst_level pushed, and instantiate_template, where we haven't.
7240 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7243 push_tinst_level (d
);
7245 pt
= ggc_alloc
<pending_template
> ();
7247 pt
->tinst
= current_tinst_level
;
7248 if (last_pending_template
)
7249 last_pending_template
->next
= pt
;
7251 pending_templates
= pt
;
7253 last_pending_template
= pt
;
7255 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7262 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7263 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7264 documentation for TEMPLATE_ID_EXPR. */
7267 lookup_template_function (tree fns
, tree arglist
)
7271 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7272 return error_mark_node
;
7274 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7276 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7278 error ("%q#D is not a function template", fns
);
7279 return error_mark_node
;
7282 if (BASELINK_P (fns
))
7284 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7286 BASELINK_FUNCTIONS (fns
),
7291 type
= TREE_TYPE (fns
);
7292 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7293 type
= unknown_type_node
;
7295 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7298 /* Within the scope of a template class S<T>, the name S gets bound
7299 (in build_self_reference) to a TYPE_DECL for the class, not a
7300 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7301 or one of its enclosing classes, and that type is a template,
7302 return the associated TEMPLATE_DECL. Otherwise, the original
7305 Also handle the case when DECL is a TREE_LIST of ambiguous
7306 injected-class-names from different bases. */
7309 maybe_get_template_decl_from_type_decl (tree decl
)
7311 if (decl
== NULL_TREE
)
7314 /* DR 176: A lookup that finds an injected-class-name (10.2
7315 [class.member.lookup]) can result in an ambiguity in certain cases
7316 (for example, if it is found in more than one base class). If all of
7317 the injected-class-names that are found refer to specializations of
7318 the same class template, and if the name is followed by a
7319 template-argument-list, the reference refers to the class template
7320 itself and not a specialization thereof, and is not ambiguous. */
7321 if (TREE_CODE (decl
) == TREE_LIST
)
7323 tree t
, tmpl
= NULL_TREE
;
7324 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7326 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7329 else if (tmpl
!= elt
)
7332 if (tmpl
&& t
== NULL_TREE
)
7338 return (decl
!= NULL_TREE
7339 && DECL_SELF_REFERENCE_P (decl
)
7340 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7341 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7344 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7345 parameters, find the desired type.
7347 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7349 IN_DECL, if non-NULL, is the template declaration we are trying to
7352 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7353 the class we are looking up.
7355 Issue error and warning messages under control of COMPLAIN.
7357 If the template class is really a local class in a template
7358 function, then the FUNCTION_CONTEXT is the function in which it is
7361 ??? Note that this function is currently called *twice* for each
7362 template-id: the first time from the parser, while creating the
7363 incomplete type (finish_template_type), and the second type during the
7364 real instantiation (instantiate_template_class). This is surely something
7365 that we want to avoid. It also causes some problems with argument
7366 coercion (see convert_nontype_argument for more information on this). */
7369 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7370 int entering_scope
, tsubst_flags_t complain
)
7372 tree templ
= NULL_TREE
, parmlist
;
7379 if (identifier_p (d1
))
7381 tree value
= innermost_non_namespace_value (d1
);
7382 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7387 push_decl_namespace (context
);
7388 templ
= lookup_name (d1
);
7389 templ
= maybe_get_template_decl_from_type_decl (templ
);
7391 pop_decl_namespace ();
7394 context
= DECL_CONTEXT (templ
);
7396 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7398 tree type
= TREE_TYPE (d1
);
7400 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7401 an implicit typename for the second A. Deal with it. */
7402 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7403 type
= TREE_TYPE (type
);
7405 if (CLASSTYPE_TEMPLATE_INFO (type
))
7407 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7408 d1
= DECL_NAME (templ
);
7411 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7412 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7414 templ
= TYPE_TI_TEMPLATE (d1
);
7415 d1
= DECL_NAME (templ
);
7417 else if (DECL_TYPE_TEMPLATE_P (d1
))
7420 d1
= DECL_NAME (templ
);
7421 context
= DECL_CONTEXT (templ
);
7423 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7426 d1
= DECL_NAME (templ
);
7429 /* Issue an error message if we didn't find a template. */
7432 if (complain
& tf_error
)
7433 error ("%qT is not a template", d1
);
7434 return error_mark_node
;
7437 if (TREE_CODE (templ
) != TEMPLATE_DECL
7438 /* Make sure it's a user visible template, if it was named by
7440 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7441 && !PRIMARY_TEMPLATE_P (templ
)))
7443 if (complain
& tf_error
)
7445 error ("non-template type %qT used as a template", d1
);
7447 error ("for template declaration %q+D", in_decl
);
7449 return error_mark_node
;
7452 complain
&= ~tf_user
;
7454 /* An alias that just changes the name of a template is equivalent to the
7455 other template, so if any of the arguments are pack expansions, strip
7456 the alias to avoid problems with a pack expansion passed to a non-pack
7457 alias template parameter (DR 1430). */
7458 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7459 templ
= get_underlying_template (templ
);
7461 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7463 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7464 template arguments */
7470 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7472 /* Consider an example where a template template parameter declared as
7474 template <class T, class U = std::allocator<T> > class TT
7476 The template parameter level of T and U are one level larger than
7477 of TT. To proper process the default argument of U, say when an
7478 instantiation `TT<int>' is seen, we need to build the full
7479 arguments containing {int} as the innermost level. Outer levels,
7480 available when not appearing as default template argument, can be
7481 obtained from the arguments of the enclosing template.
7483 Suppose that TT is later substituted with std::vector. The above
7484 instantiation is `TT<int, std::allocator<T> >' with TT at
7485 level 1, and T at level 2, while the template arguments at level 1
7486 becomes {std::vector} and the inner level 2 is {int}. */
7488 outer
= DECL_CONTEXT (templ
);
7490 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7491 else if (current_template_parms
)
7492 /* This is an argument of the current template, so we haven't set
7493 DECL_CONTEXT yet. */
7494 outer
= current_template_args ();
7497 arglist
= add_to_template_args (outer
, arglist
);
7499 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7501 /*require_all_args=*/true,
7502 /*use_default_args=*/true);
7503 if (arglist2
== error_mark_node
7504 || (!uses_template_parms (arglist2
)
7505 && check_instantiated_args (templ
, arglist2
, complain
)))
7506 return error_mark_node
;
7508 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7513 tree template_type
= TREE_TYPE (templ
);
7516 tree found
= NULL_TREE
;
7519 int is_dependent_type
;
7520 int use_partial_inst_tmpl
= false;
7522 if (template_type
== error_mark_node
)
7523 /* An error occurred while building the template TEMPL, and a
7524 diagnostic has most certainly been emitted for that
7525 already. Let's propagate that error. */
7526 return error_mark_node
;
7528 gen_tmpl
= most_general_template (templ
);
7529 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7530 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7531 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7533 if (arg_depth
== 1 && parm_depth
> 1)
7535 /* We've been given an incomplete set of template arguments.
7538 template <class T> struct S1 {
7539 template <class U> struct S2 {};
7540 template <class U> struct S2<U*> {};
7543 we will be called with an ARGLIST of `U*', but the
7544 TEMPLATE will be `template <class T> template
7545 <class U> struct S1<T>::S2'. We must fill in the missing
7548 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7550 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7553 /* Now we should have enough arguments. */
7554 gcc_assert (parm_depth
== arg_depth
);
7556 /* From here on, we're only interested in the most general
7559 /* Calculate the BOUND_ARGS. These will be the args that are
7560 actually tsubst'd into the definition to create the
7564 /* We have multiple levels of arguments to coerce, at once. */
7566 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
7568 tree bound_args
= make_tree_vec (parm_depth
);
7570 for (i
= saved_depth
,
7571 t
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7572 i
> 0 && t
!= NULL_TREE
;
7573 --i
, t
= TREE_CHAIN (t
))
7576 if (i
== saved_depth
)
7577 a
= coerce_template_parms (TREE_VALUE (t
),
7580 /*require_all_args=*/true,
7581 /*use_default_args=*/true);
7583 /* Outer levels should have already been coerced. */
7584 a
= TMPL_ARGS_LEVEL (arglist
, i
);
7586 /* Don't process further if one of the levels fails. */
7587 if (a
== error_mark_node
)
7589 /* Restore the ARGLIST to its full size. */
7590 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7591 return error_mark_node
;
7594 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
7596 /* We temporarily reduce the length of the ARGLIST so
7597 that coerce_template_parms will see only the arguments
7598 corresponding to the template parameters it is
7600 TREE_VEC_LENGTH (arglist
)--;
7603 /* Restore the ARGLIST to its full size. */
7604 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7606 arglist
= bound_args
;
7610 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
7611 INNERMOST_TEMPLATE_ARGS (arglist
),
7614 /*require_all_args=*/true,
7615 /*use_default_args=*/true);
7617 if (arglist
== error_mark_node
)
7618 /* We were unable to bind the arguments. */
7619 return error_mark_node
;
7621 /* In the scope of a template class, explicit references to the
7622 template class refer to the type of the template, not any
7623 instantiation of it. For example, in:
7625 template <class T> class C { void f(C<T>); }
7627 the `C<T>' is just the same as `C'. Outside of the
7628 class, however, such a reference is an instantiation. */
7630 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7631 || currently_open_class (template_type
))
7632 /* comp_template_args is expensive, check it last. */
7633 && comp_template_args (TYPE_TI_ARGS (template_type
),
7635 return template_type
;
7637 /* If we already have this specialization, return it. */
7638 elt
.tmpl
= gen_tmpl
;
7640 hash
= hash_specialization (&elt
);
7641 entry
= (spec_entry
*) htab_find_with_hash (type_specializations
,
7647 is_dependent_type
= uses_template_parms (arglist
);
7649 /* If the deduced arguments are invalid, then the binding
7651 if (!is_dependent_type
7652 && check_instantiated_args (gen_tmpl
,
7653 INNERMOST_TEMPLATE_ARGS (arglist
),
7655 return error_mark_node
;
7657 if (!is_dependent_type
7658 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7659 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7660 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7662 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7663 DECL_NAME (gen_tmpl
),
7664 /*tag_scope=*/ts_global
);
7668 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7670 if (context
== error_mark_node
)
7671 return error_mark_node
;
7674 context
= global_namespace
;
7676 /* Create the type. */
7677 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7679 /* The user referred to a specialization of an alias
7680 template represented by GEN_TMPL.
7682 [temp.alias]/2 says:
7684 When a template-id refers to the specialization of an
7685 alias template, it is equivalent to the associated
7686 type obtained by substitution of its
7687 template-arguments for the template-parameters in the
7688 type-id of the alias template. */
7690 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7691 /* Note that the call above (by indirectly calling
7692 register_specialization in tsubst_decl) registers the
7693 TYPE_DECL representing the specialization of the alias
7694 template. So next time someone substitutes ARGLIST for
7695 the template parms into the alias template (GEN_TMPL),
7696 she'll get that TYPE_DECL back. */
7698 if (t
== error_mark_node
)
7701 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7703 if (!is_dependent_type
)
7705 set_current_access_from_decl (TYPE_NAME (template_type
));
7706 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7707 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7708 arglist
, complain
, in_decl
),
7709 SCOPED_ENUM_P (template_type
), NULL
);
7711 if (t
== error_mark_node
)
7716 /* We don't want to call start_enum for this type, since
7717 the values for the enumeration constants may involve
7718 template parameters. And, no one should be interested
7719 in the enumeration constants for such a type. */
7720 t
= cxx_make_type (ENUMERAL_TYPE
);
7721 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7723 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7724 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7725 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7727 else if (CLASS_TYPE_P (template_type
))
7729 t
= make_class_type (TREE_CODE (template_type
));
7730 CLASSTYPE_DECLARED_CLASS (t
)
7731 = CLASSTYPE_DECLARED_CLASS (template_type
);
7732 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7733 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7735 /* A local class. Make sure the decl gets registered properly. */
7736 if (context
== current_function_decl
)
7737 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7739 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7740 /* This instantiation is another name for the primary
7741 template type. Set the TYPE_CANONICAL field
7743 TYPE_CANONICAL (t
) = template_type
;
7744 else if (any_template_arguments_need_structural_equality_p (arglist
))
7745 /* Some of the template arguments require structural
7746 equality testing, so this template class requires
7747 structural equality testing. */
7748 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7753 /* If we called start_enum or pushtag above, this information
7754 will already be set up. */
7757 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7759 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7760 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7761 DECL_SOURCE_LOCATION (type_decl
)
7762 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7765 type_decl
= TYPE_NAME (t
);
7767 if (CLASS_TYPE_P (template_type
))
7769 TREE_PRIVATE (type_decl
)
7770 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7771 TREE_PROTECTED (type_decl
)
7772 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7773 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7775 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7776 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7780 /* Let's consider the explicit specialization of a member
7781 of a class template specialization that is implicitly instantiated,
7786 template<class U> struct M {}; //#0
7791 struct S<int>::M<char> //#1
7795 [temp.expl.spec]/4 says this is valid.
7797 In this case, when we write:
7800 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7803 When we encounter #1, we want to store the partial instantiation
7804 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7806 For all cases other than this "explicit specialization of member of a
7807 class template", we just want to store the most general template into
7808 the CLASSTYPE_TI_TEMPLATE of M.
7810 This case of "explicit specialization of member of a class template"
7812 1/ the enclosing class is an instantiation of, and therefore not
7813 the same as, the context of the most general template, and
7814 2/ we aren't looking at the partial instantiation itself, i.e.
7815 the innermost arguments are not the same as the innermost parms of
7816 the most general template.
7818 So it's only when 1/ and 2/ happens that we want to use the partial
7819 instantiation of the member template in lieu of its most general
7822 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
7823 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
7824 /* the enclosing class must be an instantiation... */
7825 && CLASS_TYPE_P (context
)
7826 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
7828 tree partial_inst_args
;
7829 TREE_VEC_LENGTH (arglist
)--;
7830 ++processing_template_decl
;
7832 tsubst (INNERMOST_TEMPLATE_ARGS
7833 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
7834 arglist
, complain
, NULL_TREE
);
7835 --processing_template_decl
;
7836 TREE_VEC_LENGTH (arglist
)++;
7837 use_partial_inst_tmpl
=
7838 /*...and we must not be looking at the partial instantiation
7840 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
7844 if (!use_partial_inst_tmpl
)
7845 /* This case is easy; there are no member templates involved. */
7849 /* This is a full instantiation of a member template. Find
7850 the partial instantiation of which this is an instance. */
7852 /* Temporarily reduce by one the number of levels in the ARGLIST
7853 so as to avoid comparing the last set of arguments. */
7854 TREE_VEC_LENGTH (arglist
)--;
7855 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
7856 TREE_VEC_LENGTH (arglist
)++;
7857 /* FOUND is either a proper class type, or an alias
7858 template specialization. In the later case, it's a
7859 TYPE_DECL, resulting from the substituting of arguments
7860 for parameters in the TYPE_DECL of the alias template
7861 done earlier. So be careful while getting the template
7863 found
= TREE_CODE (found
) == TYPE_DECL
7864 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
7865 : CLASSTYPE_TI_TEMPLATE (found
);
7868 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
7871 slot
= htab_find_slot_with_hash (type_specializations
,
7872 &elt
, hash
, INSERT
);
7873 entry
= ggc_alloc
<spec_entry
> ();
7877 /* Note this use of the partial instantiation so we can check it
7878 later in maybe_process_partial_specialization. */
7879 DECL_TEMPLATE_INSTANTIATIONS (found
)
7880 = tree_cons (arglist
, t
,
7881 DECL_TEMPLATE_INSTANTIATIONS (found
));
7883 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
7884 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7885 /* Now that the type has been registered on the instantiations
7886 list, we set up the enumerators. Because the enumeration
7887 constants may involve the enumeration type itself, we make
7888 sure to register the type first, and then create the
7889 constants. That way, doing tsubst_expr for the enumeration
7890 constants won't result in recursive calls here; we'll find
7891 the instantiation and exit above. */
7892 tsubst_enum (template_type
, t
, arglist
);
7894 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
7895 /* If the type makes use of template parameters, the
7896 code that generates debugging information will crash. */
7897 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
7899 /* Possibly limit visibility based on template args. */
7900 TREE_PUBLIC (type_decl
) = 1;
7901 determine_visibility (type_decl
);
7907 /* Wrapper for lookup_template_class_1. */
7910 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
7911 int entering_scope
, tsubst_flags_t complain
)
7914 timevar_push (TV_TEMPLATE_INST
);
7915 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
7916 entering_scope
, complain
);
7917 timevar_pop (TV_TEMPLATE_INST
);
7925 /* True when we should also visit template parameters that occur in
7926 non-deduced contexts. */
7927 bool include_nondeduced_p
;
7928 hash_set
<tree
> *visited
;
7931 /* Called from for_each_template_parm via walk_tree. */
7934 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
7937 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
7938 tree_fn_t fn
= pfd
->fn
;
7939 void *data
= pfd
->data
;
7942 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
7943 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
7944 pfd
->include_nondeduced_p
))
7945 return error_mark_node
;
7947 switch (TREE_CODE (t
))
7950 if (TYPE_PTRMEMFUNC_P (t
))
7956 if (!TYPE_TEMPLATE_INFO (t
))
7958 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
7959 fn
, data
, pfd
->visited
,
7960 pfd
->include_nondeduced_p
))
7961 return error_mark_node
;
7965 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
7966 fn
, data
, pfd
->visited
,
7967 pfd
->include_nondeduced_p
)
7968 || for_each_template_parm (TYPE_MAX_VALUE (t
),
7969 fn
, data
, pfd
->visited
,
7970 pfd
->include_nondeduced_p
))
7971 return error_mark_node
;
7975 /* Since we're not going to walk subtrees, we have to do this
7977 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
7978 pfd
->visited
, pfd
->include_nondeduced_p
))
7979 return error_mark_node
;
7983 /* Check the return type. */
7984 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
7985 pfd
->include_nondeduced_p
))
7986 return error_mark_node
;
7988 /* Check the parameter types. Since default arguments are not
7989 instantiated until they are needed, the TYPE_ARG_TYPES may
7990 contain expressions that involve template parameters. But,
7991 no-one should be looking at them yet. And, once they're
7992 instantiated, they don't contain template parameters, so
7993 there's no point in looking at them then, either. */
7997 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
7998 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
7999 pfd
->visited
, pfd
->include_nondeduced_p
))
8000 return error_mark_node
;
8002 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8003 want walk_tree walking into them itself. */
8009 case UNDERLYING_TYPE
:
8010 if (pfd
->include_nondeduced_p
8011 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
8013 pfd
->include_nondeduced_p
))
8014 return error_mark_node
;
8019 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
8020 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
8021 pfd
->visited
, pfd
->include_nondeduced_p
))
8022 return error_mark_node
;
8027 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
8028 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
8029 pfd
->visited
, pfd
->include_nondeduced_p
))
8030 return error_mark_node
;
8031 if (DECL_CONTEXT (t
)
8032 && pfd
->include_nondeduced_p
8033 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
8034 pfd
->visited
, pfd
->include_nondeduced_p
))
8035 return error_mark_node
;
8038 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8039 /* Record template parameters such as `T' inside `TT<T>'. */
8040 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
8041 pfd
->include_nondeduced_p
))
8042 return error_mark_node
;
8045 case TEMPLATE_TEMPLATE_PARM
:
8046 case TEMPLATE_TYPE_PARM
:
8047 case TEMPLATE_PARM_INDEX
:
8048 if (fn
&& (*fn
)(t
, data
))
8049 return error_mark_node
;
8051 return error_mark_node
;
8055 /* A template template parameter is encountered. */
8056 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
8057 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8058 pfd
->include_nondeduced_p
))
8059 return error_mark_node
;
8061 /* Already substituted template template parameter */
8067 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8069 pfd
->include_nondeduced_p
))
8070 return error_mark_node
;
8074 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8075 && pfd
->include_nondeduced_p
8076 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8077 (TREE_TYPE (t
)), fn
, data
,
8078 pfd
->visited
, pfd
->include_nondeduced_p
))
8079 return error_mark_node
;
8084 /* If there's no type, then this thing must be some expression
8085 involving template parameters. */
8086 if (!fn
&& !TREE_TYPE (t
))
8087 return error_mark_node
;
8092 case IMPLICIT_CONV_EXPR
:
8093 case REINTERPRET_CAST_EXPR
:
8094 case CONST_CAST_EXPR
:
8095 case STATIC_CAST_EXPR
:
8096 case DYNAMIC_CAST_EXPR
:
8100 case PSEUDO_DTOR_EXPR
:
8102 return error_mark_node
;
8109 /* We didn't find any template parameters we liked. */
8113 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8114 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8115 call FN with the parameter and the DATA.
8116 If FN returns nonzero, the iteration is terminated, and
8117 for_each_template_parm returns 1. Otherwise, the iteration
8118 continues. If FN never returns a nonzero value, the value
8119 returned by for_each_template_parm is 0. If FN is NULL, it is
8120 considered to be the function which always returns 1.
8122 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8123 parameters that occur in non-deduced contexts. When false, only
8124 visits those template parameters that can be deduced. */
8127 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8128 hash_set
<tree
> *visited
,
8129 bool include_nondeduced_p
)
8131 struct pair_fn_data pfd
;
8137 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8139 /* Walk the tree. (Conceptually, we would like to walk without
8140 duplicates, but for_each_template_parm_r recursively calls
8141 for_each_template_parm, so we would need to reorganize a fair
8142 bit to use walk_tree_without_duplicates, so we keep our own
8145 pfd
.visited
= visited
;
8147 pfd
.visited
= new hash_set
<tree
>;
8148 result
= cp_walk_tree (&t
,
8149 for_each_template_parm_r
,
8151 pfd
.visited
) != NULL_TREE
;
8163 /* Returns true if T depends on any template parameter. */
8166 uses_template_parms (tree t
)
8169 int saved_processing_template_decl
;
8171 saved_processing_template_decl
= processing_template_decl
;
8172 if (!saved_processing_template_decl
)
8173 processing_template_decl
= 1;
8175 dependent_p
= dependent_type_p (t
);
8176 else if (TREE_CODE (t
) == TREE_VEC
)
8177 dependent_p
= any_dependent_template_arguments_p (t
);
8178 else if (TREE_CODE (t
) == TREE_LIST
)
8179 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8180 || uses_template_parms (TREE_CHAIN (t
)));
8181 else if (TREE_CODE (t
) == TYPE_DECL
)
8182 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8185 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8186 || TREE_CODE (t
) == OVERLOAD
8189 || TREE_CODE (t
) == TRAIT_EXPR
8190 || TREE_CODE (t
) == CONSTRUCTOR
8191 || CONSTANT_CLASS_P (t
))
8192 dependent_p
= (type_dependent_expression_p (t
)
8193 || value_dependent_expression_p (t
));
8196 gcc_assert (t
== error_mark_node
);
8197 dependent_p
= false;
8200 processing_template_decl
= saved_processing_template_decl
;
8205 /* Returns true iff current_function_decl is an incompletely instantiated
8206 template. Useful instead of processing_template_decl because the latter
8207 is set to 0 during fold_non_dependent_expr. */
8210 in_template_function (void)
8212 tree fn
= current_function_decl
;
8214 ++processing_template_decl
;
8215 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8216 && DECL_TEMPLATE_INFO (fn
)
8217 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8218 --processing_template_decl
;
8222 /* Returns true if T depends on any template parameter with level LEVEL. */
8225 uses_template_parms_level (tree t
, int level
)
8227 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8228 /*include_nondeduced_p=*/true);
8231 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8232 ill-formed translation unit, i.e. a variable or function that isn't
8233 usable in a constant expression. */
8236 neglectable_inst_p (tree d
)
8239 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8240 : decl_maybe_constant_var_p (d
)));
8243 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8244 neglectable and instantiated from within an erroneous instantiation. */
8247 limit_bad_template_recursion (tree decl
)
8249 struct tinst_level
*lev
= current_tinst_level
;
8250 int errs
= errorcount
+ sorrycount
;
8251 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8254 for (; lev
; lev
= lev
->next
)
8255 if (neglectable_inst_p (lev
->decl
))
8258 return (lev
&& errs
> lev
->errors
);
8261 static int tinst_depth
;
8262 extern int max_tinst_depth
;
8265 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8267 /* We're starting to instantiate D; record the template instantiation context
8268 for diagnostics and to restore it later. */
8271 push_tinst_level (tree d
)
8273 struct tinst_level
*new_level
;
8275 if (tinst_depth
>= max_tinst_depth
)
8277 last_error_tinst_level
= current_tinst_level
;
8278 if (TREE_CODE (d
) == TREE_LIST
)
8279 error ("template instantiation depth exceeds maximum of %d (use "
8280 "-ftemplate-depth= to increase the maximum) substituting %qS",
8281 max_tinst_depth
, d
);
8283 error ("template instantiation depth exceeds maximum of %d (use "
8284 "-ftemplate-depth= to increase the maximum) instantiating %qD",
8285 max_tinst_depth
, d
);
8287 print_instantiation_context ();
8292 /* If the current instantiation caused problems, don't let it instantiate
8293 anything else. Do allow deduction substitution and decls usable in
8294 constant expressions. */
8295 if (limit_bad_template_recursion (d
))
8298 new_level
= ggc_alloc
<tinst_level
> ();
8299 new_level
->decl
= d
;
8300 new_level
->locus
= input_location
;
8301 new_level
->errors
= errorcount
+sorrycount
;
8302 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8303 new_level
->next
= current_tinst_level
;
8304 current_tinst_level
= new_level
;
8307 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8308 depth_reached
= tinst_depth
;
8313 /* We're done instantiating this template; return to the instantiation
8317 pop_tinst_level (void)
8319 /* Restore the filename and line number stashed away when we started
8320 this instantiation. */
8321 input_location
= current_tinst_level
->locus
;
8322 current_tinst_level
= current_tinst_level
->next
;
8326 /* We're instantiating a deferred template; restore the template
8327 instantiation context in which the instantiation was requested, which
8328 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8331 reopen_tinst_level (struct tinst_level
*level
)
8333 struct tinst_level
*t
;
8336 for (t
= level
; t
; t
= t
->next
)
8339 current_tinst_level
= level
;
8341 if (current_tinst_level
)
8342 current_tinst_level
->errors
= errorcount
+sorrycount
;
8346 /* Returns the TINST_LEVEL which gives the original instantiation
8349 struct tinst_level
*
8350 outermost_tinst_level (void)
8352 struct tinst_level
*level
= current_tinst_level
;
8355 level
= level
->next
;
8359 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8360 vector of template arguments, as for tsubst.
8362 Returns an appropriate tsubst'd friend declaration. */
8365 tsubst_friend_function (tree decl
, tree args
)
8369 if (TREE_CODE (decl
) == FUNCTION_DECL
8370 && DECL_TEMPLATE_INSTANTIATION (decl
)
8371 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8372 /* This was a friend declared with an explicit template
8373 argument list, e.g.:
8377 to indicate that f was a template instantiation, not a new
8378 function declaration. Now, we have to figure out what
8379 instantiation of what template. */
8381 tree template_id
, arglist
, fns
;
8384 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8386 /* Friend functions are looked up in the containing namespace scope.
8387 We must enter that scope, to avoid finding member functions of the
8388 current class with same name. */
8389 push_nested_namespace (ns
);
8390 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8391 tf_warning_or_error
, NULL_TREE
,
8392 /*integral_constant_expression_p=*/false);
8393 pop_nested_namespace (ns
);
8394 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8395 tf_warning_or_error
, NULL_TREE
);
8396 template_id
= lookup_template_function (fns
, arglist
);
8398 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8399 tmpl
= determine_specialization (template_id
, new_friend
,
8401 /*need_member_template=*/0,
8402 TREE_VEC_LENGTH (args
),
8404 return instantiate_template (tmpl
, new_args
, tf_error
);
8407 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8409 /* The NEW_FRIEND will look like an instantiation, to the
8410 compiler, but is not an instantiation from the point of view of
8411 the language. For example, we might have had:
8413 template <class T> struct S {
8414 template <class U> friend void f(T, U);
8417 Then, in S<int>, template <class U> void f(int, U) is not an
8418 instantiation of anything. */
8419 if (new_friend
== error_mark_node
)
8420 return error_mark_node
;
8422 DECL_USE_TEMPLATE (new_friend
) = 0;
8423 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8425 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8426 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8427 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8430 /* The mangled name for the NEW_FRIEND is incorrect. The function
8431 is not a template instantiation and should not be mangled like
8432 one. Therefore, we forget the mangling here; we'll recompute it
8433 later if we need it. */
8434 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8436 SET_DECL_RTL (new_friend
, NULL
);
8437 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8440 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8443 tree new_friend_template_info
;
8444 tree new_friend_result_template_info
;
8446 int new_friend_is_defn
;
8448 /* We must save some information from NEW_FRIEND before calling
8449 duplicate decls since that function will free NEW_FRIEND if
8451 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8452 new_friend_is_defn
=
8453 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8454 (template_for_substitution (new_friend
)))
8456 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8458 /* This declaration is a `primary' template. */
8459 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8461 new_friend_result_template_info
8462 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8465 new_friend_result_template_info
= NULL_TREE
;
8467 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8468 if (new_friend_is_defn
)
8469 DECL_INITIAL (new_friend
) = error_mark_node
;
8471 /* Inside pushdecl_namespace_level, we will push into the
8472 current namespace. However, the friend function should go
8473 into the namespace of the template. */
8474 ns
= decl_namespace_context (new_friend
);
8475 push_nested_namespace (ns
);
8476 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8477 pop_nested_namespace (ns
);
8479 if (old_decl
== error_mark_node
)
8480 return error_mark_node
;
8482 if (old_decl
!= new_friend
)
8484 /* This new friend declaration matched an existing
8485 declaration. For example, given:
8487 template <class T> void f(T);
8488 template <class U> class C {
8489 template <class T> friend void f(T) {}
8492 the friend declaration actually provides the definition
8493 of `f', once C has been instantiated for some type. So,
8494 old_decl will be the out-of-class template declaration,
8495 while new_friend is the in-class definition.
8497 But, if `f' was called before this point, the
8498 instantiation of `f' will have DECL_TI_ARGS corresponding
8499 to `T' but not to `U', references to which might appear
8500 in the definition of `f'. Previously, the most general
8501 template for an instantiation of `f' was the out-of-class
8502 version; now it is the in-class version. Therefore, we
8503 run through all specialization of `f', adding to their
8504 DECL_TI_ARGS appropriately. In particular, they need a
8505 new set of outer arguments, corresponding to the
8506 arguments for this class instantiation.
8508 The same situation can arise with something like this:
8511 template <class T> class C {
8515 when `C<int>' is instantiated. Now, `f(int)' is defined
8518 if (!new_friend_is_defn
)
8519 /* On the other hand, if the in-class declaration does
8520 *not* provide a definition, then we don't want to alter
8521 existing definitions. We can just leave everything
8526 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8527 tree new_args
= TI_ARGS (new_friend_template_info
);
8529 /* Overwrite whatever template info was there before, if
8530 any, with the new template information pertaining to
8532 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8534 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8536 /* We should have called reregister_specialization in
8538 gcc_assert (retrieve_specialization (new_template
,
8542 /* Instantiate it if the global has already been used. */
8543 if (DECL_ODR_USED (old_decl
))
8544 instantiate_decl (old_decl
, /*defer_ok=*/true,
8545 /*expl_inst_class_mem_p=*/false);
8551 /* Indicate that the old function template is a partial
8553 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8554 = new_friend_result_template_info
;
8556 gcc_assert (new_template
8557 == most_general_template (new_template
));
8558 gcc_assert (new_template
!= old_decl
);
8560 /* Reassign any specializations already in the hash table
8561 to the new more general template, and add the
8562 additional template args. */
8563 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8567 tree spec
= TREE_VALUE (t
);
8570 elt
.tmpl
= old_decl
;
8571 elt
.args
= DECL_TI_ARGS (spec
);
8572 elt
.spec
= NULL_TREE
;
8574 htab_remove_elt (decl_specializations
, &elt
);
8577 = add_outermost_template_args (new_args
,
8578 DECL_TI_ARGS (spec
));
8580 register_specialization
8581 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8584 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8588 /* The information from NEW_FRIEND has been merged into OLD_DECL
8589 by duplicate_decls. */
8590 new_friend
= old_decl
;
8595 tree context
= DECL_CONTEXT (new_friend
);
8599 template <class T> class C {
8600 template <class U> friend void C1<U>::f (); // case 1
8601 friend void C2<T>::f (); // case 2
8603 we only need to make sure CONTEXT is a complete type for
8604 case 2. To distinguish between the two cases, we note that
8605 CONTEXT of case 1 remains dependent type after tsubst while
8606 this isn't true for case 2. */
8607 ++processing_template_decl
;
8608 dependent_p
= dependent_type_p (context
);
8609 --processing_template_decl
;
8612 && !complete_type_or_else (context
, NULL_TREE
))
8613 return error_mark_node
;
8615 if (COMPLETE_TYPE_P (context
))
8617 tree fn
= new_friend
;
8618 /* do_friend adds the TEMPLATE_DECL for any member friend
8619 template even if it isn't a member template, i.e.
8620 template <class T> friend A<T>::f();
8621 Look through it in that case. */
8622 if (TREE_CODE (fn
) == TEMPLATE_DECL
8623 && !PRIMARY_TEMPLATE_P (fn
))
8624 fn
= DECL_TEMPLATE_RESULT (fn
);
8625 /* Check to see that the declaration is really present, and,
8626 possibly obtain an improved declaration. */
8627 fn
= check_classfn (context
, fn
, NULL_TREE
);
8637 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8638 template arguments, as for tsubst.
8640 Returns an appropriate tsubst'd friend type or error_mark_node on
8644 tsubst_friend_class (tree friend_tmpl
, tree args
)
8650 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8652 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8653 return TREE_TYPE (t
);
8656 context
= CP_DECL_CONTEXT (friend_tmpl
);
8658 if (context
!= global_namespace
)
8660 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8661 push_nested_namespace (context
);
8663 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8666 /* Look for a class template declaration. We look for hidden names
8667 because two friend declarations of the same template are the
8668 same. For example, in:
8671 template <typename> friend class F;
8673 template <typename> struct B {
8674 template <typename> friend class F;
8677 both F templates are the same. */
8678 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8679 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8681 /* But, if we don't find one, it might be because we're in a
8682 situation like this:
8690 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8691 for `S<int>', not the TEMPLATE_DECL. */
8692 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8694 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8695 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8698 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8700 /* The friend template has already been declared. Just
8701 check to see that the declarations match, and install any new
8702 default parameters. We must tsubst the default parameters,
8703 of course. We only need the innermost template parameters
8704 because that is all that redeclare_class_template will look
8706 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8707 > TMPL_ARGS_DEPTH (args
))
8710 location_t saved_input_location
;
8711 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8712 args
, tf_warning_or_error
);
8714 saved_input_location
= input_location
;
8715 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8716 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8717 input_location
= saved_input_location
;
8721 friend_type
= TREE_TYPE (tmpl
);
8725 /* The friend template has not already been declared. In this
8726 case, the instantiation of the template class will cause the
8727 injection of this template into the global scope. */
8728 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8729 if (tmpl
== error_mark_node
)
8730 return error_mark_node
;
8732 /* The new TMPL is not an instantiation of anything, so we
8733 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8734 the new type because that is supposed to be the corresponding
8735 template decl, i.e., TMPL. */
8736 DECL_USE_TEMPLATE (tmpl
) = 0;
8737 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8738 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8739 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8740 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8742 /* Inject this template into the global scope. */
8743 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8746 if (context
!= global_namespace
)
8748 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8749 pop_nested_namespace (context
);
8751 pop_nested_class ();
8757 /* Returns zero if TYPE cannot be completed later due to circularity.
8758 Otherwise returns one. */
8761 can_complete_type_without_circularity (tree type
)
8763 if (type
== NULL_TREE
|| type
== error_mark_node
)
8765 else if (COMPLETE_TYPE_P (type
))
8767 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8768 return can_complete_type_without_circularity (TREE_TYPE (type
));
8769 else if (CLASS_TYPE_P (type
)
8770 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
8776 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
8778 /* Apply any attributes which had to be deferred until instantiation
8779 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8780 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8783 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
8784 tree args
, tsubst_flags_t complain
, tree in_decl
)
8786 tree last_dep
= NULL_TREE
;
8790 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
8791 if (ATTR_IS_DEPENDENT (t
))
8794 attributes
= copy_list (attributes
);
8798 if (DECL_P (*decl_p
))
8800 if (TREE_TYPE (*decl_p
) == error_mark_node
)
8802 p
= &DECL_ATTRIBUTES (*decl_p
);
8805 p
= &TYPE_ATTRIBUTES (*decl_p
);
8809 tree late_attrs
= NULL_TREE
;
8810 tree
*q
= &late_attrs
;
8812 for (*p
= attributes
; *p
; )
8815 if (ATTR_IS_DEPENDENT (t
))
8817 *p
= TREE_CHAIN (t
);
8818 TREE_CHAIN (t
) = NULL_TREE
;
8819 if ((flag_openmp
|| flag_cilkplus
)
8820 && is_attribute_p ("omp declare simd",
8821 get_attribute_name (t
))
8824 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
8825 clauses
= tsubst_omp_clauses (clauses
, true, args
,
8827 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
8828 clauses
= finish_omp_clauses (clauses
);
8829 tree parms
= DECL_ARGUMENTS (*decl_p
);
8831 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
8833 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
8835 TREE_VALUE (t
) = NULL_TREE
;
8837 /* If the first attribute argument is an identifier, don't
8838 pass it through tsubst. Attributes like mode, format,
8839 cleanup and several target specific attributes expect it
8841 else if (attribute_takes_identifier_p (get_attribute_name (t
))
8845 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
8847 /*integral_constant_expression_p=*/false);
8848 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
8850 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
8855 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
8856 /*integral_constant_expression_p=*/false);
8858 q
= &TREE_CHAIN (t
);
8861 p
= &TREE_CHAIN (t
);
8864 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
8868 /* Perform (or defer) access check for typedefs that were referenced
8869 from within the template TMPL code.
8870 This is a subroutine of instantiate_decl and instantiate_class_template.
8871 TMPL is the template to consider and TARGS is the list of arguments of
8875 perform_typedefs_access_check (tree tmpl
, tree targs
)
8877 location_t saved_location
;
8879 qualified_typedef_usage_t
*iter
;
8882 || (!CLASS_TYPE_P (tmpl
)
8883 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
8886 saved_location
= input_location
;
8887 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
8889 tree type_decl
= iter
->typedef_decl
;
8890 tree type_scope
= iter
->context
;
8892 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
8895 if (uses_template_parms (type_decl
))
8896 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
8897 if (uses_template_parms (type_scope
))
8898 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
8900 /* Make access check error messages point to the location
8901 of the use of the typedef. */
8902 input_location
= iter
->locus
;
8903 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
8904 type_decl
, type_decl
,
8905 tf_warning_or_error
);
8907 input_location
= saved_location
;
8911 instantiate_class_template_1 (tree type
)
8913 tree templ
, args
, pattern
, t
, member
;
8917 unsigned int saved_maximum_field_alignment
;
8920 if (type
== error_mark_node
)
8921 return error_mark_node
;
8923 if (COMPLETE_OR_OPEN_TYPE_P (type
)
8924 || uses_template_parms (type
))
8927 /* Figure out which template is being instantiated. */
8928 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
8929 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
8931 /* Determine what specialization of the original template to
8933 t
= most_specialized_class (type
, tf_warning_or_error
);
8934 if (t
== error_mark_node
)
8936 TYPE_BEING_DEFINED (type
) = 1;
8937 return error_mark_node
;
8941 /* This TYPE is actually an instantiation of a partial
8942 specialization. We replace the innermost set of ARGS with
8943 the arguments appropriate for substitution. For example,
8946 template <class T> struct S {};
8947 template <class T> struct S<T*> {};
8949 and supposing that we are instantiating S<int*>, ARGS will
8950 presently be {int*} -- but we need {int}. */
8951 pattern
= TREE_TYPE (t
);
8952 args
= TREE_PURPOSE (t
);
8956 pattern
= TREE_TYPE (templ
);
8957 args
= CLASSTYPE_TI_ARGS (type
);
8960 /* If the template we're instantiating is incomplete, then clearly
8961 there's nothing we can do. */
8962 if (!COMPLETE_TYPE_P (pattern
))
8965 /* If we've recursively instantiated too many templates, stop. */
8966 if (! push_tinst_level (type
))
8969 /* Now we're really doing the instantiation. Mark the type as in
8970 the process of being defined. */
8971 TYPE_BEING_DEFINED (type
) = 1;
8973 /* We may be in the middle of deferred access check. Disable
8975 push_deferring_access_checks (dk_no_deferred
);
8977 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
8978 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
8979 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
8980 fn_context
= error_mark_node
;
8982 push_to_top_level ();
8983 /* Use #pragma pack from the template context. */
8984 saved_maximum_field_alignment
= maximum_field_alignment
;
8985 maximum_field_alignment
= TYPE_PRECISION (pattern
);
8987 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
8989 /* Set the input location to the most specialized template definition.
8990 This is needed if tsubsting causes an error. */
8991 typedecl
= TYPE_MAIN_DECL (pattern
);
8992 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
8993 DECL_SOURCE_LOCATION (typedecl
);
8995 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
8996 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
8997 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
8998 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
8999 if (ANON_AGGR_TYPE_P (pattern
))
9000 SET_ANON_AGGR_TYPE_P (type
);
9001 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
9003 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
9004 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
9005 /* Adjust visibility for template arguments. */
9006 determine_visibility (TYPE_MAIN_DECL (type
));
9008 if (CLASS_TYPE_P (type
))
9009 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
9011 pbinfo
= TYPE_BINFO (pattern
);
9013 /* We should never instantiate a nested class before its enclosing
9014 class; we need to look up the nested class by name before we can
9015 instantiate it, and that lookup should instantiate the enclosing
9017 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
9018 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
9020 base_list
= NULL_TREE
;
9021 if (BINFO_N_BASE_BINFOS (pbinfo
))
9027 /* We must enter the scope containing the type, as that is where
9028 the accessibility of types named in dependent bases are
9030 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9032 /* Substitute into each of the bases to determine the actual
9034 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9037 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9038 tree expanded_bases
= NULL_TREE
;
9041 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9044 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9045 args
, tf_error
, NULL_TREE
);
9046 if (expanded_bases
== error_mark_node
)
9049 len
= TREE_VEC_LENGTH (expanded_bases
);
9052 for (idx
= 0; idx
< len
; idx
++)
9055 /* Extract the already-expanded base class. */
9056 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9058 /* Substitute to figure out the base class. */
9059 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9062 if (base
== error_mark_node
)
9065 base_list
= tree_cons (access
, base
, base_list
);
9066 if (BINFO_VIRTUAL_P (pbase_binfo
))
9067 TREE_TYPE (base_list
) = integer_type_node
;
9071 /* The list is now in reverse order; correct that. */
9072 base_list
= nreverse (base_list
);
9075 pop_scope (pushed_scope
);
9077 /* Now call xref_basetypes to set up all the base-class
9079 xref_basetypes (type
, base_list
);
9081 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9082 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9083 args
, tf_error
, NULL_TREE
);
9084 fixup_attribute_variants (type
);
9086 /* Now that our base classes are set up, enter the scope of the
9087 class, so that name lookups into base classes, etc. will work
9088 correctly. This is precisely analogous to what we do in
9089 begin_class_definition when defining an ordinary non-template
9090 class, except we also need to push the enclosing classes. */
9091 push_nested_class (type
);
9093 /* Now members are processed in the order of declaration. */
9094 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9095 member
; member
= TREE_CHAIN (member
))
9097 tree t
= TREE_VALUE (member
);
9099 if (TREE_PURPOSE (member
))
9103 /* Build new CLASSTYPE_NESTED_UTDS. */
9106 bool class_template_p
;
9108 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9109 && TYPE_LANG_SPECIFIC (t
)
9110 && CLASSTYPE_IS_TEMPLATE (t
));
9111 /* If the member is a class template, then -- even after
9112 substitution -- there may be dependent types in the
9113 template argument list for the class. We increment
9114 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9115 that function will assume that no types are dependent
9116 when outside of a template. */
9117 if (class_template_p
)
9118 ++processing_template_decl
;
9119 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9120 if (class_template_p
)
9121 --processing_template_decl
;
9122 if (newtag
== error_mark_node
)
9125 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9127 tree name
= TYPE_IDENTIFIER (t
);
9129 if (class_template_p
)
9130 /* Unfortunately, lookup_template_class sets
9131 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9132 instantiation (i.e., for the type of a member
9133 template class nested within a template class.)
9134 This behavior is required for
9135 maybe_process_partial_specialization to work
9136 correctly, but is not accurate in this case;
9137 the TAG is not an instantiation of anything.
9138 (The corresponding TEMPLATE_DECL is an
9139 instantiation, but the TYPE is not.) */
9140 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9142 /* Now, we call pushtag to put this NEWTAG into the scope of
9143 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9144 pushtag calling push_template_decl. We don't have to do
9145 this for enums because it will already have been done in
9148 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9149 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9152 else if (DECL_DECLARES_FUNCTION_P (t
))
9154 /* Build new TYPE_METHODS. */
9157 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9158 ++processing_template_decl
;
9159 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9160 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9161 --processing_template_decl
;
9162 set_current_access_from_decl (r
);
9163 finish_member_declaration (r
);
9164 /* Instantiate members marked with attribute used. */
9165 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9167 if (TREE_CODE (r
) == FUNCTION_DECL
9168 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9169 cp_check_omp_declare_reduction (r
);
9173 /* Build new TYPE_FIELDS. */
9174 if (TREE_CODE (t
) == STATIC_ASSERT
)
9178 ++c_inhibit_evaluation_warnings
;
9180 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9181 tf_warning_or_error
, NULL_TREE
,
9182 /*integral_constant_expression_p=*/true);
9183 --c_inhibit_evaluation_warnings
;
9185 finish_static_assert (condition
,
9186 STATIC_ASSERT_MESSAGE (t
),
9187 STATIC_ASSERT_SOURCE_LOCATION (t
),
9190 else if (TREE_CODE (t
) != CONST_DECL
)
9193 tree vec
= NULL_TREE
;
9196 /* The file and line for this declaration, to
9197 assist in error message reporting. Since we
9198 called push_tinst_level above, we don't need to
9200 input_location
= DECL_SOURCE_LOCATION (t
);
9202 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9203 ++processing_template_decl
;
9204 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9205 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9206 --processing_template_decl
;
9208 if (TREE_CODE (r
) == TREE_VEC
)
9210 /* A capture pack became multiple fields. */
9212 len
= TREE_VEC_LENGTH (vec
);
9215 for (int i
= 0; i
< len
; ++i
)
9218 r
= TREE_VEC_ELT (vec
, i
);
9223 [t]he initialization (and any associated
9224 side-effects) of a static data member does
9225 not occur unless the static data member is
9226 itself used in a way that requires the
9227 definition of the static data member to
9230 Therefore, we do not substitute into the
9231 initialized for the static data member here. */
9232 finish_static_data_member_decl
9235 /*init_const_expr_p=*/false,
9236 /*asmspec_tree=*/NULL_TREE
,
9238 /* Instantiate members marked with attribute used. */
9239 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9242 else if (TREE_CODE (r
) == FIELD_DECL
)
9244 /* Determine whether R has a valid type and can be
9245 completed later. If R is invalid, then its type
9246 is replaced by error_mark_node. */
9247 tree rtype
= TREE_TYPE (r
);
9248 if (can_complete_type_without_circularity (rtype
))
9249 complete_type (rtype
);
9251 if (!COMPLETE_TYPE_P (rtype
))
9253 cxx_incomplete_type_error (r
, rtype
);
9254 TREE_TYPE (r
) = error_mark_node
;
9258 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9259 such a thing will already have been added to the field
9260 list by tsubst_enum in finish_member_declaration in the
9261 CLASSTYPE_NESTED_UTDS case above. */
9262 if (!(TREE_CODE (r
) == TYPE_DECL
9263 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9264 && DECL_ARTIFICIAL (r
)))
9266 set_current_access_from_decl (r
);
9267 finish_member_declaration (r
);
9275 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9276 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9278 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9280 tree friend_type
= t
;
9281 bool adjust_processing_template_decl
= false;
9283 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9285 /* template <class T> friend class C; */
9286 friend_type
= tsubst_friend_class (friend_type
, args
);
9287 adjust_processing_template_decl
= true;
9289 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9291 /* template <class T> friend class C::D; */
9292 friend_type
= tsubst (friend_type
, args
,
9293 tf_warning_or_error
, NULL_TREE
);
9294 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9295 friend_type
= TREE_TYPE (friend_type
);
9296 adjust_processing_template_decl
= true;
9298 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9299 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9301 /* This could be either
9305 when dependent_type_p is false or
9307 template <class U> friend class T::C;
9310 friend_type
= tsubst (friend_type
, args
,
9311 tf_warning_or_error
, NULL_TREE
);
9312 /* Bump processing_template_decl for correct
9313 dependent_type_p calculation. */
9314 ++processing_template_decl
;
9315 if (dependent_type_p (friend_type
))
9316 adjust_processing_template_decl
= true;
9317 --processing_template_decl
;
9319 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9320 && hidden_name_p (TYPE_NAME (friend_type
)))
9324 where C hasn't been declared yet. Let's lookup name
9325 from namespace scope directly, bypassing any name that
9326 come from dependent base class. */
9327 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9329 /* The call to xref_tag_from_type does injection for friend
9331 push_nested_namespace (ns
);
9333 xref_tag_from_type (friend_type
, NULL_TREE
,
9334 /*tag_scope=*/ts_current
);
9335 pop_nested_namespace (ns
);
9337 else if (uses_template_parms (friend_type
))
9338 /* friend class C<T>; */
9339 friend_type
= tsubst (friend_type
, args
,
9340 tf_warning_or_error
, NULL_TREE
);
9345 where C is already declared or
9347 friend class C<int>;
9349 We don't have to do anything in these cases. */
9351 if (adjust_processing_template_decl
)
9352 /* Trick make_friend_class into realizing that the friend
9353 we're adding is a template, not an ordinary class. It's
9354 important that we use make_friend_class since it will
9355 perform some error-checking and output cross-reference
9357 ++processing_template_decl
;
9359 if (friend_type
!= error_mark_node
)
9360 make_friend_class (type
, friend_type
, /*complain=*/false);
9362 if (adjust_processing_template_decl
)
9363 --processing_template_decl
;
9367 /* Build new DECL_FRIENDLIST. */
9370 /* The file and line for this declaration, to
9371 assist in error message reporting. Since we
9372 called push_tinst_level above, we don't need to
9374 input_location
= DECL_SOURCE_LOCATION (t
);
9376 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9378 ++processing_template_decl
;
9379 push_deferring_access_checks (dk_no_check
);
9382 r
= tsubst_friend_function (t
, args
);
9383 add_friend (type
, r
, /*complain=*/false);
9384 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9386 pop_deferring_access_checks ();
9387 --processing_template_decl
;
9393 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9395 tree decl
= lambda_function (type
);
9398 if (!DECL_TEMPLATE_INFO (decl
)
9399 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9400 instantiate_decl (decl
, false, false);
9402 /* We need to instantiate the capture list from the template
9403 after we've instantiated the closure members, but before we
9404 consider adding the conversion op. Also keep any captures
9405 that may have been added during instantiation of the op(). */
9406 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9408 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9409 args
, tf_warning_or_error
, NULL_TREE
,
9412 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9413 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9415 maybe_add_lambda_conv_op (type
);
9418 gcc_assert (errorcount
);
9421 /* Set the file and line number information to whatever is given for
9422 the class itself. This puts error messages involving generated
9423 implicit functions at a predictable point, and the same point
9424 that would be used for non-template classes. */
9425 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9427 unreverse_member_declarations (type
);
9428 finish_struct_1 (type
);
9429 TYPE_BEING_DEFINED (type
) = 0;
9431 /* We don't instantiate default arguments for member functions. 14.7.1:
9433 The implicit instantiation of a class template specialization causes
9434 the implicit instantiation of the declarations, but not of the
9435 definitions or default arguments, of the class member functions,
9436 member classes, static data members and member templates.... */
9438 /* Some typedefs referenced from within the template code need to be access
9439 checked at template instantiation time, i.e now. These types were
9440 added to the template at parsing time. Let's get those and perform
9441 the access checks then. */
9442 perform_typedefs_access_check (pattern
, args
);
9443 perform_deferred_access_checks (tf_warning_or_error
);
9444 pop_nested_class ();
9445 maximum_field_alignment
= saved_maximum_field_alignment
;
9447 pop_from_top_level ();
9448 pop_deferring_access_checks ();
9451 /* The vtable for a template class can be emitted in any translation
9452 unit in which the class is instantiated. When there is no key
9453 method, however, finish_struct_1 will already have added TYPE to
9454 the keyed_classes list. */
9455 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9456 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9461 /* Wrapper for instantiate_class_template_1. */
9464 instantiate_class_template (tree type
)
9467 timevar_push (TV_TEMPLATE_INST
);
9468 ret
= instantiate_class_template_1 (type
);
9469 timevar_pop (TV_TEMPLATE_INST
);
9474 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9480 else if (TYPE_P (t
))
9481 r
= tsubst (t
, args
, complain
, in_decl
);
9484 if (!(complain
& tf_warning
))
9485 ++c_inhibit_evaluation_warnings
;
9486 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9487 /*integral_constant_expression_p=*/true);
9488 if (!(complain
& tf_warning
))
9489 --c_inhibit_evaluation_warnings
;
9494 /* Given a function parameter pack TMPL_PARM and some function parameters
9495 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9496 and set *SPEC_P to point at the next point in the list. */
9499 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9501 /* Collect all of the extra "packed" parameters into an
9505 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9506 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9507 tree spec_parm
= *spec_p
;
9510 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9512 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9515 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9516 parmvec
= make_tree_vec (len
);
9517 parmtypevec
= make_tree_vec (len
);
9518 spec_parm
= *spec_p
;
9519 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9521 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9522 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9525 /* Build the argument packs. */
9526 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9527 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9528 TREE_TYPE (argpack
) = argtypepack
;
9529 *spec_p
= spec_parm
;
9534 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9535 NONTYPE_ARGUMENT_PACK. */
9538 make_fnparm_pack (tree spec_parm
)
9540 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9543 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9547 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9549 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9550 if (i
>= TREE_VEC_LENGTH (vec
))
9552 return PACK_EXPANSION_P (TREE_VEC_ELT (vec
, i
));
9556 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9559 make_argument_pack_select (tree arg_pack
, unsigned index
)
9561 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9563 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9564 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9569 /* This is a subroutine of tsubst_pack_expansion.
9571 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9572 mechanism to store the (non complete list of) arguments of the
9573 substitution and return a non substituted pack expansion, in order
9574 to wait for when we have enough arguments to really perform the
9578 use_pack_expansion_extra_args_p (tree parm_packs
,
9582 /* If one pack has an expansion and another pack has a normal
9583 argument or if one pack has an empty argument and an another
9584 one hasn't then tsubst_pack_expansion cannot perform the
9585 substitution and need to fall back on the
9586 PACK_EXPANSION_EXTRA mechanism. */
9587 if (parm_packs
== NULL_TREE
)
9589 else if (has_empty_arg
)
9592 bool has_expansion_arg
= false;
9593 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9595 bool has_non_expansion_arg
= false;
9596 for (tree parm_pack
= parm_packs
;
9598 parm_pack
= TREE_CHAIN (parm_pack
))
9600 tree arg
= TREE_VALUE (parm_pack
);
9602 if (argument_pack_element_is_expansion_p (arg
, i
))
9603 has_expansion_arg
= true;
9605 has_non_expansion_arg
= true;
9608 if (has_expansion_arg
&& has_non_expansion_arg
)
9614 /* [temp.variadic]/6 says that:
9616 The instantiation of a pack expansion [...]
9617 produces a list E1,E2, ..., En, where N is the number of elements
9618 in the pack expansion parameters.
9620 This subroutine of tsubst_pack_expansion produces one of these Ei.
9622 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9623 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9624 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9625 INDEX is the index 'i' of the element Ei to produce. ARGS,
9626 COMPLAIN, and IN_DECL are the same parameters as for the
9627 tsubst_pack_expansion function.
9629 The function returns the resulting Ei upon successful completion,
9632 Note that this function possibly modifies the ARGS parameter, so
9633 it's the responsibility of the caller to restore it. */
9636 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9639 tree args
/* This parm gets
9641 tsubst_flags_t complain
,
9645 bool ith_elem_is_expansion
= false;
9647 /* For each parameter pack, change the substitution of the parameter
9648 pack to the ith argument in its argument pack, then expand the
9650 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9652 tree parm
= TREE_PURPOSE (pack
);
9653 tree arg_pack
= TREE_VALUE (pack
);
9654 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9656 ith_elem_is_expansion
|=
9657 argument_pack_element_is_expansion_p (arg_pack
, index
);
9659 /* Select the Ith argument from the pack. */
9660 if (TREE_CODE (parm
) == PARM_DECL
9661 || TREE_CODE (parm
) == FIELD_DECL
)
9665 aps
= make_argument_pack_select (arg_pack
, index
);
9667 register_local_specialization (aps
, parm
);
9670 aps
= retrieve_local_specialization (parm
);
9675 template_parm_level_and_index (parm
, &level
, &idx
);
9679 aps
= make_argument_pack_select (arg_pack
, index
);
9680 /* Update the corresponding argument. */
9681 TMPL_ARG (args
, level
, idx
) = aps
;
9684 /* Re-use the ARGUMENT_PACK_SELECT. */
9685 aps
= TMPL_ARG (args
, level
, idx
);
9687 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9690 /* Substitute into the PATTERN with the (possibly altered)
9692 if (pattern
== in_decl
)
9693 /* Expanding a fixed parameter pack from
9694 coerce_template_parameter_pack. */
9695 t
= tsubst_decl (pattern
, args
, complain
);
9696 else if (!TYPE_P (pattern
))
9697 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9698 /*integral_constant_expression_p=*/false);
9700 t
= tsubst (pattern
, args
, complain
, in_decl
);
9702 /* If the Ith argument pack element is a pack expansion, then
9703 the Ith element resulting from the substituting is going to
9704 be a pack expansion as well. */
9705 if (ith_elem_is_expansion
)
9706 t
= make_pack_expansion (t
);
9711 /* Substitute ARGS into T, which is an pack expansion
9712 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9713 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9714 (if only a partial substitution could be performed) or
9715 ERROR_MARK_NODE if there was an error. */
9717 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9721 tree pack
, packs
= NULL_TREE
;
9722 bool unsubstituted_packs
= false;
9725 struct pointer_map_t
*saved_local_specializations
= NULL
;
9726 bool need_local_specializations
= false;
9729 gcc_assert (PACK_EXPANSION_P (t
));
9730 pattern
= PACK_EXPANSION_PATTERN (t
);
9732 /* Add in any args remembered from an earlier partial instantiation. */
9733 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9735 levels
= TMPL_ARGS_DEPTH (args
);
9737 /* Determine the argument packs that will instantiate the parameter
9738 packs used in the expansion expression. While we're at it,
9739 compute the number of arguments to be expanded and make sure it
9741 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
9742 pack
= TREE_CHAIN (pack
))
9744 tree parm_pack
= TREE_VALUE (pack
);
9745 tree arg_pack
= NULL_TREE
;
9746 tree orig_arg
= NULL_TREE
;
9749 if (TREE_CODE (parm_pack
) == BASES
)
9751 if (BASES_DIRECT (parm_pack
))
9752 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9753 args
, complain
, in_decl
, false));
9755 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9756 args
, complain
, in_decl
, false));
9758 if (TREE_CODE (parm_pack
) == PARM_DECL
)
9760 if (PACK_EXPANSION_LOCAL_P (t
))
9761 arg_pack
= retrieve_local_specialization (parm_pack
);
9764 /* We can't rely on local_specializations for a parameter
9765 name used later in a function declaration (such as in a
9766 late-specified return type). Even if it exists, it might
9767 have the wrong value for a recursive call. Just make a
9768 dummy decl, since it's only used for its type. */
9769 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
9770 if (arg_pack
&& DECL_PACK_P (arg_pack
))
9771 /* Partial instantiation of the parm_pack, we can't build
9772 up an argument pack yet. */
9773 arg_pack
= NULL_TREE
;
9775 arg_pack
= make_fnparm_pack (arg_pack
);
9776 need_local_specializations
= true;
9779 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
9780 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
9784 template_parm_level_and_index (parm_pack
, &level
, &idx
);
9786 if (level
<= levels
)
9787 arg_pack
= TMPL_ARG (args
, level
, idx
);
9790 orig_arg
= arg_pack
;
9791 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
9792 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
9794 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
9795 /* This can only happen if we forget to expand an argument
9796 pack somewhere else. Just return an error, silently. */
9798 result
= make_tree_vec (1);
9799 TREE_VEC_ELT (result
, 0) = error_mark_node
;
9806 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
9808 /* Don't bother trying to do a partial substitution with
9809 incomplete packs; we'll try again after deduction. */
9810 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
9815 else if (len
!= my_len
)
9817 if (!(complain
& tf_error
))
9818 /* Fail quietly. */;
9819 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
9820 error ("mismatched argument pack lengths while expanding "
9824 error ("mismatched argument pack lengths while expanding "
9827 return error_mark_node
;
9830 /* Keep track of the parameter packs and their corresponding
9832 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
9833 TREE_TYPE (packs
) = orig_arg
;
9837 /* We can't substitute for this parameter pack. We use a flag as
9838 well as the missing_level counter because function parameter
9839 packs don't have a level. */
9840 unsubstituted_packs
= true;
9844 /* We cannot expand this expansion expression, because we don't have
9845 all of the argument packs we need. */
9846 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
9848 /* We got some full packs, but we can't substitute them in until we
9849 have values for all the packs. So remember these until then. */
9851 t
= make_pack_expansion (pattern
);
9852 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
9855 else if (unsubstituted_packs
)
9857 /* There were no real arguments, we're just replacing a parameter
9858 pack with another version of itself. Substitute into the
9859 pattern and return a PACK_EXPANSION_*. The caller will need to
9861 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
9862 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9863 /*integral_constant_expression_p=*/false);
9865 t
= tsubst (pattern
, args
, complain
, in_decl
);
9866 t
= make_pack_expansion (t
);
9870 gcc_assert (len
>= 0);
9872 if (need_local_specializations
)
9874 /* We're in a late-specified return type, so create our own local
9875 specializations map; the current map is either NULL or (in the
9876 case of recursive unification) might have bindings that we don't
9877 want to use or alter. */
9878 saved_local_specializations
= local_specializations
;
9879 local_specializations
= pointer_map_create ();
9882 /* For each argument in each argument pack, substitute into the
9884 result
= make_tree_vec (len
);
9885 for (i
= 0; i
< len
; ++i
)
9887 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
9891 TREE_VEC_ELT (result
, i
) = t
;
9892 if (t
== error_mark_node
)
9894 result
= error_mark_node
;
9899 /* Update ARGS to restore the substitution from parameter packs to
9900 their argument packs. */
9901 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
9903 tree parm
= TREE_PURPOSE (pack
);
9905 if (TREE_CODE (parm
) == PARM_DECL
9906 || TREE_CODE (parm
) == FIELD_DECL
)
9907 register_local_specialization (TREE_TYPE (pack
), parm
);
9912 if (TREE_VALUE (pack
) == NULL_TREE
)
9915 template_parm_level_and_index (parm
, &level
, &idx
);
9917 /* Update the corresponding argument. */
9918 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
9919 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
9922 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
9926 if (need_local_specializations
)
9928 pointer_map_destroy (local_specializations
);
9929 local_specializations
= saved_local_specializations
;
9935 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
9936 TMPL. We do this using DECL_PARM_INDEX, which should work even with
9937 parameter packs; all parms generated from a function parameter pack will
9938 have the same DECL_PARM_INDEX. */
9941 get_pattern_parm (tree parm
, tree tmpl
)
9943 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
9946 if (DECL_ARTIFICIAL (parm
))
9948 for (patparm
= DECL_ARGUMENTS (pattern
);
9949 patparm
; patparm
= DECL_CHAIN (patparm
))
9950 if (DECL_ARTIFICIAL (patparm
)
9951 && DECL_NAME (parm
) == DECL_NAME (patparm
))
9956 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
9957 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
9958 gcc_assert (DECL_PARM_INDEX (patparm
)
9959 == DECL_PARM_INDEX (parm
));
9965 /* Substitute ARGS into the vector or list of template arguments T. */
9968 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9971 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
9974 if (t
== error_mark_node
)
9975 return error_mark_node
;
9977 len
= TREE_VEC_LENGTH (t
);
9978 elts
= XALLOCAVEC (tree
, len
);
9980 for (i
= 0; i
< len
; i
++)
9982 tree orig_arg
= TREE_VEC_ELT (t
, i
);
9985 if (TREE_CODE (orig_arg
) == TREE_VEC
)
9986 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
9987 else if (PACK_EXPANSION_P (orig_arg
))
9989 /* Substitute into an expansion expression. */
9990 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
9992 if (TREE_CODE (new_arg
) == TREE_VEC
)
9993 /* Add to the expanded length adjustment the number of
9994 expanded arguments. We subtract one from this
9995 measurement, because the argument pack expression
9996 itself is already counted as 1 in
9997 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
9998 the argument pack is empty. */
9999 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
10001 else if (ARGUMENT_PACK_P (orig_arg
))
10003 /* Substitute into each of the arguments. */
10004 new_arg
= TYPE_P (orig_arg
)
10005 ? cxx_make_type (TREE_CODE (orig_arg
))
10006 : make_node (TREE_CODE (orig_arg
));
10008 SET_ARGUMENT_PACK_ARGS (
10010 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
10011 args
, complain
, in_decl
));
10013 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
10014 new_arg
= error_mark_node
;
10016 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
10017 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
10018 complain
, in_decl
);
10019 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
10021 if (TREE_TYPE (new_arg
) == error_mark_node
)
10022 new_arg
= error_mark_node
;
10026 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
10028 if (new_arg
== error_mark_node
)
10029 return error_mark_node
;
10032 if (new_arg
!= orig_arg
)
10039 /* Make space for the expanded arguments coming from template
10041 t
= make_tree_vec (len
+ expanded_len_adjust
);
10042 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10043 arguments for a member template.
10044 In that case each TREE_VEC in ORIG_T represents a level of template
10045 arguments, and ORIG_T won't carry any non defaulted argument count.
10046 It will rather be the nested TREE_VECs that will carry one.
10047 In other words, ORIG_T carries a non defaulted argument count only
10048 if it doesn't contain any nested TREE_VEC. */
10049 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
10051 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
10052 count
+= expanded_len_adjust
;
10053 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
10055 for (i
= 0, out
= 0; i
< len
; i
++)
10057 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
10058 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
10059 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10063 /* Now expand the template argument pack "in place". */
10064 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10065 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10069 TREE_VEC_ELT (t
, out
) = elts
[i
];
10077 /* Return the result of substituting ARGS into the template parameters
10078 given by PARMS. If there are m levels of ARGS and m + n levels of
10079 PARMS, then the result will contain n levels of PARMS. For
10080 example, if PARMS is `template <class T> template <class U>
10081 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10082 result will be `template <int*, double, class V>'. */
10085 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10087 tree r
= NULL_TREE
;
10090 /* When substituting into a template, we must set
10091 PROCESSING_TEMPLATE_DECL as the template parameters may be
10092 dependent if they are based on one-another, and the dependency
10093 predicates are short-circuit outside of templates. */
10094 ++processing_template_decl
;
10096 for (new_parms
= &r
;
10097 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10098 new_parms
= &(TREE_CHAIN (*new_parms
)),
10099 parms
= TREE_CHAIN (parms
))
10102 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10105 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10109 if (parms
== error_mark_node
)
10112 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10114 if (tuple
== error_mark_node
)
10117 TREE_VEC_ELT (new_vec
, i
) =
10118 tsubst_template_parm (tuple
, args
, complain
);
10122 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10123 - TMPL_ARGS_DEPTH (args
)),
10124 new_vec
, NULL_TREE
);
10127 --processing_template_decl
;
10132 /* Return the result of substituting ARGS into one template parameter
10133 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10134 parameter and which TREE_PURPOSE is the default argument of the
10135 template parameter. */
10138 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10140 tree default_value
, parm_decl
;
10142 if (args
== NULL_TREE
10144 || t
== error_mark_node
)
10147 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10149 default_value
= TREE_PURPOSE (t
);
10150 parm_decl
= TREE_VALUE (t
);
10152 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10153 if (TREE_CODE (parm_decl
) == PARM_DECL
10154 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10155 parm_decl
= error_mark_node
;
10156 default_value
= tsubst_template_arg (default_value
, args
,
10157 complain
, NULL_TREE
);
10159 return build_tree_list (default_value
, parm_decl
);
10162 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10163 type T. If T is not an aggregate or enumeration type, it is
10164 handled as if by tsubst. IN_DECL is as for tsubst. If
10165 ENTERING_SCOPE is nonzero, T is the context for a template which
10166 we are presently tsubst'ing. Return the substituted value. */
10169 tsubst_aggr_type (tree t
,
10171 tsubst_flags_t complain
,
10173 int entering_scope
)
10175 if (t
== NULL_TREE
)
10178 switch (TREE_CODE (t
))
10181 if (TYPE_PTRMEMFUNC_P (t
))
10182 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10184 /* Else fall through. */
10185 case ENUMERAL_TYPE
:
10187 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10192 int saved_unevaluated_operand
;
10193 int saved_inhibit_evaluation_warnings
;
10195 /* In "sizeof(X<I>)" we need to evaluate "I". */
10196 saved_unevaluated_operand
= cp_unevaluated_operand
;
10197 cp_unevaluated_operand
= 0;
10198 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10199 c_inhibit_evaluation_warnings
= 0;
10201 /* First, determine the context for the type we are looking
10203 context
= TYPE_CONTEXT (t
);
10204 if (context
&& TYPE_P (context
))
10206 context
= tsubst_aggr_type (context
, args
, complain
,
10207 in_decl
, /*entering_scope=*/1);
10208 /* If context is a nested class inside a class template,
10209 it may still need to be instantiated (c++/33959). */
10210 context
= complete_type (context
);
10213 /* Then, figure out what arguments are appropriate for the
10214 type we are trying to find. For example, given:
10216 template <class T> struct S;
10217 template <class T, class U> void f(T, U) { S<U> su; }
10219 and supposing that we are instantiating f<int, double>,
10220 then our ARGS will be {int, double}, but, when looking up
10221 S we only want {double}. */
10222 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10223 complain
, in_decl
);
10224 if (argvec
== error_mark_node
)
10225 r
= error_mark_node
;
10228 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10229 entering_scope
, complain
);
10230 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10233 cp_unevaluated_operand
= saved_unevaluated_operand
;
10234 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10239 /* This is not a template type, so there's nothing to do. */
10243 return tsubst (t
, args
, complain
, in_decl
);
10247 /* Substitute into the default argument ARG (a default argument for
10248 FN), which has the indicated TYPE. */
10251 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10253 tree saved_class_ptr
= NULL_TREE
;
10254 tree saved_class_ref
= NULL_TREE
;
10255 int errs
= errorcount
+ sorrycount
;
10257 /* This can happen in invalid code. */
10258 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10261 /* This default argument came from a template. Instantiate the
10262 default argument here, not in tsubst. In the case of
10271 we must be careful to do name lookup in the scope of S<T>,
10272 rather than in the current class. */
10273 push_access_scope (fn
);
10274 /* The "this" pointer is not valid in a default argument. */
10277 saved_class_ptr
= current_class_ptr
;
10278 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10279 saved_class_ref
= current_class_ref
;
10280 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10283 push_deferring_access_checks(dk_no_deferred
);
10284 /* The default argument expression may cause implicitly defined
10285 member functions to be synthesized, which will result in garbage
10286 collection. We must treat this situation as if we were within
10287 the body of function so as to avoid collecting live data on the
10290 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10291 complain
, NULL_TREE
,
10292 /*integral_constant_expression_p=*/false);
10294 pop_deferring_access_checks();
10296 /* Restore the "this" pointer. */
10299 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10300 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10303 if (errorcount
+sorrycount
> errs
10304 && (complain
& tf_warning_or_error
))
10305 inform (input_location
,
10306 " when instantiating default argument for call to %D", fn
);
10308 /* Make sure the default argument is reasonable. */
10309 arg
= check_default_argument (type
, arg
, complain
);
10311 pop_access_scope (fn
);
10316 /* Substitute into all the default arguments for FN. */
10319 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10324 tmpl_args
= DECL_TI_ARGS (fn
);
10326 /* If this function is not yet instantiated, we certainly don't need
10327 its default arguments. */
10328 if (uses_template_parms (tmpl_args
))
10330 /* Don't do this again for clones. */
10331 if (DECL_CLONED_FUNCTION_P (fn
))
10334 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10336 arg
= TREE_CHAIN (arg
))
10337 if (TREE_PURPOSE (arg
))
10338 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10340 TREE_PURPOSE (arg
),
10344 /* Substitute the ARGS into the T, which is a _DECL. Return the
10345 result of the substitution. Issue error and warning messages under
10346 control of COMPLAIN. */
10349 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10351 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10352 location_t saved_loc
;
10353 tree r
= NULL_TREE
;
10355 hashval_t hash
= 0;
10357 /* Set the filename and linenumber to improve error-reporting. */
10358 saved_loc
= input_location
;
10359 input_location
= DECL_SOURCE_LOCATION (t
);
10361 switch (TREE_CODE (t
))
10363 case TEMPLATE_DECL
:
10365 /* We can get here when processing a member function template,
10366 member class template, or template template parameter. */
10367 tree decl
= DECL_TEMPLATE_RESULT (t
);
10372 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10374 /* Template template parameter is treated here. */
10375 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10376 if (new_type
== error_mark_node
)
10377 RETURN (error_mark_node
);
10378 /* If we get a real template back, return it. This can happen in
10379 the context of most_specialized_class. */
10380 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10384 DECL_CHAIN (r
) = NULL_TREE
;
10385 TREE_TYPE (r
) = new_type
;
10386 DECL_TEMPLATE_RESULT (r
)
10387 = build_decl (DECL_SOURCE_LOCATION (decl
),
10388 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10389 DECL_TEMPLATE_PARMS (r
)
10390 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10392 TYPE_NAME (new_type
) = r
;
10396 /* We might already have an instance of this template.
10397 The ARGS are for the surrounding class type, so the
10398 full args contain the tsubst'd args for the context,
10399 plus the innermost args from the template decl. */
10400 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10401 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10402 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10403 /* Because this is a template, the arguments will still be
10404 dependent, even after substitution. If
10405 PROCESSING_TEMPLATE_DECL is not set, the dependency
10406 predicates will short-circuit. */
10407 ++processing_template_decl
;
10408 full_args
= tsubst_template_args (tmpl_args
, args
,
10409 complain
, in_decl
);
10410 --processing_template_decl
;
10411 if (full_args
== error_mark_node
)
10412 RETURN (error_mark_node
);
10414 /* If this is a default template template argument,
10415 tsubst might not have changed anything. */
10416 if (full_args
== tmpl_args
)
10419 hash
= hash_tmpl_and_args (t
, full_args
);
10420 spec
= retrieve_specialization (t
, full_args
, hash
);
10421 if (spec
!= NULL_TREE
)
10427 /* Make a new template decl. It will be similar to the
10428 original, but will record the current template arguments.
10429 We also create a new function declaration, which is just
10430 like the old one, but points to this new template, rather
10431 than the old one. */
10433 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10434 DECL_CHAIN (r
) = NULL_TREE
;
10436 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10438 if (TREE_CODE (decl
) == TYPE_DECL
10439 && !TYPE_DECL_ALIAS_P (decl
))
10442 ++processing_template_decl
;
10443 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10444 --processing_template_decl
;
10445 if (new_type
== error_mark_node
)
10446 RETURN (error_mark_node
);
10448 TREE_TYPE (r
) = new_type
;
10449 /* For a partial specialization, we need to keep pointing to
10450 the primary template. */
10451 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10452 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10453 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10454 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10455 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10460 ++processing_template_decl
;
10461 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10462 --processing_template_decl
;
10463 if (new_decl
== error_mark_node
)
10464 RETURN (error_mark_node
);
10466 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10467 DECL_TI_TEMPLATE (new_decl
) = r
;
10468 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10469 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10470 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10473 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10474 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10475 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10477 /* The template parameters for this new template are all the
10478 template parameters for the old template, except the
10479 outermost level of parameters. */
10480 DECL_TEMPLATE_PARMS (r
)
10481 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10484 if (PRIMARY_TEMPLATE_P (t
))
10485 DECL_PRIMARY_TEMPLATE (r
) = r
;
10487 if (TREE_CODE (decl
) != TYPE_DECL
)
10488 /* Record this non-type partial instantiation. */
10489 register_specialization (r
, t
,
10490 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10495 case FUNCTION_DECL
:
10498 tree argvec
= NULL_TREE
;
10506 /* Nobody should be tsubst'ing into non-template functions. */
10507 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10509 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10514 /* If T is not dependent, just return it. We have to
10515 increment PROCESSING_TEMPLATE_DECL because
10516 value_dependent_expression_p assumes that nothing is
10517 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10518 ++processing_template_decl
;
10519 dependent_p
= value_dependent_expression_p (t
);
10520 --processing_template_decl
;
10524 /* Calculate the most general template of which R is a
10525 specialization, and the complete set of arguments used to
10527 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10528 argvec
= tsubst_template_args (DECL_TI_ARGS
10529 (DECL_TEMPLATE_RESULT
10530 (DECL_TI_TEMPLATE (t
))),
10531 args
, complain
, in_decl
);
10532 if (argvec
== error_mark_node
)
10533 RETURN (error_mark_node
);
10535 /* Check to see if we already have this specialization. */
10536 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10537 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10545 /* We can see more levels of arguments than parameters if
10546 there was a specialization of a member template, like
10549 template <class T> struct S { template <class U> void f(); }
10550 template <> template <class U> void S<int>::f(U);
10552 Here, we'll be substituting into the specialization,
10553 because that's where we can find the code we actually
10554 want to generate, but we'll have enough arguments for
10555 the most general template.
10557 We also deal with the peculiar case:
10559 template <class T> struct S {
10560 template <class U> friend void f();
10562 template <class U> void f() {}
10564 template void f<double>();
10566 Here, the ARGS for the instantiation of will be {int,
10567 double}. But, we only need as many ARGS as there are
10568 levels of template parameters in CODE_PATTERN. We are
10569 careful not to get fooled into reducing the ARGS in
10572 template <class T> struct S { template <class U> void f(U); }
10573 template <class T> template <> void S<T>::f(int) {}
10575 which we can spot because the pattern will be a
10576 specialization in this case. */
10577 args_depth
= TMPL_ARGS_DEPTH (args
);
10579 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10580 if (args_depth
> parms_depth
10581 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10582 args
= get_innermost_template_args (args
, parms_depth
);
10586 /* This special case arises when we have something like this:
10588 template <class T> struct S {
10589 friend void f<int>(int, double);
10592 Here, the DECL_TI_TEMPLATE for the friend declaration
10593 will be an IDENTIFIER_NODE. We are being called from
10594 tsubst_friend_function, and we want only to create a
10595 new decl (R) with appropriate types so that we can call
10596 determine_specialization. */
10597 gen_tmpl
= NULL_TREE
;
10600 if (DECL_CLASS_SCOPE_P (t
))
10602 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10606 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10607 complain
, t
, /*entering_scope=*/1);
10612 ctx
= DECL_CONTEXT (t
);
10614 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10615 if (type
== error_mark_node
)
10616 RETURN (error_mark_node
);
10618 /* If we hit excessive deduction depth, the type is bogus even if
10619 it isn't error_mark_node, so don't build a decl. */
10620 if (excessive_deduction_depth
)
10621 RETURN (error_mark_node
);
10623 /* We do NOT check for matching decls pushed separately at this
10624 point, as they may not represent instantiations of this
10625 template, and in any case are considered separate under the
10628 DECL_USE_TEMPLATE (r
) = 0;
10629 TREE_TYPE (r
) = type
;
10630 /* Clear out the mangled name and RTL for the instantiation. */
10631 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10632 SET_DECL_RTL (r
, NULL
);
10633 /* Leave DECL_INITIAL set on deleted instantiations. */
10634 if (!DECL_DELETED_FN (r
))
10635 DECL_INITIAL (r
) = NULL_TREE
;
10636 DECL_CONTEXT (r
) = ctx
;
10638 /* OpenMP UDRs have the only argument a reference to the declared
10639 type. We want to diagnose if the declared type is a reference,
10640 which is invalid, but as references to references are usually
10641 quietly merged, diagnose it here. */
10642 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10645 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10646 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10647 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10648 error_at (DECL_SOURCE_LOCATION (t
),
10649 "reference type %qT in "
10650 "%<#pragma omp declare reduction%>", argtype
);
10651 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10652 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10656 if (member
&& DECL_CONV_FN_P (r
))
10657 /* Type-conversion operator. Reconstruct the name, in
10658 case it's the name of one of the template's parameters. */
10659 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10661 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10663 DECL_RESULT (r
) = NULL_TREE
;
10665 TREE_STATIC (r
) = 0;
10666 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10667 DECL_EXTERNAL (r
) = 1;
10668 /* If this is an instantiation of a function with internal
10669 linkage, we already know what object file linkage will be
10670 assigned to the instantiation. */
10671 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10672 DECL_DEFER_OUTPUT (r
) = 0;
10673 DECL_CHAIN (r
) = NULL_TREE
;
10674 DECL_PENDING_INLINE_INFO (r
) = 0;
10675 DECL_PENDING_INLINE_P (r
) = 0;
10676 DECL_SAVED_TREE (r
) = NULL_TREE
;
10677 DECL_STRUCT_FUNCTION (r
) = NULL
;
10679 /* We'll re-clone as appropriate in instantiate_template. */
10680 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10682 /* If we aren't complaining now, return on error before we register
10683 the specialization so that we'll complain eventually. */
10684 if ((complain
& tf_error
) == 0
10685 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10686 && !grok_op_properties (r
, /*complain=*/false))
10687 RETURN (error_mark_node
);
10689 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10690 this in the special friend case mentioned above where
10691 GEN_TMPL is NULL. */
10694 DECL_TEMPLATE_INFO (r
)
10695 = build_template_info (gen_tmpl
, argvec
);
10696 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10699 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10701 /* We instantiated this while substituting into
10702 the type earlier (template/friend54.C). */
10705 /* We're not supposed to instantiate default arguments
10706 until they are called, for a template. But, for a
10709 template <class T> void f ()
10710 { extern void g(int i = T()); }
10712 we should do the substitution when the template is
10713 instantiated. We handle the member function case in
10714 instantiate_class_template since the default arguments
10715 might refer to other members of the class. */
10717 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10718 && !uses_template_parms (argvec
))
10719 tsubst_default_arguments (r
, complain
);
10722 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10724 /* Copy the list of befriending classes. */
10725 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10727 friends
= &TREE_CHAIN (*friends
))
10729 *friends
= copy_node (*friends
);
10730 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
10735 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
10737 maybe_retrofit_in_chrg (r
);
10738 if (DECL_CONSTRUCTOR_P (r
))
10739 grok_ctor_properties (ctx
, r
);
10740 if (DECL_INHERITED_CTOR_BASE (r
))
10741 deduce_inheriting_ctor (r
);
10742 /* If this is an instantiation of a member template, clone it.
10743 If it isn't, that'll be handled by
10744 clone_constructors_and_destructors. */
10745 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
10746 clone_function_decl (r
, /*update_method_vec_p=*/0);
10748 else if ((complain
& tf_error
) != 0
10749 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10750 && !grok_op_properties (r
, /*complain=*/true))
10751 RETURN (error_mark_node
);
10753 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
10754 SET_DECL_FRIEND_CONTEXT (r
,
10755 tsubst (DECL_FRIEND_CONTEXT (t
),
10756 args
, complain
, in_decl
));
10758 /* Possibly limit visibility based on template args. */
10759 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10760 if (DECL_VISIBILITY_SPECIFIED (t
))
10762 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10763 DECL_ATTRIBUTES (r
)
10764 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10766 determine_visibility (r
);
10767 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
10768 && !processing_template_decl
)
10769 defaulted_late_check (r
);
10771 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10772 args
, complain
, in_decl
);
10778 tree type
= NULL_TREE
;
10780 tree expanded_types
= NULL_TREE
;
10781 tree prev_r
= NULL_TREE
;
10782 tree first_r
= NULL_TREE
;
10784 if (DECL_PACK_P (t
))
10786 /* If there is a local specialization that isn't a
10787 parameter pack, it means that we're doing a "simple"
10788 substitution from inside tsubst_pack_expansion. Just
10789 return the local specialization (which will be a single
10791 tree spec
= retrieve_local_specialization (t
);
10793 && TREE_CODE (spec
) == PARM_DECL
10794 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
10797 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10798 the parameters in this function parameter pack. */
10799 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10800 complain
, in_decl
);
10801 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10803 len
= TREE_VEC_LENGTH (expanded_types
);
10805 /* Zero-length parameter packs are boring. Just substitute
10808 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
10813 /* All we did was update the type. Make a note of that. */
10814 type
= expanded_types
;
10815 expanded_types
= NULL_TREE
;
10819 /* Loop through all of the parameters we'll build. When T is
10820 a function parameter pack, LEN is the number of expanded
10821 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10823 for (i
= 0; i
< len
; ++i
)
10827 if (DECL_TEMPLATE_PARM_P (t
))
10828 SET_DECL_TEMPLATE_PARM_P (r
);
10830 if (expanded_types
)
10831 /* We're on the Ith parameter of the function parameter
10834 /* Get the Ith type. */
10835 type
= TREE_VEC_ELT (expanded_types
, i
);
10837 /* Rename the parameter to include the index. */
10839 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10842 /* We're dealing with a normal parameter. */
10843 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10845 type
= type_decays_to (type
);
10846 TREE_TYPE (r
) = type
;
10847 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10849 if (DECL_INITIAL (r
))
10851 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
10852 DECL_INITIAL (r
) = TREE_TYPE (r
);
10854 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
10855 complain
, in_decl
);
10858 DECL_CONTEXT (r
) = NULL_TREE
;
10860 if (!DECL_TEMPLATE_PARM_P (r
))
10861 DECL_ARG_TYPE (r
) = type_passed_as (type
);
10863 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10864 args
, complain
, in_decl
);
10866 /* Keep track of the first new parameter we
10867 generate. That's what will be returned to the
10872 /* Build a proper chain of parameters when substituting
10873 into a function parameter pack. */
10875 DECL_CHAIN (prev_r
) = r
;
10878 /* If cp_unevaluated_operand is set, we're just looking for a
10879 single dummy parameter, so don't keep going. */
10880 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
10881 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
10882 complain
, DECL_CHAIN (t
));
10884 /* FIRST_R contains the start of the chain we've built. */
10891 tree type
= NULL_TREE
;
10892 tree vec
= NULL_TREE
;
10893 tree expanded_types
= NULL_TREE
;
10896 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
10898 /* This field is a lambda capture pack. Return a TREE_VEC of
10899 the expanded fields to instantiate_class_template_1 and
10900 store them in the specializations hash table as a
10901 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
10902 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10903 complain
, in_decl
);
10904 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10906 len
= TREE_VEC_LENGTH (expanded_types
);
10907 vec
= make_tree_vec (len
);
10911 /* All we did was update the type. Make a note of that. */
10912 type
= expanded_types
;
10913 expanded_types
= NULL_TREE
;
10917 for (int i
= 0; i
< len
; ++i
)
10920 if (expanded_types
)
10922 type
= TREE_VEC_ELT (expanded_types
, i
);
10924 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10927 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10929 if (type
== error_mark_node
)
10930 RETURN (error_mark_node
);
10931 TREE_TYPE (r
) = type
;
10932 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10934 if (DECL_C_BIT_FIELD (r
))
10935 /* For bit-fields, DECL_INITIAL gives the number of bits. For
10936 non-bit-fields DECL_INITIAL is a non-static data member
10937 initializer, which gets deferred instantiation. */
10939 = tsubst_expr (DECL_INITIAL (t
), args
,
10941 /*integral_constant_expression_p=*/true);
10942 else if (DECL_INITIAL (t
))
10944 /* Set up DECL_TEMPLATE_INFO so that we can get at the
10945 NSDMI in perform_member_init. Still set DECL_INITIAL
10946 so that we know there is one. */
10947 DECL_INITIAL (r
) = void_node
;
10948 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
10949 retrofit_lang_decl (r
);
10950 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10952 /* We don't have to set DECL_CONTEXT here; it is set by
10953 finish_member_declaration. */
10954 DECL_CHAIN (r
) = NULL_TREE
;
10956 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10957 args
, complain
, in_decl
);
10960 TREE_VEC_ELT (vec
, i
) = r
;
10966 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
10967 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
10968 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
10969 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
10970 TREE_TYPE (pack
) = tpack
;
10971 register_specialization (pack
, t
, args
, false, 0);
10977 /* We reach here only for member using decls. We also need to check
10978 uses_template_parms because DECL_DEPENDENT_P is not set for a
10979 using-declaration that designates a member of the current
10980 instantiation (c++/53549). */
10981 if (DECL_DEPENDENT_P (t
)
10982 || uses_template_parms (USING_DECL_SCOPE (t
)))
10984 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
10985 complain
, in_decl
);
10986 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
10987 r
= do_class_using_decl (inst_scope
, name
);
10989 r
= error_mark_node
;
10992 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
10993 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
10999 DECL_CHAIN (r
) = NULL_TREE
;
11006 tree argvec
= NULL_TREE
;
11007 tree gen_tmpl
= NULL_TREE
;
11009 tree tmpl
= NULL_TREE
;
11011 tree type
= NULL_TREE
;
11014 if (TREE_TYPE (t
) == error_mark_node
)
11015 RETURN (error_mark_node
);
11017 if (TREE_CODE (t
) == TYPE_DECL
11018 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
11020 /* If this is the canonical decl, we don't have to
11021 mess with instantiations, and often we can't (for
11022 typename, template type parms and such). Note that
11023 TYPE_NAME is not correct for the above test if
11024 we've copied the type for a typedef. */
11025 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11026 if (type
== error_mark_node
)
11027 RETURN (error_mark_node
);
11028 r
= TYPE_NAME (type
);
11032 /* Check to see if we already have the specialization we
11035 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
11037 /* T is a static data member or namespace-scope entity.
11038 We have to substitute into namespace-scope variables
11039 (even though such entities are never templates) because
11042 template <class T> void f() { extern T t; }
11044 where the entity referenced is not known until
11045 instantiation time. */
11047 ctx
= DECL_CONTEXT (t
);
11048 if (DECL_CLASS_SCOPE_P (t
))
11050 ctx
= tsubst_aggr_type (ctx
, args
,
11052 in_decl
, /*entering_scope=*/1);
11053 /* If CTX is unchanged, then T is in fact the
11054 specialization we want. That situation occurs when
11055 referencing a static data member within in its own
11056 class. We can use pointer equality, rather than
11057 same_type_p, because DECL_CONTEXT is always
11059 if (ctx
== DECL_CONTEXT (t
)
11060 && (TREE_CODE (t
) != TYPE_DECL
11061 /* ... unless T is a member template; in which
11062 case our caller can be willing to create a
11063 specialization of that template represented
11065 || !(DECL_TI_TEMPLATE (t
)
11066 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))))
11072 tmpl
= DECL_TI_TEMPLATE (t
);
11073 gen_tmpl
= most_general_template (tmpl
);
11074 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11075 if (argvec
== error_mark_node
)
11076 RETURN (error_mark_node
);
11077 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11078 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11083 /* A local variable. */
11085 /* Subsequent calls to pushdecl will fill this in. */
11087 spec
= retrieve_local_specialization (t
);
11089 /* If we already have the specialization we need, there is
11090 nothing more to do. */
11097 /* Create a new node for the specialization we need. */
11099 if (type
== NULL_TREE
)
11101 if (is_typedef_decl (t
))
11102 type
= DECL_ORIGINAL_TYPE (t
);
11104 type
= TREE_TYPE (t
);
11106 && VAR_HAD_UNKNOWN_BOUND (t
)
11107 && type
!= error_mark_node
)
11108 type
= strip_array_domain (type
);
11109 type
= tsubst (type
, args
, complain
, in_decl
);
11113 /* Even if the original location is out of scope, the
11114 newly substituted one is not. */
11115 DECL_DEAD_FOR_LOCAL (r
) = 0;
11116 DECL_INITIALIZED_P (r
) = 0;
11117 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11118 if (type
== error_mark_node
)
11119 RETURN (error_mark_node
);
11120 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11122 /* It may seem that this case cannot occur, since:
11127 declares a function, not a variable. However:
11130 template <typename T> void g() { T t; }
11131 template void g<f>();
11133 is an attempt to declare a variable with function
11135 error ("variable %qD has function type",
11136 /* R is not yet sufficiently initialized, so we
11137 just use its name. */
11139 RETURN (error_mark_node
);
11141 type
= complete_type (type
);
11142 /* Wait until cp_finish_decl to set this again, to handle
11143 circular dependency (template/instantiate6.C). */
11144 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11145 type
= check_var_type (DECL_NAME (r
), type
);
11147 if (DECL_HAS_VALUE_EXPR_P (t
))
11149 tree ve
= DECL_VALUE_EXPR (t
);
11150 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11151 /*constant_expression_p=*/false);
11152 if (REFERENCE_REF_P (ve
))
11154 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11155 ve
= TREE_OPERAND (ve
, 0);
11157 SET_DECL_VALUE_EXPR (r
, ve
);
11160 else if (DECL_SELF_REFERENCE_P (t
))
11161 SET_DECL_SELF_REFERENCE_P (r
);
11162 TREE_TYPE (r
) = type
;
11163 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11164 DECL_CONTEXT (r
) = ctx
;
11165 /* Clear out the mangled name and RTL for the instantiation. */
11166 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11167 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11168 SET_DECL_RTL (r
, NULL
);
11169 /* The initializer must not be expanded until it is required;
11170 see [temp.inst]. */
11171 DECL_INITIAL (r
) = NULL_TREE
;
11172 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11173 SET_DECL_RTL (r
, NULL
);
11174 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11177 /* Possibly limit visibility based on template args. */
11178 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11179 if (DECL_VISIBILITY_SPECIFIED (t
))
11181 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11182 DECL_ATTRIBUTES (r
)
11183 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11185 determine_visibility (r
);
11190 /* A static data member declaration is always marked
11191 external when it is declared in-class, even if an
11192 initializer is present. We mimic the non-template
11193 processing here. */
11194 DECL_EXTERNAL (r
) = 1;
11196 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11197 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11198 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11200 else if (!cp_unevaluated_operand
)
11201 register_local_specialization (r
, t
);
11203 DECL_CHAIN (r
) = NULL_TREE
;
11205 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11207 args
, complain
, in_decl
);
11209 /* Preserve a typedef that names a type. */
11210 if (is_typedef_decl (r
))
11212 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11213 set_underlying_type (r
);
11216 layout_decl (r
, 0);
11221 gcc_unreachable ();
11226 /* Restore the file and line information. */
11227 input_location
= saved_loc
;
11232 /* Substitute into the ARG_TYPES of a function type.
11233 If END is a TREE_CHAIN, leave it and any following types
11237 tsubst_arg_types (tree arg_types
,
11240 tsubst_flags_t complain
,
11243 tree remaining_arg_types
;
11244 tree type
= NULL_TREE
;
11246 tree expanded_args
= NULL_TREE
;
11249 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11252 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11253 args
, end
, complain
, in_decl
);
11254 if (remaining_arg_types
== error_mark_node
)
11255 return error_mark_node
;
11257 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11259 /* For a pack expansion, perform substitution on the
11260 entire expression. Later on, we'll handle the arguments
11262 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11263 args
, complain
, in_decl
);
11265 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11266 /* So that we'll spin through the parameters, one by one. */
11267 i
= TREE_VEC_LENGTH (expanded_args
);
11270 /* We only partially substituted into the parameter
11271 pack. Our type is TYPE_PACK_EXPANSION. */
11272 type
= expanded_args
;
11273 expanded_args
= NULL_TREE
;
11281 type
= TREE_VEC_ELT (expanded_args
, i
);
11283 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11285 if (type
== error_mark_node
)
11286 return error_mark_node
;
11287 if (VOID_TYPE_P (type
))
11289 if (complain
& tf_error
)
11291 error ("invalid parameter type %qT", type
);
11293 error ("in declaration %q+D", in_decl
);
11295 return error_mark_node
;
11298 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11299 return error_mark_node
;
11301 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11302 top-level qualifiers as required. */
11303 type
= cv_unqualified (type_decays_to (type
));
11305 /* We do not substitute into default arguments here. The standard
11306 mandates that they be instantiated only when needed, which is
11307 done in build_over_call. */
11308 default_arg
= TREE_PURPOSE (arg_types
);
11310 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11312 /* We've instantiated a template before its default arguments
11313 have been parsed. This can happen for a nested template
11314 class, and is not an error unless we require the default
11315 argument in a call of this function. */
11316 remaining_arg_types
=
11317 tree_cons (default_arg
, type
, remaining_arg_types
);
11318 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11321 remaining_arg_types
=
11322 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11325 return remaining_arg_types
;
11328 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11329 *not* handle the exception-specification for FNTYPE, because the
11330 initial substitution of explicitly provided template parameters
11331 during argument deduction forbids substitution into the
11332 exception-specification:
11336 All references in the function type of the function template to the
11337 corresponding template parameters are replaced by the specified tem-
11338 plate argument values. If a substitution in a template parameter or
11339 in the function type of the function template results in an invalid
11340 type, type deduction fails. [Note: The equivalent substitution in
11341 exception specifications is done only when the function is instanti-
11342 ated, at which point a program is ill-formed if the substitution
11343 results in an invalid type.] */
11346 tsubst_function_type (tree t
,
11348 tsubst_flags_t complain
,
11352 tree arg_types
= NULL_TREE
;
11355 /* The TYPE_CONTEXT is not used for function/method types. */
11356 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11358 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11360 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11362 if (late_return_type_p
)
11364 /* Substitute the argument types. */
11365 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11366 complain
, in_decl
);
11367 if (arg_types
== error_mark_node
)
11368 return error_mark_node
;
11370 tree save_ccp
= current_class_ptr
;
11371 tree save_ccr
= current_class_ref
;
11372 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11373 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11374 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11377 /* DR 1207: 'this' is in scope in the trailing return type. */
11378 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11381 /* Substitute the return type. */
11382 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11386 current_class_ptr
= save_ccp
;
11387 current_class_ref
= save_ccr
;
11391 /* Substitute the return type. */
11392 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11394 if (return_type
== error_mark_node
)
11395 return error_mark_node
;
11396 /* DR 486 clarifies that creation of a function type with an
11397 invalid return type is a deduction failure. */
11398 if (TREE_CODE (return_type
) == ARRAY_TYPE
11399 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11401 if (complain
& tf_error
)
11403 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11404 error ("function returning an array");
11406 error ("function returning a function");
11408 return error_mark_node
;
11411 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11412 return error_mark_node
;
11414 if (!late_return_type_p
)
11416 /* Substitute the argument types. */
11417 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11418 complain
, in_decl
);
11419 if (arg_types
== error_mark_node
)
11420 return error_mark_node
;
11423 /* Construct a new type node and return it. */
11424 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11426 fntype
= build_function_type (return_type
, arg_types
);
11427 fntype
= apply_memfn_quals (fntype
,
11428 type_memfn_quals (t
),
11429 type_memfn_rqual (t
));
11433 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11434 /* Don't pick up extra function qualifiers from the basetype. */
11435 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11436 if (! MAYBE_CLASS_TYPE_P (r
))
11440 Type deduction may fail for any of the following
11443 -- Attempting to create "pointer to member of T" when T
11444 is not a class type. */
11445 if (complain
& tf_error
)
11446 error ("creating pointer to member function of non-class type %qT",
11448 return error_mark_node
;
11451 fntype
= build_method_type_directly (r
, return_type
,
11452 TREE_CHAIN (arg_types
));
11453 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11455 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11457 if (late_return_type_p
)
11458 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11463 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11464 ARGS into that specification, and return the substituted
11465 specification. If there is no specification, return NULL_TREE. */
11468 tsubst_exception_specification (tree fntype
,
11470 tsubst_flags_t complain
,
11477 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11478 new_specs
= NULL_TREE
;
11479 if (specs
&& TREE_PURPOSE (specs
))
11481 /* A noexcept-specifier. */
11482 tree expr
= TREE_PURPOSE (specs
);
11483 if (TREE_CODE (expr
) == INTEGER_CST
)
11487 /* Defer instantiation of noexcept-specifiers to avoid
11488 excessive instantiations (c++/49107). */
11489 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11490 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11492 /* We already partially instantiated this member template,
11493 so combine the new args with the old. */
11494 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11495 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11496 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11497 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11501 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11502 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11506 new_specs
= tsubst_copy_and_build
11507 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11508 /*integral_constant_expression_p=*/true);
11509 new_specs
= build_noexcept_spec (new_specs
, complain
);
11513 if (! TREE_VALUE (specs
))
11520 tree expanded_specs
= NULL_TREE
;
11522 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11524 /* Expand the pack expansion type. */
11525 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11529 if (expanded_specs
== error_mark_node
)
11530 return error_mark_node
;
11531 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11532 len
= TREE_VEC_LENGTH (expanded_specs
);
11535 /* We're substituting into a member template, so
11536 we got a TYPE_PACK_EXPANSION back. Add that
11537 expansion and move on. */
11538 gcc_assert (TREE_CODE (expanded_specs
)
11539 == TYPE_PACK_EXPANSION
);
11540 new_specs
= add_exception_specifier (new_specs
,
11543 specs
= TREE_CHAIN (specs
);
11548 for (i
= 0; i
< len
; ++i
)
11550 if (expanded_specs
)
11551 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11553 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11554 if (spec
== error_mark_node
)
11556 new_specs
= add_exception_specifier (new_specs
, spec
,
11560 specs
= TREE_CHAIN (specs
);
11566 /* Take the tree structure T and replace template parameters used
11567 therein with the argument vector ARGS. IN_DECL is an associated
11568 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11569 Issue error and warning messages under control of COMPLAIN. Note
11570 that we must be relatively non-tolerant of extensions here, in
11571 order to preserve conformance; if we allow substitutions that
11572 should not be allowed, we may allow argument deductions that should
11573 not succeed, and therefore report ambiguous overload situations
11574 where there are none. In theory, we could allow the substitution,
11575 but indicate that it should have failed, and allow our caller to
11576 make sure that the right thing happens, but we don't try to do this
11579 This function is used for dealing with types, decls and the like;
11580 for expressions, use tsubst_expr or tsubst_copy. */
11583 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11585 enum tree_code code
;
11586 tree type
, r
= NULL_TREE
;
11588 if (t
== NULL_TREE
|| t
== error_mark_node
11589 || t
== integer_type_node
11590 || t
== void_type_node
11591 || t
== char_type_node
11592 || t
== unknown_type_node
11593 || TREE_CODE (t
) == NAMESPACE_DECL
11594 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11598 return tsubst_decl (t
, args
, complain
);
11600 if (args
== NULL_TREE
)
11603 code
= TREE_CODE (t
);
11605 if (code
== IDENTIFIER_NODE
)
11606 type
= IDENTIFIER_TYPE_VALUE (t
);
11608 type
= TREE_TYPE (t
);
11610 gcc_assert (type
!= unknown_type_node
);
11612 /* Reuse typedefs. We need to do this to handle dependent attributes,
11613 such as attribute aligned. */
11615 && typedef_variant_p (t
))
11617 tree decl
= TYPE_NAME (t
);
11619 if (alias_template_specialization_p (t
))
11621 /* DECL represents an alias template and we want to
11623 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11624 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11625 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11627 else if (DECL_CLASS_SCOPE_P (decl
)
11628 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11629 && uses_template_parms (DECL_CONTEXT (decl
)))
11631 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11632 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11633 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11635 else if (DECL_FUNCTION_SCOPE_P (decl
)
11636 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11637 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11638 r
= retrieve_local_specialization (decl
);
11640 /* The typedef is from a non-template context. */
11646 r
= cp_build_qualified_type_real
11647 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11648 complain
| tf_ignore_bad_quals
);
11653 /* We don't have an instantiation yet, so drop the typedef. */
11654 int quals
= cp_type_quals (t
);
11655 t
= DECL_ORIGINAL_TYPE (decl
);
11656 t
= cp_build_qualified_type_real (t
, quals
,
11657 complain
| tf_ignore_bad_quals
);
11662 && code
!= TYPENAME_TYPE
11663 && code
!= TEMPLATE_TYPE_PARM
11664 && code
!= IDENTIFIER_NODE
11665 && code
!= FUNCTION_TYPE
11666 && code
!= METHOD_TYPE
)
11667 type
= tsubst (type
, args
, complain
, in_decl
);
11668 if (type
== error_mark_node
)
11669 return error_mark_node
;
11675 case ENUMERAL_TYPE
:
11676 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11677 /*entering_scope=*/0);
11680 case IDENTIFIER_NODE
:
11691 if (t
== integer_type_node
)
11694 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11695 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11699 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11701 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11702 /*integral_constant_expression_p=*/false);
11704 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11706 if (TREE_CODE (max
) == NOP_EXPR
11707 && TREE_SIDE_EFFECTS (omax
)
11708 && !TREE_TYPE (max
))
11709 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11711 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11712 with TREE_SIDE_EFFECTS that indicates this is not an integral
11713 constant expression. */
11714 if (processing_template_decl
11715 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11717 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11718 TREE_SIDE_EFFECTS (max
) = 1;
11721 return compute_array_index_type (NULL_TREE
, max
, complain
);
11724 case TEMPLATE_TYPE_PARM
:
11725 case TEMPLATE_TEMPLATE_PARM
:
11726 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11727 case TEMPLATE_PARM_INDEX
:
11732 tree arg
= NULL_TREE
;
11736 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
11737 template_parm_level_and_index (t
, &level
, &idx
);
11739 levels
= TMPL_ARGS_DEPTH (args
);
11740 if (level
<= levels
)
11742 arg
= TMPL_ARG (args
, level
, idx
);
11744 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
11746 /* See through ARGUMENT_PACK_SELECT arguments. */
11747 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
11748 /* If the selected argument is an expansion E, that most
11749 likely means we were called from
11750 gen_elem_of_pack_expansion_instantiation during the
11751 substituting of pack an argument pack (which Ith
11752 element is a pack expansion, where I is
11753 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11754 In this case, the Ith element resulting from this
11755 substituting is going to be a pack expansion, which
11756 pattern is the pattern of E. Let's return the
11758 gen_elem_of_pack_expansion_instantiation will
11759 build the resulting pack expansion from it. */
11760 if (PACK_EXPANSION_P (arg
))
11761 arg
= PACK_EXPANSION_PATTERN (arg
);
11765 if (arg
== error_mark_node
)
11766 return error_mark_node
;
11767 else if (arg
!= NULL_TREE
)
11769 if (ARGUMENT_PACK_P (arg
))
11770 /* If ARG is an argument pack, we don't actually want to
11771 perform a substitution here, because substitutions
11772 for argument packs are only done
11773 element-by-element. We can get to this point when
11774 substituting the type of a non-type template
11775 parameter pack, when that type actually contains
11776 template parameter packs from an outer template, e.g.,
11778 template<typename... Types> struct A {
11779 template<Types... Values> struct B { };
11783 if (code
== TEMPLATE_TYPE_PARM
)
11786 gcc_assert (TYPE_P (arg
));
11788 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
11790 return cp_build_qualified_type_real
11791 (arg
, quals
, complain
| tf_ignore_bad_quals
);
11793 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11795 /* We are processing a type constructed from a
11796 template template parameter. */
11797 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
11798 args
, complain
, in_decl
);
11799 if (argvec
== error_mark_node
)
11800 return error_mark_node
;
11802 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
11803 || TREE_CODE (arg
) == TEMPLATE_DECL
11804 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
11806 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
11807 /* Consider this code:
11809 template <template <class> class Template>
11811 template <class Arg> using Bind = Template<Arg>;
11814 template <template <class> class Template, class Arg>
11815 using Instantiate = Template<Arg>; //#0
11817 template <template <class> class Template,
11820 Instantiate<Internal<Template>::template Bind,
11823 When #1 is parsed, the
11824 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11825 parameter `Template' in #0 matches the
11826 UNBOUND_CLASS_TEMPLATE representing the argument
11827 `Internal<Template>::template Bind'; We then want
11828 to assemble the type `Bind<Argument>' that can't
11829 be fully created right now, because
11830 `Internal<Template>' not being complete, the Bind
11831 template cannot be looked up in that context. So
11832 we need to "store" `Bind<Argument>' for later
11833 when the context of Bind becomes complete. Let's
11834 store that in a TYPENAME_TYPE. */
11835 return make_typename_type (TYPE_CONTEXT (arg
),
11836 build_nt (TEMPLATE_ID_EXPR
,
11837 TYPE_IDENTIFIER (arg
),
11842 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11843 are resolving nested-types in the signature of a
11844 member function templates. Otherwise ARG is a
11845 TEMPLATE_DECL and is the real template to be
11847 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11848 arg
= TYPE_NAME (arg
);
11850 r
= lookup_template_class (arg
,
11852 DECL_CONTEXT (arg
),
11853 /*entering_scope=*/0,
11855 return cp_build_qualified_type_real
11856 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
11859 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11860 return convert_from_reference (unshare_expr (arg
));
11864 /* This can happen during the attempted tsubst'ing in
11865 unify. This means that we don't yet have any information
11866 about the template parameter in question. */
11869 /* Early in template argument deduction substitution, we don't
11870 want to reduce the level of 'auto', or it will be confused
11871 with a normal template parm in subsequent deduction. */
11872 if (is_auto (t
) && (complain
& tf_partial
))
11875 /* If we get here, we must have been looking at a parm for a
11876 more deeply nested template. Make a new version of this
11877 template parameter, but with a lower level. */
11880 case TEMPLATE_TYPE_PARM
:
11881 case TEMPLATE_TEMPLATE_PARM
:
11882 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11883 if (cp_type_quals (t
))
11885 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
11886 r
= cp_build_qualified_type_real
11887 (r
, cp_type_quals (t
),
11888 complain
| (code
== TEMPLATE_TYPE_PARM
11889 ? tf_ignore_bad_quals
: 0));
11894 TEMPLATE_TYPE_PARM_INDEX (r
)
11895 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
11896 r
, levels
, args
, complain
);
11897 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
11898 TYPE_MAIN_VARIANT (r
) = r
;
11899 TYPE_POINTER_TO (r
) = NULL_TREE
;
11900 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
11902 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
11903 /* We have reduced the level of the template
11904 template parameter, but not the levels of its
11905 template parameters, so canonical_type_parameter
11906 will not be able to find the canonical template
11907 template parameter for this level. Thus, we
11908 require structural equality checking to compare
11909 TEMPLATE_TEMPLATE_PARMs. */
11910 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11911 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
11912 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11914 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
11916 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11918 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
11919 complain
, in_decl
);
11920 if (argvec
== error_mark_node
)
11921 return error_mark_node
;
11923 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
11924 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
11929 case TEMPLATE_PARM_INDEX
:
11930 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
11934 gcc_unreachable ();
11942 tree purpose
, value
, chain
;
11944 if (t
== void_list_node
)
11947 purpose
= TREE_PURPOSE (t
);
11950 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
11951 if (purpose
== error_mark_node
)
11952 return error_mark_node
;
11954 value
= TREE_VALUE (t
);
11957 value
= tsubst (value
, args
, complain
, in_decl
);
11958 if (value
== error_mark_node
)
11959 return error_mark_node
;
11961 chain
= TREE_CHAIN (t
);
11962 if (chain
&& chain
!= void_type_node
)
11964 chain
= tsubst (chain
, args
, complain
, in_decl
);
11965 if (chain
== error_mark_node
)
11966 return error_mark_node
;
11968 if (purpose
== TREE_PURPOSE (t
)
11969 && value
== TREE_VALUE (t
)
11970 && chain
== TREE_CHAIN (t
))
11972 return hash_tree_cons (purpose
, value
, chain
);
11976 /* We should never be tsubsting a binfo. */
11977 gcc_unreachable ();
11980 /* A vector of template arguments. */
11981 gcc_assert (!type
);
11982 return tsubst_template_args (t
, args
, complain
, in_decl
);
11985 case REFERENCE_TYPE
:
11987 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
11992 Type deduction may fail for any of the following
11995 -- Attempting to create a pointer to reference type.
11996 -- Attempting to create a reference to a reference type or
11997 a reference to void.
11999 Core issue 106 says that creating a reference to a reference
12000 during instantiation is no longer a cause for failure. We
12001 only enforce this check in strict C++98 mode. */
12002 if ((TREE_CODE (type
) == REFERENCE_TYPE
12003 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
12004 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
12006 static location_t last_loc
;
12008 /* We keep track of the last time we issued this error
12009 message to avoid spewing a ton of messages during a
12010 single bad template instantiation. */
12011 if (complain
& tf_error
12012 && last_loc
!= input_location
)
12014 if (VOID_TYPE_P (type
))
12015 error ("forming reference to void");
12016 else if (code
== POINTER_TYPE
)
12017 error ("forming pointer to reference type %qT", type
);
12019 error ("forming reference to reference type %qT", type
);
12020 last_loc
= input_location
;
12023 return error_mark_node
;
12025 else if (TREE_CODE (type
) == FUNCTION_TYPE
12026 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
12027 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12029 if (complain
& tf_error
)
12031 if (code
== POINTER_TYPE
)
12032 error ("forming pointer to qualified function type %qT",
12035 error ("forming reference to qualified function type %qT",
12038 return error_mark_node
;
12040 else if (code
== POINTER_TYPE
)
12042 r
= build_pointer_type (type
);
12043 if (TREE_CODE (type
) == METHOD_TYPE
)
12044 r
= build_ptrmemfunc_type (r
);
12046 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12047 /* In C++0x, during template argument substitution, when there is an
12048 attempt to create a reference to a reference type, reference
12049 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12051 "If a template-argument for a template-parameter T names a type
12052 that is a reference to a type A, an attempt to create the type
12053 'lvalue reference to cv T' creates the type 'lvalue reference to
12054 A,' while an attempt to create the type type rvalue reference to
12055 cv T' creates the type T"
12057 r
= cp_build_reference_type
12059 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12061 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12062 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12064 if (cxx_dialect
>= cxx1y
12065 && !(TREE_CODE (t
) == REFERENCE_TYPE
&& REFERENCE_VLA_OK (t
))
12066 && array_of_runtime_bound_p (type
)
12067 && (flag_iso
|| warn_vla
> 0))
12069 if (complain
& tf_warning_or_error
)
12071 (input_location
, OPT_Wvla
,
12072 code
== REFERENCE_TYPE
12073 ? G_("cannot declare reference to array of runtime bound")
12074 : G_("cannot declare pointer to array of runtime bound"));
12076 r
= error_mark_node
;
12079 if (r
!= error_mark_node
)
12080 /* Will this ever be needed for TYPE_..._TO values? */
12087 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12088 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12092 Type deduction may fail for any of the following
12095 -- Attempting to create "pointer to member of T" when T
12096 is not a class type. */
12097 if (complain
& tf_error
)
12098 error ("creating pointer to member of non-class type %qT", r
);
12099 return error_mark_node
;
12101 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12103 if (complain
& tf_error
)
12104 error ("creating pointer to member reference type %qT", type
);
12105 return error_mark_node
;
12107 if (VOID_TYPE_P (type
))
12109 if (complain
& tf_error
)
12110 error ("creating pointer to member of type void");
12111 return error_mark_node
;
12113 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12114 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12116 /* The type of the implicit object parameter gets its
12117 cv-qualifiers from the FUNCTION_TYPE. */
12120 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12121 type_memfn_rqual (type
));
12122 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12123 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12127 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12131 case FUNCTION_TYPE
:
12136 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12137 if (fntype
== error_mark_node
)
12138 return error_mark_node
;
12140 /* Substitute the exception specification. */
12141 specs
= tsubst_exception_specification (t
, args
, complain
,
12142 in_decl
, /*defer_ok*/true);
12143 if (specs
== error_mark_node
)
12144 return error_mark_node
;
12146 fntype
= build_exception_variant (fntype
, specs
);
12151 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12152 if (domain
== error_mark_node
)
12153 return error_mark_node
;
12155 /* As an optimization, we avoid regenerating the array type if
12156 it will obviously be the same as T. */
12157 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12160 /* These checks should match the ones in create_array_type_for_decl.
12164 The deduction may fail for any of the following reasons:
12166 -- Attempting to create an array with an element type that
12167 is void, a function type, or a reference type, or [DR337]
12168 an abstract class type. */
12169 if (VOID_TYPE_P (type
)
12170 || TREE_CODE (type
) == FUNCTION_TYPE
12171 || (TREE_CODE (type
) == ARRAY_TYPE
12172 && TYPE_DOMAIN (type
) == NULL_TREE
)
12173 || TREE_CODE (type
) == REFERENCE_TYPE
)
12175 if (complain
& tf_error
)
12176 error ("creating array of %qT", type
);
12177 return error_mark_node
;
12180 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12181 return error_mark_node
;
12183 r
= build_cplus_array_type (type
, domain
);
12185 if (TYPE_USER_ALIGN (t
))
12187 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12188 TYPE_USER_ALIGN (r
) = 1;
12194 case TYPENAME_TYPE
:
12196 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12197 in_decl
, /*entering_scope=*/1);
12198 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12199 complain
, in_decl
);
12201 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12202 return error_mark_node
;
12204 if (!MAYBE_CLASS_TYPE_P (ctx
))
12206 if (complain
& tf_error
)
12207 error ("%qT is not a class, struct, or union type", ctx
);
12208 return error_mark_node
;
12210 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12212 /* Normally, make_typename_type does not require that the CTX
12213 have complete type in order to allow things like:
12215 template <class T> struct S { typename S<T>::X Y; };
12217 But, such constructs have already been resolved by this
12218 point, so here CTX really should have complete type, unless
12219 it's a partial instantiation. */
12220 ctx
= complete_type (ctx
);
12221 if (!COMPLETE_TYPE_P (ctx
))
12223 if (complain
& tf_error
)
12224 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12225 return error_mark_node
;
12229 f
= make_typename_type (ctx
, f
, typename_type
,
12230 complain
| tf_keep_type_decl
);
12231 if (f
== error_mark_node
)
12233 if (TREE_CODE (f
) == TYPE_DECL
)
12235 complain
|= tf_ignore_bad_quals
;
12239 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12241 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12243 if (complain
& tf_error
)
12244 error ("%qT resolves to %qT, which is not an enumeration type",
12247 return error_mark_node
;
12249 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12251 if (complain
& tf_error
)
12252 error ("%qT resolves to %qT, which is is not a class type",
12255 return error_mark_node
;
12259 return cp_build_qualified_type_real
12260 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12263 case UNBOUND_CLASS_TEMPLATE
:
12265 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12266 in_decl
, /*entering_scope=*/1);
12267 tree name
= TYPE_IDENTIFIER (t
);
12268 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12270 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12271 return error_mark_node
;
12274 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12275 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12282 ++cp_unevaluated_operand
;
12283 ++c_inhibit_evaluation_warnings
;
12285 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12287 /*integral_constant_expression_p=*/false);
12289 --cp_unevaluated_operand
;
12290 --c_inhibit_evaluation_warnings
;
12292 type
= finish_typeof (type
);
12293 return cp_build_qualified_type_real (type
,
12295 | cp_type_quals (type
),
12299 case DECLTYPE_TYPE
:
12303 ++cp_unevaluated_operand
;
12304 ++c_inhibit_evaluation_warnings
;
12306 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12307 complain
|tf_decltype
, in_decl
,
12308 /*function_p*/false,
12309 /*integral_constant_expression*/false);
12311 --cp_unevaluated_operand
;
12312 --c_inhibit_evaluation_warnings
;
12314 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12315 type
= lambda_capture_field_type (type
,
12316 DECLTYPE_FOR_INIT_CAPTURE (t
));
12317 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12318 type
= lambda_proxy_type (type
);
12321 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12322 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12324 /* In a template ~id could be either a complement expression
12325 or an unqualified-id naming a destructor; if instantiating
12326 it produces an expression, it's not an id-expression or
12329 type
= finish_decltype_type (type
, id
, complain
);
12331 return cp_build_qualified_type_real (type
,
12333 | cp_type_quals (type
),
12337 case UNDERLYING_TYPE
:
12339 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12340 complain
, in_decl
);
12341 return finish_underlying_type (type
);
12344 case TYPE_ARGUMENT_PACK
:
12345 case NONTYPE_ARGUMENT_PACK
:
12347 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12349 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12353 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12355 /* For template nontype argument packs, also substitute into
12357 if (code
== NONTYPE_ARGUMENT_PACK
)
12358 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12377 /* We should use one of the expression tsubsts for these codes. */
12378 gcc_unreachable ();
12381 sorry ("use of %qs in template", get_tree_code_name (code
));
12382 return error_mark_node
;
12386 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12387 type of the expression on the left-hand side of the "." or "->"
12391 tsubst_baselink (tree baselink
, tree object_type
,
12392 tree args
, tsubst_flags_t complain
, tree in_decl
)
12395 tree qualifying_scope
;
12398 tree template_args
= 0;
12399 bool template_id_p
= false;
12400 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12402 /* A baselink indicates a function from a base class. Both the
12403 BASELINK_ACCESS_BINFO and the base class referenced may
12404 indicate bases of the template class, rather than the
12405 instantiated class. In addition, lookups that were not
12406 ambiguous before may be ambiguous now. Therefore, we perform
12407 the lookup again. */
12408 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12409 qualifying_scope
= tsubst (qualifying_scope
, args
,
12410 complain
, in_decl
);
12411 fns
= BASELINK_FUNCTIONS (baselink
);
12412 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12413 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12415 template_id_p
= true;
12416 template_args
= TREE_OPERAND (fns
, 1);
12417 fns
= TREE_OPERAND (fns
, 0);
12419 template_args
= tsubst_template_args (template_args
, args
,
12420 complain
, in_decl
);
12422 name
= DECL_NAME (get_first_fn (fns
));
12423 if (IDENTIFIER_TYPENAME_P (name
))
12424 name
= mangle_conv_op_name_for_type (optype
);
12425 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12427 return error_mark_node
;
12429 /* If lookup found a single function, mark it as used at this
12430 point. (If it lookup found multiple functions the one selected
12431 later by overload resolution will be marked as used at that
12433 if (BASELINK_P (baselink
))
12434 fns
= BASELINK_FUNCTIONS (baselink
);
12435 if (!template_id_p
&& !really_overloaded_fn (fns
))
12436 mark_used (OVL_CURRENT (fns
));
12438 /* Add back the template arguments, if present. */
12439 if (BASELINK_P (baselink
) && template_id_p
)
12440 BASELINK_FUNCTIONS (baselink
)
12441 = build_nt (TEMPLATE_ID_EXPR
,
12442 BASELINK_FUNCTIONS (baselink
),
12444 /* Update the conversion operator type. */
12445 BASELINK_OPTYPE (baselink
) = optype
;
12448 object_type
= current_class_type
;
12451 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12457 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12458 true if the qualified-id will be a postfix-expression in-and-of
12459 itself; false if more of the postfix-expression follows the
12460 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12464 tsubst_qualified_id (tree qualified_id
, tree args
,
12465 tsubst_flags_t complain
, tree in_decl
,
12466 bool done
, bool address_p
)
12472 tree template_args
;
12473 location_t loc
= UNKNOWN_LOCATION
;
12475 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12477 /* Figure out what name to look up. */
12478 name
= TREE_OPERAND (qualified_id
, 1);
12479 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12481 is_template
= true;
12482 loc
= EXPR_LOCATION (name
);
12483 template_args
= TREE_OPERAND (name
, 1);
12485 template_args
= tsubst_template_args (template_args
, args
,
12486 complain
, in_decl
);
12487 name
= TREE_OPERAND (name
, 0);
12491 is_template
= false;
12492 template_args
= NULL_TREE
;
12495 /* Substitute into the qualifying scope. When there are no ARGS, we
12496 are just trying to simplify a non-dependent expression. In that
12497 case the qualifying scope may be dependent, and, in any case,
12498 substituting will not help. */
12499 scope
= TREE_OPERAND (qualified_id
, 0);
12502 scope
= tsubst (scope
, args
, complain
, in_decl
);
12503 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12508 if (dependent_scope_p (scope
))
12511 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12512 return build_qualified_name (NULL_TREE
, scope
, expr
,
12513 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12516 if (!BASELINK_P (name
) && !DECL_P (expr
))
12518 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12520 /* A BIT_NOT_EXPR is used to represent a destructor. */
12521 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12523 error ("qualifying type %qT does not match destructor name ~%qT",
12524 scope
, TREE_OPERAND (expr
, 0));
12525 expr
= error_mark_node
;
12528 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12529 /*is_type_p=*/0, false);
12532 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12533 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12534 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12536 if (complain
& tf_error
)
12538 error ("dependent-name %qE is parsed as a non-type, but "
12539 "instantiation yields a type", qualified_id
);
12540 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12542 return error_mark_node
;
12548 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12550 /* Remember that there was a reference to this entity. */
12554 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12556 if (complain
& tf_error
)
12557 qualified_name_lookup_error (scope
,
12558 TREE_OPERAND (qualified_id
, 1),
12559 expr
, input_location
);
12560 return error_mark_node
;
12564 expr
= lookup_template_function (expr
, template_args
);
12566 if (expr
== error_mark_node
&& complain
& tf_error
)
12567 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12568 expr
, input_location
);
12569 else if (TYPE_P (scope
))
12571 expr
= (adjust_result_of_qualified_name_lookup
12572 (expr
, scope
, current_nonlambda_class_type ()));
12573 expr
= (finish_qualified_id_expr
12574 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12575 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12576 /*template_arg_p=*/false, complain
));
12579 /* Expressions do not generally have reference type. */
12580 if (TREE_CODE (expr
) != SCOPE_REF
12581 /* However, if we're about to form a pointer-to-member, we just
12582 want the referenced member referenced. */
12583 && TREE_CODE (expr
) != OFFSET_REF
)
12584 expr
= convert_from_reference (expr
);
12589 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12590 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12594 tsubst_init (tree init
, tree decl
, tree args
,
12595 tsubst_flags_t complain
, tree in_decl
)
12600 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12604 /* If we had an initializer but it
12605 instantiated to nothing,
12606 value-initialize the object. This will
12607 only occur when the initializer was a
12608 pack expansion where the parameter packs
12609 used in that expansion were of length
12611 init
= build_value_init (TREE_TYPE (decl
),
12613 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12614 init
= get_target_expr_sfinae (init
, complain
);
12620 /* Like tsubst, but deals with expressions. This function just replaces
12621 template parms; to finish processing the resultant expression, use
12622 tsubst_copy_and_build or tsubst_expr. */
12625 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12627 enum tree_code code
;
12630 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12633 code
= TREE_CODE (t
);
12638 r
= retrieve_local_specialization (t
);
12640 if (r
== NULL_TREE
)
12642 /* We get here for a use of 'this' in an NSDMI. */
12643 if (DECL_NAME (t
) == this_identifier
12644 && current_function_decl
12645 && DECL_CONSTRUCTOR_P (current_function_decl
))
12646 return current_class_ptr
;
12648 /* This can happen for a parameter name used later in a function
12649 declaration (such as in a late-specified return type). Just
12650 make a dummy decl, since it's only used for its type. */
12651 gcc_assert (cp_unevaluated_operand
!= 0);
12652 r
= tsubst_decl (t
, args
, complain
);
12653 /* Give it the template pattern as its context; its true context
12654 hasn't been instantiated yet and this is good enough for
12656 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12659 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12660 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12669 if (DECL_TEMPLATE_PARM_P (t
))
12670 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12671 /* There is no need to substitute into namespace-scope
12673 if (DECL_NAMESPACE_SCOPE_P (t
))
12675 /* If ARGS is NULL, then T is known to be non-dependent. */
12676 if (args
== NULL_TREE
)
12677 return integral_constant_value (t
);
12679 /* Unfortunately, we cannot just call lookup_name here.
12682 template <int I> int f() {
12684 struct S { void g() { E e = a; } };
12687 When we instantiate f<7>::S::g(), say, lookup_name is not
12688 clever enough to find f<7>::a. */
12690 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12691 /*entering_scope=*/0);
12693 for (v
= TYPE_VALUES (enum_type
);
12695 v
= TREE_CHAIN (v
))
12696 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12697 return TREE_VALUE (v
);
12699 /* We didn't find the name. That should never happen; if
12700 name-lookup found it during preliminary parsing, we
12701 should find it again here during instantiation. */
12702 gcc_unreachable ();
12707 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12709 /* Check for a local specialization set up by
12710 tsubst_pack_expansion. */
12711 if (tree r
= retrieve_local_specialization (t
))
12713 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12714 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12718 /* When retrieving a capture pack from a generic lambda, remove the
12719 lambda call op's own template argument list from ARGS. Only the
12720 template arguments active for the closure type should be used to
12721 retrieve the pack specialization. */
12722 if (LAMBDA_FUNCTION_P (current_function_decl
)
12723 && (template_class_depth (DECL_CONTEXT (t
))
12724 != TMPL_ARGS_DEPTH (args
)))
12725 args
= strip_innermost_template_args (args
, 1);
12727 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12728 tsubst_decl put in the hash table. */
12729 return retrieve_specialization (t
, args
, 0);
12732 if (DECL_CONTEXT (t
))
12736 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12737 /*entering_scope=*/1);
12738 if (ctx
!= DECL_CONTEXT (t
))
12740 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
12743 if (complain
& tf_error
)
12744 error ("using invalid field %qD", t
);
12745 return error_mark_node
;
12754 case FUNCTION_DECL
:
12755 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
12756 r
= tsubst (t
, args
, complain
, in_decl
);
12757 else if (local_variable_p (t
))
12759 r
= retrieve_local_specialization (t
);
12760 if (r
== NULL_TREE
)
12762 /* First try name lookup to find the instantiation. */
12763 r
= lookup_name (DECL_NAME (t
));
12766 /* Make sure that the one we found is the one we want. */
12767 tree ctx
= tsubst (DECL_CONTEXT (t
), args
,
12768 complain
, in_decl
);
12769 if (ctx
!= DECL_CONTEXT (r
))
12777 /* This can happen for a variable used in a
12778 late-specified return type of a local lambda, or for a
12779 local static or constant. Building a new VAR_DECL
12780 should be OK in all those cases. */
12781 r
= tsubst_decl (t
, args
, complain
);
12782 if (decl_maybe_constant_var_p (r
))
12784 /* We can't call cp_finish_decl, so handle the
12785 initializer by hand. */
12786 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
12787 complain
, in_decl
);
12788 if (!processing_template_decl
)
12789 init
= maybe_constant_init (init
);
12790 if (processing_template_decl
12791 ? potential_constant_expression (init
)
12792 : reduced_constant_expression_p (init
))
12793 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
12794 = TREE_CONSTANT (r
) = true;
12795 DECL_INITIAL (r
) = init
;
12797 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
12798 || decl_constant_var_p (r
)
12799 || errorcount
|| sorrycount
);
12800 if (!processing_template_decl
)
12802 if (TREE_STATIC (r
))
12803 rest_of_decl_compilation (r
, toplevel_bindings_p (),
12805 else if (decl_constant_var_p (r
))
12806 /* A use of a local constant decays to its value.
12807 FIXME update for core DR 696. */
12808 r
= integral_constant_value (r
);
12811 /* Remember this for subsequent uses. */
12812 if (local_specializations
)
12813 register_local_specialization (r
, t
);
12821 case NAMESPACE_DECL
:
12825 /* An OVERLOAD will always be a non-dependent overload set; an
12826 overload set from function scope will just be represented with an
12827 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12828 gcc_assert (!uses_template_parms (t
));
12832 return tsubst_baselink (t
, current_nonlambda_class_type (),
12833 args
, complain
, in_decl
);
12835 case TEMPLATE_DECL
:
12836 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12837 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
12838 args
, complain
, in_decl
);
12839 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
12840 return tsubst (t
, args
, complain
, in_decl
);
12841 else if (DECL_CLASS_SCOPE_P (t
)
12842 && uses_template_parms (DECL_CONTEXT (t
)))
12844 /* Template template argument like the following example need
12847 template <template <class> class TT> struct C {};
12848 template <class T> struct D {
12849 template <class U> struct E {};
12854 We are processing the template argument `E' in #1 for
12855 the template instantiation #2. Originally, `E' is a
12856 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12857 have to substitute this with one having context `D<int>'. */
12859 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
12860 return lookup_field (context
, DECL_NAME(t
), 0, false);
12863 /* Ordinary template template argument. */
12867 case REINTERPRET_CAST_EXPR
:
12868 case CONST_CAST_EXPR
:
12869 case STATIC_CAST_EXPR
:
12870 case DYNAMIC_CAST_EXPR
:
12871 case IMPLICIT_CONV_EXPR
:
12875 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12876 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12877 return build1 (code
, type
, op0
);
12881 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
12884 tree expanded
, op
= TREE_OPERAND (t
, 0);
12887 if (SIZEOF_EXPR_TYPE_P (t
))
12888 op
= TREE_TYPE (op
);
12890 ++cp_unevaluated_operand
;
12891 ++c_inhibit_evaluation_warnings
;
12892 /* We only want to compute the number of arguments. */
12893 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
12894 --cp_unevaluated_operand
;
12895 --c_inhibit_evaluation_warnings
;
12897 if (TREE_CODE (expanded
) == TREE_VEC
)
12898 len
= TREE_VEC_LENGTH (expanded
);
12900 if (expanded
== error_mark_node
)
12901 return error_mark_node
;
12902 else if (PACK_EXPANSION_P (expanded
)
12903 || (TREE_CODE (expanded
) == TREE_VEC
12905 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
12907 if (TREE_CODE (expanded
) == TREE_VEC
)
12908 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
12910 if (TYPE_P (expanded
))
12911 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
12912 complain
& tf_error
);
12914 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
12915 complain
& tf_error
);
12918 return build_int_cst (size_type_node
, len
);
12920 if (SIZEOF_EXPR_TYPE_P (t
))
12922 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
12923 args
, complain
, in_decl
);
12924 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
12925 r
= build1 (SIZEOF_EXPR
,
12926 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
12927 SIZEOF_EXPR_TYPE_P (r
) = 1;
12934 case TRUTH_NOT_EXPR
:
12937 case UNARY_PLUS_EXPR
: /* Unary + */
12939 case AT_ENCODE_EXPR
:
12943 case REALPART_EXPR
:
12944 case IMAGPART_EXPR
:
12947 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12948 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12949 return build1 (code
, type
, op0
);
12952 case COMPONENT_REF
:
12957 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12958 name
= TREE_OPERAND (t
, 1);
12959 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
12961 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12962 complain
, in_decl
);
12963 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12965 else if (TREE_CODE (name
) == SCOPE_REF
12966 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
12968 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12969 complain
, in_decl
);
12970 name
= TREE_OPERAND (name
, 1);
12971 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12972 complain
, in_decl
);
12973 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12974 name
= build_qualified_name (/*type=*/NULL_TREE
,
12976 /*template_p=*/false);
12978 else if (BASELINK_P (name
))
12979 name
= tsubst_baselink (name
,
12980 non_reference (TREE_TYPE (object
)),
12984 name
= tsubst_copy (name
, args
, complain
, in_decl
);
12985 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
12991 case TRUNC_DIV_EXPR
:
12992 case CEIL_DIV_EXPR
:
12993 case FLOOR_DIV_EXPR
:
12994 case ROUND_DIV_EXPR
:
12995 case EXACT_DIV_EXPR
:
12999 case TRUNC_MOD_EXPR
:
13000 case FLOOR_MOD_EXPR
:
13001 case TRUTH_ANDIF_EXPR
:
13002 case TRUTH_ORIF_EXPR
:
13003 case TRUTH_AND_EXPR
:
13004 case TRUTH_OR_EXPR
:
13017 case COMPOUND_EXPR
:
13020 case PREDECREMENT_EXPR
:
13021 case PREINCREMENT_EXPR
:
13022 case POSTDECREMENT_EXPR
:
13023 case POSTINCREMENT_EXPR
:
13025 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13026 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13027 return build_nt (code
, op0
, op1
);
13032 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13033 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13034 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
13035 QUALIFIED_NAME_IS_TEMPLATE (t
));
13040 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13041 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13042 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13047 int n
= VL_EXP_OPERAND_LENGTH (t
);
13048 tree result
= build_vl_exp (CALL_EXPR
, n
);
13050 for (i
= 0; i
< n
; i
++)
13051 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13052 complain
, in_decl
);
13058 case PSEUDO_DTOR_EXPR
:
13059 case VEC_PERM_EXPR
:
13061 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13062 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13063 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13064 r
= build_nt (code
, op0
, op1
, op2
);
13065 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13071 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13072 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13073 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13074 r
= build_nt (code
, op0
, op1
, op2
);
13075 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13081 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13082 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13083 r
= build_nt (code
, op0
, op1
);
13084 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13085 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13089 case TEMPLATE_ID_EXPR
:
13091 /* Substituted template arguments */
13092 tree fn
= TREE_OPERAND (t
, 0);
13093 tree targs
= TREE_OPERAND (t
, 1);
13095 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13097 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13099 return lookup_template_function (fn
, targs
);
13104 tree purpose
, value
, chain
;
13106 if (t
== void_list_node
)
13109 purpose
= TREE_PURPOSE (t
);
13111 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13112 value
= TREE_VALUE (t
);
13114 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13115 chain
= TREE_CHAIN (t
);
13116 if (chain
&& chain
!= void_type_node
)
13117 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13118 if (purpose
== TREE_PURPOSE (t
)
13119 && value
== TREE_VALUE (t
)
13120 && chain
== TREE_CHAIN (t
))
13122 return tree_cons (purpose
, value
, chain
);
13127 case ENUMERAL_TYPE
:
13129 case TEMPLATE_TYPE_PARM
:
13130 case TEMPLATE_TEMPLATE_PARM
:
13131 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13132 case TEMPLATE_PARM_INDEX
:
13134 case REFERENCE_TYPE
:
13136 case FUNCTION_TYPE
:
13139 case TYPENAME_TYPE
:
13140 case UNBOUND_CLASS_TEMPLATE
:
13142 case DECLTYPE_TYPE
:
13144 return tsubst (t
, args
, complain
, in_decl
);
13148 /* Fall through. */
13149 case IDENTIFIER_NODE
:
13150 if (IDENTIFIER_TYPENAME_P (t
))
13152 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13153 return mangle_conv_op_name_for_type (new_type
);
13159 /* This is handled by tsubst_copy_and_build. */
13160 gcc_unreachable ();
13164 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13165 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13166 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13169 case CLEANUP_POINT_EXPR
:
13170 /* We shouldn't have built any of these during initial template
13171 generation. Instead, they should be built during instantiation
13172 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13173 gcc_unreachable ();
13177 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13178 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13179 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13180 r
= build2 (code
, type
, op0
, op1
);
13181 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13182 mark_used (TREE_OPERAND (r
, 1));
13186 case EXPR_PACK_EXPANSION
:
13187 error ("invalid use of pack expansion expression");
13188 return error_mark_node
;
13190 case NONTYPE_ARGUMENT_PACK
:
13191 error ("use %<...%> to expand argument pack");
13192 return error_mark_node
;
13195 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13203 /* Instantiate any typedefs in the type. */
13204 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13205 r
= fold_convert (type
, t
);
13206 gcc_assert (TREE_CODE (r
) == code
);
13211 /* These can sometimes show up in a partial instantiation, but never
13212 involve template parms. */
13213 gcc_assert (!uses_template_parms (t
));
13217 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13218 gcc_checking_assert (false);
13223 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13226 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13227 tree args
, tsubst_flags_t complain
, tree in_decl
)
13229 tree new_clauses
= NULL
, nc
, oc
;
13231 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13233 nc
= copy_node (oc
);
13234 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13237 switch (OMP_CLAUSE_CODE (nc
))
13239 case OMP_CLAUSE_LASTPRIVATE
:
13240 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13242 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13243 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13244 in_decl
, /*integral_constant_expression_p=*/false);
13245 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13246 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13249 case OMP_CLAUSE_PRIVATE
:
13250 case OMP_CLAUSE_SHARED
:
13251 case OMP_CLAUSE_FIRSTPRIVATE
:
13252 case OMP_CLAUSE_COPYIN
:
13253 case OMP_CLAUSE_COPYPRIVATE
:
13254 case OMP_CLAUSE_IF
:
13255 case OMP_CLAUSE_NUM_THREADS
:
13256 case OMP_CLAUSE_SCHEDULE
:
13257 case OMP_CLAUSE_COLLAPSE
:
13258 case OMP_CLAUSE_FINAL
:
13259 case OMP_CLAUSE_DEPEND
:
13260 case OMP_CLAUSE_FROM
:
13261 case OMP_CLAUSE_TO
:
13262 case OMP_CLAUSE_UNIFORM
:
13263 case OMP_CLAUSE_MAP
:
13264 case OMP_CLAUSE_DEVICE
:
13265 case OMP_CLAUSE_DIST_SCHEDULE
:
13266 case OMP_CLAUSE_NUM_TEAMS
:
13267 case OMP_CLAUSE_THREAD_LIMIT
:
13268 case OMP_CLAUSE_SAFELEN
:
13269 case OMP_CLAUSE_SIMDLEN
:
13270 OMP_CLAUSE_OPERAND (nc
, 0)
13271 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13272 in_decl
, /*integral_constant_expression_p=*/false);
13274 case OMP_CLAUSE_REDUCTION
:
13275 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13277 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13278 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13280 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13281 complain
, in_decl
);
13282 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13283 = build_qualified_name (NULL_TREE
, scope
,
13284 TREE_OPERAND (placeholder
, 1),
13288 gcc_assert (identifier_p (placeholder
));
13290 OMP_CLAUSE_OPERAND (nc
, 0)
13291 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13292 in_decl
, /*integral_constant_expression_p=*/false);
13294 case OMP_CLAUSE_LINEAR
:
13295 case OMP_CLAUSE_ALIGNED
:
13296 OMP_CLAUSE_OPERAND (nc
, 0)
13297 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13298 in_decl
, /*integral_constant_expression_p=*/false);
13299 OMP_CLAUSE_OPERAND (nc
, 1)
13300 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13301 in_decl
, /*integral_constant_expression_p=*/false);
13304 case OMP_CLAUSE_NOWAIT
:
13305 case OMP_CLAUSE_ORDERED
:
13306 case OMP_CLAUSE_DEFAULT
:
13307 case OMP_CLAUSE_UNTIED
:
13308 case OMP_CLAUSE_MERGEABLE
:
13309 case OMP_CLAUSE_INBRANCH
:
13310 case OMP_CLAUSE_NOTINBRANCH
:
13311 case OMP_CLAUSE_PROC_BIND
:
13312 case OMP_CLAUSE_FOR
:
13313 case OMP_CLAUSE_PARALLEL
:
13314 case OMP_CLAUSE_SECTIONS
:
13315 case OMP_CLAUSE_TASKGROUP
:
13318 gcc_unreachable ();
13322 new_clauses
= nreverse (new_clauses
);
13324 new_clauses
= finish_omp_clauses (new_clauses
);
13325 return new_clauses
;
13328 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13331 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13334 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13336 tree purpose
, value
, chain
;
13341 if (TREE_CODE (t
) != TREE_LIST
)
13342 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13343 /*function_p=*/false,
13344 /*integral_constant_expression_p=*/false);
13346 if (t
== void_list_node
)
13349 purpose
= TREE_PURPOSE (t
);
13351 purpose
= RECUR (purpose
);
13352 value
= TREE_VALUE (t
);
13355 if (TREE_CODE (value
) != LABEL_DECL
)
13356 value
= RECUR (value
);
13359 value
= lookup_label (DECL_NAME (value
));
13360 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13361 TREE_USED (value
) = 1;
13364 chain
= TREE_CHAIN (t
);
13365 if (chain
&& chain
!= void_type_node
)
13366 chain
= RECUR (chain
);
13367 return tree_cons (purpose
, value
, chain
);
13371 /* Substitute one OMP_FOR iterator. */
13374 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13375 tree condv
, tree incrv
, tree
*clauses
,
13376 tree args
, tsubst_flags_t complain
, tree in_decl
,
13377 bool integral_constant_expression_p
)
13379 #define RECUR(NODE) \
13380 tsubst_expr ((NODE), args, complain, in_decl, \
13381 integral_constant_expression_p)
13382 tree decl
, init
, cond
, incr
;
13384 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13385 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13386 decl
= TREE_OPERAND (init
, 0);
13387 init
= TREE_OPERAND (init
, 1);
13388 tree decl_expr
= NULL_TREE
;
13389 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13391 /* We need to jump through some hoops to handle declarations in the
13392 for-init-statement, since we might need to handle auto deduction,
13393 but we need to keep control of initialization. */
13395 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13396 decl
= tsubst_decl (decl
, args
, complain
);
13399 decl
= RECUR (decl
);
13400 init
= RECUR (init
);
13402 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13403 if (auto_node
&& init
)
13405 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13407 gcc_assert (!type_dependent_expression_p (decl
));
13409 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13413 /* Declare the variable, but don't let that initialize it. */
13414 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13415 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13417 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13420 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13421 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13422 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13424 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13425 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13426 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13427 NOP_EXPR
, rhs
, complain
);
13430 incr
= RECUR (incr
);
13431 TREE_VEC_ELT (declv
, i
) = decl
;
13432 TREE_VEC_ELT (initv
, i
) = init
;
13433 TREE_VEC_ELT (condv
, i
) = cond
;
13434 TREE_VEC_ELT (incrv
, i
) = incr
;
13440 /* Declare and initialize the variable. */
13447 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13449 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13450 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13451 && OMP_CLAUSE_DECL (c
) == decl
)
13453 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13454 && OMP_CLAUSE_DECL (c
) == decl
)
13455 error ("iteration variable %qD should not be firstprivate", decl
);
13456 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13457 && OMP_CLAUSE_DECL (c
) == decl
)
13458 error ("iteration variable %qD should not be reduction", decl
);
13462 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13463 OMP_CLAUSE_DECL (c
) = decl
;
13464 c
= finish_omp_clauses (c
);
13467 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13472 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13473 if (COMPARISON_CLASS_P (cond
))
13475 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13476 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13477 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13480 cond
= RECUR (cond
);
13481 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13482 switch (TREE_CODE (incr
))
13484 case PREINCREMENT_EXPR
:
13485 case PREDECREMENT_EXPR
:
13486 case POSTINCREMENT_EXPR
:
13487 case POSTDECREMENT_EXPR
:
13488 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13489 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13492 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13493 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13495 tree rhs
= TREE_OPERAND (incr
, 1);
13496 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13497 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13498 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13499 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13500 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13504 incr
= RECUR (incr
);
13507 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13508 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13510 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13511 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13512 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13513 TREE_TYPE (decl
), lhs
,
13514 RECUR (TREE_OPERAND (incr
, 2))));
13516 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13517 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13518 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13520 tree rhs
= TREE_OPERAND (incr
, 2);
13521 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13522 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13523 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13524 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13525 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13529 incr
= RECUR (incr
);
13532 incr
= RECUR (incr
);
13536 TREE_VEC_ELT (declv
, i
) = decl
;
13537 TREE_VEC_ELT (initv
, i
) = init
;
13538 TREE_VEC_ELT (condv
, i
) = cond
;
13539 TREE_VEC_ELT (incrv
, i
) = incr
;
13543 /* Like tsubst_copy for expressions, etc. but also does semantic
13547 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13548 bool integral_constant_expression_p
)
13550 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13551 #define RECUR(NODE) \
13552 tsubst_expr ((NODE), args, complain, in_decl, \
13553 integral_constant_expression_p)
13559 if (t
== NULL_TREE
|| t
== error_mark_node
)
13562 loc
= input_location
;
13563 if (EXPR_HAS_LOCATION (t
))
13564 input_location
= EXPR_LOCATION (t
);
13565 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13566 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13568 switch (TREE_CODE (t
))
13570 case STATEMENT_LIST
:
13572 tree_stmt_iterator i
;
13573 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13574 RECUR (tsi_stmt (i
));
13578 case CTOR_INITIALIZER
:
13579 finish_mem_initializers (tsubst_initializer_list
13580 (TREE_OPERAND (t
, 0), args
));
13584 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13588 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13589 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13590 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13592 finish_expr_stmt (tmp
);
13596 do_using_directive (USING_STMT_NAMESPACE (t
));
13601 tree decl
, pattern_decl
;
13604 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13605 if (TREE_CODE (decl
) == LABEL_DECL
)
13606 finish_label_decl (DECL_NAME (decl
));
13607 else if (TREE_CODE (decl
) == USING_DECL
)
13609 tree scope
= USING_DECL_SCOPE (decl
);
13610 tree name
= DECL_NAME (decl
);
13613 scope
= tsubst (scope
, args
, complain
, in_decl
);
13614 decl
= lookup_qualified_name (scope
, name
,
13615 /*is_type_p=*/false,
13616 /*complain=*/false);
13617 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13618 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13620 do_local_using_decl (decl
, scope
, name
);
13622 else if (DECL_PACK_P (decl
))
13624 /* Don't build up decls for a variadic capture proxy, we'll
13625 instantiate the elements directly as needed. */
13630 init
= DECL_INITIAL (decl
);
13631 decl
= tsubst (decl
, args
, complain
, in_decl
);
13632 if (decl
!= error_mark_node
)
13634 /* By marking the declaration as instantiated, we avoid
13635 trying to instantiate it. Since instantiate_decl can't
13636 handle local variables, and since we've already done
13637 all that needs to be done, that's the right thing to
13640 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13642 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13643 /* Anonymous aggregates are a special case. */
13644 finish_anon_union (decl
);
13645 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13647 DECL_CONTEXT (decl
) = current_function_decl
;
13648 if (DECL_NAME (decl
) == this_identifier
)
13650 tree lam
= DECL_CONTEXT (current_function_decl
);
13651 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13652 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13654 insert_capture_proxy (decl
);
13656 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13657 /* We already did a pushtag. */;
13658 else if (TREE_CODE (decl
) == FUNCTION_DECL
13659 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13660 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13662 DECL_CONTEXT (decl
) = NULL_TREE
;
13664 DECL_CONTEXT (decl
) = current_function_decl
;
13665 cp_check_omp_declare_reduction (decl
);
13669 int const_init
= false;
13670 maybe_push_decl (decl
);
13672 && DECL_PRETTY_FUNCTION_P (decl
))
13674 /* For __PRETTY_FUNCTION__ we have to adjust the
13676 const char *const name
13677 = cxx_printable_name (current_function_decl
, 2);
13678 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13681 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
13684 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13686 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13695 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13696 RECUR (FOR_INIT_STMT (t
));
13697 finish_for_init_stmt (stmt
);
13698 tmp
= RECUR (FOR_COND (t
));
13699 finish_for_cond (tmp
, stmt
, false);
13700 tmp
= RECUR (FOR_EXPR (t
));
13701 finish_for_expr (tmp
, stmt
);
13702 RECUR (FOR_BODY (t
));
13703 finish_for_stmt (stmt
);
13706 case RANGE_FOR_STMT
:
13709 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13710 decl
= RANGE_FOR_DECL (t
);
13711 decl
= tsubst (decl
, args
, complain
, in_decl
);
13712 maybe_push_decl (decl
);
13713 expr
= RECUR (RANGE_FOR_EXPR (t
));
13714 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13715 RECUR (RANGE_FOR_BODY (t
));
13716 finish_for_stmt (stmt
);
13721 stmt
= begin_while_stmt ();
13722 tmp
= RECUR (WHILE_COND (t
));
13723 finish_while_stmt_cond (tmp
, stmt
, false);
13724 RECUR (WHILE_BODY (t
));
13725 finish_while_stmt (stmt
);
13729 stmt
= begin_do_stmt ();
13730 RECUR (DO_BODY (t
));
13731 finish_do_body (stmt
);
13732 tmp
= RECUR (DO_COND (t
));
13733 finish_do_stmt (tmp
, stmt
, false);
13737 stmt
= begin_if_stmt ();
13738 tmp
= RECUR (IF_COND (t
));
13739 finish_if_stmt_cond (tmp
, stmt
);
13740 RECUR (THEN_CLAUSE (t
));
13741 finish_then_clause (stmt
);
13743 if (ELSE_CLAUSE (t
))
13745 begin_else_clause (stmt
);
13746 RECUR (ELSE_CLAUSE (t
));
13747 finish_else_clause (stmt
);
13750 finish_if_stmt (stmt
);
13754 if (BIND_EXPR_BODY_BLOCK (t
))
13755 stmt
= begin_function_body ();
13757 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
13758 ? BCS_TRY_BLOCK
: 0);
13760 RECUR (BIND_EXPR_BODY (t
));
13762 if (BIND_EXPR_BODY_BLOCK (t
))
13763 finish_function_body (stmt
);
13765 finish_compound_stmt (stmt
);
13769 finish_break_stmt ();
13772 case CONTINUE_STMT
:
13773 finish_continue_stmt ();
13777 stmt
= begin_switch_stmt ();
13778 tmp
= RECUR (SWITCH_STMT_COND (t
));
13779 finish_switch_cond (tmp
, stmt
);
13780 RECUR (SWITCH_STMT_BODY (t
));
13781 finish_switch_stmt (stmt
);
13784 case CASE_LABEL_EXPR
:
13786 tree low
= RECUR (CASE_LOW (t
));
13787 tree high
= RECUR (CASE_HIGH (t
));
13788 finish_case_label (EXPR_LOCATION (t
), low
, high
);
13794 tree decl
= LABEL_EXPR_LABEL (t
);
13797 label
= finish_label_stmt (DECL_NAME (decl
));
13798 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13799 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13804 tmp
= GOTO_DESTINATION (t
);
13805 if (TREE_CODE (tmp
) != LABEL_DECL
)
13806 /* Computed goto's must be tsubst'd into. On the other hand,
13807 non-computed gotos must not be; the identifier in question
13808 will have no binding. */
13811 tmp
= DECL_NAME (tmp
);
13812 finish_goto_stmt (tmp
);
13817 tree string
= RECUR (ASM_STRING (t
));
13818 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
13819 complain
, in_decl
);
13820 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
13821 complain
, in_decl
);
13822 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
13823 complain
, in_decl
);
13824 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
13825 complain
, in_decl
);
13826 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
13828 tree asm_expr
= tmp
;
13829 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
13830 asm_expr
= TREE_OPERAND (asm_expr
, 0);
13831 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
13838 stmt
= begin_try_block ();
13839 RECUR (TRY_STMTS (t
));
13840 finish_cleanup_try_block (stmt
);
13841 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
13845 tree compound_stmt
= NULL_TREE
;
13847 if (FN_TRY_BLOCK_P (t
))
13848 stmt
= begin_function_try_block (&compound_stmt
);
13850 stmt
= begin_try_block ();
13852 RECUR (TRY_STMTS (t
));
13854 if (FN_TRY_BLOCK_P (t
))
13855 finish_function_try_block (stmt
);
13857 finish_try_block (stmt
);
13859 RECUR (TRY_HANDLERS (t
));
13860 if (FN_TRY_BLOCK_P (t
))
13861 finish_function_handler_sequence (stmt
, compound_stmt
);
13863 finish_handler_sequence (stmt
);
13869 tree decl
= HANDLER_PARMS (t
);
13873 decl
= tsubst (decl
, args
, complain
, in_decl
);
13874 /* Prevent instantiate_decl from trying to instantiate
13875 this variable. We've already done all that needs to be
13877 if (decl
!= error_mark_node
)
13878 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13880 stmt
= begin_handler ();
13881 finish_handler_parms (decl
, stmt
);
13882 RECUR (HANDLER_BODY (t
));
13883 finish_handler (stmt
);
13888 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
13889 if (CLASS_TYPE_P (tmp
))
13891 /* Local classes are not independent templates; they are
13892 instantiated along with their containing function. And this
13893 way we don't have to deal with pushing out of one local class
13894 to instantiate a member of another local class. */
13896 /* Closures are handled by the LAMBDA_EXPR. */
13897 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
13898 complete_type (tmp
);
13899 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
13900 if (!DECL_ARTIFICIAL (fn
))
13901 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
13905 case STATIC_ASSERT
:
13909 ++c_inhibit_evaluation_warnings
;
13911 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
13914 /*integral_constant_expression_p=*/true);
13915 --c_inhibit_evaluation_warnings
;
13917 finish_static_assert (condition
,
13918 STATIC_ASSERT_MESSAGE (t
),
13919 STATIC_ASSERT_SOURCE_LOCATION (t
),
13920 /*member_p=*/false);
13925 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
13926 args
, complain
, in_decl
);
13927 stmt
= begin_omp_parallel ();
13928 RECUR (OMP_PARALLEL_BODY (t
));
13929 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
13930 = OMP_PARALLEL_COMBINED (t
);
13934 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
13935 args
, complain
, in_decl
);
13936 stmt
= begin_omp_task ();
13937 RECUR (OMP_TASK_BODY (t
));
13938 finish_omp_task (tmp
, stmt
);
13944 case OMP_DISTRIBUTE
:
13946 tree clauses
, body
, pre_body
;
13947 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
13948 tree incrv
= NULL_TREE
;
13951 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
13952 args
, complain
, in_decl
);
13953 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13955 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13956 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13957 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13958 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13961 stmt
= begin_omp_structured_block ();
13963 pre_body
= push_stmt_list ();
13964 RECUR (OMP_FOR_PRE_BODY (t
));
13965 pre_body
= pop_stmt_list (pre_body
);
13967 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13968 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
13969 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
13970 &clauses
, args
, complain
, in_decl
,
13971 integral_constant_expression_p
);
13973 body
= push_stmt_list ();
13974 RECUR (OMP_FOR_BODY (t
));
13975 body
= pop_stmt_list (body
);
13977 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13978 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
13979 condv
, incrv
, body
, pre_body
, clauses
);
13982 t
= make_node (TREE_CODE (t
));
13983 TREE_TYPE (t
) = void_type_node
;
13984 OMP_FOR_BODY (t
) = body
;
13985 OMP_FOR_PRE_BODY (t
) = pre_body
;
13986 OMP_FOR_CLAUSES (t
) = clauses
;
13987 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
13991 add_stmt (finish_omp_structured_block (stmt
));
13998 case OMP_TARGET_DATA
:
14000 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14001 args
, complain
, in_decl
);
14002 stmt
= push_stmt_list ();
14003 RECUR (OMP_BODY (t
));
14004 stmt
= pop_stmt_list (stmt
);
14007 OMP_BODY (t
) = stmt
;
14008 OMP_CLAUSES (t
) = tmp
;
14012 case OMP_TARGET_UPDATE
:
14013 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
14014 args
, complain
, in_decl
);
14016 OMP_CLAUSES (t
) = tmp
;
14023 case OMP_TASKGROUP
:
14025 stmt
= push_stmt_list ();
14026 RECUR (OMP_BODY (t
));
14027 stmt
= pop_stmt_list (stmt
);
14030 OMP_BODY (t
) = stmt
;
14035 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14036 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14038 tree op1
= TREE_OPERAND (t
, 1);
14039 tree rhs1
= NULL_TREE
;
14041 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14043 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14044 op1
= TREE_OPERAND (op1
, 1);
14046 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14047 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14048 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14049 NULL_TREE
, NULL_TREE
, rhs1
,
14050 OMP_ATOMIC_SEQ_CST (t
));
14054 tree op1
= TREE_OPERAND (t
, 1);
14055 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14056 tree rhs1
= NULL_TREE
;
14057 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14058 enum tree_code opcode
= NOP_EXPR
;
14059 if (code
== OMP_ATOMIC_READ
)
14061 v
= RECUR (TREE_OPERAND (op1
, 0));
14062 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14064 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14065 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14067 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14068 v
= RECUR (TREE_OPERAND (op1
, 0));
14069 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14070 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14072 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14073 op11
= TREE_OPERAND (op11
, 1);
14075 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14076 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14077 opcode
= TREE_CODE (op11
);
14078 if (opcode
== MODIFY_EXPR
)
14084 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14085 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14087 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14088 OMP_ATOMIC_SEQ_CST (t
));
14092 case TRANSACTION_EXPR
:
14095 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14096 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14098 if (TRANSACTION_EXPR_IS_STMT (t
))
14100 tree body
= TRANSACTION_EXPR_BODY (t
);
14101 tree noex
= NULL_TREE
;
14102 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14104 noex
= MUST_NOT_THROW_COND (body
);
14105 if (noex
== NULL_TREE
)
14106 noex
= boolean_true_node
;
14107 body
= TREE_OPERAND (body
, 0);
14109 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14111 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14115 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14116 RECUR (TRANSACTION_EXPR_BODY (t
)),
14123 case MUST_NOT_THROW_EXPR
:
14125 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14126 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14127 RETURN (build_must_not_throw_expr (op0
, cond
));
14130 case EXPR_PACK_EXPANSION
:
14131 error ("invalid use of pack expansion expression");
14132 RETURN (error_mark_node
);
14134 case NONTYPE_ARGUMENT_PACK
:
14135 error ("use %<...%> to expand argument pack");
14136 RETURN (error_mark_node
);
14138 case CILK_SPAWN_STMT
:
14139 cfun
->calls_cilk_spawn
= 1;
14140 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14142 case CILK_SYNC_STMT
:
14143 RETURN (build_cilk_sync ());
14145 case COMPOUND_EXPR
:
14146 tmp
= RECUR (TREE_OPERAND (t
, 0));
14147 if (tmp
== NULL_TREE
)
14148 /* If the first operand was a statement, we're done with it. */
14149 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14150 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14151 RECUR (TREE_OPERAND (t
, 1)),
14154 case ANNOTATE_EXPR
:
14155 tmp
= RECUR (TREE_OPERAND (t
, 0));
14156 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14157 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14160 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14162 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14163 /*function_p=*/false,
14164 integral_constant_expression_p
));
14167 RETURN (NULL_TREE
);
14169 input_location
= loc
;
14175 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14176 function. For description of the body see comment above
14177 cp_parser_omp_declare_reduction_exprs. */
14180 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14182 if (t
== NULL_TREE
|| t
== error_mark_node
)
14185 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14187 tree_stmt_iterator tsi
;
14190 memset (stmts
, 0, sizeof stmts
);
14191 for (i
= 0, tsi
= tsi_start (t
);
14192 i
< 7 && !tsi_end_p (tsi
);
14193 i
++, tsi_next (&tsi
))
14194 stmts
[i
] = tsi_stmt (tsi
);
14195 gcc_assert (tsi_end_p (tsi
));
14199 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14200 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14201 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14202 args
, complain
, in_decl
);
14203 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14204 args
, complain
, in_decl
);
14205 DECL_CONTEXT (omp_out
) = current_function_decl
;
14206 DECL_CONTEXT (omp_in
) = current_function_decl
;
14207 keep_next_level (true);
14208 tree block
= begin_omp_structured_block ();
14209 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14210 block
= finish_omp_structured_block (block
);
14211 block
= maybe_cleanup_point_expr_void (block
);
14212 add_decl_expr (omp_out
);
14213 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14214 TREE_NO_WARNING (omp_out
) = 1;
14215 add_decl_expr (omp_in
);
14216 finish_expr_stmt (block
);
14220 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14221 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14222 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14223 args
, complain
, in_decl
);
14224 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14225 args
, complain
, in_decl
);
14226 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14227 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14228 keep_next_level (true);
14229 tree block
= begin_omp_structured_block ();
14230 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14231 block
= finish_omp_structured_block (block
);
14232 block
= maybe_cleanup_point_expr_void (block
);
14233 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14234 add_decl_expr (omp_priv
);
14235 add_decl_expr (omp_orig
);
14236 finish_expr_stmt (block
);
14238 add_decl_expr (omp_orig
);
14242 /* T is a postfix-expression that is not being used in a function
14243 call. Return the substituted version of T. */
14246 tsubst_non_call_postfix_expression (tree t
, tree args
,
14247 tsubst_flags_t complain
,
14250 if (TREE_CODE (t
) == SCOPE_REF
)
14251 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14252 /*done=*/false, /*address_p=*/false);
14254 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14255 /*function_p=*/false,
14256 /*integral_constant_expression_p=*/false);
14261 /* Sentinel to disable certain warnings during template substitution. */
14263 struct warning_sentinel
{
14266 warning_sentinel(int& flag
, bool suppress
=true)
14267 : flag(flag
), val(flag
) { if (suppress
) flag
= 0; }
14268 ~warning_sentinel() { flag
= val
; }
14271 /* Like tsubst but deals with expressions and performs semantic
14272 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14275 tsubst_copy_and_build (tree t
,
14277 tsubst_flags_t complain
,
14280 bool integral_constant_expression_p
)
14282 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14283 #define RECUR(NODE) \
14284 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14285 /*function_p=*/false, \
14286 integral_constant_expression_p)
14291 if (t
== NULL_TREE
|| t
== error_mark_node
)
14294 loc
= input_location
;
14295 if (EXPR_HAS_LOCATION (t
))
14296 input_location
= EXPR_LOCATION (t
);
14298 /* N3276 decltype magic only applies to calls at the top level or on the
14299 right side of a comma. */
14300 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14301 complain
&= ~tf_decltype
;
14303 switch (TREE_CODE (t
))
14307 /* Fall through. */
14308 case IDENTIFIER_NODE
:
14312 bool non_integral_constant_expression_p
;
14313 const char *error_msg
;
14315 if (IDENTIFIER_TYPENAME_P (t
))
14317 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14318 t
= mangle_conv_op_name_for_type (new_type
);
14321 /* Look up the name. */
14322 decl
= lookup_name (t
);
14324 /* By convention, expressions use ERROR_MARK_NODE to indicate
14325 failure, not NULL_TREE. */
14326 if (decl
== NULL_TREE
)
14327 decl
= error_mark_node
;
14329 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14331 integral_constant_expression_p
,
14332 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14333 &non_integral_constant_expression_p
,
14334 /*template_p=*/false,
14336 /*address_p=*/false,
14337 /*template_arg_p=*/false,
14342 if (!function_p
&& identifier_p (decl
))
14344 if (complain
& tf_error
)
14345 unqualified_name_lookup_error (decl
);
14346 decl
= error_mark_node
;
14351 case TEMPLATE_ID_EXPR
:
14354 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14355 tree targs
= TREE_OPERAND (t
, 1);
14358 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14360 if (TREE_CODE (templ
) == COMPONENT_REF
)
14362 object
= TREE_OPERAND (templ
, 0);
14363 templ
= TREE_OPERAND (templ
, 1);
14366 object
= NULL_TREE
;
14367 templ
= lookup_template_function (templ
, targs
);
14370 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14371 object
, templ
, NULL_TREE
));
14373 RETURN (baselink_for_fns (templ
));
14378 tree r
= RECUR (TREE_OPERAND (t
, 0));
14380 if (REFERENCE_REF_P (t
))
14382 /* A type conversion to reference type will be enclosed in
14383 such an indirect ref, but the substitution of the cast
14384 will have also added such an indirect ref. */
14385 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14386 r
= convert_from_reference (r
);
14389 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14390 complain
|decltype_flag
);
14396 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14397 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14398 RETURN (build_nop (type
, op0
));
14401 case IMPLICIT_CONV_EXPR
:
14403 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14404 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14405 int flags
= LOOKUP_IMPLICIT
;
14406 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14407 flags
= LOOKUP_NORMAL
;
14408 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14414 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14415 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14416 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14420 case REINTERPRET_CAST_EXPR
:
14421 case CONST_CAST_EXPR
:
14422 case DYNAMIC_CAST_EXPR
:
14423 case STATIC_CAST_EXPR
:
14426 tree op
, r
= NULL_TREE
;
14428 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14429 if (integral_constant_expression_p
14430 && !cast_valid_in_integral_constant_expression_p (type
))
14432 if (complain
& tf_error
)
14433 error ("a cast to a type other than an integral or "
14434 "enumeration type cannot appear in a constant-expression");
14435 RETURN (error_mark_node
);
14438 op
= RECUR (TREE_OPERAND (t
, 0));
14440 warning_sentinel
s(warn_useless_cast
);
14441 switch (TREE_CODE (t
))
14444 r
= build_functional_cast (type
, op
, complain
);
14446 case REINTERPRET_CAST_EXPR
:
14447 r
= build_reinterpret_cast (type
, op
, complain
);
14449 case CONST_CAST_EXPR
:
14450 r
= build_const_cast (type
, op
, complain
);
14452 case DYNAMIC_CAST_EXPR
:
14453 r
= build_dynamic_cast (type
, op
, complain
);
14455 case STATIC_CAST_EXPR
:
14456 r
= build_static_cast (type
, op
, complain
);
14459 gcc_unreachable ();
14465 case POSTDECREMENT_EXPR
:
14466 case POSTINCREMENT_EXPR
:
14467 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14468 args
, complain
, in_decl
);
14469 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14470 complain
|decltype_flag
));
14472 case PREDECREMENT_EXPR
:
14473 case PREINCREMENT_EXPR
:
14477 case TRUTH_NOT_EXPR
:
14478 case UNARY_PLUS_EXPR
: /* Unary + */
14479 case REALPART_EXPR
:
14480 case IMAGPART_EXPR
:
14481 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14482 RECUR (TREE_OPERAND (t
, 0)),
14483 complain
|decltype_flag
));
14485 case FIX_TRUNC_EXPR
:
14486 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14490 op1
= TREE_OPERAND (t
, 0);
14491 if (TREE_CODE (op1
) == LABEL_DECL
)
14492 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14493 EXPR_LOCATION (op1
)));
14494 if (TREE_CODE (op1
) == SCOPE_REF
)
14495 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14496 /*done=*/true, /*address_p=*/true);
14498 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14500 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14501 complain
|decltype_flag
));
14506 case TRUNC_DIV_EXPR
:
14507 case CEIL_DIV_EXPR
:
14508 case FLOOR_DIV_EXPR
:
14509 case ROUND_DIV_EXPR
:
14510 case EXACT_DIV_EXPR
:
14514 case TRUNC_MOD_EXPR
:
14515 case FLOOR_MOD_EXPR
:
14516 case TRUTH_ANDIF_EXPR
:
14517 case TRUTH_ORIF_EXPR
:
14518 case TRUTH_AND_EXPR
:
14519 case TRUTH_OR_EXPR
:
14535 warning_sentinel
s1(warn_type_limits
);
14536 warning_sentinel
s2(warn_div_by_zero
);
14537 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14538 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14539 tree r
= build_x_binary_op
14540 (input_location
, TREE_CODE (t
),
14542 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14544 : TREE_CODE (TREE_OPERAND (t
, 0))),
14546 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14548 : TREE_CODE (TREE_OPERAND (t
, 1))),
14550 complain
|decltype_flag
);
14551 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14552 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14557 case POINTER_PLUS_EXPR
:
14559 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14560 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14561 return fold_build_pointer_plus (op0
, op1
);
14565 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14566 /*address_p=*/false));
14568 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14569 args
, complain
, in_decl
);
14570 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14571 RECUR (TREE_OPERAND (t
, 1)),
14572 complain
|decltype_flag
));
14574 case ARRAY_NOTATION_REF
:
14576 tree start_index
, length
, stride
;
14577 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14578 args
, complain
, in_decl
);
14579 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14580 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14581 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14582 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14583 length
, stride
, TREE_TYPE (op1
)));
14586 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14587 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14594 op1
= TREE_OPERAND (t
, 0);
14595 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14596 op1
= TREE_TYPE (op1
);
14599 /* When there are no ARGS, we are trying to evaluate a
14600 non-dependent expression from the parser. Trying to do
14601 the substitutions may not work. */
14603 op1
= TREE_TYPE (op1
);
14607 ++cp_unevaluated_operand
;
14608 ++c_inhibit_evaluation_warnings
;
14610 op1
= tsubst (op1
, args
, complain
, in_decl
);
14612 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14613 /*function_p=*/false,
14614 /*integral_constant_expression_p=*/
14616 --cp_unevaluated_operand
;
14617 --c_inhibit_evaluation_warnings
;
14620 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14621 complain
& tf_error
);
14623 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14624 complain
& tf_error
);
14625 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14627 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14629 if (!processing_template_decl
&& TYPE_P (op1
))
14631 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14632 build1 (NOP_EXPR
, op1
, error_mark_node
));
14633 SIZEOF_EXPR_TYPE_P (r
) = 1;
14636 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14637 TREE_SIDE_EFFECTS (r
) = 0;
14638 TREE_READONLY (r
) = 1;
14640 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14645 case AT_ENCODE_EXPR
:
14647 op1
= TREE_OPERAND (t
, 0);
14648 ++cp_unevaluated_operand
;
14649 ++c_inhibit_evaluation_warnings
;
14650 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14651 /*function_p=*/false,
14652 /*integral_constant_expression_p=*/false);
14653 --cp_unevaluated_operand
;
14654 --c_inhibit_evaluation_warnings
;
14655 RETURN (objc_build_encode_expr (op1
));
14658 case NOEXCEPT_EXPR
:
14659 op1
= TREE_OPERAND (t
, 0);
14660 ++cp_unevaluated_operand
;
14661 ++c_inhibit_evaluation_warnings
;
14662 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14663 /*function_p=*/false,
14664 /*integral_constant_expression_p=*/false);
14665 --cp_unevaluated_operand
;
14666 --c_inhibit_evaluation_warnings
;
14667 RETURN (finish_noexcept_expr (op1
, complain
));
14671 warning_sentinel
s(warn_div_by_zero
);
14672 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
14673 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
14674 tree r
= build_x_modify_expr
14675 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
14676 complain
|decltype_flag
);
14677 /* TREE_NO_WARNING must be set if either the expression was
14678 parenthesized or it uses an operator such as >>= rather
14679 than plain assignment. In the former case, it was already
14680 set and must be copied. In the latter case,
14681 build_x_modify_expr sets it and it must not be reset
14683 if (TREE_NO_WARNING (t
))
14684 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14690 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14691 args
, complain
, in_decl
);
14692 /* Remember that there was a reference to this entity. */
14695 RETURN (build_x_arrow (input_location
, op1
, complain
));
14699 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14700 tree init
= RECUR (TREE_OPERAND (t
, 3));
14701 vec
<tree
, va_gc
> *placement_vec
;
14702 vec
<tree
, va_gc
> *init_vec
;
14705 if (placement
== NULL_TREE
)
14706 placement_vec
= NULL
;
14709 placement_vec
= make_tree_vector ();
14710 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14711 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14714 /* If there was an initializer in the original tree, but it
14715 instantiated to an empty list, then we should pass a
14716 non-NULL empty vector to tell build_new that it was an
14717 empty initializer() rather than no initializer. This can
14718 only happen when the initializer is a pack expansion whose
14719 parameter packs are of length zero. */
14720 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
14724 init_vec
= make_tree_vector ();
14725 if (init
== void_node
)
14726 gcc_assert (init_vec
!= NULL
);
14729 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
14730 vec_safe_push (init_vec
, TREE_VALUE (init
));
14734 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14735 tree op2
= RECUR (TREE_OPERAND (t
, 2));
14736 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
14737 NEW_EXPR_USE_GLOBAL (t
),
14740 if (placement_vec
!= NULL
)
14741 release_tree_vector (placement_vec
);
14742 if (init_vec
!= NULL
)
14743 release_tree_vector (init_vec
);
14750 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14751 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14752 RETURN (delete_sanity (op0
, op1
,
14753 DELETE_EXPR_USE_VEC (t
),
14754 DELETE_EXPR_USE_GLOBAL (t
),
14758 case COMPOUND_EXPR
:
14760 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
14761 complain
& ~tf_decltype
, in_decl
,
14762 /*function_p=*/false,
14763 integral_constant_expression_p
);
14764 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
14766 RECUR (TREE_OPERAND (t
, 1)),
14767 complain
|decltype_flag
));
14773 vec
<tree
, va_gc
> *call_args
;
14774 unsigned int nargs
, i
;
14779 function
= CALL_EXPR_FN (t
);
14780 /* When we parsed the expression, we determined whether or
14781 not Koenig lookup should be performed. */
14782 koenig_p
= KOENIG_LOOKUP_P (t
);
14783 if (TREE_CODE (function
) == SCOPE_REF
)
14785 qualified_p
= true;
14786 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
14788 /*address_p=*/false);
14790 else if (koenig_p
&& identifier_p (function
))
14792 /* Do nothing; calling tsubst_copy_and_build on an identifier
14793 would incorrectly perform unqualified lookup again.
14795 Note that we can also have an IDENTIFIER_NODE if the earlier
14796 unqualified lookup found a member function; in that case
14797 koenig_p will be false and we do want to do the lookup
14798 again to find the instantiated member function.
14800 FIXME but doing that causes c++/15272, so we need to stop
14801 using IDENTIFIER_NODE in that situation. */
14802 qualified_p
= false;
14806 if (TREE_CODE (function
) == COMPONENT_REF
)
14808 tree op
= TREE_OPERAND (function
, 1);
14810 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
14811 || (BASELINK_P (op
)
14812 && BASELINK_QUALIFIED_P (op
)));
14815 qualified_p
= false;
14817 if (TREE_CODE (function
) == ADDR_EXPR
14818 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
14819 /* Avoid error about taking the address of a constructor. */
14820 function
= TREE_OPERAND (function
, 0);
14822 function
= tsubst_copy_and_build (function
, args
, complain
,
14825 integral_constant_expression_p
);
14827 if (BASELINK_P (function
))
14828 qualified_p
= true;
14831 nargs
= call_expr_nargs (t
);
14832 call_args
= make_tree_vector ();
14833 for (i
= 0; i
< nargs
; ++i
)
14835 tree arg
= CALL_EXPR_ARG (t
, i
);
14837 if (!PACK_EXPANSION_P (arg
))
14838 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
14841 /* Expand the pack expansion and push each entry onto
14843 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
14844 if (TREE_CODE (arg
) == TREE_VEC
)
14846 unsigned int len
, j
;
14848 len
= TREE_VEC_LENGTH (arg
);
14849 for (j
= 0; j
< len
; ++j
)
14851 tree value
= TREE_VEC_ELT (arg
, j
);
14852 if (value
!= NULL_TREE
)
14853 value
= convert_from_reference (value
);
14854 vec_safe_push (call_args
, value
);
14859 /* A partial substitution. Add one entry. */
14860 vec_safe_push (call_args
, arg
);
14865 /* We do not perform argument-dependent lookup if normal
14866 lookup finds a non-function, in accordance with the
14867 expected resolution of DR 218. */
14869 && ((is_overloaded_fn (function
)
14870 /* If lookup found a member function, the Koenig lookup is
14871 not appropriate, even if an unqualified-name was used
14872 to denote the function. */
14873 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
14874 || identifier_p (function
))
14875 /* Only do this when substitution turns a dependent call
14876 into a non-dependent call. */
14877 && type_dependent_expression_p_push (t
)
14878 && !any_type_dependent_arguments_p (call_args
))
14879 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
14881 if (identifier_p (function
)
14882 && !any_type_dependent_arguments_p (call_args
))
14884 if (koenig_p
&& (complain
& tf_warning_or_error
))
14886 /* For backwards compatibility and good diagnostics, try
14887 the unqualified lookup again if we aren't in SFINAE
14889 tree unq
= (tsubst_copy_and_build
14890 (function
, args
, complain
, in_decl
, true,
14891 integral_constant_expression_p
));
14892 if (unq
== error_mark_node
)
14893 RETURN (error_mark_node
);
14895 if (unq
!= function
)
14898 if (INDIRECT_REF_P (fn
))
14899 fn
= TREE_OPERAND (fn
, 0);
14900 if (TREE_CODE (fn
) == COMPONENT_REF
)
14901 fn
= TREE_OPERAND (fn
, 1);
14902 if (is_overloaded_fn (fn
))
14903 fn
= get_first_fn (fn
);
14904 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
14905 "%qD was not declared in this scope, "
14906 "and no declarations were found by "
14907 "argument-dependent lookup at the point "
14908 "of instantiation", function
))
14911 /* Can't say anything more. */;
14912 else if (DECL_CLASS_SCOPE_P (fn
))
14914 location_t loc
= EXPR_LOC_OR_LOC (t
,
14917 "declarations in dependent base %qT are "
14918 "not found by unqualified lookup",
14919 DECL_CLASS_CONTEXT (fn
));
14920 if (current_class_ptr
)
14922 "use %<this->%D%> instead", function
);
14925 "use %<%T::%D%> instead",
14926 current_class_name
, function
);
14929 inform (0, "%q+D declared here, later in the "
14930 "translation unit", fn
);
14935 if (identifier_p (function
))
14937 if (complain
& tf_error
)
14938 unqualified_name_lookup_error (function
);
14939 release_tree_vector (call_args
);
14940 RETURN (error_mark_node
);
14944 /* Remember that there was a reference to this entity. */
14945 if (DECL_P (function
))
14946 mark_used (function
);
14948 /* Put back tf_decltype for the actual call. */
14949 complain
|= decltype_flag
;
14951 if (TREE_CODE (function
) == OFFSET_REF
)
14952 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
14954 else if (TREE_CODE (function
) == COMPONENT_REF
)
14956 tree instance
= TREE_OPERAND (function
, 0);
14957 tree fn
= TREE_OPERAND (function
, 1);
14959 if (processing_template_decl
14960 && (type_dependent_expression_p (instance
)
14961 || (!BASELINK_P (fn
)
14962 && TREE_CODE (fn
) != FIELD_DECL
)
14963 || type_dependent_expression_p (fn
)
14964 || any_type_dependent_arguments_p (call_args
)))
14965 ret
= build_nt_call_vec (function
, call_args
);
14966 else if (!BASELINK_P (fn
))
14967 ret
= finish_call_expr (function
, &call_args
,
14968 /*disallow_virtual=*/false,
14969 /*koenig_p=*/false,
14972 ret
= (build_new_method_call
14974 &call_args
, NULL_TREE
,
14975 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
14980 ret
= finish_call_expr (function
, &call_args
,
14981 /*disallow_virtual=*/qualified_p
,
14985 release_tree_vector (call_args
);
14992 tree cond
= RECUR (TREE_OPERAND (t
, 0));
14995 if (TREE_CODE (cond
) == INTEGER_CST
)
14997 if (integer_zerop (cond
))
14999 ++c_inhibit_evaluation_warnings
;
15000 exp1
= RECUR (TREE_OPERAND (t
, 1));
15001 --c_inhibit_evaluation_warnings
;
15002 exp2
= RECUR (TREE_OPERAND (t
, 2));
15006 exp1
= RECUR (TREE_OPERAND (t
, 1));
15007 ++c_inhibit_evaluation_warnings
;
15008 exp2
= RECUR (TREE_OPERAND (t
, 2));
15009 --c_inhibit_evaluation_warnings
;
15014 exp1
= RECUR (TREE_OPERAND (t
, 1));
15015 exp2
= RECUR (TREE_OPERAND (t
, 2));
15018 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
15019 cond
, exp1
, exp2
, complain
));
15022 case PSEUDO_DTOR_EXPR
:
15024 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15025 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15026 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15027 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
15033 tree purpose
, value
, chain
;
15035 if (t
== void_list_node
)
15038 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15039 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15041 /* We have pack expansions, so expand those and
15042 create a new list out of it. */
15043 tree purposevec
= NULL_TREE
;
15044 tree valuevec
= NULL_TREE
;
15048 /* Expand the argument expressions. */
15049 if (TREE_PURPOSE (t
))
15050 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15051 complain
, in_decl
);
15052 if (TREE_VALUE (t
))
15053 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15054 complain
, in_decl
);
15056 /* Build the rest of the list. */
15057 chain
= TREE_CHAIN (t
);
15058 if (chain
&& chain
!= void_type_node
)
15059 chain
= RECUR (chain
);
15061 /* Determine the number of arguments. */
15062 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15064 len
= TREE_VEC_LENGTH (purposevec
);
15065 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15067 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15068 len
= TREE_VEC_LENGTH (valuevec
);
15071 /* Since we only performed a partial substitution into
15072 the argument pack, we only RETURN (a single list
15074 if (purposevec
== TREE_PURPOSE (t
)
15075 && valuevec
== TREE_VALUE (t
)
15076 && chain
== TREE_CHAIN (t
))
15079 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15082 /* Convert the argument vectors into a TREE_LIST */
15086 /* Grab the Ith values. */
15088 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15091 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15094 /* Build the list (backwards). */
15095 chain
= tree_cons (purpose
, value
, chain
);
15101 purpose
= TREE_PURPOSE (t
);
15103 purpose
= RECUR (purpose
);
15104 value
= TREE_VALUE (t
);
15106 value
= RECUR (value
);
15107 chain
= TREE_CHAIN (t
);
15108 if (chain
&& chain
!= void_type_node
)
15109 chain
= RECUR (chain
);
15110 if (purpose
== TREE_PURPOSE (t
)
15111 && value
== TREE_VALUE (t
)
15112 && chain
== TREE_CHAIN (t
))
15114 RETURN (tree_cons (purpose
, value
, chain
));
15117 case COMPONENT_REF
:
15124 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15125 args
, complain
, in_decl
);
15126 /* Remember that there was a reference to this entity. */
15127 if (DECL_P (object
))
15128 mark_used (object
);
15129 object_type
= TREE_TYPE (object
);
15131 member
= TREE_OPERAND (t
, 1);
15132 if (BASELINK_P (member
))
15133 member
= tsubst_baselink (member
,
15134 non_reference (TREE_TYPE (object
)),
15135 args
, complain
, in_decl
);
15137 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15138 if (member
== error_mark_node
)
15139 RETURN (error_mark_node
);
15141 if (type_dependent_expression_p (object
))
15142 /* We can't do much here. */;
15143 else if (!CLASS_TYPE_P (object_type
))
15145 if (scalarish_type_p (object_type
))
15147 tree s
= NULL_TREE
;
15148 tree dtor
= member
;
15150 if (TREE_CODE (dtor
) == SCOPE_REF
)
15152 s
= TREE_OPERAND (dtor
, 0);
15153 dtor
= TREE_OPERAND (dtor
, 1);
15155 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15157 dtor
= TREE_OPERAND (dtor
, 0);
15159 RETURN (finish_pseudo_destructor_expr
15160 (object
, s
, dtor
, input_location
));
15164 else if (TREE_CODE (member
) == SCOPE_REF
15165 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15167 /* Lookup the template functions now that we know what the
15169 tree scope
= TREE_OPERAND (member
, 0);
15170 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15171 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15172 member
= lookup_qualified_name (scope
, tmpl
,
15173 /*is_type_p=*/false,
15174 /*complain=*/false);
15175 if (BASELINK_P (member
))
15177 BASELINK_FUNCTIONS (member
)
15178 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15180 member
= (adjust_result_of_qualified_name_lookup
15181 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15186 qualified_name_lookup_error (scope
, tmpl
, member
,
15188 RETURN (error_mark_node
);
15191 else if (TREE_CODE (member
) == SCOPE_REF
15192 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15193 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15195 if (complain
& tf_error
)
15197 if (TYPE_P (TREE_OPERAND (member
, 0)))
15198 error ("%qT is not a class or namespace",
15199 TREE_OPERAND (member
, 0));
15201 error ("%qD is not a class or namespace",
15202 TREE_OPERAND (member
, 0));
15204 RETURN (error_mark_node
);
15206 else if (TREE_CODE (member
) == FIELD_DECL
)
15208 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15209 if (TREE_CODE (r
) == COMPONENT_REF
)
15210 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15214 r
= finish_class_member_access_expr (object
, member
,
15215 /*template_p=*/false,
15217 if (TREE_CODE (r
) == COMPONENT_REF
)
15218 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15223 RETURN (build_throw
15224 (RECUR (TREE_OPERAND (t
, 0))));
15228 vec
<constructor_elt
, va_gc
> *n
;
15229 constructor_elt
*ce
;
15230 unsigned HOST_WIDE_INT idx
;
15231 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15232 bool process_index_p
;
15234 bool need_copy_p
= false;
15237 if (type
== error_mark_node
)
15238 RETURN (error_mark_node
);
15240 /* digest_init will do the wrong thing if we let it. */
15241 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15244 /* We do not want to process the index of aggregate
15245 initializers as they are identifier nodes which will be
15246 looked up by digest_init. */
15247 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15249 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15250 newlen
= vec_safe_length (n
);
15251 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15253 if (ce
->index
&& process_index_p
15254 /* An identifier index is looked up in the type
15255 being initialized, not the current scope. */
15256 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15257 ce
->index
= RECUR (ce
->index
);
15259 if (PACK_EXPANSION_P (ce
->value
))
15261 /* Substitute into the pack expansion. */
15262 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15265 if (ce
->value
== error_mark_node
15266 || PACK_EXPANSION_P (ce
->value
))
15268 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15269 /* Just move the argument into place. */
15270 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15273 /* Update the length of the final CONSTRUCTOR
15274 arguments vector, and note that we will need to
15276 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15277 need_copy_p
= true;
15281 ce
->value
= RECUR (ce
->value
);
15286 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15288 vec_alloc (n
, newlen
);
15289 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15291 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15293 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15294 for (i
= 0; i
< len
; ++i
)
15295 CONSTRUCTOR_APPEND_ELT (n
, 0,
15296 TREE_VEC_ELT (ce
->value
, i
));
15299 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15303 r
= build_constructor (init_list_type_node
, n
);
15304 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15306 if (TREE_HAS_CONSTRUCTOR (t
))
15307 RETURN (finish_compound_literal (type
, r
, complain
));
15309 TREE_TYPE (r
) = type
;
15315 tree operand_0
= TREE_OPERAND (t
, 0);
15316 if (TYPE_P (operand_0
))
15318 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15319 RETURN (get_typeid (operand_0
, complain
));
15323 operand_0
= RECUR (operand_0
);
15324 RETURN (build_typeid (operand_0
, complain
));
15331 else if (DECL_PACK_P (t
))
15333 /* We don't build decls for an instantiation of a
15334 variadic capture proxy, we instantiate the elements
15336 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15337 return RECUR (DECL_VALUE_EXPR (t
));
15343 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15345 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15346 /* If the original type was a reference, we'll be wrapped in
15347 the appropriate INDIRECT_REF. */
15348 r
= convert_from_reference (r
);
15354 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15355 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15356 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15359 case OFFSETOF_EXPR
:
15360 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0))));
15364 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15365 complain
, in_decl
);
15367 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15369 type2
= tsubst (type2
, args
, complain
, in_decl
);
15371 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15376 tree old_stmt_expr
= cur_stmt_expr
;
15377 tree stmt_expr
= begin_stmt_expr ();
15379 cur_stmt_expr
= stmt_expr
;
15380 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15381 integral_constant_expression_p
);
15382 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15383 cur_stmt_expr
= old_stmt_expr
;
15385 /* If the resulting list of expression statement is empty,
15386 fold it further into void_node. */
15387 if (empty_expr_stmt_p (stmt_expr
))
15388 stmt_expr
= void_node
;
15390 RETURN (stmt_expr
);
15395 tree r
= build_lambda_expr ();
15397 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15398 LAMBDA_EXPR_CLOSURE (r
) = type
;
15399 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15401 LAMBDA_EXPR_LOCATION (r
)
15402 = LAMBDA_EXPR_LOCATION (t
);
15403 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15404 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15405 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15406 LAMBDA_EXPR_DISCRIMINATOR (r
)
15407 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15408 /* For a function scope, we want to use tsubst so that we don't
15409 complain about referring to an auto function before its return
15410 type has been deduced. Otherwise, we want to use tsubst_copy so
15411 that we look up the existing field/parameter/variable rather
15412 than build a new one. */
15413 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15414 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15415 scope
= tsubst (scope
, args
, complain
, in_decl
);
15416 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15418 /* Look up the parameter we want directly, as tsubst_copy
15419 doesn't do what we need. */
15420 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15421 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15422 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15423 parm
= DECL_CHAIN (parm
);
15425 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15426 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15427 DECL_CONTEXT (scope
) = fn
;
15430 scope
= RECUR (scope
);
15431 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15432 LAMBDA_EXPR_RETURN_TYPE (r
)
15433 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15435 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15436 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15438 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15439 determine_visibility (TYPE_NAME (type
));
15440 /* Now that we know visibility, instantiate the type so we have a
15441 declaration of the op() for later calls to lambda_function. */
15442 complete_type (type
);
15444 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15446 RETURN (build_lambda_object (r
));
15450 /* We can get here for a constant initializer of non-dependent type.
15451 FIXME stop folding in cp_parser_initializer_clause. */
15453 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15458 case TRANSACTION_EXPR
:
15459 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15460 integral_constant_expression_p
));
15463 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15465 case VEC_PERM_EXPR
:
15467 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15468 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15469 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15470 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15475 /* Handle Objective-C++ constructs, if appropriate. */
15478 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15479 in_decl
, /*function_p=*/false);
15483 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15489 input_location
= loc
;
15493 /* Verify that the instantiated ARGS are valid. For type arguments,
15494 make sure that the type's linkage is ok. For non-type arguments,
15495 make sure they are constants if they are integral or enumerations.
15496 Emit an error under control of COMPLAIN, and return TRUE on error. */
15499 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15501 if (dependent_template_arg_p (t
))
15503 if (ARGUMENT_PACK_P (t
))
15505 tree vec
= ARGUMENT_PACK_ARGS (t
);
15506 int len
= TREE_VEC_LENGTH (vec
);
15507 bool result
= false;
15510 for (i
= 0; i
< len
; ++i
)
15511 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15515 else if (TYPE_P (t
))
15517 /* [basic.link]: A name with no linkage (notably, the name
15518 of a class or enumeration declared in a local scope)
15519 shall not be used to declare an entity with linkage.
15520 This implies that names with no linkage cannot be used as
15523 DR 757 relaxes this restriction for C++0x. */
15524 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15525 : no_linkage_check (t
, /*relaxed_p=*/false));
15529 /* DR 488 makes use of a type with no linkage cause
15530 type deduction to fail. */
15531 if (complain
& tf_error
)
15533 if (TYPE_ANONYMOUS_P (nt
))
15534 error ("%qT is/uses anonymous type", t
);
15536 error ("template argument for %qD uses local type %qT",
15541 /* In order to avoid all sorts of complications, we do not
15542 allow variably-modified types as template arguments. */
15543 else if (variably_modified_type_p (t
, NULL_TREE
))
15545 if (complain
& tf_error
)
15546 error ("%qT is a variably modified type", t
);
15550 /* Class template and alias template arguments should be OK. */
15551 else if (DECL_TYPE_TEMPLATE_P (t
))
15553 /* A non-type argument of integral or enumerated type must be a
15555 else if (TREE_TYPE (t
)
15556 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15557 && !TREE_CONSTANT (t
))
15559 if (complain
& tf_error
)
15560 error ("integral expression %qE is not constant", t
);
15567 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15569 int ix
, len
= DECL_NTPARMS (tmpl
);
15570 bool result
= false;
15572 for (ix
= 0; ix
!= len
; ix
++)
15574 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15577 if (result
&& (complain
& tf_error
))
15578 error (" trying to instantiate %qD", tmpl
);
15582 /* We're out of SFINAE context now, so generate diagnostics for the access
15583 errors we saw earlier when instantiating D from TMPL and ARGS. */
15586 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15588 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15589 tree type
= TREE_TYPE (pattern
);
15590 location_t loc
= input_location
;
15592 push_access_scope (d
);
15593 push_deferring_access_checks (dk_no_deferred
);
15594 input_location
= DECL_SOURCE_LOCATION (pattern
);
15595 tsubst (type
, args
, tf_warning_or_error
, d
);
15596 input_location
= loc
;
15597 pop_deferring_access_checks ();
15598 pop_access_scope (d
);
15601 /* Instantiate the indicated variable, function, or alias template TMPL with
15602 the template arguments in TARG_PTR. */
15605 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15607 tree targ_ptr
= orig_args
;
15611 bool access_ok
= true;
15613 if (tmpl
== error_mark_node
)
15614 return error_mark_node
;
15616 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15618 /* If this function is a clone, handle it specially. */
15619 if (DECL_CLONED_FUNCTION_P (tmpl
))
15624 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15625 DECL_CLONED_FUNCTION. */
15626 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15627 targ_ptr
, complain
);
15628 if (spec
== error_mark_node
)
15629 return error_mark_node
;
15631 /* Look for the clone. */
15632 FOR_EACH_CLONE (clone
, spec
)
15633 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15635 /* We should always have found the clone by now. */
15636 gcc_unreachable ();
15640 if (targ_ptr
== error_mark_node
)
15641 return error_mark_node
;
15643 /* Check to see if we already have this specialization. */
15644 gen_tmpl
= most_general_template (tmpl
);
15645 if (tmpl
!= gen_tmpl
)
15646 /* The TMPL is a partial instantiation. To get a full set of
15647 arguments we must add the arguments used to perform the
15648 partial instantiation. */
15649 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15652 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15653 but it doesn't seem to be on the hot path. */
15654 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15656 gcc_assert (tmpl
== gen_tmpl
15657 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15659 || fndecl
== NULL_TREE
);
15661 if (spec
!= NULL_TREE
)
15663 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15665 if (complain
& tf_error
)
15666 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15667 return error_mark_node
;
15672 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15674 return error_mark_node
;
15676 /* We are building a FUNCTION_DECL, during which the access of its
15677 parameters and return types have to be checked. However this
15678 FUNCTION_DECL which is the desired context for access checking
15679 is not built yet. We solve this chicken-and-egg problem by
15680 deferring all checks until we have the FUNCTION_DECL. */
15681 push_deferring_access_checks (dk_deferred
);
15683 /* Instantiation of the function happens in the context of the function
15684 template, not the context of the overload resolution we're doing. */
15685 push_to_top_level ();
15686 /* If there are dependent arguments, e.g. because we're doing partial
15687 ordering, make sure processing_template_decl stays set. */
15688 if (uses_template_parms (targ_ptr
))
15689 ++processing_template_decl
;
15690 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15692 tree ctx
= tsubst (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15693 complain
, gen_tmpl
);
15694 push_nested_class (ctx
);
15696 /* Substitute template parameters to obtain the specialization. */
15697 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
15698 targ_ptr
, complain
, gen_tmpl
);
15699 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15700 pop_nested_class ();
15701 pop_from_top_level ();
15703 if (fndecl
== error_mark_node
)
15705 pop_deferring_access_checks ();
15706 return error_mark_node
;
15709 /* The DECL_TI_TEMPLATE should always be the immediate parent
15710 template, not the most general template. */
15711 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
15713 /* Now we know the specialization, compute access previously
15715 push_access_scope (fndecl
);
15716 if (!perform_deferred_access_checks (complain
))
15718 pop_access_scope (fndecl
);
15719 pop_deferring_access_checks ();
15721 /* If we've just instantiated the main entry point for a function,
15722 instantiate all the alternate entry points as well. We do this
15723 by cloning the instantiation of the main entry point, not by
15724 instantiating the template clones. */
15725 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
15726 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
15730 if (!(complain
& tf_error
))
15732 /* Remember to reinstantiate when we're out of SFINAE so the user
15733 can see the errors. */
15734 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
15736 return error_mark_node
;
15741 /* Wrapper for instantiate_template_1. */
15744 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15747 timevar_push (TV_TEMPLATE_INST
);
15748 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
15749 timevar_pop (TV_TEMPLATE_INST
);
15753 /* Instantiate the alias template TMPL with ARGS. Also push a template
15754 instantiation level, which instantiate_template doesn't do because
15755 functions and variables have sufficient context established by the
15759 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
15761 struct pending_template
*old_last_pend
= last_pending_template
;
15762 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15763 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
15764 return error_mark_node
;
15765 tree tinst
= build_tree_list (tmpl
, args
);
15766 if (!push_tinst_level (tinst
))
15769 return error_mark_node
;
15773 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
15774 args
, tmpl
, complain
,
15775 /*require_all_args=*/true,
15776 /*use_default_args=*/true);
15778 tree r
= instantiate_template (tmpl
, args
, complain
);
15779 pop_tinst_level ();
15780 /* We can't free this if a pending_template entry or last_error_tinst_level
15781 is pointing at it. */
15782 if (last_pending_template
== old_last_pend
15783 && last_error_tinst_level
== old_error_tinst
)
15789 /* PARM is a template parameter pack for FN. Returns true iff
15790 PARM is used in a deducible way in the argument list of FN. */
15793 pack_deducible_p (tree parm
, tree fn
)
15795 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
15796 for (; t
; t
= TREE_CHAIN (t
))
15798 tree type
= TREE_VALUE (t
);
15800 if (!PACK_EXPANSION_P (type
))
15802 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
15803 packs
; packs
= TREE_CHAIN (packs
))
15804 if (template_args_equal (TREE_VALUE (packs
), parm
))
15806 /* The template parameter pack is used in a function parameter
15807 pack. If this is the end of the parameter list, the
15808 template parameter pack is deducible. */
15809 if (TREE_CHAIN (t
) == void_list_node
)
15812 /* Otherwise, not. Well, it could be deduced from
15813 a non-pack parameter, but doing so would end up with
15814 a deduction mismatch, so don't bother. */
15818 /* The template parameter pack isn't used in any function parameter
15819 packs, but it might be used deeper, e.g. tuple<Args...>. */
15823 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
15824 NARGS elements of the arguments that are being used when calling
15825 it. TARGS is a vector into which the deduced template arguments
15828 Returns either a FUNCTION_DECL for the matching specialization of FN or
15829 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
15830 true, diagnostics will be printed to explain why it failed.
15832 If FN is a conversion operator, or we are trying to produce a specific
15833 specialization, RETURN_TYPE is the return type desired.
15835 The EXPLICIT_TARGS are explicit template arguments provided via a
15838 The parameter STRICT is one of:
15841 We are deducing arguments for a function call, as in
15842 [temp.deduct.call].
15845 We are deducing arguments for a conversion function, as in
15846 [temp.deduct.conv].
15849 We are deducing arguments when doing an explicit instantiation
15850 as in [temp.explicit], when determining an explicit specialization
15851 as in [temp.expl.spec], or when taking the address of a function
15852 template, as in [temp.deduct.funcaddr]. */
15855 fn_type_unification (tree fn
,
15856 tree explicit_targs
,
15859 unsigned int nargs
,
15861 unification_kind_t strict
,
15868 tree decl
= NULL_TREE
;
15869 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
15871 static int deduction_depth
;
15872 struct pending_template
*old_last_pend
= last_pending_template
;
15873 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15874 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
15876 tree r
= error_mark_node
;
15879 complain
|= tf_decltype
;
15881 /* In C++0x, it's possible to have a function template whose type depends
15882 on itself recursively. This is most obvious with decltype, but can also
15883 occur with enumeration scope (c++/48969). So we need to catch infinite
15884 recursion and reject the substitution at deduction time; this function
15885 will return error_mark_node for any repeated substitution.
15887 This also catches excessive recursion such as when f<N> depends on
15888 f<N-1> across all integers, and returns error_mark_node for all the
15889 substitutions back up to the initial one.
15891 This is, of course, not reentrant. */
15892 if (excessive_deduction_depth
)
15893 return error_mark_node
;
15894 tinst
= build_tree_list (fn
, NULL_TREE
);
15897 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
15899 fntype
= TREE_TYPE (fn
);
15900 if (explicit_targs
)
15904 The specified template arguments must match the template
15905 parameters in kind (i.e., type, nontype, template), and there
15906 must not be more arguments than there are parameters;
15907 otherwise type deduction fails.
15909 Nontype arguments must match the types of the corresponding
15910 nontype template parameters, or must be convertible to the
15911 types of the corresponding nontype parameters as specified in
15912 _temp.arg.nontype_, otherwise type deduction fails.
15914 All references in the function type of the function template
15915 to the corresponding template parameters are replaced by the
15916 specified template argument values. If a substitution in a
15917 template parameter or in the function type of the function
15918 template results in an invalid type, type deduction fails. */
15919 int i
, len
= TREE_VEC_LENGTH (tparms
);
15920 location_t loc
= input_location
;
15921 bool incomplete
= false;
15923 /* Adjust any explicit template arguments before entering the
15924 substitution context. */
15926 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
15928 /*require_all_args=*/false,
15929 /*use_default_args=*/false));
15930 if (explicit_targs
== error_mark_node
)
15933 /* Substitute the explicit args into the function type. This is
15934 necessary so that, for instance, explicitly declared function
15935 arguments can match null pointed constants. If we were given
15936 an incomplete set of explicit args, we must not do semantic
15937 processing during substitution as we could create partial
15939 for (i
= 0; i
< len
; i
++)
15941 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
15942 bool parameter_pack
= false;
15943 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
15945 /* Dig out the actual parm. */
15946 if (TREE_CODE (parm
) == TYPE_DECL
15947 || TREE_CODE (parm
) == TEMPLATE_DECL
)
15949 parm
= TREE_TYPE (parm
);
15950 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
15952 else if (TREE_CODE (parm
) == PARM_DECL
)
15954 parm
= DECL_INITIAL (parm
);
15955 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
15958 if (!parameter_pack
&& targ
== NULL_TREE
)
15959 /* No explicit argument for this template parameter. */
15962 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
15964 /* Mark the argument pack as "incomplete". We could
15965 still deduce more arguments during unification.
15966 We remove this mark in type_unification_real. */
15969 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
15970 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
15971 = ARGUMENT_PACK_ARGS (targ
);
15974 /* We have some incomplete argument packs. */
15979 TREE_VALUE (tinst
) = explicit_targs
;
15980 if (!push_tinst_level (tinst
))
15982 excessive_deduction_depth
= true;
15985 processing_template_decl
+= incomplete
;
15986 input_location
= DECL_SOURCE_LOCATION (fn
);
15987 /* Ignore any access checks; we'll see them again in
15988 instantiate_template and they might have the wrong
15989 access path at this point. */
15990 push_deferring_access_checks (dk_deferred
);
15991 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
15992 complain
| tf_partial
, NULL_TREE
);
15993 pop_deferring_access_checks ();
15994 input_location
= loc
;
15995 processing_template_decl
-= incomplete
;
15996 pop_tinst_level ();
15998 if (fntype
== error_mark_node
)
16001 /* Place the explicitly specified arguments in TARGS. */
16002 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
16003 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
16006 /* Never do unification on the 'this' parameter. */
16007 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
16013 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
16014 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
16015 new_args
[0] = return_type
;
16016 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
16021 /* We allow incomplete unification without an error message here
16022 because the standard doesn't seem to explicitly prohibit it. Our
16023 callers must be ready to deal with unification failures in any
16026 TREE_VALUE (tinst
) = targs
;
16027 /* If we aren't explaining yet, push tinst context so we can see where
16028 any errors (e.g. from class instantiations triggered by instantiation
16029 of default template arguments) come from. If we are explaining, this
16030 context is redundant. */
16031 if (!explain_p
&& !push_tinst_level (tinst
))
16033 excessive_deduction_depth
= true;
16037 /* type_unification_real will pass back any access checks from default
16038 template argument substitution. */
16039 vec
<deferred_access_check
, va_gc
> *checks
;
16042 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16043 targs
, parms
, args
, nargs
, /*subr=*/0,
16044 strict
, flags
, &checks
, explain_p
);
16046 pop_tinst_level ();
16050 /* Now that we have bindings for all of the template arguments,
16051 ensure that the arguments deduced for the template template
16052 parameters have compatible template parameter lists. We cannot
16053 check this property before we have deduced all template
16054 arguments, because the template parameter types of a template
16055 template parameter might depend on prior template parameters
16056 deduced after the template template parameter. The following
16057 ill-formed example illustrates this issue:
16059 template<typename T, template<T> class C> void f(C<5>, T);
16061 template<int N> struct X {};
16064 f(X<5>(), 5l); // error: template argument deduction fails
16067 The template parameter list of 'C' depends on the template type
16068 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16069 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16070 time that we deduce 'C'. */
16071 if (!template_template_parm_bindings_ok_p
16072 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16074 unify_inconsistent_template_template_parameters (explain_p
);
16078 /* All is well so far. Now, check:
16082 When all template arguments have been deduced, all uses of
16083 template parameters in nondeduced contexts are replaced with
16084 the corresponding deduced argument values. If the
16085 substitution results in an invalid type, as described above,
16086 type deduction fails. */
16087 TREE_VALUE (tinst
) = targs
;
16088 if (!push_tinst_level (tinst
))
16090 excessive_deduction_depth
= true;
16094 /* Also collect access checks from the instantiation. */
16095 reopen_deferring_access_checks (checks
);
16097 decl
= instantiate_template (fn
, targs
, complain
);
16099 checks
= get_deferred_access_checks ();
16100 pop_deferring_access_checks ();
16102 pop_tinst_level ();
16104 if (decl
== error_mark_node
)
16107 /* Now perform any access checks encountered during substitution. */
16108 push_access_scope (decl
);
16109 ok
= perform_access_checks (checks
, complain
);
16110 pop_access_scope (decl
);
16114 /* If we're looking for an exact match, check that what we got
16115 is indeed an exact match. It might not be if some template
16116 parameters are used in non-deduced contexts. But don't check
16117 for an exact match if we have dependent template arguments;
16118 in that case we're doing partial ordering, and we already know
16119 that we have two candidates that will provide the actual type. */
16120 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16122 tree substed
= TREE_TYPE (decl
);
16126 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16128 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16129 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16130 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16132 unify_type_mismatch (explain_p
, args
[i
],
16133 TREE_VALUE (sarg
));
16142 if (excessive_deduction_depth
)
16144 if (deduction_depth
== 0)
16145 /* Reset once we're all the way out. */
16146 excessive_deduction_depth
= false;
16149 /* We can't free this if a pending_template entry or last_error_tinst_level
16150 is pointing at it. */
16151 if (last_pending_template
== old_last_pend
16152 && last_error_tinst_level
== old_error_tinst
)
16158 /* Adjust types before performing type deduction, as described in
16159 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16160 sections are symmetric. PARM is the type of a function parameter
16161 or the return type of the conversion function. ARG is the type of
16162 the argument passed to the call, or the type of the value
16163 initialized with the result of the conversion function.
16164 ARG_EXPR is the original argument expression, which may be null. */
16167 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16181 /* Swap PARM and ARG throughout the remainder of this
16182 function; the handling is precisely symmetric since PARM
16183 will initialize ARG rather than vice versa. */
16191 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16192 too, but here handle it by stripping the reference from PARM
16193 rather than by adding it to ARG. */
16194 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16195 && TYPE_REF_IS_RVALUE (*parm
)
16196 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16197 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16198 && TREE_CODE (*arg
) == REFERENCE_TYPE
16199 && !TYPE_REF_IS_RVALUE (*arg
))
16200 *parm
= TREE_TYPE (*parm
);
16201 /* Nothing else to do in this case. */
16205 gcc_unreachable ();
16208 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16210 /* [temp.deduct.call]
16212 If P is not a reference type:
16214 --If A is an array type, the pointer type produced by the
16215 array-to-pointer standard conversion (_conv.array_) is
16216 used in place of A for type deduction; otherwise,
16218 --If A is a function type, the pointer type produced by
16219 the function-to-pointer standard conversion
16220 (_conv.func_) is used in place of A for type deduction;
16223 --If A is a cv-qualified type, the top level
16224 cv-qualifiers of A's type are ignored for type
16226 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16227 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16228 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16229 *arg
= build_pointer_type (*arg
);
16231 *arg
= TYPE_MAIN_VARIANT (*arg
);
16234 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16235 of the form T&&, where T is a template parameter, and the argument
16236 is an lvalue, T is deduced as A& */
16237 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16238 && TYPE_REF_IS_RVALUE (*parm
)
16239 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16240 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16241 && (arg_expr
? real_lvalue_p (arg_expr
)
16242 /* try_one_overload doesn't provide an arg_expr, but
16243 functions are always lvalues. */
16244 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16245 *arg
= build_reference_type (*arg
);
16247 /* [temp.deduct.call]
16249 If P is a cv-qualified type, the top level cv-qualifiers
16250 of P's type are ignored for type deduction. If P is a
16251 reference type, the type referred to by P is used for
16253 *parm
= TYPE_MAIN_VARIANT (*parm
);
16254 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16256 *parm
= TREE_TYPE (*parm
);
16257 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16260 /* DR 322. For conversion deduction, remove a reference type on parm
16261 too (which has been swapped into ARG). */
16262 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16263 *arg
= TREE_TYPE (*arg
);
16268 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16269 template which does contain any deducible template parameters; check if
16270 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16271 unify_one_argument. */
16274 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16275 int flags
, bool explain_p
)
16280 type
= TREE_TYPE (arg
);
16284 if (same_type_p (parm
, type
))
16285 return unify_success (explain_p
);
16287 if (strict
== DEDUCE_CONV
)
16289 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16290 explain_p
? tf_warning_or_error
: tf_none
))
16291 return unify_success (explain_p
);
16293 else if (strict
!= DEDUCE_EXACT
)
16295 if (can_convert_arg (parm
, type
,
16296 TYPE_P (arg
) ? NULL_TREE
: arg
,
16297 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16298 return unify_success (explain_p
);
16301 if (strict
== DEDUCE_EXACT
)
16302 return unify_type_mismatch (explain_p
, parm
, arg
);
16304 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16307 static bool uses_deducible_template_parms (tree type
);
16309 /* Returns true iff the expression EXPR is one from which a template
16310 argument can be deduced. In other words, if it's an undecorated
16311 use of a template non-type parameter. */
16314 deducible_expression (tree expr
)
16316 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16319 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16320 deducible way; that is, if it has a max value of <PARM> - 1. */
16323 deducible_array_bound (tree domain
)
16325 if (domain
== NULL_TREE
)
16328 tree max
= TYPE_MAX_VALUE (domain
);
16329 if (TREE_CODE (max
) != MINUS_EXPR
)
16332 return deducible_expression (TREE_OPERAND (max
, 0));
16335 /* Returns true iff the template arguments ARGS use a template parameter
16336 in a deducible way. */
16339 deducible_template_args (tree args
)
16341 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16344 tree elt
= TREE_VEC_ELT (args
, i
);
16345 if (ARGUMENT_PACK_P (elt
))
16346 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16349 if (PACK_EXPANSION_P (elt
))
16350 elt
= PACK_EXPANSION_PATTERN (elt
);
16351 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16353 else if (TYPE_P (elt
))
16354 deducible
= uses_deducible_template_parms (elt
);
16356 deducible
= deducible_expression (elt
);
16364 /* Returns true iff TYPE contains any deducible references to template
16365 parameters, as per 14.8.2.5. */
16368 uses_deducible_template_parms (tree type
)
16370 if (PACK_EXPANSION_P (type
))
16371 type
= PACK_EXPANSION_PATTERN (type
);
16378 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16379 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16385 if (POINTER_TYPE_P (type
))
16386 return uses_deducible_template_parms (TREE_TYPE (type
));
16388 /* T[integer-constant ]
16390 if (TREE_CODE (type
) == ARRAY_TYPE
)
16391 return (uses_deducible_template_parms (TREE_TYPE (type
))
16392 || deducible_array_bound (TYPE_DOMAIN (type
)));
16404 if (TYPE_PTRMEM_P (type
))
16405 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16406 || (uses_deducible_template_parms
16407 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16409 /* template-name <T> (where template-name refers to a class template)
16410 template-name <i> (where template-name refers to a class template) */
16411 if (CLASS_TYPE_P (type
)
16412 && CLASSTYPE_TEMPLATE_INFO (type
)
16413 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16414 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16415 (CLASSTYPE_TI_ARGS (type
)));
16420 if (TREE_CODE (type
) == FUNCTION_TYPE
16421 || TREE_CODE (type
) == METHOD_TYPE
)
16423 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16425 tree parm
= TYPE_ARG_TYPES (type
);
16426 if (TREE_CODE (type
) == METHOD_TYPE
)
16427 parm
= TREE_CHAIN (parm
);
16428 for (; parm
; parm
= TREE_CHAIN (parm
))
16429 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16436 /* Subroutine of type_unification_real and unify_pack_expansion to
16437 handle unification of a single P/A pair. Parameters are as
16438 for those functions. */
16441 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16442 int subr
, unification_kind_t strict
, int flags
,
16445 tree arg_expr
= NULL_TREE
;
16448 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16449 return unify_invalid (explain_p
);
16450 if (arg
== unknown_type_node
)
16451 /* We can't deduce anything from this, but we might get all the
16452 template args from other function args. */
16453 return unify_success (explain_p
);
16455 /* Implicit conversions (Clause 4) will be performed on a function
16456 argument to convert it to the type of the corresponding function
16457 parameter if the parameter type contains no template-parameters that
16458 participate in template argument deduction. */
16459 if (TYPE_P (parm
) && !uses_template_parms (parm
))
16460 /* For function parameters that contain no template-parameters at all,
16461 we have historically checked for convertibility in order to shortcut
16462 consideration of this candidate. */
16463 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
16465 else if (strict
== DEDUCE_CALL
16466 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16467 /* For function parameters with only non-deducible template parameters,
16469 return unify_success (explain_p
);
16474 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16475 | UNIFY_ALLOW_MORE_CV_QUAL
16476 | UNIFY_ALLOW_DERIVED
);
16480 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16484 arg_strict
= UNIFY_ALLOW_NONE
;
16488 gcc_unreachable ();
16491 /* We only do these transformations if this is the top-level
16492 parameter_type_list in a call or declaration matching; in other
16493 situations (nested function declarators, template argument lists) we
16494 won't be comparing a type to an expression, and we don't do any type
16500 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16501 if (type_unknown_p (arg
))
16503 /* [temp.deduct.type] A template-argument can be
16504 deduced from a pointer to function or pointer
16505 to member function argument if the set of
16506 overloaded functions does not contain function
16507 templates and at most one of a set of
16508 overloaded functions provides a unique
16511 if (resolve_overloaded_unification
16512 (tparms
, targs
, parm
, arg
, strict
,
16513 arg_strict
, explain_p
))
16514 return unify_success (explain_p
);
16515 return unify_overload_resolution_failure (explain_p
, arg
);
16519 arg
= unlowered_expr_type (arg
);
16520 if (arg
== error_mark_node
)
16521 return unify_invalid (explain_p
);
16525 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16528 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16529 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
16530 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16532 /* For deduction from an init-list we need the actual list. */
16533 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16535 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16538 /* Most parms like fn_type_unification.
16540 If SUBR is 1, we're being called recursively (to unify the
16541 arguments of a function or method parameter of a function
16544 CHECKS is a pointer to a vector of access checks encountered while
16545 substituting default template arguments. */
16548 type_unification_real (tree tparms
,
16552 unsigned int xnargs
,
16554 unification_kind_t strict
,
16556 vec
<deferred_access_check
, va_gc
> **checks
,
16561 int ntparms
= TREE_VEC_LENGTH (tparms
);
16562 int saw_undeduced
= 0;
16565 unsigned int nargs
;
16568 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16569 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16570 gcc_assert (ntparms
> 0);
16572 /* Reset the number of non-defaulted template arguments contained
16574 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16582 while (parms
&& parms
!= void_list_node
16585 parm
= TREE_VALUE (parms
);
16587 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16588 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16589 /* For a function parameter pack that occurs at the end of the
16590 parameter-declaration-list, the type A of each remaining
16591 argument of the call is compared with the type P of the
16592 declarator-id of the function parameter pack. */
16595 parms
= TREE_CHAIN (parms
);
16597 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16598 /* For a function parameter pack that does not occur at the
16599 end of the parameter-declaration-list, the type of the
16600 parameter pack is a non-deduced context. */
16606 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16612 && parms
!= void_list_node
16613 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16615 /* Unify the remaining arguments with the pack expansion type. */
16617 tree parmvec
= make_tree_vec (1);
16619 /* Allocate a TREE_VEC and copy in all of the arguments */
16620 argvec
= make_tree_vec (nargs
- ia
);
16621 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16622 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16624 /* Copy the parameter into parmvec. */
16625 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16626 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16627 /*subr=*/subr
, explain_p
))
16630 /* Advance to the end of the list of parameters. */
16631 parms
= TREE_CHAIN (parms
);
16634 /* Fail if we've reached the end of the parm list, and more args
16635 are present, and the parm list isn't variadic. */
16636 if (ia
< nargs
&& parms
== void_list_node
)
16637 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16638 /* Fail if parms are left and they don't have default values and
16639 they aren't all deduced as empty packs (c++/57397). This is
16640 consistent with sufficient_parms_p. */
16641 if (parms
&& parms
!= void_list_node
16642 && TREE_PURPOSE (parms
) == NULL_TREE
)
16644 unsigned int count
= nargs
;
16649 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
16652 p
= TREE_CHAIN (p
);
16654 while (p
&& p
!= void_list_node
);
16655 if (count
!= nargs
)
16656 return unify_too_few_arguments (explain_p
, ia
, count
,
16662 tsubst_flags_t complain
= (explain_p
16663 ? tf_warning_or_error
16666 for (i
= 0; i
< ntparms
; i
++)
16668 tree targ
= TREE_VEC_ELT (targs
, i
);
16669 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16671 /* Clear the "incomplete" flags on all argument packs now so that
16672 substituting them into later default arguments works. */
16673 if (targ
&& ARGUMENT_PACK_P (targ
))
16675 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16676 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16679 if (targ
|| tparm
== error_mark_node
)
16681 tparm
= TREE_VALUE (tparm
);
16683 /* If this is an undeduced nontype parameter that depends on
16684 a type parameter, try another pass; its type may have been
16685 deduced from a later argument than the one from which
16686 this parameter can be deduced. */
16687 if (TREE_CODE (tparm
) == PARM_DECL
16688 && uses_template_parms (TREE_TYPE (tparm
))
16689 && !saw_undeduced
++)
16692 /* Core issue #226 (C++0x) [temp.deduct]:
16694 If a template argument has not been deduced, its
16695 default template argument, if any, is used.
16697 When we are in C++98 mode, TREE_PURPOSE will either
16698 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16699 to explicitly check cxx_dialect here. */
16700 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
16702 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16703 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
16704 reopen_deferring_access_checks (*checks
);
16705 location_t save_loc
= input_location
;
16707 input_location
= DECL_SOURCE_LOCATION (parm
);
16708 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
16709 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
16711 input_location
= save_loc
;
16712 *checks
= get_deferred_access_checks ();
16713 pop_deferring_access_checks ();
16714 if (arg
== error_mark_node
)
16718 TREE_VEC_ELT (targs
, i
) = arg
;
16719 /* The position of the first default template argument,
16720 is also the number of non-defaulted arguments in TARGS.
16722 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16723 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
16728 /* If the type parameter is a parameter pack, then it will
16729 be deduced to an empty parameter pack. */
16730 if (template_parameter_pack_p (tparm
))
16734 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
16736 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
16737 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
16738 TREE_CONSTANT (arg
) = 1;
16741 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16743 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
16745 TREE_VEC_ELT (targs
, i
) = arg
;
16749 return unify_parameter_deduction_failure (explain_p
, tparm
);
16752 #ifdef ENABLE_CHECKING
16753 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16754 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
16757 return unify_success (explain_p
);
16760 /* Subroutine of type_unification_real. Args are like the variables
16761 at the call site. ARG is an overloaded function (or template-id);
16762 we try deducing template args from each of the overloads, and if
16763 only one succeeds, we go with that. Modifies TARGS and returns
16764 true on success. */
16767 resolve_overloaded_unification (tree tparms
,
16771 unification_kind_t strict
,
16775 tree tempargs
= copy_node (targs
);
16777 tree goodfn
= NULL_TREE
;
16780 if (TREE_CODE (arg
) == ADDR_EXPR
)
16782 arg
= TREE_OPERAND (arg
, 0);
16788 if (TREE_CODE (arg
) == COMPONENT_REF
)
16789 /* Handle `&x' where `x' is some static or non-static member
16791 arg
= TREE_OPERAND (arg
, 1);
16793 if (TREE_CODE (arg
) == OFFSET_REF
)
16794 arg
= TREE_OPERAND (arg
, 1);
16796 /* Strip baselink information. */
16797 if (BASELINK_P (arg
))
16798 arg
= BASELINK_FUNCTIONS (arg
);
16800 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
16802 /* If we got some explicit template args, we need to plug them into
16803 the affected templates before we try to unify, in case the
16804 explicit args will completely resolve the templates in question. */
16807 tree expl_subargs
= TREE_OPERAND (arg
, 1);
16808 arg
= TREE_OPERAND (arg
, 0);
16810 for (; arg
; arg
= OVL_NEXT (arg
))
16812 tree fn
= OVL_CURRENT (arg
);
16813 tree subargs
, elem
;
16815 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16818 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16819 expl_subargs
, NULL_TREE
, tf_none
,
16820 /*require_all_args=*/true,
16821 /*use_default_args=*/true);
16822 if (subargs
!= error_mark_node
16823 && !any_dependent_template_arguments_p (subargs
))
16825 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
16826 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16827 elem
, strict
, sub_strict
, addr_p
, explain_p
)
16828 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
16837 /* If no templates (or more than one) are fully resolved by the
16838 explicit arguments, this template-id is a non-deduced context; it
16839 could still be OK if we deduce all template arguments for the
16840 enclosing call through other arguments. */
16844 else if (TREE_CODE (arg
) != OVERLOAD
16845 && TREE_CODE (arg
) != FUNCTION_DECL
)
16846 /* If ARG is, for example, "(0, &f)" then its type will be unknown
16847 -- but the deduction does not succeed because the expression is
16848 not just the function on its own. */
16851 for (; arg
; arg
= OVL_NEXT (arg
))
16852 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16853 TREE_TYPE (OVL_CURRENT (arg
)),
16854 strict
, sub_strict
, addr_p
, explain_p
)
16855 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
16857 goodfn
= OVL_CURRENT (arg
);
16861 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16862 to function or pointer to member function argument if the set of
16863 overloaded functions does not contain function templates and at most
16864 one of a set of overloaded functions provides a unique match.
16866 So if we found multiple possibilities, we return success but don't
16867 deduce anything. */
16871 int i
= TREE_VEC_LENGTH (targs
);
16873 if (TREE_VEC_ELT (tempargs
, i
))
16875 tree old
= TREE_VEC_ELT (targs
, i
);
16876 tree new_
= TREE_VEC_ELT (tempargs
, i
);
16877 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
16878 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
16879 /* Don't forget explicit template arguments in a pack. */
16880 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
16881 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
16882 TREE_VEC_ELT (targs
, i
) = new_
;
16891 /* Core DR 115: In contexts where deduction is done and fails, or in
16892 contexts where deduction is not done, if a template argument list is
16893 specified and it, along with any default template arguments, identifies
16894 a single function template specialization, then the template-id is an
16895 lvalue for the function template specialization. */
16898 resolve_nondeduced_context (tree orig_expr
)
16900 tree expr
, offset
, baselink
;
16903 if (!type_unknown_p (orig_expr
))
16908 offset
= NULL_TREE
;
16909 baselink
= NULL_TREE
;
16911 if (TREE_CODE (expr
) == ADDR_EXPR
)
16913 expr
= TREE_OPERAND (expr
, 0);
16916 if (TREE_CODE (expr
) == OFFSET_REF
)
16919 expr
= TREE_OPERAND (expr
, 1);
16921 if (BASELINK_P (expr
))
16924 expr
= BASELINK_FUNCTIONS (expr
);
16927 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
16930 tree goodfn
= NULL_TREE
;
16932 /* If we got some explicit template args, we need to plug them into
16933 the affected templates before we try to unify, in case the
16934 explicit args will completely resolve the templates in question. */
16936 tree expl_subargs
= TREE_OPERAND (expr
, 1);
16937 tree arg
= TREE_OPERAND (expr
, 0);
16938 tree badfn
= NULL_TREE
;
16939 tree badargs
= NULL_TREE
;
16941 for (; arg
; arg
= OVL_NEXT (arg
))
16943 tree fn
= OVL_CURRENT (arg
);
16944 tree subargs
, elem
;
16946 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16949 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16950 expl_subargs
, NULL_TREE
, tf_none
,
16951 /*require_all_args=*/true,
16952 /*use_default_args=*/true);
16953 if (subargs
!= error_mark_node
16954 && !any_dependent_template_arguments_p (subargs
))
16956 elem
= instantiate_template (fn
, subargs
, tf_none
);
16957 if (elem
== error_mark_node
)
16962 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
16971 mark_used (goodfn
);
16974 expr
= build_baselink (BASELINK_BINFO (baselink
),
16975 BASELINK_ACCESS_BINFO (baselink
),
16976 expr
, BASELINK_OPTYPE (baselink
));
16980 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
16981 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
16984 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
16987 else if (good
== 0 && badargs
)
16988 /* There were no good options and at least one bad one, so let the
16989 user know what the problem is. */
16990 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
16995 /* Subroutine of resolve_overloaded_unification; does deduction for a single
16996 overload. Fills TARGS with any deduced arguments, or error_mark_node if
16997 different overloads deduce different arguments for a given parm.
16998 ADDR_P is true if the expression for which deduction is being
16999 performed was of the form "& fn" rather than simply "fn".
17001 Returns 1 on success. */
17004 try_one_overload (tree tparms
,
17009 unification_kind_t strict
,
17018 if (arg
== error_mark_node
)
17021 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17022 to function or pointer to member function argument if the set of
17023 overloaded functions does not contain function templates and at most
17024 one of a set of overloaded functions provides a unique match.
17026 So if this is a template, just return success. */
17028 if (uses_template_parms (arg
))
17031 if (TREE_CODE (arg
) == METHOD_TYPE
)
17032 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
17034 arg
= build_pointer_type (arg
);
17036 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
17038 /* We don't copy orig_targs for this because if we have already deduced
17039 some template args from previous args, unify would complain when we
17040 try to deduce a template parameter for the same argument, even though
17041 there isn't really a conflict. */
17042 nargs
= TREE_VEC_LENGTH (targs
);
17043 tempargs
= make_tree_vec (nargs
);
17045 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
17048 /* First make sure we didn't deduce anything that conflicts with
17049 explicitly specified args. */
17050 for (i
= nargs
; i
--; )
17052 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17053 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17057 else if (uses_template_parms (elt
))
17058 /* Since we're unifying against ourselves, we will fill in
17059 template args used in the function parm list with our own
17060 template parms. Discard them. */
17061 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17062 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17066 for (i
= nargs
; i
--; )
17068 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17071 TREE_VEC_ELT (targs
, i
) = elt
;
17077 /* PARM is a template class (perhaps with unbound template
17078 parameters). ARG is a fully instantiated type. If ARG can be
17079 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17080 TARGS are as for unify. */
17083 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17086 tree copy_of_targs
;
17088 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17089 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17090 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17093 /* We need to make a new template argument vector for the call to
17094 unify. If we used TARGS, we'd clutter it up with the result of
17095 the attempted unification, even if this class didn't work out.
17096 We also don't want to commit ourselves to all the unifications
17097 we've already done, since unification is supposed to be done on
17098 an argument-by-argument basis. In other words, consider the
17099 following pathological case:
17101 template <int I, int J, int K>
17104 template <int I, int J>
17105 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17107 template <int I, int J, int K>
17108 void f(S<I, J, K>, S<I, I, I>);
17117 Now, by the time we consider the unification involving `s2', we
17118 already know that we must have `f<0, 0, 0>'. But, even though
17119 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17120 because there are two ways to unify base classes of S<0, 1, 2>
17121 with S<I, I, I>. If we kept the already deduced knowledge, we
17122 would reject the possibility I=1. */
17123 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17125 /* If unification failed, we're done. */
17126 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17127 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17133 /* Given a template type PARM and a class type ARG, find the unique
17134 base type in ARG that is an instance of PARM. We do not examine
17135 ARG itself; only its base-classes. If there is not exactly one
17136 appropriate base class, return NULL_TREE. PARM may be the type of
17137 a partial specialization, as well as a plain template type. Used
17140 static enum template_base_result
17141 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17142 bool explain_p
, tree
*result
)
17144 tree rval
= NULL_TREE
;
17147 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17149 binfo
= TYPE_BINFO (complete_type (arg
));
17152 /* The type could not be completed. */
17153 *result
= NULL_TREE
;
17154 return tbr_incomplete_type
;
17157 /* Walk in inheritance graph order. The search order is not
17158 important, and this avoids multiple walks of virtual bases. */
17159 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17161 tree r
= try_class_unification (tparms
, targs
, parm
,
17162 BINFO_TYPE (binfo
), explain_p
);
17166 /* If there is more than one satisfactory baseclass, then:
17170 If they yield more than one possible deduced A, the type
17174 if (rval
&& !same_type_p (r
, rval
))
17176 *result
= NULL_TREE
;
17177 return tbr_ambiguous_baseclass
;
17185 return tbr_success
;
17188 /* Returns the level of DECL, which declares a template parameter. */
17191 template_decl_level (tree decl
)
17193 switch (TREE_CODE (decl
))
17196 case TEMPLATE_DECL
:
17197 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17200 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17203 gcc_unreachable ();
17208 /* Decide whether ARG can be unified with PARM, considering only the
17209 cv-qualifiers of each type, given STRICT as documented for unify.
17210 Returns nonzero iff the unification is OK on that basis. */
17213 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17215 int arg_quals
= cp_type_quals (arg
);
17216 int parm_quals
= cp_type_quals (parm
);
17218 /* DR 1584: cv-qualification of a deduced function type is
17219 ignored; see 8.3.5 [dcl.fct]. */
17220 if (TREE_CODE (arg
) == FUNCTION_TYPE
)
17223 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17224 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17226 /* Although a CVR qualifier is ignored when being applied to a
17227 substituted template parameter ([8.3.2]/1 for example), that
17228 does not allow us to unify "const T" with "int&" because both
17229 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17230 It is ok when we're allowing additional CV qualifiers
17231 at the outer level [14.8.2.1]/3,1st bullet. */
17232 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17233 || TREE_CODE (arg
) == FUNCTION_TYPE
17234 || TREE_CODE (arg
) == METHOD_TYPE
)
17235 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17238 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17239 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17243 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17244 && (arg_quals
& parm_quals
) != parm_quals
)
17247 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17248 && (parm_quals
& arg_quals
) != arg_quals
)
17254 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17256 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17258 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17259 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17260 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17262 *index
= TEMPLATE_TYPE_IDX (parm
);
17263 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17267 *index
= TEMPLATE_PARM_IDX (parm
);
17268 *level
= TEMPLATE_PARM_LEVEL (parm
);
17272 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17274 if (unify (TP, TA, P, A, S, EP)) \
17278 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17279 expansion at the end of PACKED_PARMS. Returns 0 if the type
17280 deduction succeeds, 1 otherwise. STRICT is the same as in
17281 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17282 call argument list. We'll need to adjust the arguments to make them
17283 types. SUBR tells us if this is from a recursive call to
17284 type_unification_real, or for comparing two template argument
17288 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17289 tree packed_args
, unification_kind_t strict
,
17290 bool subr
, bool explain_p
)
17293 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17294 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17295 tree pack
, packs
= NULL_TREE
;
17296 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17298 packed_args
= expand_template_argument_pack (packed_args
);
17300 int len
= TREE_VEC_LENGTH (packed_args
);
17302 /* Determine the parameter packs we will be deducing from the
17303 pattern, and record their current deductions. */
17304 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17305 pack
; pack
= TREE_CHAIN (pack
))
17307 tree parm_pack
= TREE_VALUE (pack
);
17310 /* Determine the index and level of this parameter pack. */
17311 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17313 /* Keep track of the parameter packs and their corresponding
17315 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17316 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17319 /* Loop through all of the arguments that have not yet been
17320 unified and unify each with the pattern. */
17321 for (i
= start
; i
< len
; i
++)
17324 bool any_explicit
= false;
17325 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17327 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17328 or the element of its argument pack at the current index if
17329 this argument was explicitly specified. */
17330 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17334 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17337 if (TREE_VALUE (pack
)
17338 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17339 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17341 any_explicit
= true;
17342 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17344 TMPL_ARG (targs
, level
, idx
) = arg
;
17347 /* If we had explicit template arguments, substitute them into the
17348 pattern before deduction. */
17351 /* Some arguments might still be unspecified or dependent. */
17353 ++processing_template_decl
;
17354 dependent
= any_dependent_template_arguments_p (targs
);
17356 --processing_template_decl
;
17357 parm
= tsubst (pattern
, targs
,
17358 explain_p
? tf_warning_or_error
: tf_none
,
17361 --processing_template_decl
;
17362 if (parm
== error_mark_node
)
17368 /* Unify the pattern with the current argument. */
17369 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17370 LOOKUP_IMPLICIT
, explain_p
))
17373 /* For each parameter pack, collect the deduced value. */
17374 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17377 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17379 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17380 TMPL_ARG (targs
, level
, idx
);
17384 /* Verify that the results of unification with the parameter packs
17385 produce results consistent with what we've seen before, and make
17386 the deduced argument packs available. */
17387 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17389 tree old_pack
= TREE_VALUE (pack
);
17390 tree new_args
= TREE_TYPE (pack
);
17391 int i
, len
= TREE_VEC_LENGTH (new_args
);
17393 bool nondeduced_p
= false;
17395 /* By default keep the original deduced argument pack.
17396 If necessary, more specific code is going to update the
17397 resulting deduced argument later down in this function. */
17398 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17399 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17401 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17402 actually deduce anything. */
17403 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17404 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17405 nondeduced_p
= true;
17409 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17411 /* If we had fewer function args than explicit template args,
17412 just use the explicits. */
17413 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17414 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17415 if (len
< explicit_len
)
17416 new_args
= explicit_args
;
17422 /* Build the deduced *_ARGUMENT_PACK. */
17423 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17425 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17426 TREE_TYPE (result
) =
17427 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17428 TREE_CONSTANT (result
) = 1;
17431 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17433 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17435 /* Note the deduced argument packs for this parameter
17437 TMPL_ARG (targs
, level
, idx
) = result
;
17439 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17440 && (ARGUMENT_PACK_ARGS (old_pack
)
17441 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17443 /* We only had the explicitly-provided arguments before, but
17444 now we have a complete set of arguments. */
17445 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17447 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17448 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17449 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17453 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17454 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17456 if (!comp_template_args_with_info (old_args
, new_args
,
17457 &bad_old_arg
, &bad_new_arg
))
17458 /* Inconsistent unification of this parameter pack. */
17459 return unify_parameter_pack_inconsistent (explain_p
,
17465 return unify_success (explain_p
);
17468 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17469 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17470 parameters and return value are as for unify. */
17473 unify_array_domain (tree tparms
, tree targs
,
17474 tree parm_dom
, tree arg_dom
,
17482 /* Our representation of array types uses "N - 1" as the
17483 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17484 not an integer constant. We cannot unify arbitrarily
17485 complex expressions, so we eliminate the MINUS_EXPRs
17487 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17488 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17491 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17492 parm_max
= TREE_OPERAND (parm_max
, 0);
17494 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17495 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17498 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17499 trying to unify the type of a variable with the type
17500 of a template parameter. For example:
17502 template <unsigned int N>
17503 void f (char (&) [N]);
17510 Here, the type of the ARG will be "int [g(i)]", and
17511 may be a SAVE_EXPR, etc. */
17512 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17513 return unify_vla_arg (explain_p
, arg_dom
);
17514 arg_max
= TREE_OPERAND (arg_max
, 0);
17517 /* If only one of the bounds used a MINUS_EXPR, compensate
17518 by adding one to the other bound. */
17519 if (parm_cst
&& !arg_cst
)
17520 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17524 else if (arg_cst
&& !parm_cst
)
17525 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17530 return unify (tparms
, targs
, parm_max
, arg_max
,
17531 UNIFY_ALLOW_INTEGER
, explain_p
);
17534 /* Deduce the value of template parameters. TPARMS is the (innermost)
17535 set of template parameters to a template. TARGS is the bindings
17536 for those template parameters, as determined thus far; TARGS may
17537 include template arguments for outer levels of template parameters
17538 as well. PARM is a parameter to a template function, or a
17539 subcomponent of that parameter; ARG is the corresponding argument.
17540 This function attempts to match PARM with ARG in a manner
17541 consistent with the existing assignments in TARGS. If more values
17542 are deduced, then TARGS is updated.
17544 Returns 0 if the type deduction succeeds, 1 otherwise. The
17545 parameter STRICT is a bitwise or of the following flags:
17548 Require an exact match between PARM and ARG.
17549 UNIFY_ALLOW_MORE_CV_QUAL:
17550 Allow the deduced ARG to be more cv-qualified (by qualification
17551 conversion) than ARG.
17552 UNIFY_ALLOW_LESS_CV_QUAL:
17553 Allow the deduced ARG to be less cv-qualified than ARG.
17554 UNIFY_ALLOW_DERIVED:
17555 Allow the deduced ARG to be a template base class of ARG,
17556 or a pointer to a template base class of the type pointed to by
17558 UNIFY_ALLOW_INTEGER:
17559 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17560 case for more information.
17561 UNIFY_ALLOW_OUTER_LEVEL:
17562 This is the outermost level of a deduction. Used to determine validity
17563 of qualification conversions. A valid qualification conversion must
17564 have const qualified pointers leading up to the inner type which
17565 requires additional CV quals, except at the outer level, where const
17566 is not required [conv.qual]. It would be normal to set this flag in
17567 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17568 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17569 This is the outermost level of a deduction, and PARM can be more CV
17570 qualified at this point.
17571 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17572 This is the outermost level of a deduction, and PARM can be less CV
17573 qualified at this point. */
17576 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17582 int strict_in
= strict
;
17584 /* I don't think this will do the right thing with respect to types.
17585 But the only case I've seen it in so far has been array bounds, where
17586 signedness is the only information lost, and I think that will be
17588 while (TREE_CODE (parm
) == NOP_EXPR
)
17589 parm
= TREE_OPERAND (parm
, 0);
17591 if (arg
== error_mark_node
)
17592 return unify_invalid (explain_p
);
17593 if (arg
== unknown_type_node
17594 || arg
== init_list_type_node
)
17595 /* We can't deduce anything from this, but we might get all the
17596 template args from other function args. */
17597 return unify_success (explain_p
);
17599 /* If PARM uses template parameters, then we can't bail out here,
17600 even if ARG == PARM, since we won't record unifications for the
17601 template parameters. We might need them if we're trying to
17602 figure out which of two things is more specialized. */
17603 if (arg
== parm
&& !uses_template_parms (parm
))
17604 return unify_success (explain_p
);
17606 /* Handle init lists early, so the rest of the function can assume
17607 we're dealing with a type. */
17608 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17612 tree orig_parm
= parm
;
17614 /* Replace T with std::initializer_list<T> for deduction. */
17615 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17616 && flag_deduce_init_list
)
17617 parm
= listify (parm
);
17619 if (!is_std_init_list (parm
)
17620 && TREE_CODE (parm
) != ARRAY_TYPE
)
17621 /* We can only deduce from an initializer list argument if the
17622 parameter is std::initializer_list or an array; otherwise this
17623 is a non-deduced context. */
17624 return unify_success (explain_p
);
17626 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17627 elttype
= TREE_TYPE (parm
);
17629 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17631 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
17633 int elt_strict
= strict
;
17635 if (elt
== error_mark_node
)
17636 return unify_invalid (explain_p
);
17638 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
17640 tree type
= TREE_TYPE (elt
);
17641 /* It should only be possible to get here for a call. */
17642 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
17643 elt_strict
|= maybe_adjust_types_for_deduction
17644 (DEDUCE_CALL
, &elttype
, &type
, elt
);
17648 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
17652 if (TREE_CODE (parm
) == ARRAY_TYPE
17653 && deducible_array_bound (TYPE_DOMAIN (parm
)))
17655 /* Also deduce from the length of the initializer list. */
17656 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
17657 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
17658 if (idx
== error_mark_node
)
17659 return unify_invalid (explain_p
);
17660 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17664 /* If the std::initializer_list<T> deduction worked, replace the
17665 deduced A with std::initializer_list<A>. */
17666 if (orig_parm
!= parm
)
17668 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
17669 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17670 targ
= listify (targ
);
17671 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
17673 return unify_success (explain_p
);
17676 /* Immediately reject some pairs that won't unify because of
17677 cv-qualification mismatches. */
17678 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17680 /* It is the elements of the array which hold the cv quals of an array
17681 type, and the elements might be template type parms. We'll check
17682 when we recurse. */
17683 && TREE_CODE (arg
) != ARRAY_TYPE
17684 /* We check the cv-qualifiers when unifying with template type
17685 parameters below. We want to allow ARG `const T' to unify with
17686 PARM `T' for example, when computing which of two templates
17687 is more specialized, for example. */
17688 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
17689 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
17690 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17692 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
17693 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
17694 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
17695 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
17696 strict
&= ~UNIFY_ALLOW_DERIVED
;
17697 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17698 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
17700 switch (TREE_CODE (parm
))
17702 case TYPENAME_TYPE
:
17704 case UNBOUND_CLASS_TEMPLATE
:
17705 /* In a type which contains a nested-name-specifier, template
17706 argument values cannot be deduced for template parameters used
17707 within the nested-name-specifier. */
17708 return unify_success (explain_p
);
17710 case TEMPLATE_TYPE_PARM
:
17711 case TEMPLATE_TEMPLATE_PARM
:
17712 case BOUND_TEMPLATE_TEMPLATE_PARM
:
17713 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17714 if (error_operand_p (tparm
))
17715 return unify_invalid (explain_p
);
17717 if (TEMPLATE_TYPE_LEVEL (parm
)
17718 != template_decl_level (tparm
))
17719 /* The PARM is not one we're trying to unify. Just check
17720 to see if it matches ARG. */
17722 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17723 && (is_auto (parm
) ? is_auto (arg
)
17724 : same_type_p (parm
, arg
)))
17725 return unify_success (explain_p
);
17727 return unify_type_mismatch (explain_p
, parm
, arg
);
17729 idx
= TEMPLATE_TYPE_IDX (parm
);
17730 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17731 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
17732 if (error_operand_p (tparm
))
17733 return unify_invalid (explain_p
);
17735 /* Check for mixed types and values. */
17736 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17737 && TREE_CODE (tparm
) != TYPE_DECL
)
17738 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17739 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
17740 gcc_unreachable ();
17742 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17744 /* ARG must be constructed from a template class or a template
17745 template parameter. */
17746 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
17747 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
17748 return unify_template_deduction_failure (explain_p
, parm
, arg
);
17750 tree parmvec
= TYPE_TI_ARGS (parm
);
17751 /* An alias template name is never deduced. */
17752 if (TYPE_ALIAS_P (arg
))
17753 arg
= strip_typedefs (arg
);
17754 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
17755 tree full_argvec
= add_to_template_args (targs
, argvec
);
17757 = DECL_INNERMOST_TEMPLATE_PARMS
17758 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
17760 int parm_variadic_p
= 0;
17762 /* The resolution to DR150 makes clear that default
17763 arguments for an N-argument may not be used to bind T
17764 to a template template parameter with fewer than N
17765 parameters. It is not safe to permit the binding of
17766 default arguments as an extension, as that may change
17767 the meaning of a conforming program. Consider:
17769 struct Dense { static const unsigned int dim = 1; };
17771 template <template <typename> class View,
17773 void operator+(float, View<Block> const&);
17775 template <typename Block,
17776 unsigned int Dim = Block::dim>
17777 struct Lvalue_proxy { operator float() const; };
17781 Lvalue_proxy<Dense> p;
17786 Here, if Lvalue_proxy is permitted to bind to View, then
17787 the global operator+ will be used; if they are not, the
17788 Lvalue_proxy will be converted to float. */
17789 if (coerce_template_parms (parm_parms
,
17791 TYPE_TI_TEMPLATE (parm
),
17793 ? tf_warning_or_error
17795 /*require_all_args=*/true,
17796 /*use_default_args=*/false)
17797 == error_mark_node
)
17800 /* Deduce arguments T, i from TT<T> or TT<i>.
17801 We check each element of PARMVEC and ARGVEC individually
17802 rather than the whole TREE_VEC since they can have
17803 different number of elements. */
17805 parmvec
= expand_template_argument_pack (parmvec
);
17806 argvec
= expand_template_argument_pack (argvec
);
17808 len
= TREE_VEC_LENGTH (parmvec
);
17810 /* Check if the parameters end in a pack, making them
17813 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
17814 parm_variadic_p
= 1;
17816 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17817 /* If the template argument list of P contains a pack
17818 expansion that is not the last template argument, the
17819 entire template argument list is a non-deduced
17821 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
17822 return unify_success (explain_p
);
17824 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
17825 return unify_too_few_arguments (explain_p
,
17826 TREE_VEC_LENGTH (argvec
), len
);
17828 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17830 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17831 TREE_VEC_ELT (parmvec
, i
),
17832 TREE_VEC_ELT (argvec
, i
),
17833 UNIFY_ALLOW_NONE
, explain_p
);
17836 if (parm_variadic_p
17837 && unify_pack_expansion (tparms
, targs
,
17840 /*subr=*/true, explain_p
))
17843 arg
= TYPE_TI_TEMPLATE (arg
);
17845 /* Fall through to deduce template name. */
17848 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17849 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17851 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
17853 /* Simple cases: Value already set, does match or doesn't. */
17854 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
17855 return unify_success (explain_p
);
17857 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17861 /* If PARM is `const T' and ARG is only `int', we don't have
17862 a match unless we are allowing additional qualification.
17863 If ARG is `const int' and PARM is just `T' that's OK;
17864 that binds `const int' to `T'. */
17865 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
17867 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17869 /* Consider the case where ARG is `const volatile int' and
17870 PARM is `const T'. Then, T should be `volatile int'. */
17871 arg
= cp_build_qualified_type_real
17872 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
17873 if (arg
== error_mark_node
)
17874 return unify_invalid (explain_p
);
17876 /* Simple cases: Value already set, does match or doesn't. */
17877 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
17878 return unify_success (explain_p
);
17880 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17882 /* Make sure that ARG is not a variable-sized array. (Note
17883 that were talking about variable-sized arrays (like
17884 `int[n]'), rather than arrays of unknown size (like
17885 `int[]').) We'll get very confused by such a type since
17886 the bound of the array is not constant, and therefore
17887 not mangleable. Besides, such types are not allowed in
17888 ISO C++, so we can do as we please here. We do allow
17889 them for 'auto' deduction, since that isn't ABI-exposed. */
17890 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
17891 return unify_vla_arg (explain_p
, arg
);
17893 /* Strip typedefs as in convert_template_argument. */
17894 arg
= canonicalize_type_argument (arg
, tf_none
);
17897 /* If ARG is a parameter pack or an expansion, we cannot unify
17898 against it unless PARM is also a parameter pack. */
17899 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17900 && !template_parameter_pack_p (parm
))
17901 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17903 /* If the argument deduction results is a METHOD_TYPE,
17904 then there is a problem.
17905 METHOD_TYPE doesn't map to any real C++ type the result of
17906 the deduction can not be of that type. */
17907 if (TREE_CODE (arg
) == METHOD_TYPE
)
17908 return unify_method_type_error (explain_p
, arg
);
17910 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17911 return unify_success (explain_p
);
17913 case TEMPLATE_PARM_INDEX
:
17914 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17915 if (error_operand_p (tparm
))
17916 return unify_invalid (explain_p
);
17918 if (TEMPLATE_PARM_LEVEL (parm
)
17919 != template_decl_level (tparm
))
17921 /* The PARM is not one we're trying to unify. Just check
17922 to see if it matches ARG. */
17923 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
17924 && cp_tree_equal (parm
, arg
));
17926 unify_expression_unequal (explain_p
, parm
, arg
);
17930 idx
= TEMPLATE_PARM_IDX (parm
);
17931 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17935 int x
= !cp_tree_equal (targ
, arg
);
17937 unify_inconsistency (explain_p
, parm
, targ
, arg
);
17941 /* [temp.deduct.type] If, in the declaration of a function template
17942 with a non-type template-parameter, the non-type
17943 template-parameter is used in an expression in the function
17944 parameter-list and, if the corresponding template-argument is
17945 deduced, the template-argument type shall match the type of the
17946 template-parameter exactly, except that a template-argument
17947 deduced from an array bound may be of any integral type.
17948 The non-type parameter might use already deduced type parameters. */
17949 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
17950 if (!TREE_TYPE (arg
))
17951 /* Template-parameter dependent expression. Just accept it for now.
17952 It will later be processed in convert_template_argument. */
17954 else if (same_type_p (TREE_TYPE (arg
), tparm
))
17956 else if ((strict
& UNIFY_ALLOW_INTEGER
)
17957 && CP_INTEGRAL_TYPE_P (tparm
))
17958 /* Convert the ARG to the type of PARM; the deduced non-type
17959 template argument must exactly match the types of the
17960 corresponding parameter. */
17961 arg
= fold (build_nop (tparm
, arg
));
17962 else if (uses_template_parms (tparm
))
17963 /* We haven't deduced the type of this parameter yet. Try again
17965 return unify_success (explain_p
);
17967 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
17969 /* If ARG is a parameter pack or an expansion, we cannot unify
17970 against it unless PARM is also a parameter pack. */
17971 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17972 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
17973 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17975 arg
= strip_typedefs_expr (arg
);
17976 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17977 return unify_success (explain_p
);
17981 /* A pointer-to-member constant can be unified only with
17982 another constant. */
17983 if (TREE_CODE (arg
) != PTRMEM_CST
)
17984 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
17986 /* Just unify the class member. It would be useless (and possibly
17987 wrong, depending on the strict flags) to unify also
17988 PTRMEM_CST_CLASS, because we want to be sure that both parm and
17989 arg refer to the same variable, even if through different
17990 classes. For instance:
17992 struct A { int x; };
17995 Unification of &A::x and &B::x must succeed. */
17996 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
17997 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
18002 if (!TYPE_PTR_P (arg
))
18003 return unify_type_mismatch (explain_p
, parm
, arg
);
18005 /* [temp.deduct.call]
18007 A can be another pointer or pointer to member type that can
18008 be converted to the deduced A via a qualification
18009 conversion (_conv.qual_).
18011 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18012 This will allow for additional cv-qualification of the
18013 pointed-to types if appropriate. */
18015 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
18016 /* The derived-to-base conversion only persists through one
18017 level of pointers. */
18018 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
18020 return unify (tparms
, targs
, TREE_TYPE (parm
),
18021 TREE_TYPE (arg
), strict
, explain_p
);
18024 case REFERENCE_TYPE
:
18025 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
18026 return unify_type_mismatch (explain_p
, parm
, arg
);
18027 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18028 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18031 if (TREE_CODE (arg
) != ARRAY_TYPE
)
18032 return unify_type_mismatch (explain_p
, parm
, arg
);
18033 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
18034 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
18035 return unify_type_mismatch (explain_p
, parm
, arg
);
18036 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18037 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18038 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
18039 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18040 TYPE_DOMAIN (arg
), explain_p
);
18041 return unify_success (explain_p
);
18048 case ENUMERAL_TYPE
:
18051 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18052 return unify_type_mismatch (explain_p
, parm
, arg
);
18054 /* We have already checked cv-qualification at the top of the
18056 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
18057 return unify_type_mismatch (explain_p
, parm
, arg
);
18059 /* As far as unification is concerned, this wins. Later checks
18060 will invalidate it if necessary. */
18061 return unify_success (explain_p
);
18063 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18064 /* Type INTEGER_CST can come from ordinary constant template args. */
18066 while (TREE_CODE (arg
) == NOP_EXPR
)
18067 arg
= TREE_OPERAND (arg
, 0);
18069 if (TREE_CODE (arg
) != INTEGER_CST
)
18070 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18071 return (tree_int_cst_equal (parm
, arg
)
18072 ? unify_success (explain_p
)
18073 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18077 int i
, len
, argslen
;
18078 int parm_variadic_p
= 0;
18080 if (TREE_CODE (arg
) != TREE_VEC
)
18081 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18083 len
= TREE_VEC_LENGTH (parm
);
18084 argslen
= TREE_VEC_LENGTH (arg
);
18086 /* Check for pack expansions in the parameters. */
18087 for (i
= 0; i
< len
; ++i
)
18089 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18092 /* We can unify against something with a trailing
18094 parm_variadic_p
= 1;
18096 /* [temp.deduct.type]/9: If the template argument list of
18097 P contains a pack expansion that is not the last
18098 template argument, the entire template argument list
18099 is a non-deduced context. */
18100 return unify_success (explain_p
);
18104 /* If we don't have enough arguments to satisfy the parameters
18105 (not counting the pack expression at the end), or we have
18106 too many arguments for a parameter list that doesn't end in
18107 a pack expression, we can't unify. */
18108 if (parm_variadic_p
18109 ? argslen
< len
- parm_variadic_p
18111 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18113 /* Unify all of the parameters that precede the (optional)
18114 pack expression. */
18115 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18117 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18118 TREE_VEC_ELT (parm
, i
),
18119 TREE_VEC_ELT (arg
, i
),
18120 UNIFY_ALLOW_NONE
, explain_p
);
18122 if (parm_variadic_p
)
18123 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18125 /*subr=*/true, explain_p
);
18126 return unify_success (explain_p
);
18131 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18132 return unify_type_mismatch (explain_p
, parm
, arg
);
18134 if (TYPE_PTRMEMFUNC_P (parm
))
18136 if (!TYPE_PTRMEMFUNC_P (arg
))
18137 return unify_type_mismatch (explain_p
, parm
, arg
);
18139 return unify (tparms
, targs
,
18140 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18141 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18142 strict
, explain_p
);
18144 else if (TYPE_PTRMEMFUNC_P (arg
))
18145 return unify_type_mismatch (explain_p
, parm
, arg
);
18147 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18149 tree t
= NULL_TREE
;
18151 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18153 /* First, we try to unify the PARM and ARG directly. */
18154 t
= try_class_unification (tparms
, targs
,
18155 parm
, arg
, explain_p
);
18159 /* Fallback to the special case allowed in
18160 [temp.deduct.call]:
18162 If P is a class, and P has the form
18163 template-id, then A can be a derived class of
18164 the deduced A. Likewise, if P is a pointer to
18165 a class of the form template-id, A can be a
18166 pointer to a derived class pointed to by the
18168 enum template_base_result r
;
18169 r
= get_template_base (tparms
, targs
, parm
, arg
,
18173 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18176 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18177 && (CLASSTYPE_TI_TEMPLATE (parm
)
18178 == CLASSTYPE_TI_TEMPLATE (arg
)))
18179 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18180 Then, we should unify `int' and `U'. */
18183 /* There's no chance of unification succeeding. */
18184 return unify_type_mismatch (explain_p
, parm
, arg
);
18186 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18187 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18189 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18190 return unify_type_mismatch (explain_p
, parm
, arg
);
18191 return unify_success (explain_p
);
18194 case FUNCTION_TYPE
:
18196 unsigned int nargs
;
18201 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18202 return unify_type_mismatch (explain_p
, parm
, arg
);
18204 /* CV qualifications for methods can never be deduced, they must
18205 match exactly. We need to check them explicitly here,
18206 because type_unification_real treats them as any other
18207 cv-qualified parameter. */
18208 if (TREE_CODE (parm
) == METHOD_TYPE
18209 && (!check_cv_quals_for_unify
18211 class_of_this_parm (arg
),
18212 class_of_this_parm (parm
))))
18213 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18215 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18216 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18218 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18219 args
= XALLOCAVEC (tree
, nargs
);
18220 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18221 a
!= NULL_TREE
&& a
!= void_list_node
;
18222 a
= TREE_CHAIN (a
), ++i
)
18223 args
[i
] = TREE_VALUE (a
);
18226 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18227 args
, nargs
, 1, DEDUCE_EXACT
,
18228 LOOKUP_NORMAL
, NULL
, explain_p
);
18232 /* Unify a pointer to member with a pointer to member function, which
18233 deduces the type of the member as a function type. */
18234 if (TYPE_PTRMEMFUNC_P (arg
))
18236 /* Check top-level cv qualifiers */
18237 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18238 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18240 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18241 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18242 UNIFY_ALLOW_NONE
, explain_p
);
18244 /* Determine the type of the function we are unifying against. */
18245 tree fntype
= static_fn_type (arg
);
18247 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18250 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18251 return unify_type_mismatch (explain_p
, parm
, arg
);
18252 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18253 TYPE_OFFSET_BASETYPE (arg
),
18254 UNIFY_ALLOW_NONE
, explain_p
);
18255 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18256 strict
, explain_p
);
18259 if (DECL_TEMPLATE_PARM_P (parm
))
18260 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18261 if (arg
!= integral_constant_value (parm
))
18262 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18263 return unify_success (explain_p
);
18266 case TEMPLATE_DECL
:
18267 /* Matched cases are handled by the ARG == PARM test above. */
18268 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18271 /* A non-type template parameter that is a variable should be a
18272 an integral constant, in which case, it whould have been
18273 folded into its (constant) value. So we should not be getting
18274 a variable here. */
18275 gcc_unreachable ();
18277 case TYPE_ARGUMENT_PACK
:
18278 case NONTYPE_ARGUMENT_PACK
:
18279 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18280 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18283 case DECLTYPE_TYPE
:
18284 case UNDERLYING_TYPE
:
18285 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18286 or UNDERLYING_TYPE nodes. */
18287 return unify_success (explain_p
);
18290 /* Unification fails if we hit an error node. */
18291 return unify_invalid (explain_p
);
18294 if (REFERENCE_REF_P (parm
))
18295 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18296 strict
, explain_p
);
18300 /* An unresolved overload is a nondeduced context. */
18301 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18302 return unify_success (explain_p
);
18303 gcc_assert (EXPR_P (parm
));
18305 /* We must be looking at an expression. This can happen with
18309 void foo(S<I>, S<I + 2>);
18311 This is a "nondeduced context":
18315 The nondeduced contexts are:
18317 --A type that is a template-id in which one or more of
18318 the template-arguments is an expression that references
18319 a template-parameter.
18321 In these cases, we assume deduction succeeded, but don't
18322 actually infer any unifications. */
18324 if (!uses_template_parms (parm
)
18325 && !template_args_equal (parm
, arg
))
18326 return unify_expression_unequal (explain_p
, parm
, arg
);
18328 return unify_success (explain_p
);
18331 #undef RECUR_AND_CHECK_FAILURE
18333 /* Note that DECL can be defined in this translation unit, if
18337 mark_definable (tree decl
)
18340 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18341 FOR_EACH_CLONE (clone
, decl
)
18342 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18345 /* Called if RESULT is explicitly instantiated, or is a member of an
18346 explicitly instantiated class. */
18349 mark_decl_instantiated (tree result
, int extern_p
)
18351 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18353 /* If this entity has already been written out, it's too late to
18354 make any modifications. */
18355 if (TREE_ASM_WRITTEN (result
))
18358 /* For anonymous namespace we don't need to do anything. */
18359 if (decl_anon_ns_mem_p (result
))
18361 gcc_assert (!TREE_PUBLIC (result
));
18365 if (TREE_CODE (result
) != FUNCTION_DECL
)
18366 /* The TREE_PUBLIC flag for function declarations will have been
18367 set correctly by tsubst. */
18368 TREE_PUBLIC (result
) = 1;
18370 /* This might have been set by an earlier implicit instantiation. */
18371 DECL_COMDAT (result
) = 0;
18374 DECL_NOT_REALLY_EXTERN (result
) = 0;
18377 mark_definable (result
);
18378 mark_needed (result
);
18379 /* Always make artificials weak. */
18380 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18381 comdat_linkage (result
);
18382 /* For WIN32 we also want to put explicit instantiations in
18383 linkonce sections. */
18384 else if (TREE_PUBLIC (result
))
18385 maybe_make_one_only (result
);
18388 /* If EXTERN_P, then this function will not be emitted -- unless
18389 followed by an explicit instantiation, at which point its linkage
18390 will be adjusted. If !EXTERN_P, then this function will be
18391 emitted here. In neither circumstance do we want
18392 import_export_decl to adjust the linkage. */
18393 DECL_INTERFACE_KNOWN (result
) = 1;
18396 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18397 important template arguments. If any are missing, we check whether
18398 they're important by using error_mark_node for substituting into any
18399 args that were used for partial ordering (the ones between ARGS and END)
18400 and seeing if it bubbles up. */
18403 check_undeduced_parms (tree targs
, tree args
, tree end
)
18405 bool found
= false;
18407 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18408 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18411 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18415 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18416 if (substed
== error_mark_node
)
18422 /* Given two function templates PAT1 and PAT2, return:
18424 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18425 -1 if PAT2 is more specialized than PAT1.
18426 0 if neither is more specialized.
18428 LEN indicates the number of parameters we should consider
18429 (defaulted parameters should not be considered).
18431 The 1998 std underspecified function template partial ordering, and
18432 DR214 addresses the issue. We take pairs of arguments, one from
18433 each of the templates, and deduce them against each other. One of
18434 the templates will be more specialized if all the *other*
18435 template's arguments deduce against its arguments and at least one
18436 of its arguments *does* *not* deduce against the other template's
18437 corresponding argument. Deduction is done as for class templates.
18438 The arguments used in deduction have reference and top level cv
18439 qualifiers removed. Iff both arguments were originally reference
18440 types *and* deduction succeeds in both directions, an lvalue reference
18441 wins against an rvalue reference and otherwise the template
18442 with the more cv-qualified argument wins for that pairing (if
18443 neither is more cv-qualified, they both are equal). Unlike regular
18444 deduction, after all the arguments have been deduced in this way,
18445 we do *not* verify the deduced template argument values can be
18446 substituted into non-deduced contexts.
18448 The logic can be a bit confusing here, because we look at deduce1 and
18449 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18450 can find template arguments for pat1 to make arg1 look like arg2, that
18451 means that arg2 is at least as specialized as arg1. */
18454 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18456 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18457 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18458 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18459 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18460 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18461 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18462 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18463 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18464 tree origs1
, origs2
;
18465 bool lose1
= false;
18466 bool lose2
= false;
18468 /* Remove the this parameter from non-static member functions. If
18469 one is a non-static member function and the other is not a static
18470 member function, remove the first parameter from that function
18471 also. This situation occurs for operator functions where we
18472 locate both a member function (with this pointer) and non-member
18473 operator (with explicit first operand). */
18474 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18476 len
--; /* LEN is the number of significant arguments for DECL1 */
18477 args1
= TREE_CHAIN (args1
);
18478 if (!DECL_STATIC_FUNCTION_P (decl2
))
18479 args2
= TREE_CHAIN (args2
);
18481 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18483 args2
= TREE_CHAIN (args2
);
18484 if (!DECL_STATIC_FUNCTION_P (decl1
))
18487 args1
= TREE_CHAIN (args1
);
18491 /* If only one is a conversion operator, they are unordered. */
18492 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18495 /* Consider the return type for a conversion function */
18496 if (DECL_CONV_FN_P (decl1
))
18498 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18499 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18503 processing_template_decl
++;
18509 /* Stop when an ellipsis is seen. */
18510 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18512 tree arg1
= TREE_VALUE (args1
);
18513 tree arg2
= TREE_VALUE (args2
);
18514 int deduce1
, deduce2
;
18520 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18521 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18523 /* When both arguments are pack expansions, we need only
18524 unify the patterns themselves. */
18525 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18526 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18528 /* This is the last comparison we need to do. */
18532 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18534 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18535 arg1
= TREE_TYPE (arg1
);
18536 quals1
= cp_type_quals (arg1
);
18539 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18541 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18542 arg2
= TREE_TYPE (arg2
);
18543 quals2
= cp_type_quals (arg2
);
18546 arg1
= TYPE_MAIN_VARIANT (arg1
);
18547 arg2
= TYPE_MAIN_VARIANT (arg2
);
18549 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18551 int i
, len2
= list_length (args2
);
18552 tree parmvec
= make_tree_vec (1);
18553 tree argvec
= make_tree_vec (len2
);
18556 /* Setup the parameter vector, which contains only ARG1. */
18557 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18559 /* Setup the argument vector, which contains the remaining
18561 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18562 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18564 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18565 argvec
, DEDUCE_EXACT
,
18566 /*subr=*/true, /*explain_p=*/false)
18569 /* We cannot deduce in the other direction, because ARG1 is
18570 a pack expansion but ARG2 is not. */
18573 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18575 int i
, len1
= list_length (args1
);
18576 tree parmvec
= make_tree_vec (1);
18577 tree argvec
= make_tree_vec (len1
);
18580 /* Setup the parameter vector, which contains only ARG1. */
18581 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18583 /* Setup the argument vector, which contains the remaining
18585 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18586 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18588 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18589 argvec
, DEDUCE_EXACT
,
18590 /*subr=*/true, /*explain_p=*/false)
18593 /* We cannot deduce in the other direction, because ARG2 is
18594 a pack expansion but ARG1 is not.*/
18600 /* The normal case, where neither argument is a pack
18602 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18603 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18605 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18606 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18610 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18611 arg2, then arg2 is not as specialized as arg1. */
18617 /* "If, for a given type, deduction succeeds in both directions
18618 (i.e., the types are identical after the transformations above)
18619 and both P and A were reference types (before being replaced with
18620 the type referred to above):
18621 - if the type from the argument template was an lvalue reference and
18622 the type from the parameter template was not, the argument type is
18623 considered to be more specialized than the other; otherwise,
18624 - if the type from the argument template is more cv-qualified
18625 than the type from the parameter template (as described above),
18626 the argument type is considered to be more specialized than the other;
18628 - neither type is more specialized than the other." */
18630 if (deduce1
&& deduce2
)
18632 if (ref1
&& ref2
&& ref1
!= ref2
)
18639 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
18641 if ((quals1
& quals2
) == quals2
)
18643 if ((quals1
& quals2
) == quals1
)
18648 if (lose1
&& lose2
)
18649 /* We've failed to deduce something in either direction.
18650 These must be unordered. */
18653 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18654 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18655 /* We have already processed all of the arguments in our
18656 handing of the pack expansion type. */
18659 args1
= TREE_CHAIN (args1
);
18660 args2
= TREE_CHAIN (args2
);
18663 /* "In most cases, all template parameters must have values in order for
18664 deduction to succeed, but for partial ordering purposes a template
18665 parameter may remain without a value provided it is not used in the
18666 types being used for partial ordering."
18668 Thus, if we are missing any of the targs1 we need to substitute into
18669 origs1, then pat2 is not as specialized as pat1. This can happen when
18670 there is a nondeduced context. */
18671 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
18673 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
18676 processing_template_decl
--;
18678 /* All things being equal, if the next argument is a pack expansion
18679 for one function but not for the other, prefer the
18680 non-variadic function. FIXME this is bogus; see c++/41958. */
18682 && args1
&& TREE_VALUE (args1
)
18683 && args2
&& TREE_VALUE (args2
))
18685 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
18686 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
18689 if (lose1
== lose2
)
18697 /* Determine which of two partial specializations of TMPL is more
18700 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18701 to the first partial specialization. The TREE_VALUE is the
18702 innermost set of template parameters for the partial
18703 specialization. PAT2 is similar, but for the second template.
18705 Return 1 if the first partial specialization is more specialized;
18706 -1 if the second is more specialized; 0 if neither is more
18709 See [temp.class.order] for information about determining which of
18710 two templates is more specialized. */
18713 more_specialized_class (tree tmpl
, tree pat1
, tree pat2
)
18718 bool any_deductions
= false;
18720 tmpl1
= TREE_TYPE (pat1
);
18721 tmpl2
= TREE_TYPE (pat2
);
18723 /* Just like what happens for functions, if we are ordering between
18724 different class template specializations, we may encounter dependent
18725 types in the arguments, and we need our dependency check functions
18726 to behave correctly. */
18727 ++processing_template_decl
;
18728 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat1
),
18729 CLASSTYPE_TI_ARGS (tmpl1
),
18730 CLASSTYPE_TI_ARGS (tmpl2
));
18734 any_deductions
= true;
18737 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat2
),
18738 CLASSTYPE_TI_ARGS (tmpl2
),
18739 CLASSTYPE_TI_ARGS (tmpl1
));
18743 any_deductions
= true;
18745 --processing_template_decl
;
18747 /* In the case of a tie where at least one of the class templates
18748 has a parameter pack at the end, the template with the most
18749 non-packed parameters wins. */
18752 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
18753 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
18755 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
18756 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
18757 int len1
= TREE_VEC_LENGTH (args1
);
18758 int len2
= TREE_VEC_LENGTH (args2
);
18760 /* We don't count the pack expansion at the end. */
18761 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
18763 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
18768 else if (len1
< len2
)
18775 /* Return the template arguments that will produce the function signature
18776 DECL from the function template FN, with the explicit template
18777 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18778 also match. Return NULL_TREE if no satisfactory arguments could be
18782 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
18784 int ntparms
= DECL_NTPARMS (fn
);
18785 tree targs
= make_tree_vec (ntparms
);
18786 tree decl_type
= TREE_TYPE (decl
);
18787 tree decl_arg_types
;
18789 unsigned int nargs
, ix
;
18792 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
18794 /* Never do unification on the 'this' parameter. */
18795 decl_arg_types
= skip_artificial_parms_for (decl
,
18796 TYPE_ARG_TYPES (decl_type
));
18798 nargs
= list_length (decl_arg_types
);
18799 args
= XALLOCAVEC (tree
, nargs
);
18800 for (arg
= decl_arg_types
, ix
= 0;
18801 arg
!= NULL_TREE
&& arg
!= void_list_node
;
18802 arg
= TREE_CHAIN (arg
), ++ix
)
18803 args
[ix
] = TREE_VALUE (arg
);
18805 if (fn_type_unification (fn
, explicit_args
, targs
,
18807 (check_rettype
|| DECL_CONV_FN_P (fn
)
18808 ? TREE_TYPE (decl_type
) : NULL_TREE
),
18809 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
18811 == error_mark_node
)
18817 /* Return the innermost template arguments that, when applied to a partial
18818 specialization of TMPL whose innermost template parameters are
18819 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
18822 For example, suppose we have:
18824 template <class T, class U> struct S {};
18825 template <class T> struct S<T*, int> {};
18827 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
18828 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
18829 int}. The resulting vector will be {double}, indicating that `T'
18830 is bound to `double'. */
18833 get_class_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
18835 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
18837 tree innermost_deduced_args
;
18839 innermost_deduced_args
= make_tree_vec (ntparms
);
18840 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18842 deduced_args
= copy_node (args
);
18843 SET_TMPL_ARGS_LEVEL (deduced_args
,
18844 TMPL_ARGS_DEPTH (deduced_args
),
18845 innermost_deduced_args
);
18848 deduced_args
= innermost_deduced_args
;
18850 if (unify (tparms
, deduced_args
,
18851 INNERMOST_TEMPLATE_ARGS (spec_args
),
18852 INNERMOST_TEMPLATE_ARGS (args
),
18853 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
18856 for (i
= 0; i
< ntparms
; ++i
)
18857 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
18860 /* Verify that nondeduced template arguments agree with the type
18861 obtained from argument deduction.
18865 struct A { typedef int X; };
18866 template <class T, class U> struct C {};
18867 template <class T> struct C<T, typename T::X> {};
18869 Then with the instantiation `C<A, int>', we can deduce that
18870 `T' is `A' but unify () does not check whether `typename T::X'
18872 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
18873 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
18875 tf_none
, false, false);
18876 if (spec_args
== error_mark_node
18877 /* We only need to check the innermost arguments; the other
18878 arguments will always agree. */
18879 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
18880 INNERMOST_TEMPLATE_ARGS (args
)))
18883 /* Now that we have bindings for all of the template arguments,
18884 ensure that the arguments deduced for the template template
18885 parameters have compatible template parameter lists. See the use
18886 of template_template_parm_bindings_ok_p in fn_type_unification
18887 for more information. */
18888 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
18891 return deduced_args
;
18894 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
18895 Return the TREE_LIST node with the most specialized template, if
18896 any. If there is no most specialized template, the error_mark_node
18899 Note that this function does not look at, or modify, the
18900 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
18901 returned is one of the elements of INSTANTIATIONS, callers may
18902 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
18903 and retrieve it from the value returned. */
18906 most_specialized_instantiation (tree templates
)
18910 ++processing_template_decl
;
18913 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
18917 if (get_bindings (TREE_VALUE (champ
),
18918 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18919 NULL_TREE
, /*check_ret=*/true))
18922 if (get_bindings (TREE_VALUE (fn
),
18923 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18924 NULL_TREE
, /*check_ret=*/true))
18931 /* Equally specialized, move to next function. If there
18932 is no next function, nothing's most specialized. */
18933 fn
= TREE_CHAIN (fn
);
18941 /* Now verify that champ is better than everything earlier in the
18942 instantiation list. */
18943 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
18944 if (get_bindings (TREE_VALUE (champ
),
18945 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18946 NULL_TREE
, /*check_ret=*/true)
18947 || !get_bindings (TREE_VALUE (fn
),
18948 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18949 NULL_TREE
, /*check_ret=*/true))
18955 processing_template_decl
--;
18958 return error_mark_node
;
18963 /* If DECL is a specialization of some template, return the most
18964 general such template. Otherwise, returns NULL_TREE.
18966 For example, given:
18968 template <class T> struct S { template <class U> void f(U); };
18970 if TMPL is `template <class U> void S<int>::f(U)' this will return
18971 the full template. This function will not trace past partial
18972 specializations, however. For example, given in addition:
18974 template <class T> struct S<T*> { template <class U> void f(U); };
18976 if TMPL is `template <class U> void S<int*>::f(U)' this will return
18977 `template <class T> template <class U> S<T*>::f(U)'. */
18980 most_general_template (tree decl
)
18982 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18984 if (tree tinfo
= get_template_info (decl
))
18985 decl
= TI_TEMPLATE (tinfo
);
18986 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
18987 template friend, or a FIELD_DECL for a capture pack. */
18988 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18992 /* Look for more and more general templates. */
18993 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
18995 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
18996 (See cp-tree.h for details.) */
18997 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
19000 if (CLASS_TYPE_P (TREE_TYPE (decl
))
19001 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
19004 /* Stop if we run into an explicitly specialized class template. */
19005 if (!DECL_NAMESPACE_SCOPE_P (decl
)
19006 && DECL_CONTEXT (decl
)
19007 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
19010 decl
= DECL_TI_TEMPLATE (decl
);
19016 /* Return the most specialized of the class template partial
19017 specializations which can produce TYPE, a specialization of some class
19018 template. The value returned is actually a TREE_LIST; the TREE_TYPE is
19019 a _TYPE node corresponding to the partial specialization, while the
19020 TREE_PURPOSE is the set of template arguments that must be
19021 substituted into the TREE_TYPE in order to generate TYPE.
19023 If the choice of partial specialization is ambiguous, a diagnostic
19024 is issued, and the error_mark_node is returned. If there are no
19025 partial specializations matching TYPE, then NULL_TREE is
19026 returned, indicating that the primary template should be used. */
19029 most_specialized_class (tree type
, tsubst_flags_t complain
)
19031 tree list
= NULL_TREE
;
19036 tree outer_args
= NULL_TREE
;
19038 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
19039 tree main_tmpl
= most_general_template (tmpl
);
19040 tree args
= CLASSTYPE_TI_ARGS (type
);
19042 /* For determining which partial specialization to use, only the
19043 innermost args are interesting. */
19044 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19046 outer_args
= strip_innermost_template_args (args
, 1);
19047 args
= INNERMOST_TEMPLATE_ARGS (args
);
19050 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
19052 tree partial_spec_args
;
19054 tree spec_tmpl
= TREE_VALUE (t
);
19055 tree orig_parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19057 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
19059 ++processing_template_decl
;
19063 /* Discard the outer levels of args, and then substitute in the
19064 template args from the enclosing class. */
19065 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19066 partial_spec_args
= tsubst_template_args
19067 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19069 /* And the same for the partial specialization TEMPLATE_DECL. */
19070 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19073 partial_spec_args
=
19074 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19077 /*require_all_args=*/true,
19078 /*use_default_args=*/true);
19080 --processing_template_decl
;
19082 if (partial_spec_args
== error_mark_node
)
19083 return error_mark_node
;
19084 if (spec_tmpl
== error_mark_node
)
19085 return error_mark_node
;
19087 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19088 spec_args
= get_class_bindings (tmpl
, parms
,
19094 spec_args
= add_to_template_args (outer_args
, spec_args
);
19095 list
= tree_cons (spec_args
, orig_parms
, list
);
19096 TREE_TYPE (list
) = TREE_TYPE (t
);
19103 ambiguous_p
= false;
19106 t
= TREE_CHAIN (t
);
19107 for (; t
; t
= TREE_CHAIN (t
))
19109 fate
= more_specialized_class (tmpl
, champ
, t
);
19116 t
= TREE_CHAIN (t
);
19119 ambiguous_p
= true;
19128 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19130 fate
= more_specialized_class (tmpl
, champ
, t
);
19133 ambiguous_p
= true;
19141 char *spaces
= NULL
;
19142 if (!(complain
& tf_error
))
19143 return error_mark_node
;
19144 error ("ambiguous class template instantiation for %q#T", type
);
19145 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19146 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19148 error ("%s %+#T", spaces
? spaces
: str
, TREE_TYPE (t
));
19149 spaces
= spaces
? spaces
: get_spaces (str
);
19152 return error_mark_node
;
19158 /* Explicitly instantiate DECL. */
19161 do_decl_instantiation (tree decl
, tree storage
)
19163 tree result
= NULL_TREE
;
19166 if (!decl
|| decl
== error_mark_node
)
19167 /* An error occurred, for which grokdeclarator has already issued
19168 an appropriate message. */
19170 else if (! DECL_LANG_SPECIFIC (decl
))
19172 error ("explicit instantiation of non-template %q#D", decl
);
19175 else if (VAR_P (decl
))
19177 /* There is an asymmetry here in the way VAR_DECLs and
19178 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19179 the latter, the DECL we get back will be marked as a
19180 template instantiation, and the appropriate
19181 DECL_TEMPLATE_INFO will be set up. This does not happen for
19182 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19183 should handle VAR_DECLs as it currently handles
19185 if (!DECL_CLASS_SCOPE_P (decl
))
19187 error ("%qD is not a static data member of a class template", decl
);
19190 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19191 if (!result
|| !VAR_P (result
))
19193 error ("no matching template for %qD found", decl
);
19196 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19198 error ("type %qT for explicit instantiation %qD does not match "
19199 "declared type %qT", TREE_TYPE (result
), decl
,
19204 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
19206 error ("explicit instantiation of %q#D", decl
);
19212 /* Check for various error cases. Note that if the explicit
19213 instantiation is valid the RESULT will currently be marked as an
19214 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19215 until we get here. */
19217 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19219 /* DR 259 [temp.spec].
19221 Both an explicit instantiation and a declaration of an explicit
19222 specialization shall not appear in a program unless the explicit
19223 instantiation follows a declaration of the explicit specialization.
19225 For a given set of template parameters, if an explicit
19226 instantiation of a template appears after a declaration of an
19227 explicit specialization for that template, the explicit
19228 instantiation has no effect. */
19231 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19235 No program shall explicitly instantiate any template more
19238 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19239 the first instantiation was `extern' and the second is not,
19240 and EXTERN_P for the opposite case. */
19241 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19242 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19243 /* If an "extern" explicit instantiation follows an ordinary
19244 explicit instantiation, the template is instantiated. */
19248 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19250 error ("no matching template for %qD found", result
);
19253 else if (!DECL_TEMPLATE_INFO (result
))
19255 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19259 if (storage
== NULL_TREE
)
19261 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19263 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19264 pedwarn (input_location
, OPT_Wpedantic
,
19265 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19270 error ("storage class %qD applied to template instantiation", storage
);
19272 check_explicit_instantiation_namespace (result
);
19273 mark_decl_instantiated (result
, extern_p
);
19275 instantiate_decl (result
, /*defer_ok=*/1,
19276 /*expl_inst_class_mem_p=*/false);
19280 mark_class_instantiated (tree t
, int extern_p
)
19282 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19283 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19284 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19285 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19288 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19289 rest_of_type_compilation (t
, 1);
19293 /* Called from do_type_instantiation through binding_table_foreach to
19294 do recursive instantiation for the type bound in ENTRY. */
19296 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19298 tree storage
= *(tree
*) data
;
19300 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19301 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19302 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19305 /* Called from do_type_instantiation to instantiate a member
19306 (a member function or a static member variable) of an
19307 explicitly instantiated class template. */
19309 instantiate_class_member (tree decl
, int extern_p
)
19311 mark_decl_instantiated (decl
, extern_p
);
19313 instantiate_decl (decl
, /*defer_ok=*/1,
19314 /*expl_inst_class_mem_p=*/true);
19317 /* Perform an explicit instantiation of template class T. STORAGE, if
19318 non-null, is the RID for extern, inline or static. COMPLAIN is
19319 nonzero if this is called from the parser, zero if called recursively,
19320 since the standard is unclear (as detailed below). */
19323 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19328 int previous_instantiation_extern_p
= 0;
19330 if (TREE_CODE (t
) == TYPE_DECL
)
19333 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19336 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19338 error ("explicit instantiation of non-class template %qD", tmpl
);
19340 error ("explicit instantiation of non-template type %qT", t
);
19346 if (!COMPLETE_TYPE_P (t
))
19348 if (complain
& tf_error
)
19349 error ("explicit instantiation of %q#T before definition of template",
19354 if (storage
!= NULL_TREE
)
19356 if (!in_system_header_at (input_location
))
19358 if (storage
== ridpointers
[(int) RID_EXTERN
])
19360 if (cxx_dialect
== cxx98
)
19361 pedwarn (input_location
, OPT_Wpedantic
,
19362 "ISO C++ 1998 forbids the use of %<extern%> on "
19363 "explicit instantiations");
19366 pedwarn (input_location
, OPT_Wpedantic
,
19367 "ISO C++ forbids the use of %qE"
19368 " on explicit instantiations", storage
);
19371 if (storage
== ridpointers
[(int) RID_INLINE
])
19373 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19375 else if (storage
== ridpointers
[(int) RID_STATIC
])
19379 error ("storage class %qD applied to template instantiation",
19385 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19387 /* DR 259 [temp.spec].
19389 Both an explicit instantiation and a declaration of an explicit
19390 specialization shall not appear in a program unless the explicit
19391 instantiation follows a declaration of the explicit specialization.
19393 For a given set of template parameters, if an explicit
19394 instantiation of a template appears after a declaration of an
19395 explicit specialization for that template, the explicit
19396 instantiation has no effect. */
19399 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19403 No program shall explicitly instantiate any template more
19406 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19407 instantiation was `extern'. If EXTERN_P then the second is.
19408 These cases are OK. */
19409 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19411 if (!previous_instantiation_extern_p
&& !extern_p
19412 && (complain
& tf_error
))
19413 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19415 /* If we've already instantiated the template, just return now. */
19416 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19420 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19421 mark_class_instantiated (t
, extern_p
);
19429 /* In contrast to implicit instantiation, where only the
19430 declarations, and not the definitions, of members are
19431 instantiated, we have here:
19435 The explicit instantiation of a class template specialization
19436 implies the instantiation of all of its members not
19437 previously explicitly specialized in the translation unit
19438 containing the explicit instantiation.
19440 Of course, we can't instantiate member template classes, since
19441 we don't have any arguments for them. Note that the standard
19442 is unclear on whether the instantiation of the members are
19443 *explicit* instantiations or not. However, the most natural
19444 interpretation is that it should be an explicit instantiation. */
19447 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19448 if (TREE_CODE (tmp
) == FUNCTION_DECL
19449 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19450 instantiate_class_member (tmp
, extern_p
);
19452 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19453 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19454 instantiate_class_member (tmp
, extern_p
);
19456 if (CLASSTYPE_NESTED_UTDS (t
))
19457 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19458 bt_instantiate_type_proc
, &storage
);
19462 /* Given a function DECL, which is a specialization of TMPL, modify
19463 DECL to be a re-instantiation of TMPL with the same template
19464 arguments. TMPL should be the template into which tsubst'ing
19465 should occur for DECL, not the most general template.
19467 One reason for doing this is a scenario like this:
19470 void f(const T&, int i);
19472 void g() { f(3, 7); }
19475 void f(const T& t, const int i) { }
19477 Note that when the template is first instantiated, with
19478 instantiate_template, the resulting DECL will have no name for the
19479 first parameter, and the wrong type for the second. So, when we go
19480 to instantiate the DECL, we regenerate it. */
19483 regenerate_decl_from_template (tree decl
, tree tmpl
)
19485 /* The arguments used to instantiate DECL, from the most general
19490 args
= DECL_TI_ARGS (decl
);
19491 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19493 /* Make sure that we can see identifiers, and compute access
19495 push_access_scope (decl
);
19497 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19505 args_depth
= TMPL_ARGS_DEPTH (args
);
19506 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19507 if (args_depth
> parms_depth
)
19508 args
= get_innermost_template_args (args
, parms_depth
);
19510 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19511 args
, tf_error
, NULL_TREE
,
19512 /*defer_ok*/false);
19513 if (specs
&& specs
!= error_mark_node
)
19514 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19517 /* Merge parameter declarations. */
19518 decl_parm
= skip_artificial_parms_for (decl
,
19519 DECL_ARGUMENTS (decl
));
19521 = skip_artificial_parms_for (code_pattern
,
19522 DECL_ARGUMENTS (code_pattern
));
19523 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19528 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19529 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19530 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19532 parm_type
= type_decays_to (parm_type
);
19533 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19534 TREE_TYPE (decl_parm
) = parm_type
;
19535 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19536 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19538 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19539 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19541 decl_parm
= DECL_CHAIN (decl_parm
);
19542 pattern_parm
= DECL_CHAIN (pattern_parm
);
19544 /* Merge any parameters that match with the function parameter
19546 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19549 tree expanded_types
;
19550 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19551 the parameters in this function parameter pack. */
19552 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19553 args
, tf_error
, NULL_TREE
);
19554 len
= TREE_VEC_LENGTH (expanded_types
);
19555 for (i
= 0; i
< len
; i
++)
19560 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19561 /* Rename the parameter to include the index. */
19562 DECL_NAME (decl_parm
) =
19563 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19564 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19565 parm_type
= type_decays_to (parm_type
);
19566 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19567 TREE_TYPE (decl_parm
) = parm_type
;
19568 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19569 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19571 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19572 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19574 decl_parm
= DECL_CHAIN (decl_parm
);
19577 /* Merge additional specifiers from the CODE_PATTERN. */
19578 if (DECL_DECLARED_INLINE_P (code_pattern
)
19579 && !DECL_DECLARED_INLINE_P (decl
))
19580 DECL_DECLARED_INLINE_P (decl
) = 1;
19582 else if (VAR_P (decl
))
19584 DECL_INITIAL (decl
) =
19585 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19586 tf_error
, DECL_TI_TEMPLATE (decl
),
19587 /*integral_constant_expression_p=*/false);
19588 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19589 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19590 tf_error
, DECL_TI_TEMPLATE (decl
));
19593 gcc_unreachable ();
19595 pop_access_scope (decl
);
19598 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19599 substituted to get DECL. */
19602 template_for_substitution (tree decl
)
19604 tree tmpl
= DECL_TI_TEMPLATE (decl
);
19606 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19607 for the instantiation. This is not always the most general
19608 template. Consider, for example:
19611 struct S { template <class U> void f();
19612 template <> void f<int>(); };
19614 and an instantiation of S<double>::f<int>. We want TD to be the
19615 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19616 while (/* An instantiation cannot have a definition, so we need a
19617 more general template. */
19618 DECL_TEMPLATE_INSTANTIATION (tmpl
)
19619 /* We must also deal with friend templates. Given:
19621 template <class T> struct S {
19622 template <class U> friend void f() {};
19625 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19626 so far as the language is concerned, but that's still
19627 where we get the pattern for the instantiation from. On
19628 other hand, if the definition comes outside the class, say:
19630 template <class T> struct S {
19631 template <class U> friend void f();
19633 template <class U> friend void f() {}
19635 we don't need to look any further. That's what the check for
19636 DECL_INITIAL is for. */
19637 || (TREE_CODE (decl
) == FUNCTION_DECL
19638 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
19639 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
19641 /* The present template, TD, should not be a definition. If it
19642 were a definition, we should be using it! Note that we
19643 cannot restructure the loop to just keep going until we find
19644 a template with a definition, since that might go too far if
19645 a specialization was declared, but not defined. */
19646 gcc_assert (!VAR_P (decl
)
19647 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl
)));
19649 /* Fetch the more general template. */
19650 tmpl
= DECL_TI_TEMPLATE (tmpl
);
19656 /* Returns true if we need to instantiate this template instance even if we
19657 know we aren't going to emit it.. */
19660 always_instantiate_p (tree decl
)
19662 /* We always instantiate inline functions so that we can inline them. An
19663 explicit instantiation declaration prohibits implicit instantiation of
19664 non-inline functions. With high levels of optimization, we would
19665 normally inline non-inline functions -- but we're not allowed to do
19666 that for "extern template" functions. Therefore, we check
19667 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19668 return ((TREE_CODE (decl
) == FUNCTION_DECL
19669 && (DECL_DECLARED_INLINE_P (decl
)
19670 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
19671 /* And we need to instantiate static data members so that
19672 their initializers are available in integral constant
19675 && decl_maybe_constant_var_p (decl
)));
19678 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19679 instantiate it now, modifying TREE_TYPE (fn). */
19682 maybe_instantiate_noexcept (tree fn
)
19684 tree fntype
, spec
, noex
, clone
;
19686 /* Don't instantiate a noexcept-specification from template context. */
19687 if (processing_template_decl
)
19690 if (DECL_CLONED_FUNCTION_P (fn
))
19691 fn
= DECL_CLONED_FUNCTION (fn
);
19692 fntype
= TREE_TYPE (fn
);
19693 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
19695 if (!spec
|| !TREE_PURPOSE (spec
))
19698 noex
= TREE_PURPOSE (spec
);
19700 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
19702 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
19703 spec
= get_defaulted_eh_spec (fn
);
19704 else if (push_tinst_level (fn
))
19706 push_access_scope (fn
);
19707 push_deferring_access_checks (dk_no_deferred
);
19708 input_location
= DECL_SOURCE_LOCATION (fn
);
19709 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
19710 DEFERRED_NOEXCEPT_ARGS (noex
),
19711 tf_warning_or_error
, fn
,
19712 /*function_p=*/false,
19713 /*integral_constant_expression_p=*/true);
19714 pop_deferring_access_checks ();
19715 pop_access_scope (fn
);
19716 pop_tinst_level ();
19717 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
19718 if (spec
== error_mark_node
)
19719 spec
= noexcept_false_spec
;
19722 spec
= noexcept_false_spec
;
19724 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
19727 FOR_EACH_CLONE (clone
, fn
)
19729 if (TREE_TYPE (clone
) == fntype
)
19730 TREE_TYPE (clone
) = TREE_TYPE (fn
);
19732 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
19736 /* Produce the definition of D, a _DECL generated from a template. If
19737 DEFER_OK is nonzero, then we don't have to actually do the
19738 instantiation now; we just have to do it sometime. Normally it is
19739 an error if this is an explicit instantiation but D is undefined.
19740 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19741 explicitly instantiated class template. */
19744 instantiate_decl (tree d
, int defer_ok
,
19745 bool expl_inst_class_mem_p
)
19747 tree tmpl
= DECL_TI_TEMPLATE (d
);
19754 bool pattern_defined
;
19755 location_t saved_loc
= input_location
;
19756 int saved_unevaluated_operand
= cp_unevaluated_operand
;
19757 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
19763 /* This function should only be used to instantiate templates for
19764 functions and static member variables. */
19765 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
19767 /* Variables are never deferred; if instantiation is required, they
19768 are instantiated right away. That allows for better code in the
19769 case that an expression refers to the value of the variable --
19770 if the variable has a constant value the referring expression can
19771 take advantage of that fact. */
19773 || DECL_DECLARED_CONSTEXPR_P (d
))
19776 /* Don't instantiate cloned functions. Instead, instantiate the
19777 functions they cloned. */
19778 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
19779 d
= DECL_CLONED_FUNCTION (d
);
19781 if (DECL_TEMPLATE_INSTANTIATED (d
)
19782 || (TREE_CODE (d
) == FUNCTION_DECL
19783 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
19784 || DECL_TEMPLATE_SPECIALIZATION (d
))
19785 /* D has already been instantiated or explicitly specialized, so
19786 there's nothing for us to do here.
19788 It might seem reasonable to check whether or not D is an explicit
19789 instantiation, and, if so, stop here. But when an explicit
19790 instantiation is deferred until the end of the compilation,
19791 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
19792 the instantiation. */
19795 /* Check to see whether we know that this template will be
19796 instantiated in some other file, as with "extern template"
19798 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
19800 /* In general, we do not instantiate such templates. */
19801 if (external_p
&& !always_instantiate_p (d
))
19804 gen_tmpl
= most_general_template (tmpl
);
19805 gen_args
= DECL_TI_ARGS (d
);
19807 if (tmpl
!= gen_tmpl
)
19808 /* We should already have the extra args. */
19809 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
19810 == TMPL_ARGS_DEPTH (gen_args
));
19811 /* And what's in the hash table should match D. */
19812 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
19813 || spec
== NULL_TREE
);
19815 /* This needs to happen before any tsubsting. */
19816 if (! push_tinst_level (d
))
19819 timevar_push (TV_TEMPLATE_INST
);
19821 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
19822 for the instantiation. */
19823 td
= template_for_substitution (d
);
19824 code_pattern
= DECL_TEMPLATE_RESULT (td
);
19826 /* We should never be trying to instantiate a member of a class
19827 template or partial specialization. */
19828 gcc_assert (d
!= code_pattern
);
19830 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
19831 || DECL_TEMPLATE_SPECIALIZATION (td
))
19832 /* In the case of a friend template whose definition is provided
19833 outside the class, we may have too many arguments. Drop the
19834 ones we don't need. The same is true for specializations. */
19835 args
= get_innermost_template_args
19836 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
19840 if (TREE_CODE (d
) == FUNCTION_DECL
)
19842 deleted_p
= DECL_DELETED_FN (code_pattern
);
19843 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
19844 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
19850 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
19853 /* We may be in the middle of deferred access check. Disable it now. */
19854 push_deferring_access_checks (dk_no_deferred
);
19856 /* Unless an explicit instantiation directive has already determined
19857 the linkage of D, remember that a definition is available for
19859 if (pattern_defined
19860 && !DECL_INTERFACE_KNOWN (d
)
19861 && !DECL_NOT_REALLY_EXTERN (d
))
19862 mark_definable (d
);
19864 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
19865 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
19866 input_location
= DECL_SOURCE_LOCATION (d
);
19868 /* If D is a member of an explicitly instantiated class template,
19869 and no definition is available, treat it like an implicit
19871 if (!pattern_defined
&& expl_inst_class_mem_p
19872 && DECL_EXPLICIT_INSTANTIATION (d
))
19874 /* Leave linkage flags alone on instantiations with anonymous
19876 if (TREE_PUBLIC (d
))
19878 DECL_NOT_REALLY_EXTERN (d
) = 0;
19879 DECL_INTERFACE_KNOWN (d
) = 0;
19881 SET_DECL_IMPLICIT_INSTANTIATION (d
);
19884 /* Defer all other templates, unless we have been explicitly
19885 forbidden from doing so. */
19886 if (/* If there is no definition, we cannot instantiate the
19889 /* If it's OK to postpone instantiation, do so. */
19891 /* If this is a static data member that will be defined
19892 elsewhere, we don't want to instantiate the entire data
19893 member, but we do want to instantiate the initializer so that
19894 we can substitute that elsewhere. */
19895 || (external_p
&& VAR_P (d
))
19896 /* Handle here a deleted function too, avoid generating
19897 its body (c++/61080). */
19900 /* The definition of the static data member is now required so
19901 we must substitute the initializer. */
19903 && !DECL_INITIAL (d
)
19904 && DECL_INITIAL (code_pattern
))
19908 bool const_init
= false;
19910 ns
= decl_namespace_context (d
);
19911 push_nested_namespace (ns
);
19912 push_nested_class (DECL_CONTEXT (d
));
19913 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
19915 tf_warning_or_error
, NULL_TREE
,
19916 /*integral_constant_expression_p=*/false);
19917 /* Make sure the initializer is still constant, in case of
19918 circular dependency (template/instantiate6.C). */
19920 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19921 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
19922 /*asmspec_tree=*/NULL_TREE
,
19923 LOOKUP_ONLYCONVERTING
);
19924 pop_nested_class ();
19925 pop_nested_namespace (ns
);
19928 /* We restore the source position here because it's used by
19929 add_pending_template. */
19930 input_location
= saved_loc
;
19932 if (at_eof
&& !pattern_defined
19933 && DECL_EXPLICIT_INSTANTIATION (d
)
19934 && DECL_NOT_REALLY_EXTERN (d
))
19937 The definition of a non-exported function template, a
19938 non-exported member function template, or a non-exported
19939 member function or static data member of a class template
19940 shall be present in every translation unit in which it is
19941 explicitly instantiated. */
19942 permerror (input_location
, "explicit instantiation of %qD "
19943 "but no definition available", d
);
19945 /* If we're in unevaluated context, we just wanted to get the
19946 constant value; this isn't an odr use, so don't queue
19947 a full instantiation. */
19948 if (cp_unevaluated_operand
!= 0)
19950 /* ??? Historically, we have instantiated inline functions, even
19951 when marked as "extern template". */
19952 if (!(external_p
&& VAR_P (d
)))
19953 add_pending_template (d
);
19956 /* Tell the repository that D is available in this translation unit
19957 -- and see if it is supposed to be instantiated here. */
19958 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
19960 /* In a PCH file, despite the fact that the repository hasn't
19961 requested instantiation in the PCH it is still possible that
19962 an instantiation will be required in a file that includes the
19965 add_pending_template (d
);
19966 /* Instantiate inline functions so that the inliner can do its
19967 job, even though we'll not be emitting a copy of this
19969 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
19973 fn_context
= decl_function_context (d
);
19974 nested
= (current_function_decl
!= NULL_TREE
);
19976 push_to_top_level ();
19980 push_function_context ();
19981 cp_unevaluated_operand
= 0;
19982 c_inhibit_evaluation_warnings
= 0;
19985 /* Mark D as instantiated so that recursive calls to
19986 instantiate_decl do not try to instantiate it again. */
19987 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
19989 /* Regenerate the declaration in case the template has been modified
19990 by a subsequent redeclaration. */
19991 regenerate_decl_from_template (d
, td
);
19993 /* We already set the file and line above. Reset them now in case
19994 they changed as a result of calling regenerate_decl_from_template. */
19995 input_location
= DECL_SOURCE_LOCATION (d
);
20000 bool const_init
= false;
20002 /* Clear out DECL_RTL; whatever was there before may not be right
20003 since we've reset the type of the declaration. */
20004 SET_DECL_RTL (d
, NULL
);
20005 DECL_IN_AGGR_P (d
) = 0;
20007 /* The initializer is placed in DECL_INITIAL by
20008 regenerate_decl_from_template so we don't need to
20009 push/pop_access_scope again here. Pull it out so that
20010 cp_finish_decl can process it. */
20011 init
= DECL_INITIAL (d
);
20012 DECL_INITIAL (d
) = NULL_TREE
;
20013 DECL_INITIALIZED_P (d
) = 0;
20015 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20016 initializer. That function will defer actual emission until
20017 we have a chance to determine linkage. */
20018 DECL_EXTERNAL (d
) = 0;
20020 /* Enter the scope of D so that access-checking works correctly. */
20021 push_nested_class (DECL_CONTEXT (d
));
20022 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20023 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
20024 pop_nested_class ();
20026 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
20027 synthesize_method (d
);
20028 else if (TREE_CODE (d
) == FUNCTION_DECL
)
20030 struct pointer_map_t
*saved_local_specializations
;
20034 tree block
= NULL_TREE
;
20036 /* Save away the current list, in case we are instantiating one
20037 template from within the body of another. */
20038 saved_local_specializations
= local_specializations
;
20040 /* Set up the list of local specializations. */
20041 local_specializations
= pointer_map_create ();
20043 /* Set up context. */
20044 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20045 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20046 block
= push_stmt_list ();
20048 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
20050 /* Some typedefs referenced from within the template code need to be
20051 access checked at template instantiation time, i.e now. These
20052 types were added to the template at parsing time. Let's get those
20053 and perform the access checks then. */
20054 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20057 /* Create substitution entries for the parameters. */
20058 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20059 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20060 spec_parm
= DECL_ARGUMENTS (d
);
20061 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20063 register_local_specialization (spec_parm
, tmpl_parm
);
20064 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20065 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20067 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20069 if (!DECL_PACK_P (tmpl_parm
))
20071 register_local_specialization (spec_parm
, tmpl_parm
);
20072 spec_parm
= DECL_CHAIN (spec_parm
);
20076 /* Register the (value) argument pack as a specialization of
20077 TMPL_PARM, then move on. */
20078 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20079 register_local_specialization (argpack
, tmpl_parm
);
20082 gcc_assert (!spec_parm
);
20084 /* Substitute into the body of the function. */
20085 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20086 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20087 tf_warning_or_error
, tmpl
);
20090 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20091 tf_warning_or_error
, tmpl
,
20092 /*integral_constant_expression_p=*/false);
20094 /* Set the current input_location to the end of the function
20095 so that finish_function knows where we are. */
20097 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20099 /* Remember if we saw an infinite loop in the template. */
20100 current_function_infinite_loop
20101 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20104 /* We don't need the local specializations any more. */
20105 pointer_map_destroy (local_specializations
);
20106 local_specializations
= saved_local_specializations
;
20108 /* Finish the function. */
20109 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20110 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20111 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20114 d
= finish_function (0);
20115 expand_or_defer_fn (d
);
20118 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20119 cp_check_omp_declare_reduction (d
);
20122 /* We're not deferring instantiation any more. */
20123 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20126 pop_from_top_level ();
20128 pop_function_context ();
20131 input_location
= saved_loc
;
20132 cp_unevaluated_operand
= saved_unevaluated_operand
;
20133 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20134 pop_deferring_access_checks ();
20135 pop_tinst_level ();
20137 timevar_pop (TV_TEMPLATE_INST
);
20142 /* Run through the list of templates that we wish we could
20143 instantiate, and instantiate any we can. RETRIES is the
20144 number of times we retry pending template instantiation. */
20147 instantiate_pending_templates (int retries
)
20150 location_t saved_loc
= input_location
;
20152 /* Instantiating templates may trigger vtable generation. This in turn
20153 may require further template instantiations. We place a limit here
20154 to avoid infinite loop. */
20155 if (pending_templates
&& retries
>= max_tinst_depth
)
20157 tree decl
= pending_templates
->tinst
->decl
;
20159 error ("template instantiation depth exceeds maximum of %d"
20160 " instantiating %q+D, possibly from virtual table generation"
20161 " (use -ftemplate-depth= to increase the maximum)",
20162 max_tinst_depth
, decl
);
20163 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20164 /* Pretend that we defined it. */
20165 DECL_INITIAL (decl
) = error_mark_node
;
20171 struct pending_template
**t
= &pending_templates
;
20172 struct pending_template
*last
= NULL
;
20176 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20177 bool complete
= false;
20179 if (TYPE_P (instantiation
))
20183 if (!COMPLETE_TYPE_P (instantiation
))
20185 instantiate_class_template (instantiation
);
20186 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20187 for (fn
= TYPE_METHODS (instantiation
);
20189 fn
= TREE_CHAIN (fn
))
20190 if (! DECL_ARTIFICIAL (fn
))
20191 instantiate_decl (fn
,
20193 /*expl_inst_class_mem_p=*/false);
20194 if (COMPLETE_TYPE_P (instantiation
))
20198 complete
= COMPLETE_TYPE_P (instantiation
);
20202 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20203 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20206 = instantiate_decl (instantiation
,
20208 /*expl_inst_class_mem_p=*/false);
20209 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20213 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20214 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20218 /* If INSTANTIATION has been instantiated, then we don't
20219 need to consider it again in the future. */
20227 current_tinst_level
= NULL
;
20229 last_pending_template
= last
;
20231 while (reconsider
);
20233 input_location
= saved_loc
;
20236 /* Substitute ARGVEC into T, which is a list of initializers for
20237 either base class or a non-static data member. The TREE_PURPOSEs
20238 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20239 instantiate_decl. */
20242 tsubst_initializer_list (tree t
, tree argvec
)
20244 tree inits
= NULL_TREE
;
20246 for (; t
; t
= TREE_CHAIN (t
))
20250 tree expanded_bases
= NULL_TREE
;
20251 tree expanded_arguments
= NULL_TREE
;
20254 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20259 /* Expand the base class expansion type into separate base
20261 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20262 tf_warning_or_error
,
20264 if (expanded_bases
== error_mark_node
)
20267 /* We'll be building separate TREE_LISTs of arguments for
20269 len
= TREE_VEC_LENGTH (expanded_bases
);
20270 expanded_arguments
= make_tree_vec (len
);
20271 for (i
= 0; i
< len
; i
++)
20272 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20274 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20275 expand each argument in the TREE_VALUE of t. */
20276 expr
= make_node (EXPR_PACK_EXPANSION
);
20277 PACK_EXPANSION_LOCAL_P (expr
) = true;
20278 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20279 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20281 if (TREE_VALUE (t
) == void_type_node
)
20282 /* VOID_TYPE_NODE is used to indicate
20283 value-initialization. */
20285 for (i
= 0; i
< len
; i
++)
20286 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20290 /* Substitute parameter packs into each argument in the
20292 in_base_initializer
= 1;
20293 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20295 tree expanded_exprs
;
20297 /* Expand the argument. */
20298 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20300 = tsubst_pack_expansion (expr
, argvec
,
20301 tf_warning_or_error
,
20303 if (expanded_exprs
== error_mark_node
)
20306 /* Prepend each of the expanded expressions to the
20307 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20308 for (i
= 0; i
< len
; i
++)
20310 TREE_VEC_ELT (expanded_arguments
, i
) =
20311 tree_cons (NULL_TREE
,
20312 TREE_VEC_ELT (expanded_exprs
, i
),
20313 TREE_VEC_ELT (expanded_arguments
, i
));
20316 in_base_initializer
= 0;
20318 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20319 since we built them backwards. */
20320 for (i
= 0; i
< len
; i
++)
20322 TREE_VEC_ELT (expanded_arguments
, i
) =
20323 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20328 for (i
= 0; i
< len
; ++i
)
20330 if (expanded_bases
)
20332 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20333 decl
= expand_member_init (decl
);
20334 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20339 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20340 tf_warning_or_error
, NULL_TREE
);
20342 decl
= expand_member_init (decl
);
20343 if (decl
&& !DECL_P (decl
))
20344 in_base_initializer
= 1;
20346 init
= TREE_VALUE (t
);
20348 if (init
!= void_type_node
)
20349 init
= tsubst_expr (init
, argvec
,
20350 tf_warning_or_error
, NULL_TREE
,
20351 /*integral_constant_expression_p=*/false);
20352 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20353 /* If we had an initializer but it instantiated to nothing,
20354 value-initialize the object. This will only occur when
20355 the initializer was a pack expansion where the parameter
20356 packs used in that expansion were of length zero. */
20357 init
= void_type_node
;
20358 in_base_initializer
= 0;
20363 init
= build_tree_list (decl
, init
);
20364 TREE_CHAIN (init
) = inits
;
20372 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20375 set_current_access_from_decl (tree decl
)
20377 if (TREE_PRIVATE (decl
))
20378 current_access_specifier
= access_private_node
;
20379 else if (TREE_PROTECTED (decl
))
20380 current_access_specifier
= access_protected_node
;
20382 current_access_specifier
= access_public_node
;
20385 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20386 is the instantiation (which should have been created with
20387 start_enum) and ARGS are the template arguments to use. */
20390 tsubst_enum (tree tag
, tree newtag
, tree args
)
20394 if (SCOPED_ENUM_P (newtag
))
20395 begin_scope (sk_scoped_enum
, newtag
);
20397 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20402 decl
= TREE_VALUE (e
);
20403 /* Note that in a template enum, the TREE_VALUE is the
20404 CONST_DECL, not the corresponding INTEGER_CST. */
20405 value
= tsubst_expr (DECL_INITIAL (decl
),
20406 args
, tf_warning_or_error
, NULL_TREE
,
20407 /*integral_constant_expression_p=*/true);
20409 /* Give this enumeration constant the correct access. */
20410 set_current_access_from_decl (decl
);
20412 /* Actually build the enumerator itself. */
20414 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
20417 if (SCOPED_ENUM_P (newtag
))
20420 finish_enum_value_list (newtag
);
20421 finish_enum (newtag
);
20423 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20424 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20427 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20428 its type -- but without substituting the innermost set of template
20429 arguments. So, innermost set of template parameters will appear in
20433 get_mostly_instantiated_function_type (tree decl
)
20441 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
20442 targs
= DECL_TI_ARGS (decl
);
20443 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
20444 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
20446 /* There should be as many levels of arguments as there are levels
20448 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
20450 fn_type
= TREE_TYPE (tmpl
);
20452 if (parm_depth
== 1)
20453 /* No substitution is necessary. */
20460 /* Replace the innermost level of the TARGS with NULL_TREEs to
20461 let tsubst know not to substitute for those parameters. */
20462 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20463 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
20464 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
20465 TMPL_ARGS_LEVEL (targs
, i
));
20466 SET_TMPL_ARGS_LEVEL (partial_args
,
20467 TMPL_ARGS_DEPTH (targs
),
20468 make_tree_vec (DECL_NTPARMS (tmpl
)));
20470 /* Make sure that we can see identifiers, and compute access
20472 push_access_scope (decl
);
20474 ++processing_template_decl
;
20475 /* Now, do the (partial) substitution to figure out the
20476 appropriate function type. */
20477 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
20478 --processing_template_decl
;
20480 /* Substitute into the template parameters to obtain the real
20481 innermost set of parameters. This step is important if the
20482 innermost set of template parameters contains value
20483 parameters whose types depend on outer template parameters. */
20484 TREE_VEC_LENGTH (partial_args
)--;
20485 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
20487 pop_access_scope (decl
);
20493 /* Return truthvalue if we're processing a template different from
20494 the last one involved in diagnostics. */
20496 problematic_instantiation_changed (void)
20498 return current_tinst_level
!= last_error_tinst_level
;
20501 /* Remember current template involved in diagnostics. */
20503 record_last_problematic_instantiation (void)
20505 last_error_tinst_level
= current_tinst_level
;
20508 struct tinst_level
*
20509 current_instantiation (void)
20511 return current_tinst_level
;
20514 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20515 type. Return zero for ok, nonzero for disallowed. Issue error and
20516 warning messages under control of COMPLAIN. */
20519 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20521 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20523 else if (POINTER_TYPE_P (type
))
20525 else if (TYPE_PTRMEM_P (type
))
20527 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20529 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20531 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20533 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20536 if (complain
& tf_error
)
20538 if (type
== error_mark_node
)
20539 inform (input_location
, "invalid template non-type parameter");
20541 error ("%q#T is not a valid type for a template non-type parameter",
20547 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20548 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20551 dependent_type_p_r (tree type
)
20557 A type is dependent if it is:
20559 -- a template parameter. Template template parameters are types
20560 for us (since TYPE_P holds true for them) so we handle
20562 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20563 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20565 /* -- a qualified-id with a nested-name-specifier which contains a
20566 class-name that names a dependent type or whose unqualified-id
20567 names a dependent type. */
20568 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20570 /* -- a cv-qualified type where the cv-unqualified type is
20572 type
= TYPE_MAIN_VARIANT (type
);
20573 /* -- a compound type constructed from any dependent type. */
20574 if (TYPE_PTRMEM_P (type
))
20575 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20576 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20578 else if (TYPE_PTR_P (type
)
20579 || TREE_CODE (type
) == REFERENCE_TYPE
)
20580 return dependent_type_p (TREE_TYPE (type
));
20581 else if (TREE_CODE (type
) == FUNCTION_TYPE
20582 || TREE_CODE (type
) == METHOD_TYPE
)
20586 if (dependent_type_p (TREE_TYPE (type
)))
20588 for (arg_type
= TYPE_ARG_TYPES (type
);
20590 arg_type
= TREE_CHAIN (arg_type
))
20591 if (dependent_type_p (TREE_VALUE (arg_type
)))
20595 /* -- an array type constructed from any dependent type or whose
20596 size is specified by a constant expression that is
20599 We checked for type- and value-dependence of the bounds in
20600 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20601 if (TREE_CODE (type
) == ARRAY_TYPE
)
20603 if (TYPE_DOMAIN (type
)
20604 && dependent_type_p (TYPE_DOMAIN (type
)))
20606 return dependent_type_p (TREE_TYPE (type
));
20609 /* -- a template-id in which either the template name is a template
20611 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20613 /* ... or any of the template arguments is a dependent type or
20614 an expression that is type-dependent or value-dependent. */
20615 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
20616 && (any_dependent_template_arguments_p
20617 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
20620 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20621 dependent; if the argument of the `typeof' expression is not
20622 type-dependent, then it should already been have resolved. */
20623 if (TREE_CODE (type
) == TYPEOF_TYPE
20624 || TREE_CODE (type
) == DECLTYPE_TYPE
20625 || TREE_CODE (type
) == UNDERLYING_TYPE
)
20628 /* A template argument pack is dependent if any of its packed
20630 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
20632 tree args
= ARGUMENT_PACK_ARGS (type
);
20633 int i
, len
= TREE_VEC_LENGTH (args
);
20634 for (i
= 0; i
< len
; ++i
)
20635 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20639 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20640 be template parameters. */
20641 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
20644 /* The standard does not specifically mention types that are local
20645 to template functions or local classes, but they should be
20646 considered dependent too. For example:
20648 template <int I> void f() {
20653 The size of `E' cannot be known until the value of `I' has been
20654 determined. Therefore, `E' must be considered dependent. */
20655 scope
= TYPE_CONTEXT (type
);
20656 if (scope
&& TYPE_P (scope
))
20657 return dependent_type_p (scope
);
20658 /* Don't use type_dependent_expression_p here, as it can lead
20659 to infinite recursion trying to determine whether a lambda
20660 nested in a lambda is dependent (c++/47687). */
20661 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
20662 && DECL_LANG_SPECIFIC (scope
)
20663 && DECL_TEMPLATE_INFO (scope
)
20664 && (any_dependent_template_arguments_p
20665 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
20668 /* Other types are non-dependent. */
20672 /* Returns TRUE if TYPE is dependent, in the sense of
20673 [temp.dep.type]. Note that a NULL type is considered dependent. */
20676 dependent_type_p (tree type
)
20678 /* If there are no template parameters in scope, then there can't be
20679 any dependent types. */
20680 if (!processing_template_decl
)
20682 /* If we are not processing a template, then nobody should be
20683 providing us with a dependent type. */
20685 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
20689 /* If the type is NULL, we have not computed a type for the entity
20690 in question; in that case, the type is dependent. */
20694 /* Erroneous types can be considered non-dependent. */
20695 if (type
== error_mark_node
)
20698 /* If we have not already computed the appropriate value for TYPE,
20700 if (!TYPE_DEPENDENT_P_VALID (type
))
20702 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
20703 TYPE_DEPENDENT_P_VALID (type
) = 1;
20706 return TYPE_DEPENDENT_P (type
);
20709 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20710 lookup. In other words, a dependent type that is not the current
20714 dependent_scope_p (tree scope
)
20716 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
20717 && !currently_open_class (scope
));
20720 /* T is a SCOPE_REF; return whether we need to consider it
20721 instantiation-dependent so that we can check access at instantiation
20722 time even though we know which member it resolves to. */
20725 instantiation_dependent_scope_ref_p (tree t
)
20727 if (DECL_P (TREE_OPERAND (t
, 1))
20728 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
20729 && accessible_in_template_p (TREE_OPERAND (t
, 0),
20730 TREE_OPERAND (t
, 1)))
20736 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20737 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20740 /* Note that this predicate is not appropriate for general expressions;
20741 only constant expressions (that satisfy potential_constant_expression)
20742 can be tested for value dependence. */
20745 value_dependent_expression_p (tree expression
)
20747 if (!processing_template_decl
)
20750 /* A name declared with a dependent type. */
20751 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
20754 switch (TREE_CODE (expression
))
20756 case IDENTIFIER_NODE
:
20757 /* A name that has not been looked up -- must be dependent. */
20760 case TEMPLATE_PARM_INDEX
:
20761 /* A non-type template parm. */
20765 /* A non-type template parm. */
20766 if (DECL_TEMPLATE_PARM_P (expression
))
20768 return value_dependent_expression_p (DECL_INITIAL (expression
));
20771 /* A constant with literal type and is initialized
20772 with an expression that is value-dependent.
20774 Note that a non-dependent parenthesized initializer will have
20775 already been replaced with its constant value, so if we see
20776 a TREE_LIST it must be dependent. */
20777 if (DECL_INITIAL (expression
)
20778 && decl_constant_var_p (expression
)
20779 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
20780 || value_dependent_expression_p (DECL_INITIAL (expression
))))
20784 case DYNAMIC_CAST_EXPR
:
20785 case STATIC_CAST_EXPR
:
20786 case CONST_CAST_EXPR
:
20787 case REINTERPRET_CAST_EXPR
:
20789 /* These expressions are value-dependent if the type to which
20790 the cast occurs is dependent or the expression being casted
20791 is value-dependent. */
20793 tree type
= TREE_TYPE (expression
);
20795 if (dependent_type_p (type
))
20798 /* A functional cast has a list of operands. */
20799 expression
= TREE_OPERAND (expression
, 0);
20802 /* If there are no operands, it must be an expression such
20803 as "int()". This should not happen for aggregate types
20804 because it would form non-constant expressions. */
20805 gcc_assert (cxx_dialect
>= cxx11
20806 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
20811 if (TREE_CODE (expression
) == TREE_LIST
)
20812 return any_value_dependent_elements_p (expression
);
20814 return value_dependent_expression_p (expression
);
20818 if (SIZEOF_EXPR_TYPE_P (expression
))
20819 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
20823 /* A `sizeof' expression is value-dependent if the operand is
20824 type-dependent or is a pack expansion. */
20825 expression
= TREE_OPERAND (expression
, 0);
20826 if (PACK_EXPANSION_P (expression
))
20828 else if (TYPE_P (expression
))
20829 return dependent_type_p (expression
);
20830 return instantiation_dependent_expression_p (expression
);
20832 case AT_ENCODE_EXPR
:
20833 /* An 'encode' expression is value-dependent if the operand is
20835 expression
= TREE_OPERAND (expression
, 0);
20836 return dependent_type_p (expression
);
20838 case NOEXCEPT_EXPR
:
20839 expression
= TREE_OPERAND (expression
, 0);
20840 return instantiation_dependent_expression_p (expression
);
20843 /* All instantiation-dependent expressions should also be considered
20844 value-dependent. */
20845 return instantiation_dependent_scope_ref_p (expression
);
20847 case COMPONENT_REF
:
20848 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
20849 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
20851 case NONTYPE_ARGUMENT_PACK
:
20852 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
20853 is value-dependent. */
20855 tree values
= ARGUMENT_PACK_ARGS (expression
);
20856 int i
, len
= TREE_VEC_LENGTH (values
);
20858 for (i
= 0; i
< len
; ++i
)
20859 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
20867 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
20868 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
20869 || (type2
? dependent_type_p (type2
) : false));
20873 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20874 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
20877 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20878 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
20882 tree op
= TREE_OPERAND (expression
, 0);
20883 return (value_dependent_expression_p (op
)
20884 || has_value_dependent_address (op
));
20889 tree fn
= get_callee_fndecl (expression
);
20891 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
20893 nargs
= call_expr_nargs (expression
);
20894 for (i
= 0; i
< nargs
; ++i
)
20896 tree op
= CALL_EXPR_ARG (expression
, i
);
20897 /* In a call to a constexpr member function, look through the
20898 implicit ADDR_EXPR on the object argument so that it doesn't
20899 cause the call to be considered value-dependent. We also
20900 look through it in potential_constant_expression. */
20901 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
20902 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
20903 && TREE_CODE (op
) == ADDR_EXPR
)
20904 op
= TREE_OPERAND (op
, 0);
20905 if (value_dependent_expression_p (op
))
20911 case TEMPLATE_ID_EXPR
:
20912 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
20914 return type_dependent_expression_p (expression
);
20920 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
20921 if (value_dependent_expression_p (val
))
20927 /* Treat a GNU statement expression as dependent to avoid crashing
20928 under fold_non_dependent_expr; it can't be constant. */
20932 /* A constant expression is value-dependent if any subexpression is
20933 value-dependent. */
20934 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
20936 case tcc_reference
:
20938 case tcc_comparison
:
20940 case tcc_expression
:
20943 int i
, len
= cp_tree_operand_length (expression
);
20945 for (i
= 0; i
< len
; i
++)
20947 tree t
= TREE_OPERAND (expression
, i
);
20949 /* In some cases, some of the operands may be missing.l
20950 (For example, in the case of PREDECREMENT_EXPR, the
20951 amount to increment by may be missing.) That doesn't
20952 make the expression dependent. */
20953 if (t
&& value_dependent_expression_p (t
))
20964 /* The expression is not value-dependent. */
20968 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
20969 [temp.dep.expr]. Note that an expression with no type is
20970 considered dependent. Other parts of the compiler arrange for an
20971 expression with type-dependent subexpressions to have no type, so
20972 this function doesn't have to be fully recursive. */
20975 type_dependent_expression_p (tree expression
)
20977 if (!processing_template_decl
)
20980 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
20983 /* An unresolved name is always dependent. */
20984 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
20987 /* Some expression forms are never type-dependent. */
20988 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
20989 || TREE_CODE (expression
) == SIZEOF_EXPR
20990 || TREE_CODE (expression
) == ALIGNOF_EXPR
20991 || TREE_CODE (expression
) == AT_ENCODE_EXPR
20992 || TREE_CODE (expression
) == NOEXCEPT_EXPR
20993 || TREE_CODE (expression
) == TRAIT_EXPR
20994 || TREE_CODE (expression
) == TYPEID_EXPR
20995 || TREE_CODE (expression
) == DELETE_EXPR
20996 || TREE_CODE (expression
) == VEC_DELETE_EXPR
20997 || TREE_CODE (expression
) == THROW_EXPR
)
21000 /* The types of these expressions depends only on the type to which
21001 the cast occurs. */
21002 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
21003 || TREE_CODE (expression
) == STATIC_CAST_EXPR
21004 || TREE_CODE (expression
) == CONST_CAST_EXPR
21005 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
21006 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
21007 || TREE_CODE (expression
) == CAST_EXPR
)
21008 return dependent_type_p (TREE_TYPE (expression
));
21010 /* The types of these expressions depends only on the type created
21011 by the expression. */
21012 if (TREE_CODE (expression
) == NEW_EXPR
21013 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
21015 /* For NEW_EXPR tree nodes created inside a template, either
21016 the object type itself or a TREE_LIST may appear as the
21018 tree type
= TREE_OPERAND (expression
, 1);
21019 if (TREE_CODE (type
) == TREE_LIST
)
21020 /* This is an array type. We need to check array dimensions
21022 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
21023 || value_dependent_expression_p
21024 (TREE_OPERAND (TREE_VALUE (type
), 1));
21026 return dependent_type_p (type
);
21029 if (TREE_CODE (expression
) == SCOPE_REF
)
21031 tree scope
= TREE_OPERAND (expression
, 0);
21032 tree name
= TREE_OPERAND (expression
, 1);
21034 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21035 contains an identifier associated by name lookup with one or more
21036 declarations declared with a dependent type, or...a
21037 nested-name-specifier or qualified-id that names a member of an
21038 unknown specialization. */
21039 return (type_dependent_expression_p (name
)
21040 || dependent_scope_p (scope
));
21043 if (TREE_CODE (expression
) == FUNCTION_DECL
21044 && DECL_LANG_SPECIFIC (expression
)
21045 && DECL_TEMPLATE_INFO (expression
)
21046 && (any_dependent_template_arguments_p
21047 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
21050 if (TREE_CODE (expression
) == TEMPLATE_DECL
21051 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
21054 if (TREE_CODE (expression
) == STMT_EXPR
)
21055 expression
= stmt_expr_value_expr (expression
);
21057 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21062 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21064 if (type_dependent_expression_p (elt
))
21070 /* A static data member of the current instantiation with incomplete
21071 array type is type-dependent, as the definition and specializations
21072 can have different bounds. */
21073 if (VAR_P (expression
)
21074 && DECL_CLASS_SCOPE_P (expression
)
21075 && dependent_type_p (DECL_CONTEXT (expression
))
21076 && VAR_HAD_UNKNOWN_BOUND (expression
))
21079 /* An array of unknown bound depending on a variadic parameter, eg:
21081 template<typename... Args>
21082 void foo (Args... args)
21084 int arr[] = { args... };
21087 template<int... vals>
21090 int arr[] = { vals... };
21093 If the array has no length and has an initializer, it must be that
21094 we couldn't determine its length in cp_complete_array_type because
21095 it is dependent. */
21096 if (VAR_P (expression
)
21097 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21098 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21099 && DECL_INITIAL (expression
))
21102 if (TREE_TYPE (expression
) == unknown_type_node
)
21104 if (TREE_CODE (expression
) == ADDR_EXPR
)
21105 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21106 if (TREE_CODE (expression
) == COMPONENT_REF
21107 || TREE_CODE (expression
) == OFFSET_REF
)
21109 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21111 expression
= TREE_OPERAND (expression
, 1);
21112 if (identifier_p (expression
))
21115 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21116 if (TREE_CODE (expression
) == SCOPE_REF
)
21119 /* Always dependent, on the number of arguments if nothing else. */
21120 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21123 if (BASELINK_P (expression
))
21125 if (BASELINK_OPTYPE (expression
)
21126 && dependent_type_p (BASELINK_OPTYPE (expression
)))
21128 expression
= BASELINK_FUNCTIONS (expression
);
21131 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21133 if (any_dependent_template_arguments_p
21134 (TREE_OPERAND (expression
, 1)))
21136 expression
= TREE_OPERAND (expression
, 0);
21138 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21139 || TREE_CODE (expression
) == FUNCTION_DECL
);
21143 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21145 expression
= OVL_NEXT (expression
);
21150 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21152 return (dependent_type_p (TREE_TYPE (expression
)));
21155 /* walk_tree callback function for instantiation_dependent_expression_p,
21156 below. Returns non-zero if a dependent subexpression is found. */
21159 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21164 /* We don't have to worry about decltype currently because decltype
21165 of an instantiation-dependent expr is a dependent type. This
21166 might change depending on the resolution of DR 1172. */
21167 *walk_subtrees
= false;
21170 enum tree_code code
= TREE_CODE (*tp
);
21173 /* Don't treat an argument list as dependent just because it has no
21181 /* A constant with a dependent initializer is dependent. */
21182 if (value_dependent_expression_p (*tp
))
21186 case TEMPLATE_PARM_INDEX
:
21189 /* Handle expressions with type operands. */
21193 case AT_ENCODE_EXPR
:
21195 tree op
= TREE_OPERAND (*tp
, 0);
21196 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21197 op
= TREE_TYPE (op
);
21200 if (dependent_type_p (op
))
21204 *walk_subtrees
= false;
21212 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21213 || (TRAIT_EXPR_TYPE2 (*tp
)
21214 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21216 *walk_subtrees
= false;
21219 case COMPONENT_REF
:
21220 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21221 /* In a template, finish_class_member_access_expr creates a
21222 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21223 type-dependent, so that we can check access control at
21224 instantiation time (PR 42277). See also Core issue 1273. */
21229 if (instantiation_dependent_scope_ref_p (*tp
))
21234 /* Treat statement-expressions as dependent. */
21242 if (type_dependent_expression_p (*tp
))
21248 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21249 sense defined by the ABI:
21251 "An expression is instantiation-dependent if it is type-dependent
21252 or value-dependent, or it has a subexpression that is type-dependent
21253 or value-dependent." */
21256 instantiation_dependent_expression_p (tree expression
)
21260 if (!processing_template_decl
)
21263 if (expression
== error_mark_node
)
21266 result
= cp_walk_tree_without_duplicates (&expression
,
21267 instantiation_dependent_r
, NULL
);
21268 return result
!= NULL_TREE
;
21271 /* Like type_dependent_expression_p, but it also works while not processing
21272 a template definition, i.e. during substitution or mangling. */
21275 type_dependent_expression_p_push (tree expr
)
21278 ++processing_template_decl
;
21279 b
= type_dependent_expression_p (expr
);
21280 --processing_template_decl
;
21284 /* Returns TRUE if ARGS contains a type-dependent expression. */
21287 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21292 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21294 if (type_dependent_expression_p (arg
))
21300 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21301 expressions) contains any type-dependent expressions. */
21304 any_type_dependent_elements_p (const_tree list
)
21306 for (; list
; list
= TREE_CHAIN (list
))
21307 if (type_dependent_expression_p (TREE_VALUE (list
)))
21313 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21314 expressions) contains any value-dependent expressions. */
21317 any_value_dependent_elements_p (const_tree list
)
21319 for (; list
; list
= TREE_CHAIN (list
))
21320 if (value_dependent_expression_p (TREE_VALUE (list
)))
21326 /* Returns TRUE if the ARG (a template argument) is dependent. */
21329 dependent_template_arg_p (tree arg
)
21331 if (!processing_template_decl
)
21334 /* Assume a template argument that was wrongly written by the user
21335 is dependent. This is consistent with what
21336 any_dependent_template_arguments_p [that calls this function]
21338 if (!arg
|| arg
== error_mark_node
)
21341 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21342 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21344 if (TREE_CODE (arg
) == TEMPLATE_DECL
21345 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21346 return dependent_template_p (arg
);
21347 else if (ARGUMENT_PACK_P (arg
))
21349 tree args
= ARGUMENT_PACK_ARGS (arg
);
21350 int i
, len
= TREE_VEC_LENGTH (args
);
21351 for (i
= 0; i
< len
; ++i
)
21353 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21359 else if (TYPE_P (arg
))
21360 return dependent_type_p (arg
);
21362 return (type_dependent_expression_p (arg
)
21363 || value_dependent_expression_p (arg
));
21366 /* Returns true if ARGS (a collection of template arguments) contains
21367 any types that require structural equality testing. */
21370 any_template_arguments_need_structural_equality_p (tree args
)
21377 if (args
== error_mark_node
)
21380 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21382 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21383 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21385 tree arg
= TREE_VEC_ELT (level
, j
);
21386 tree packed_args
= NULL_TREE
;
21389 if (ARGUMENT_PACK_P (arg
))
21391 /* Look inside the argument pack. */
21392 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21393 len
= TREE_VEC_LENGTH (packed_args
);
21396 for (k
= 0; k
< len
; ++k
)
21399 arg
= TREE_VEC_ELT (packed_args
, k
);
21401 if (error_operand_p (arg
))
21403 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21405 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21407 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21408 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21417 /* Returns true if ARGS (a collection of template arguments) contains
21418 any dependent arguments. */
21421 any_dependent_template_arguments_p (const_tree args
)
21428 if (args
== error_mark_node
)
21431 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21433 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21434 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21435 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21442 /* Returns TRUE if the template TMPL is dependent. */
21445 dependent_template_p (tree tmpl
)
21447 if (TREE_CODE (tmpl
) == OVERLOAD
)
21451 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21453 tmpl
= OVL_NEXT (tmpl
);
21458 /* Template template parameters are dependent. */
21459 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21460 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21462 /* So are names that have not been looked up. */
21463 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21465 /* So are member templates of dependent classes. */
21466 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21467 return dependent_type_p (DECL_CONTEXT (tmpl
));
21471 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21474 dependent_template_id_p (tree tmpl
, tree args
)
21476 return (dependent_template_p (tmpl
)
21477 || any_dependent_template_arguments_p (args
));
21480 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21484 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21488 if (!processing_template_decl
)
21491 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21493 tree decl
= TREE_VEC_ELT (declv
, i
);
21494 tree init
= TREE_VEC_ELT (initv
, i
);
21495 tree cond
= TREE_VEC_ELT (condv
, i
);
21496 tree incr
= TREE_VEC_ELT (incrv
, i
);
21498 if (type_dependent_expression_p (decl
))
21501 if (init
&& type_dependent_expression_p (init
))
21504 if (type_dependent_expression_p (cond
))
21507 if (COMPARISON_CLASS_P (cond
)
21508 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21509 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21512 if (TREE_CODE (incr
) == MODOP_EXPR
)
21514 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21515 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21518 else if (type_dependent_expression_p (incr
))
21520 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21522 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21524 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21526 tree t
= TREE_OPERAND (incr
, 1);
21527 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21528 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21537 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21538 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21539 no such TYPE can be found. Note that this function peers inside
21540 uninstantiated templates and therefore should be used only in
21541 extremely limited situations. ONLY_CURRENT_P restricts this
21542 peering to the currently open classes hierarchy (which is required
21543 when comparing types). */
21546 resolve_typename_type (tree type
, bool only_current_p
)
21555 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21557 scope
= TYPE_CONTEXT (type
);
21558 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21559 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21560 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21561 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21562 identifier of the TYPENAME_TYPE anymore.
21563 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21564 TYPENAME_TYPE instead, we avoid messing up with a possible
21565 typedef variant case. */
21566 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21568 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21569 it first before we can figure out what NAME refers to. */
21570 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21572 if (TYPENAME_IS_RESOLVING_P (scope
))
21573 /* Given a class template A with a dependent base with nested type C,
21574 typedef typename A::C::C C will land us here, as trying to resolve
21575 the initial A::C leads to the local C typedef, which leads back to
21576 A::C::C. So we break the recursion now. */
21579 scope
= resolve_typename_type (scope
, only_current_p
);
21581 /* If we don't know what SCOPE refers to, then we cannot resolve the
21583 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21585 /* If the SCOPE is a template type parameter, we have no way of
21586 resolving the name. */
21587 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21589 /* If the SCOPE is not the current instantiation, there's no reason
21590 to look inside it. */
21591 if (only_current_p
&& !currently_open_class (scope
))
21593 /* If this is a typedef, we don't want to look inside (c++/11987). */
21594 if (typedef_variant_p (type
))
21596 /* If SCOPE isn't the template itself, it will not have a valid
21597 TYPE_FIELDS list. */
21598 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21599 /* scope is either the template itself or a compatible instantiation
21600 like X<T>, so look up the name in the original template. */
21601 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
21603 /* scope is a partial instantiation, so we can't do the lookup or we
21604 will lose the template arguments. */
21606 /* Enter the SCOPE so that name lookup will be resolved as if we
21607 were in the class definition. In particular, SCOPE will no
21608 longer be considered a dependent type. */
21609 pushed_scope
= push_scope (scope
);
21610 /* Look up the declaration. */
21611 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
21612 tf_warning_or_error
);
21614 result
= NULL_TREE
;
21616 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21617 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21620 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
21621 && TREE_CODE (decl
) == TYPE_DECL
)
21623 result
= TREE_TYPE (decl
);
21624 if (result
== error_mark_node
)
21625 result
= NULL_TREE
;
21627 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
21628 && DECL_CLASS_TEMPLATE_P (decl
))
21632 /* Obtain the template and the arguments. */
21633 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
21634 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
21635 /* Instantiate the template. */
21636 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
21637 /*entering_scope=*/0,
21638 tf_error
| tf_user
);
21639 if (result
== error_mark_node
)
21640 result
= NULL_TREE
;
21643 /* Leave the SCOPE. */
21645 pop_scope (pushed_scope
);
21647 /* If we failed to resolve it, return the original typename. */
21651 /* If lookup found a typename type, resolve that too. */
21652 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
21654 /* Ill-formed programs can cause infinite recursion here, so we
21655 must catch that. */
21656 TYPENAME_IS_RESOLVING_P (type
) = 1;
21657 result
= resolve_typename_type (result
, only_current_p
);
21658 TYPENAME_IS_RESOLVING_P (type
) = 0;
21661 /* Qualify the resulting type. */
21662 quals
= cp_type_quals (type
);
21664 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
21669 /* EXPR is an expression which is not type-dependent. Return a proxy
21670 for EXPR that can be used to compute the types of larger
21671 expressions containing EXPR. */
21674 build_non_dependent_expr (tree expr
)
21678 #ifdef ENABLE_CHECKING
21679 /* Try to get a constant value for all non-dependent expressions in
21680 order to expose bugs in *_dependent_expression_p and constexpr. */
21681 if (cxx_dialect
>= cxx11
)
21682 maybe_constant_value (fold_non_dependent_expr_sfinae (expr
, tf_none
));
21685 /* Preserve OVERLOADs; the functions must be available to resolve
21688 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
21689 inner_expr
= stmt_expr_value_expr (inner_expr
);
21690 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
21691 inner_expr
= TREE_OPERAND (inner_expr
, 0);
21692 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
21693 inner_expr
= TREE_OPERAND (inner_expr
, 1);
21694 if (is_overloaded_fn (inner_expr
)
21695 || TREE_CODE (inner_expr
) == OFFSET_REF
)
21697 /* There is no need to return a proxy for a variable. */
21700 /* Preserve string constants; conversions from string constants to
21701 "char *" are allowed, even though normally a "const char *"
21702 cannot be used to initialize a "char *". */
21703 if (TREE_CODE (expr
) == STRING_CST
)
21705 /* Preserve void and arithmetic constants, as an optimization -- there is no
21706 reason to create a new node. */
21707 if (TREE_CODE (expr
) == VOID_CST
21708 || TREE_CODE (expr
) == INTEGER_CST
21709 || TREE_CODE (expr
) == REAL_CST
)
21711 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21712 There is at least one place where we want to know that a
21713 particular expression is a throw-expression: when checking a ?:
21714 expression, there are special rules if the second or third
21715 argument is a throw-expression. */
21716 if (TREE_CODE (expr
) == THROW_EXPR
)
21719 /* Don't wrap an initializer list, we need to be able to look inside. */
21720 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
21723 /* Don't wrap a dummy object, we need to be able to test for it. */
21724 if (is_dummy_object (expr
))
21727 if (TREE_CODE (expr
) == COND_EXPR
)
21728 return build3 (COND_EXPR
,
21730 TREE_OPERAND (expr
, 0),
21731 (TREE_OPERAND (expr
, 1)
21732 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
21733 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
21734 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
21735 if (TREE_CODE (expr
) == COMPOUND_EXPR
21736 && !COMPOUND_EXPR_OVERLOADED (expr
))
21737 return build2 (COMPOUND_EXPR
,
21739 TREE_OPERAND (expr
, 0),
21740 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
21742 /* If the type is unknown, it can't really be non-dependent */
21743 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
21745 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21746 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
21749 /* ARGS is a vector of expressions as arguments to a function call.
21750 Replace the arguments with equivalent non-dependent expressions.
21751 This modifies ARGS in place. */
21754 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
21759 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
21761 tree newarg
= build_non_dependent_expr (arg
);
21763 (*args
)[ix
] = newarg
;
21767 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21768 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21772 make_auto_1 (tree name
)
21774 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
21775 TYPE_NAME (au
) = build_decl (input_location
,
21776 TYPE_DECL
, name
, au
);
21777 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
21778 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
21779 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
21780 TYPE_NAME (au
), NULL_TREE
);
21781 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
21782 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
21783 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
21789 make_decltype_auto (void)
21791 return make_auto_1 (get_identifier ("decltype(auto)"));
21797 return make_auto_1 (get_identifier ("auto"));
21800 /* Given type ARG, return std::initializer_list<ARG>. */
21805 tree std_init_list
= namespace_binding
21806 (get_identifier ("initializer_list"), std_node
);
21808 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
21810 error ("deducing from brace-enclosed initializer list requires "
21811 "#include <initializer_list>");
21812 return error_mark_node
;
21814 argvec
= make_tree_vec (1);
21815 TREE_VEC_ELT (argvec
, 0) = arg
;
21816 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
21817 NULL_TREE
, 0, tf_warning_or_error
);
21820 /* Replace auto in TYPE with std::initializer_list<auto>. */
21823 listify_autos (tree type
, tree auto_node
)
21825 tree init_auto
= listify (auto_node
);
21826 tree argvec
= make_tree_vec (1);
21827 TREE_VEC_ELT (argvec
, 0) = init_auto
;
21828 if (processing_template_decl
)
21829 argvec
= add_to_template_args (current_template_args (), argvec
);
21830 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21833 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
21834 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
21837 do_auto_deduction (tree type
, tree init
, tree auto_node
)
21841 if (init
== error_mark_node
)
21842 return error_mark_node
;
21844 if (type_dependent_expression_p (init
))
21845 /* Defining a subset of type-dependent expressions that we can deduce
21846 from ahead of time isn't worth the trouble. */
21849 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
21850 with either a new invented type template parameter U or, if the
21851 initializer is a braced-init-list (8.5.4), with
21852 std::initializer_list<U>. */
21853 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
21854 type
= listify_autos (type
, auto_node
);
21856 init
= resolve_nondeduced_context (init
);
21858 targs
= make_tree_vec (1);
21859 if (AUTO_IS_DECLTYPE (auto_node
))
21861 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
21862 && !REF_PARENTHESIZED_P (init
)));
21863 TREE_VEC_ELT (targs
, 0)
21864 = finish_decltype_type (init
, id
, tf_warning_or_error
);
21865 if (type
!= auto_node
)
21867 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
21868 return error_mark_node
;
21873 tree parms
= build_tree_list (NULL_TREE
, type
);
21874 tree tparms
= make_tree_vec (1);
21877 TREE_VEC_ELT (tparms
, 0)
21878 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
21879 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
21880 DEDUCE_CALL
, LOOKUP_NORMAL
,
21881 NULL
, /*explain_p=*/false);
21884 if (processing_template_decl
)
21885 /* Try again at instantiation time. */
21887 if (type
&& type
!= error_mark_node
)
21888 /* If type is error_mark_node a diagnostic must have been
21889 emitted by now. Also, having a mention to '<type error>'
21890 in the diagnostic is not really useful to the user. */
21892 if (cfun
&& auto_node
== current_function_auto_return_pattern
21893 && LAMBDA_FUNCTION_P (current_function_decl
))
21894 error ("unable to deduce lambda return type from %qE", init
);
21896 error ("unable to deduce %qT from %qE", type
, init
);
21898 return error_mark_node
;
21902 /* If the list of declarators contains more than one declarator, the type
21903 of each declared variable is determined as described above. If the
21904 type deduced for the template parameter U is not the same in each
21905 deduction, the program is ill-formed. */
21906 if (TREE_TYPE (auto_node
)
21907 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
21909 if (cfun
&& auto_node
== current_function_auto_return_pattern
21910 && LAMBDA_FUNCTION_P (current_function_decl
))
21911 error ("inconsistent types %qT and %qT deduced for "
21912 "lambda return type", TREE_TYPE (auto_node
),
21913 TREE_VEC_ELT (targs
, 0));
21915 error ("inconsistent deduction for %qT: %qT and then %qT",
21916 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
21917 return error_mark_node
;
21919 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
21921 if (processing_template_decl
)
21922 targs
= add_to_template_args (current_template_args (), targs
);
21923 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
21926 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
21930 splice_late_return_type (tree type
, tree late_return_type
)
21934 if (late_return_type
== NULL_TREE
)
21936 argvec
= make_tree_vec (1);
21937 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
21938 if (processing_template_parmlist
)
21939 /* For a late-specified return type in a template type-parameter, we
21940 need to add a dummy argument level for its parmlist. */
21941 argvec
= add_to_template_args
21942 (make_tree_vec (processing_template_parmlist
), argvec
);
21943 if (current_template_parms
)
21944 argvec
= add_to_template_args (current_template_args (), argvec
);
21945 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21948 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
21949 'decltype(auto)'. */
21952 is_auto (const_tree type
)
21954 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
21955 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
21956 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
21962 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
21963 a use of `auto'. Returns NULL_TREE otherwise. */
21966 type_uses_auto (tree type
)
21968 return find_type_usage (type
, is_auto
);
21971 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
21972 'decltype(auto)' or a concept. */
21975 is_auto_or_concept (const_tree type
)
21977 return is_auto (type
); // or concept
21980 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
21981 a concept identifier) iff TYPE contains a use of a generic type. Returns
21982 NULL_TREE otherwise. */
21985 type_uses_auto_or_concept (tree type
)
21987 return find_type_usage (type
, is_auto_or_concept
);
21991 /* For a given template T, return the vector of typedefs referenced
21992 in T for which access check is needed at T instantiation time.
21993 T is either a FUNCTION_DECL or a RECORD_TYPE.
21994 Those typedefs were added to T by the function
21995 append_type_to_template_for_access_check. */
21997 vec
<qualified_typedef_usage_t
, va_gc
> *
21998 get_types_needing_access_check (tree t
)
22001 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
22003 if (!t
|| t
== error_mark_node
)
22006 if (!(ti
= get_template_info (t
)))
22009 if (CLASS_TYPE_P (t
)
22010 || TREE_CODE (t
) == FUNCTION_DECL
)
22012 if (!TI_TEMPLATE (ti
))
22015 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
22021 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22022 tied to T. That list of typedefs will be access checked at
22023 T instantiation time.
22024 T is either a FUNCTION_DECL or a RECORD_TYPE.
22025 TYPE_DECL is a TYPE_DECL node representing a typedef.
22026 SCOPE is the scope through which TYPE_DECL is accessed.
22027 LOCATION is the location of the usage point of TYPE_DECL.
22029 This function is a subroutine of
22030 append_type_to_template_for_access_check. */
22033 append_type_to_template_for_access_check_1 (tree t
,
22036 location_t location
)
22038 qualified_typedef_usage_t typedef_usage
;
22041 if (!t
|| t
== error_mark_node
)
22044 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
22045 || CLASS_TYPE_P (t
))
22047 && TREE_CODE (type_decl
) == TYPE_DECL
22050 if (!(ti
= get_template_info (t
)))
22053 gcc_assert (TI_TEMPLATE (ti
));
22055 typedef_usage
.typedef_decl
= type_decl
;
22056 typedef_usage
.context
= scope
;
22057 typedef_usage
.locus
= location
;
22059 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22062 /* Append TYPE_DECL to the template TEMPL.
22063 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22064 At TEMPL instanciation time, TYPE_DECL will be checked to see
22065 if it can be accessed through SCOPE.
22066 LOCATION is the location of the usage point of TYPE_DECL.
22068 e.g. consider the following code snippet:
22075 template<class U> struct S
22077 C::myint mi; // <-- usage point of the typedef C::myint
22082 At S<char> instantiation time, we need to check the access of C::myint
22083 In other words, we need to check the access of the myint typedef through
22084 the C scope. For that purpose, this function will add the myint typedef
22085 and the scope C through which its being accessed to a list of typedefs
22086 tied to the template S. That list will be walked at template instantiation
22087 time and access check performed on each typedefs it contains.
22088 Note that this particular code snippet should yield an error because
22089 myint is private to C. */
22092 append_type_to_template_for_access_check (tree templ
,
22095 location_t location
)
22097 qualified_typedef_usage_t
*iter
;
22100 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22102 /* Make sure we don't append the type to the template twice. */
22103 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22104 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22107 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22111 /* Convert the generic type parameters in PARM that match the types given in the
22112 range [START_IDX, END_IDX) from the current_template_parms into generic type
22116 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22118 tree current
= current_template_parms
;
22119 int depth
= TMPL_PARMS_DEPTH (current
);
22120 current
= INNERMOST_TEMPLATE_PARMS (current
);
22121 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22123 for (int i
= 0; i
< start_idx
; ++i
)
22124 TREE_VEC_ELT (replacement
, i
)
22125 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22127 for (int i
= start_idx
; i
< end_idx
; ++i
)
22129 /* Create a distinct parameter pack type from the current parm and add it
22130 to the replacement args to tsubst below into the generic function
22133 tree o
= TREE_TYPE (TREE_VALUE
22134 (TREE_VEC_ELT (current
, i
)));
22135 tree t
= copy_type (o
);
22136 TEMPLATE_TYPE_PARM_INDEX (t
)
22137 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22139 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22140 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22141 TYPE_MAIN_VARIANT (t
) = t
;
22142 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22143 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22144 TREE_VEC_ELT (replacement
, i
) = t
;
22145 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22148 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22149 TREE_VEC_ELT (replacement
, i
)
22150 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22152 /* If there are more levels then build up the replacement with the outer
22155 replacement
= add_to_template_args (template_parms_to_args
22156 (TREE_CHAIN (current_template_parms
)),
22159 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22163 /* Set up the hash tables for template instantiations. */
22166 init_template_processing (void)
22168 decl_specializations
= htab_create_ggc (37,
22169 hash_specialization
,
22170 eq_specializations
,
22172 type_specializations
= htab_create_ggc (37,
22173 hash_specialization
,
22174 eq_specializations
,
22178 /* Print stats about the template hash tables for -fstats. */
22181 print_template_statistics (void)
22183 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22184 "%f collisions\n", (long) htab_size (decl_specializations
),
22185 (long) htab_elements (decl_specializations
),
22186 htab_collisions (decl_specializations
));
22187 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22188 "%f collisions\n", (long) htab_size (type_specializations
),
22189 (long) htab_elements (type_specializations
),
22190 htab_collisions (type_specializations
));
22193 #include "gt-cp-pt.h"