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 struct pointer_set_t
*, 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 /* Register this specialization so that we can find it
2793 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
, 0);
2795 /* A 'structor should already have clones. */
2796 gcc_assert (decl
== error_mark_node
2797 || !(DECL_CONSTRUCTOR_P (decl
)
2798 || DECL_DESTRUCTOR_P (decl
))
2799 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
2806 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2807 parameters. These are represented in the same format used for
2808 DECL_TEMPLATE_PARMS. */
2811 comp_template_parms (const_tree parms1
, const_tree parms2
)
2816 if (parms1
== parms2
)
2819 for (p1
= parms1
, p2
= parms2
;
2820 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2821 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2823 tree t1
= TREE_VALUE (p1
);
2824 tree t2
= TREE_VALUE (p2
);
2827 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2828 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2830 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2833 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2835 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2836 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2838 /* If either of the template parameters are invalid, assume
2839 they match for the sake of error recovery. */
2840 if (error_operand_p (parm1
) || error_operand_p (parm2
))
2843 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2846 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2847 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2848 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2850 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2855 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2856 /* One set of parameters has more parameters lists than the
2863 /* Determine whether PARM is a parameter pack. */
2866 template_parameter_pack_p (const_tree parm
)
2868 /* Determine if we have a non-type template parameter pack. */
2869 if (TREE_CODE (parm
) == PARM_DECL
)
2870 return (DECL_TEMPLATE_PARM_P (parm
)
2871 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2872 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
2873 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
2875 /* If this is a list of template parameters, we could get a
2876 TYPE_DECL or a TEMPLATE_DECL. */
2877 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2878 parm
= TREE_TYPE (parm
);
2880 /* Otherwise it must be a type template parameter. */
2881 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2882 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2883 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2886 /* Determine if T is a function parameter pack. */
2889 function_parameter_pack_p (const_tree t
)
2891 if (t
&& TREE_CODE (t
) == PARM_DECL
)
2892 return DECL_PACK_P (t
);
2896 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2897 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2900 get_function_template_decl (const_tree primary_func_tmpl_inst
)
2902 if (! primary_func_tmpl_inst
2903 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
2904 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
2907 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
2910 /* Return true iff the function parameter PARAM_DECL was expanded
2911 from the function parameter pack PACK. */
2914 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
2916 if (DECL_ARTIFICIAL (param_decl
)
2917 || !function_parameter_pack_p (pack
))
2920 /* The parameter pack and its pack arguments have the same
2922 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
2925 /* Determine whether ARGS describes a variadic template args list,
2926 i.e., one that is terminated by a template argument pack. */
2929 template_args_variadic_p (tree args
)
2934 if (args
== NULL_TREE
)
2937 args
= INNERMOST_TEMPLATE_ARGS (args
);
2938 nargs
= TREE_VEC_LENGTH (args
);
2943 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
2945 return ARGUMENT_PACK_P (last_parm
);
2948 /* Generate a new name for the parameter pack name NAME (an
2949 IDENTIFIER_NODE) that incorporates its */
2952 make_ith_pack_parameter_name (tree name
, int i
)
2954 /* Munge the name to include the parameter index. */
2955 #define NUMBUF_LEN 128
2956 char numbuf
[NUMBUF_LEN
];
2960 if (name
== NULL_TREE
)
2962 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
2963 newname_len
= IDENTIFIER_LENGTH (name
)
2964 + strlen (numbuf
) + 2;
2965 newname
= (char*)alloca (newname_len
);
2966 snprintf (newname
, newname_len
,
2967 "%s#%i", IDENTIFIER_POINTER (name
), i
);
2968 return get_identifier (newname
);
2971 /* Return true if T is a primary function, class or alias template
2975 primary_template_instantiation_p (const_tree t
)
2980 if (TREE_CODE (t
) == FUNCTION_DECL
)
2981 return DECL_LANG_SPECIFIC (t
)
2982 && DECL_TEMPLATE_INSTANTIATION (t
)
2983 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
2984 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
2985 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
2986 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
2987 else if (alias_template_specialization_p (t
))
2992 /* Return true if PARM is a template template parameter. */
2995 template_template_parameter_p (const_tree parm
)
2997 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3000 /* Return true iff PARM is a DECL representing a type template
3004 template_type_parameter_p (const_tree parm
)
3007 && (TREE_CODE (parm
) == TYPE_DECL
3008 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3009 && DECL_TEMPLATE_PARM_P (parm
));
3012 /* Return the template parameters of T if T is a
3013 primary template instantiation, NULL otherwise. */
3016 get_primary_template_innermost_parameters (const_tree t
)
3018 tree parms
= NULL
, template_info
= NULL
;
3020 if ((template_info
= get_template_info (t
))
3021 && primary_template_instantiation_p (t
))
3022 parms
= INNERMOST_TEMPLATE_PARMS
3023 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3028 /* Return the template parameters of the LEVELth level from the full list
3029 of template parameters PARMS. */
3032 get_template_parms_at_level (tree parms
, int level
)
3036 || TREE_CODE (parms
) != TREE_LIST
3037 || level
> TMPL_PARMS_DEPTH (parms
))
3040 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3041 if (TMPL_PARMS_DEPTH (p
) == level
)
3047 /* Returns the template arguments of T if T is a template instantiation,
3051 get_template_innermost_arguments (const_tree t
)
3053 tree args
= NULL
, template_info
= NULL
;
3055 if ((template_info
= get_template_info (t
))
3056 && TI_ARGS (template_info
))
3057 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3062 /* Return the argument pack elements of T if T is a template argument pack,
3066 get_template_argument_pack_elems (const_tree t
)
3068 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3069 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3072 return ARGUMENT_PACK_ARGS (t
);
3075 /* Structure used to track the progress of find_parameter_packs_r. */
3076 struct find_parameter_pack_data
3078 /* TREE_LIST that will contain all of the parameter packs found by
3080 tree
* parameter_packs
;
3082 /* Set of AST nodes that have been visited by the traversal. */
3083 struct pointer_set_t
*visited
;
3086 /* Identifies all of the argument packs that occur in a template
3087 argument and appends them to the TREE_LIST inside DATA, which is a
3088 find_parameter_pack_data structure. This is a subroutine of
3089 make_pack_expansion and uses_parameter_packs. */
3091 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3094 struct find_parameter_pack_data
* ppd
=
3095 (struct find_parameter_pack_data
*)data
;
3096 bool parameter_pack_p
= false;
3098 /* Handle type aliases/typedefs. */
3099 if (TYPE_ALIAS_P (t
))
3101 if (TYPE_TEMPLATE_INFO (t
))
3102 cp_walk_tree (&TYPE_TI_ARGS (t
),
3103 &find_parameter_packs_r
,
3109 /* Identify whether this is a parameter pack or not. */
3110 switch (TREE_CODE (t
))
3112 case TEMPLATE_PARM_INDEX
:
3113 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3114 parameter_pack_p
= true;
3117 case TEMPLATE_TYPE_PARM
:
3118 t
= TYPE_MAIN_VARIANT (t
);
3119 case TEMPLATE_TEMPLATE_PARM
:
3120 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3121 parameter_pack_p
= true;
3126 if (DECL_PACK_P (t
))
3128 /* We don't want to walk into the type of a PARM_DECL,
3129 because we don't want to see the type parameter pack. */
3131 parameter_pack_p
= true;
3135 /* Look through a lambda capture proxy to the field pack. */
3137 if (DECL_HAS_VALUE_EXPR_P (t
))
3139 tree v
= DECL_VALUE_EXPR (t
);
3141 &find_parameter_packs_r
,
3148 parameter_pack_p
= true;
3151 /* Not a parameter pack. */
3155 if (parameter_pack_p
)
3157 /* Add this parameter pack to the list. */
3158 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3162 cp_walk_tree (&TYPE_CONTEXT (t
),
3163 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3165 /* This switch statement will return immediately if we don't find a
3167 switch (TREE_CODE (t
))
3169 case TEMPLATE_PARM_INDEX
:
3172 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3173 /* Check the template itself. */
3174 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3175 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3176 /* Check the template arguments. */
3177 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3182 case TEMPLATE_TYPE_PARM
:
3183 case TEMPLATE_TEMPLATE_PARM
:
3190 if (TYPE_PTRMEMFUNC_P (t
))
3196 if (TYPE_TEMPLATE_INFO (t
))
3197 cp_walk_tree (&TYPE_TI_ARGS (t
),
3198 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3205 cp_walk_tree (&TREE_TYPE (t
),
3206 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3210 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3215 case TYPE_PACK_EXPANSION
:
3216 case EXPR_PACK_EXPANSION
:
3221 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3226 case IDENTIFIER_NODE
:
3227 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3239 /* Determines if the expression or type T uses any parameter packs. */
3241 uses_parameter_packs (tree t
)
3243 tree parameter_packs
= NULL_TREE
;
3244 struct find_parameter_pack_data ppd
;
3245 ppd
.parameter_packs
= ¶meter_packs
;
3246 ppd
.visited
= pointer_set_create ();
3247 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3248 pointer_set_destroy (ppd
.visited
);
3249 return parameter_packs
!= NULL_TREE
;
3252 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3253 representation a base-class initializer into a parameter pack
3254 expansion. If all goes well, the resulting node will be an
3255 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3258 make_pack_expansion (tree arg
)
3261 tree parameter_packs
= NULL_TREE
;
3262 bool for_types
= false;
3263 struct find_parameter_pack_data ppd
;
3265 if (!arg
|| arg
== error_mark_node
)
3268 if (TREE_CODE (arg
) == TREE_LIST
)
3270 /* The only time we will see a TREE_LIST here is for a base
3271 class initializer. In this case, the TREE_PURPOSE will be a
3272 _TYPE node (representing the base class expansion we're
3273 initializing) and the TREE_VALUE will be a TREE_LIST
3274 containing the initialization arguments.
3276 The resulting expansion looks somewhat different from most
3277 expansions. Rather than returning just one _EXPANSION, we
3278 return a TREE_LIST whose TREE_PURPOSE is a
3279 TYPE_PACK_EXPANSION containing the bases that will be
3280 initialized. The TREE_VALUE will be identical to the
3281 original TREE_VALUE, which is a list of arguments that will
3282 be passed to each base. We do not introduce any new pack
3283 expansion nodes into the TREE_VALUE (although it is possible
3284 that some already exist), because the TREE_PURPOSE and
3285 TREE_VALUE all need to be expanded together with the same
3286 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3287 resulting TREE_PURPOSE will mention the parameter packs in
3288 both the bases and the arguments to the bases. */
3291 tree parameter_packs
= NULL_TREE
;
3293 /* Determine which parameter packs will be used by the base
3295 ppd
.visited
= pointer_set_create ();
3296 ppd
.parameter_packs
= ¶meter_packs
;
3297 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3300 if (parameter_packs
== NULL_TREE
)
3302 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3303 pointer_set_destroy (ppd
.visited
);
3304 return error_mark_node
;
3307 if (TREE_VALUE (arg
) != void_type_node
)
3309 /* Collect the sets of parameter packs used in each of the
3310 initialization arguments. */
3311 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3313 /* Determine which parameter packs will be expanded in this
3315 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3320 pointer_set_destroy (ppd
.visited
);
3322 /* Create the pack expansion type for the base type. */
3323 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3324 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3325 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3327 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3328 they will rarely be compared to anything. */
3329 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3331 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3334 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3337 /* Build the PACK_EXPANSION_* node. */
3339 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3340 : make_node (EXPR_PACK_EXPANSION
);
3341 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3342 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3344 /* Propagate type and const-expression information. */
3345 TREE_TYPE (result
) = TREE_TYPE (arg
);
3346 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3349 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3350 they will rarely be compared to anything. */
3351 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3353 /* Determine which parameter packs will be expanded. */
3354 ppd
.parameter_packs
= ¶meter_packs
;
3355 ppd
.visited
= pointer_set_create ();
3356 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3357 pointer_set_destroy (ppd
.visited
);
3359 /* Make sure we found some parameter packs. */
3360 if (parameter_packs
== NULL_TREE
)
3363 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3365 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3366 return error_mark_node
;
3368 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3370 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3375 /* Checks T for any "bare" parameter packs, which have not yet been
3376 expanded, and issues an error if any are found. This operation can
3377 only be done on full expressions or types (e.g., an expression
3378 statement, "if" condition, etc.), because we could have expressions like:
3380 foo(f(g(h(args)))...)
3382 where "args" is a parameter pack. check_for_bare_parameter_packs
3383 should not be called for the subexpressions args, h(args),
3384 g(h(args)), or f(g(h(args))), because we would produce erroneous
3387 Returns TRUE and emits an error if there were bare parameter packs,
3388 returns FALSE otherwise. */
3390 check_for_bare_parameter_packs (tree t
)
3392 tree parameter_packs
= NULL_TREE
;
3393 struct find_parameter_pack_data ppd
;
3395 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3398 if (TREE_CODE (t
) == TYPE_DECL
)
3401 ppd
.parameter_packs
= ¶meter_packs
;
3402 ppd
.visited
= pointer_set_create ();
3403 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3404 pointer_set_destroy (ppd
.visited
);
3406 if (parameter_packs
)
3408 error ("parameter packs not expanded with %<...%>:");
3409 while (parameter_packs
)
3411 tree pack
= TREE_VALUE (parameter_packs
);
3412 tree name
= NULL_TREE
;
3414 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3415 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3416 name
= TYPE_NAME (pack
);
3417 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3418 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3420 name
= DECL_NAME (pack
);
3423 inform (input_location
, " %qD", name
);
3425 inform (input_location
, " <anonymous>");
3427 parameter_packs
= TREE_CHAIN (parameter_packs
);
3436 /* Expand any parameter packs that occur in the template arguments in
3439 expand_template_argument_pack (tree args
)
3441 tree result_args
= NULL_TREE
;
3442 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3443 int num_result_args
= -1;
3444 int non_default_args_count
= -1;
3446 /* First, determine if we need to expand anything, and the number of
3447 slots we'll need. */
3448 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3450 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3451 if (arg
== NULL_TREE
)
3453 if (ARGUMENT_PACK_P (arg
))
3455 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3456 if (num_result_args
< 0)
3457 num_result_args
= in_arg
+ num_packed
;
3459 num_result_args
+= num_packed
;
3463 if (num_result_args
>= 0)
3468 /* If no expansion is necessary, we're done. */
3469 if (num_result_args
< 0)
3472 /* Expand arguments. */
3473 result_args
= make_tree_vec (num_result_args
);
3474 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3475 non_default_args_count
=
3476 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3477 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3479 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3480 if (ARGUMENT_PACK_P (arg
))
3482 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3483 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3484 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3485 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3486 if (non_default_args_count
> 0)
3487 non_default_args_count
+= num_packed
- 1;
3491 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3495 if (non_default_args_count
>= 0)
3496 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3500 /* Checks if DECL shadows a template parameter.
3502 [temp.local]: A template-parameter shall not be redeclared within its
3503 scope (including nested scopes).
3505 Emits an error and returns TRUE if the DECL shadows a parameter,
3506 returns FALSE otherwise. */
3509 check_template_shadow (tree decl
)
3513 /* If we're not in a template, we can't possibly shadow a template
3515 if (!current_template_parms
)
3518 /* Figure out what we're shadowing. */
3519 if (TREE_CODE (decl
) == OVERLOAD
)
3520 decl
= OVL_CURRENT (decl
);
3521 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3523 /* If there's no previous binding for this name, we're not shadowing
3524 anything, let alone a template parameter. */
3528 /* If we're not shadowing a template parameter, we're done. Note
3529 that OLDDECL might be an OVERLOAD (or perhaps even an
3530 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3532 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3535 /* We check for decl != olddecl to avoid bogus errors for using a
3536 name inside a class. We check TPFI to avoid duplicate errors for
3537 inline member templates. */
3539 || (DECL_TEMPLATE_PARM_P (decl
)
3540 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
3543 /* Don't complain about the injected class name, as we've already
3544 complained about the class itself. */
3545 if (DECL_SELF_REFERENCE_P (decl
))
3548 error ("declaration of %q+#D", decl
);
3549 error (" shadows template parm %q+#D", olddecl
);
3553 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3554 ORIG_LEVEL, DECL, and TYPE. */
3557 build_template_parm_index (int index
,
3563 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3564 TEMPLATE_PARM_IDX (t
) = index
;
3565 TEMPLATE_PARM_LEVEL (t
) = level
;
3566 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3567 TEMPLATE_PARM_DECL (t
) = decl
;
3568 TREE_TYPE (t
) = type
;
3569 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3570 TREE_READONLY (t
) = TREE_READONLY (decl
);
3575 /* Find the canonical type parameter for the given template type
3576 parameter. Returns the canonical type parameter, which may be TYPE
3577 if no such parameter existed. */
3580 canonical_type_parameter (tree type
)
3583 int idx
= TEMPLATE_TYPE_IDX (type
);
3584 if (!canonical_template_parms
)
3585 vec_alloc (canonical_template_parms
, idx
+1);
3587 while (canonical_template_parms
->length () <= (unsigned)idx
)
3588 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3590 list
= (*canonical_template_parms
)[idx
];
3591 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3592 list
= TREE_CHAIN (list
);
3595 return TREE_VALUE (list
);
3598 (*canonical_template_parms
)[idx
]
3599 = tree_cons (NULL_TREE
, type
,
3600 (*canonical_template_parms
)[idx
]);
3605 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3606 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3607 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3608 new one is created. */
3611 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3612 tsubst_flags_t complain
)
3614 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3615 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3616 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3617 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3619 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3622 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3623 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3624 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3625 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3626 DECL_ARTIFICIAL (decl
) = 1;
3627 SET_DECL_TEMPLATE_PARM_P (decl
);
3629 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3630 TEMPLATE_PARM_LEVEL (index
) - levels
,
3631 TEMPLATE_PARM_ORIG_LEVEL (index
),
3633 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3634 TEMPLATE_PARM_PARAMETER_PACK (t
)
3635 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3637 /* Template template parameters need this. */
3638 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3639 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3640 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
)),
3644 return TEMPLATE_PARM_DESCENDANTS (index
);
3647 /* Process information from new template parameter PARM and append it
3648 to the LIST being built. This new parameter is a non-type
3649 parameter iff IS_NON_TYPE is true. This new parameter is a
3650 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3654 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
3655 bool is_non_type
, bool is_parameter_pack
)
3661 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
3662 defval
= TREE_PURPOSE (parm
);
3666 tree p
= tree_last (list
);
3668 if (p
&& TREE_VALUE (p
) != error_mark_node
)
3671 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
3672 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
3674 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
3682 parm
= TREE_VALUE (parm
);
3684 SET_DECL_TEMPLATE_PARM_P (parm
);
3686 if (TREE_TYPE (parm
) != error_mark_node
)
3690 The top-level cv-qualifiers on the template-parameter are
3691 ignored when determining its type. */
3692 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
3693 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
3694 TREE_TYPE (parm
) = error_mark_node
;
3695 else if (uses_parameter_packs (TREE_TYPE (parm
))
3696 && !is_parameter_pack
3697 /* If we're in a nested template parameter list, the template
3698 template parameter could be a parameter pack. */
3699 && processing_template_parmlist
== 1)
3701 /* This template parameter is not a parameter pack, but it
3702 should be. Complain about "bare" parameter packs. */
3703 check_for_bare_parameter_packs (TREE_TYPE (parm
));
3705 /* Recover by calling this a parameter pack. */
3706 is_parameter_pack
= true;
3710 /* A template parameter is not modifiable. */
3711 TREE_CONSTANT (parm
) = 1;
3712 TREE_READONLY (parm
) = 1;
3713 decl
= build_decl (parm_loc
,
3714 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
3715 TREE_CONSTANT (decl
) = 1;
3716 TREE_READONLY (decl
) = 1;
3717 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
3718 = build_template_parm_index (idx
, processing_template_decl
,
3719 processing_template_decl
,
3720 decl
, TREE_TYPE (parm
));
3722 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
3723 = is_parameter_pack
;
3728 parm
= TREE_VALUE (TREE_VALUE (parm
));
3730 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
3732 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
3733 /* This is for distinguishing between real templates and template
3734 template parameters */
3735 TREE_TYPE (parm
) = t
;
3736 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
3741 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
3742 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3743 decl
= build_decl (parm_loc
,
3744 TYPE_DECL
, parm
, t
);
3747 TYPE_NAME (t
) = decl
;
3748 TYPE_STUB_DECL (t
) = decl
;
3750 TEMPLATE_TYPE_PARM_INDEX (t
)
3751 = build_template_parm_index (idx
, processing_template_decl
,
3752 processing_template_decl
,
3753 decl
, TREE_TYPE (parm
));
3754 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
3755 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
3757 DECL_ARTIFICIAL (decl
) = 1;
3758 SET_DECL_TEMPLATE_PARM_P (decl
);
3760 parm
= build_tree_list (defval
, parm
);
3761 return chainon (list
, parm
);
3764 /* The end of a template parameter list has been reached. Process the
3765 tree list into a parameter vector, converting each parameter into a more
3766 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3770 end_template_parm_list (tree parms
)
3774 tree saved_parmlist
= make_tree_vec (list_length (parms
));
3776 current_template_parms
3777 = tree_cons (size_int (processing_template_decl
),
3778 saved_parmlist
, current_template_parms
);
3780 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3782 next
= TREE_CHAIN (parm
);
3783 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3784 TREE_CHAIN (parm
) = NULL_TREE
;
3787 --processing_template_parmlist
;
3789 return saved_parmlist
;
3792 /* end_template_decl is called after a template declaration is seen. */
3795 end_template_decl (void)
3797 reset_specialization ();
3799 if (! processing_template_decl
)
3802 /* This matches the pushlevel in begin_template_parm_list. */
3805 --processing_template_decl
;
3806 current_template_parms
= TREE_CHAIN (current_template_parms
);
3809 /* Takes a TREE_LIST representing a template parameter and convert it
3810 into an argument suitable to be passed to the type substitution
3811 functions. Note that If the TREE_LIST contains an error_mark
3812 node, the returned argument is error_mark_node. */
3815 template_parm_to_arg (tree t
)
3819 || TREE_CODE (t
) != TREE_LIST
)
3822 if (error_operand_p (TREE_VALUE (t
)))
3823 return error_mark_node
;
3827 if (TREE_CODE (t
) == TYPE_DECL
3828 || TREE_CODE (t
) == TEMPLATE_DECL
)
3832 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3834 /* Turn this argument into a TYPE_ARGUMENT_PACK
3835 with a single element, which expands T. */
3836 tree vec
= make_tree_vec (1);
3837 #ifdef ENABLE_CHECKING
3838 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3839 (vec
, TREE_VEC_LENGTH (vec
));
3841 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3843 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
3844 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3849 t
= DECL_INITIAL (t
);
3851 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3853 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3854 with a single element, which expands T. */
3855 tree vec
= make_tree_vec (1);
3856 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3857 #ifdef ENABLE_CHECKING
3858 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3859 (vec
, TREE_VEC_LENGTH (vec
));
3861 t
= convert_from_reference (t
);
3862 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3864 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3865 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3866 TREE_TYPE (t
) = type
;
3869 t
= convert_from_reference (t
);
3874 /* Given a set of template parameters, return them as a set of template
3875 arguments. The template parameters are represented as a TREE_VEC, in
3876 the form documented in cp-tree.h for template arguments. */
3879 template_parms_to_args (tree parms
)
3882 tree args
= NULL_TREE
;
3883 int length
= TMPL_PARMS_DEPTH (parms
);
3886 /* If there is only one level of template parameters, we do not
3887 create a TREE_VEC of TREE_VECs. Instead, we return a single
3888 TREE_VEC containing the arguments. */
3890 args
= make_tree_vec (length
);
3892 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
3894 tree a
= copy_node (TREE_VALUE (header
));
3897 TREE_TYPE (a
) = NULL_TREE
;
3898 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
3899 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
3901 #ifdef ENABLE_CHECKING
3902 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
3906 TREE_VEC_ELT (args
, --l
) = a
;
3911 if (length
> 1 && TREE_VEC_ELT (args
, 0) == NULL_TREE
)
3912 /* This can happen for template parms of a template template
3915 template<template<class T, class U> class TT> struct S;
3917 Consider the level of the parms of TT; T and U both have
3918 level 2; TT has no template parm of level 1. So in this case
3919 the first element of full_template_args is NULL_TREE. If we
3920 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
3921 of 2. This will make tsubst wrongly consider that T and U
3922 have level 1. Instead, let's create a dummy vector as the
3923 first element of full_template_args so that TMPL_ARGS_DEPTH
3924 returns the correct depth for args. */
3925 TREE_VEC_ELT (args
, 0) = make_tree_vec (1);
3929 /* Within the declaration of a template, return the currently active
3930 template parameters as an argument TREE_VEC. */
3933 current_template_args (void)
3935 return template_parms_to_args (current_template_parms
);
3938 /* Update the declared TYPE by doing any lookups which were thought to be
3939 dependent, but are not now that we know the SCOPE of the declarator. */
3942 maybe_update_decl_type (tree orig_type
, tree scope
)
3944 tree type
= orig_type
;
3946 if (type
== NULL_TREE
)
3949 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3950 type
= TREE_TYPE (type
);
3952 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
3953 && dependent_type_p (type
)
3954 /* Don't bother building up the args in this case. */
3955 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
3957 /* tsubst in the args corresponding to the template parameters,
3958 including auto if present. Most things will be unchanged, but
3959 make_typename_type and tsubst_qualified_id will resolve
3960 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3961 tree args
= current_template_args ();
3962 tree auto_node
= type_uses_auto (type
);
3966 tree auto_vec
= make_tree_vec (1);
3967 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
3968 args
= add_to_template_args (args
, auto_vec
);
3970 pushed
= push_scope (scope
);
3971 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
3976 if (type
== error_mark_node
)
3979 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3981 if (same_type_p (type
, TREE_TYPE (orig_type
)))
3984 type
= TYPE_NAME (type
);
3989 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3990 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3991 a member template. Used by push_template_decl below. */
3994 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
3996 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
3997 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
3998 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
3999 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4000 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4005 struct template_parm_data
4007 /* The level of the template parameters we are currently
4011 /* The index of the specialization argument we are currently
4015 /* An array whose size is the number of template parameters. The
4016 elements are nonzero if the parameter has been used in any one
4017 of the arguments processed so far. */
4020 /* An array whose size is the number of template arguments. The
4021 elements are nonzero if the argument makes use of template
4022 parameters of this level. */
4023 int* arg_uses_template_parms
;
4026 /* Subroutine of push_template_decl used to see if each template
4027 parameter in a partial specialization is used in the explicit
4028 argument list. If T is of the LEVEL given in DATA (which is
4029 treated as a template_parm_data*), then DATA->PARMS is marked
4033 mark_template_parm (tree t
, void* data
)
4037 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4039 template_parm_level_and_index (t
, &level
, &idx
);
4041 if (level
== tpd
->level
)
4043 tpd
->parms
[idx
] = 1;
4044 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4047 /* Return zero so that for_each_template_parm will continue the
4048 traversal of the tree; we want to mark *every* template parm. */
4052 /* Process the partial specialization DECL. */
4055 process_partial_specialization (tree decl
)
4057 tree type
= TREE_TYPE (decl
);
4058 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
4059 tree specargs
= CLASSTYPE_TI_ARGS (type
);
4060 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4061 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4064 int nargs
= TREE_VEC_LENGTH (inner_args
);
4067 bool did_error_intro
= false;
4068 struct template_parm_data tpd
;
4069 struct template_parm_data tpd2
;
4071 gcc_assert (current_template_parms
);
4073 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4074 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4076 /* We check that each of the template parameters given in the
4077 partial specialization is used in the argument list to the
4078 specialization. For example:
4080 template <class T> struct S;
4081 template <class T> struct S<T*>;
4083 The second declaration is OK because `T*' uses the template
4084 parameter T, whereas
4086 template <class T> struct S<int>;
4088 is no good. Even trickier is:
4099 The S2<T> declaration is actually invalid; it is a
4100 full-specialization. Of course,
4103 struct S2<T (*)(U)>;
4105 or some such would have been OK. */
4106 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4107 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4108 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4110 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4111 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4112 for (i
= 0; i
< nargs
; ++i
)
4114 tpd
.current_arg
= i
;
4115 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4116 &mark_template_parm
,
4119 /*include_nondeduced_p=*/false);
4121 for (i
= 0; i
< ntparms
; ++i
)
4122 if (tpd
.parms
[i
] == 0)
4124 /* One of the template parms was not used in a deduced context in the
4126 if (!did_error_intro
)
4128 error ("template parameters not deducible in "
4129 "partial specialization:");
4130 did_error_intro
= true;
4133 inform (input_location
, " %qD",
4134 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4137 if (did_error_intro
)
4138 return error_mark_node
;
4140 /* [temp.class.spec]
4142 The argument list of the specialization shall not be identical to
4143 the implicit argument list of the primary template. */
4144 if (comp_template_args
4146 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
4148 error ("partial specialization %qT does not specialize any template arguments", type
);
4150 /* A partial specialization that replaces multiple parameters of the
4151 primary template with a pack expansion is less specialized for those
4153 if (nargs
< DECL_NTPARMS (maintmpl
))
4155 error ("partial specialization is not more specialized than the "
4156 "primary template because it replaces multiple parameters "
4157 "with a pack expansion");
4158 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4162 /* [temp.class.spec]
4164 A partially specialized non-type argument expression shall not
4165 involve template parameters of the partial specialization except
4166 when the argument expression is a simple identifier.
4168 The type of a template parameter corresponding to a specialized
4169 non-type argument shall not be dependent on a parameter of the
4172 Also, we verify that pack expansions only occur at the
4173 end of the argument list. */
4174 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4176 for (i
= 0; i
< nargs
; ++i
)
4178 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4179 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4180 tree packed_args
= NULL_TREE
;
4183 if (ARGUMENT_PACK_P (arg
))
4185 /* Extract the arguments from the argument pack. We'll be
4186 iterating over these in the following loop. */
4187 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4188 len
= TREE_VEC_LENGTH (packed_args
);
4191 for (j
= 0; j
< len
; j
++)
4194 /* Get the Jth argument in the parameter pack. */
4195 arg
= TREE_VEC_ELT (packed_args
, j
);
4197 if (PACK_EXPANSION_P (arg
))
4199 /* Pack expansions must come at the end of the
4201 if ((packed_args
&& j
< len
- 1)
4202 || (!packed_args
&& i
< nargs
- 1))
4204 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4205 error ("parameter pack argument %qE must be at the "
4206 "end of the template argument list", arg
);
4208 error ("parameter pack argument %qT must be at the "
4209 "end of the template argument list", arg
);
4213 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4214 /* We only care about the pattern. */
4215 arg
= PACK_EXPANSION_PATTERN (arg
);
4217 if (/* These first two lines are the `non-type' bit. */
4219 && TREE_CODE (arg
) != TEMPLATE_DECL
4220 /* This next two lines are the `argument expression is not just a
4221 simple identifier' condition and also the `specialized
4222 non-type argument' bit. */
4223 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4224 && !(REFERENCE_REF_P (arg
)
4225 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4227 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4228 || (packed_args
&& uses_template_parms (arg
)))
4229 error ("template argument %qE involves template parameter(s)",
4233 /* Look at the corresponding template parameter,
4234 marking which template parameters its type depends
4236 tree type
= TREE_TYPE (parm
);
4240 /* We haven't yet initialized TPD2. Do so now. */
4241 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4242 /* The number of parameters here is the number in the
4243 main template, which, as checked in the assertion
4245 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4247 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4250 /* Mark the template parameters. But this time, we're
4251 looking for the template parameters of the main
4252 template, not in the specialization. */
4253 tpd2
.current_arg
= i
;
4254 tpd2
.arg_uses_template_parms
[i
] = 0;
4255 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4256 for_each_template_parm (type
,
4257 &mark_template_parm
,
4260 /*include_nondeduced_p=*/false);
4262 if (tpd2
.arg_uses_template_parms
[i
])
4264 /* The type depended on some template parameters.
4265 If they are fully specialized in the
4266 specialization, that's OK. */
4269 for (j
= 0; j
< nargs
; ++j
)
4270 if (tpd2
.parms
[j
] != 0
4271 && tpd
.arg_uses_template_parms
[j
])
4274 error_n (input_location
, count
,
4275 "type %qT of template argument %qE depends "
4276 "on a template parameter",
4277 "type %qT of template argument %qE depends "
4278 "on template parameters",
4287 /* We should only get here once. */
4288 gcc_assert (!COMPLETE_TYPE_P (type
));
4290 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4291 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4292 TREE_TYPE (tmpl
) = type
;
4293 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4294 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4295 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4296 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4298 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4299 = tree_cons (specargs
, tmpl
,
4300 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4301 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4303 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4304 inst
= TREE_CHAIN (inst
))
4306 tree inst_type
= TREE_VALUE (inst
);
4307 if (COMPLETE_TYPE_P (inst_type
)
4308 && CLASSTYPE_IMPLICIT_INSTANTIATION (inst_type
))
4310 tree spec
= most_specialized_class (inst_type
, tf_none
);
4311 if (spec
&& TREE_TYPE (spec
) == type
)
4312 permerror (input_location
,
4313 "partial specialization of %qT after instantiation "
4314 "of %qT", type
, inst_type
);
4321 /* PARM is a template parameter of some form; return the corresponding
4322 TEMPLATE_PARM_INDEX. */
4325 get_template_parm_index (tree parm
)
4327 if (TREE_CODE (parm
) == PARM_DECL
4328 || TREE_CODE (parm
) == CONST_DECL
)
4329 parm
= DECL_INITIAL (parm
);
4330 else if (TREE_CODE (parm
) == TYPE_DECL
4331 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4332 parm
= TREE_TYPE (parm
);
4333 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4334 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4335 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4336 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4340 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4341 parameter packs used by the template parameter PARM. */
4344 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4346 /* A type parm can't refer to another parm. */
4347 if (TREE_CODE (parm
) == TYPE_DECL
)
4349 else if (TREE_CODE (parm
) == PARM_DECL
)
4351 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4356 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4358 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4359 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4360 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4363 /* PARM is a template parameter pack. Return any parameter packs used in
4364 its type or the type of any of its template parameters. If there are
4365 any such packs, it will be instantiated into a fixed template parameter
4366 list by partial instantiation rather than be fully deduced. */
4369 fixed_parameter_pack_p (tree parm
)
4371 /* This can only be true in a member template. */
4372 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4374 /* This can only be true for a parameter pack. */
4375 if (!template_parameter_pack_p (parm
))
4377 /* A type parm can't refer to another parm. */
4378 if (TREE_CODE (parm
) == TYPE_DECL
)
4381 tree parameter_packs
= NULL_TREE
;
4382 struct find_parameter_pack_data ppd
;
4383 ppd
.parameter_packs
= ¶meter_packs
;
4384 ppd
.visited
= pointer_set_create ();
4386 fixed_parameter_pack_p_1 (parm
, &ppd
);
4388 pointer_set_destroy (ppd
.visited
);
4389 return parameter_packs
;
4392 /* Check that a template declaration's use of default arguments and
4393 parameter packs is not invalid. Here, PARMS are the template
4394 parameters. IS_PRIMARY is true if DECL is the thing declared by
4395 a primary template. IS_PARTIAL is true if DECL is a partial
4398 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4399 declaration (but not a definition); 1 indicates a declaration, 2
4400 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4401 emitted for extraneous default arguments.
4403 Returns TRUE if there were no errors found, FALSE otherwise. */
4406 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4407 bool is_partial
, int is_friend_decl
)
4410 int last_level_to_check
;
4412 bool no_errors
= true;
4416 A default template-argument shall not be specified in a
4417 function template declaration or a function template definition, nor
4418 in the template-parameter-list of the definition of a member of a
4421 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
4422 /* You can't have a function template declaration in a local
4423 scope, nor you can you define a member of a class template in a
4427 if (TREE_CODE (decl
) == TYPE_DECL
4429 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4430 /* A lambda doesn't have an explicit declaration; don't complain
4431 about the parms of the enclosing class. */
4434 if (current_class_type
4435 && !TYPE_BEING_DEFINED (current_class_type
)
4436 && DECL_LANG_SPECIFIC (decl
)
4437 && DECL_DECLARES_FUNCTION_P (decl
)
4438 /* If this is either a friend defined in the scope of the class
4439 or a member function. */
4440 && (DECL_FUNCTION_MEMBER_P (decl
)
4441 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4442 : DECL_FRIEND_CONTEXT (decl
)
4443 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4445 /* And, if it was a member function, it really was defined in
4446 the scope of the class. */
4447 && (!DECL_FUNCTION_MEMBER_P (decl
)
4448 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4449 /* We already checked these parameters when the template was
4450 declared, so there's no need to do it again now. This function
4451 was defined in class scope, but we're processing its body now
4452 that the class is complete. */
4455 /* Core issue 226 (C++0x only): the following only applies to class
4458 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4462 If a template-parameter has a default template-argument, all
4463 subsequent template-parameters shall have a default
4464 template-argument supplied. */
4465 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4467 tree inner_parms
= TREE_VALUE (parm_level
);
4468 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4469 int seen_def_arg_p
= 0;
4472 for (i
= 0; i
< ntparms
; ++i
)
4474 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4476 if (parm
== error_mark_node
)
4479 if (TREE_PURPOSE (parm
))
4481 else if (seen_def_arg_p
4482 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4484 error ("no default argument for %qD", TREE_VALUE (parm
));
4485 /* For better subsequent error-recovery, we indicate that
4486 there should have been a default argument. */
4487 TREE_PURPOSE (parm
) = error_mark_node
;
4490 else if (!is_partial
4492 /* Don't complain about an enclosing partial
4494 && parm_level
== parms
4495 && TREE_CODE (decl
) == TYPE_DECL
4497 && template_parameter_pack_p (TREE_VALUE (parm
))
4498 /* A fixed parameter pack will be partially
4499 instantiated into a fixed length list. */
4500 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4502 /* A primary class template can only have one
4503 parameter pack, at the end of the template
4506 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
4507 error ("parameter pack %qE must be at the end of the"
4508 " template parameter list", TREE_VALUE (parm
));
4510 error ("parameter pack %qT must be at the end of the"
4511 " template parameter list",
4512 TREE_TYPE (TREE_VALUE (parm
)));
4514 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4522 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4526 /* For an ordinary class template, default template arguments are
4527 allowed at the innermost level, e.g.:
4528 template <class T = int>
4530 but, in a partial specialization, they're not allowed even
4531 there, as we have in [temp.class.spec]:
4533 The template parameter list of a specialization shall not
4534 contain default template argument values.
4536 So, for a partial specialization, or for a function template
4537 (in C++98/C++03), we look at all of them. */
4540 /* But, for a primary class template that is not a partial
4541 specialization we look at all template parameters except the
4543 parms
= TREE_CHAIN (parms
);
4545 /* Figure out what error message to issue. */
4546 if (is_friend_decl
== 2)
4547 msg
= G_("default template arguments may not be used in function template "
4548 "friend re-declaration");
4549 else if (is_friend_decl
)
4550 msg
= G_("default template arguments may not be used in function template "
4551 "friend declarations");
4552 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4553 msg
= G_("default template arguments may not be used in function templates "
4554 "without -std=c++11 or -std=gnu++11");
4555 else if (is_partial
)
4556 msg
= G_("default template arguments may not be used in "
4557 "partial specializations");
4559 msg
= G_("default argument for template parameter for class enclosing %qD");
4561 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4562 /* If we're inside a class definition, there's no need to
4563 examine the parameters to the class itself. On the one
4564 hand, they will be checked when the class is defined, and,
4565 on the other, default arguments are valid in things like:
4566 template <class T = double>
4567 struct S { template <class U> void f(U); };
4568 Here the default argument for `S' has no bearing on the
4569 declaration of `f'. */
4570 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4572 /* Check everything. */
4573 last_level_to_check
= 0;
4575 for (parm_level
= parms
;
4576 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4577 parm_level
= TREE_CHAIN (parm_level
))
4579 tree inner_parms
= TREE_VALUE (parm_level
);
4583 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4584 for (i
= 0; i
< ntparms
; ++i
)
4586 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4589 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4594 if (is_friend_decl
== 2)
4601 /* Clear out the default argument so that we are not
4603 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
4607 /* At this point, if we're still interested in issuing messages,
4608 they must apply to classes surrounding the object declared. */
4610 msg
= G_("default argument for template parameter for class "
4617 /* Worker for push_template_decl_real, called via
4618 for_each_template_parm. DATA is really an int, indicating the
4619 level of the parameters we are interested in. If T is a template
4620 parameter of that level, return nonzero. */
4623 template_parm_this_level_p (tree t
, void* data
)
4625 int this_level
= *(int *)data
;
4628 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4629 level
= TEMPLATE_PARM_LEVEL (t
);
4631 level
= TEMPLATE_TYPE_LEVEL (t
);
4632 return level
== this_level
;
4635 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4636 parameters given by current_template_args, or reuses a
4637 previously existing one, if appropriate. Returns the DECL, or an
4638 equivalent one, if it is replaced via a call to duplicate_decls.
4640 If IS_FRIEND is true, DECL is a friend declaration. */
4643 push_template_decl_real (tree decl
, bool is_friend
)
4651 int new_template_p
= 0;
4652 /* True if the template is a member template, in the sense of
4654 bool member_template_p
= false;
4656 if (decl
== error_mark_node
|| !current_template_parms
)
4657 return error_mark_node
;
4659 /* See if this is a partial specialization. */
4660 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
4661 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
4662 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
4664 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
4668 /* For a friend, we want the context of the friend function, not
4669 the type of which it is a friend. */
4670 ctx
= CP_DECL_CONTEXT (decl
);
4671 else if (CP_DECL_CONTEXT (decl
)
4672 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4673 /* In the case of a virtual function, we want the class in which
4675 ctx
= CP_DECL_CONTEXT (decl
);
4677 /* Otherwise, if we're currently defining some class, the DECL
4678 is assumed to be a member of the class. */
4679 ctx
= current_scope ();
4681 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
4684 if (!DECL_CONTEXT (decl
))
4685 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
4687 /* See if this is a primary template. */
4688 if (is_friend
&& ctx
4689 && uses_template_parms_level (ctx
, processing_template_decl
))
4690 /* A friend template that specifies a class context, i.e.
4691 template <typename T> friend void A<T>::f();
4695 is_primary
= template_parm_scope_p ();
4699 if (DECL_CLASS_SCOPE_P (decl
))
4700 member_template_p
= true;
4701 if (TREE_CODE (decl
) == TYPE_DECL
4702 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
4704 error ("template class without a name");
4705 return error_mark_node
;
4707 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
4709 if (DECL_DESTRUCTOR_P (decl
))
4713 A destructor shall not be a member template. */
4714 error ("destructor %qD declared as member template", decl
);
4715 return error_mark_node
;
4717 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
4718 && (!prototype_p (TREE_TYPE (decl
))
4719 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
4720 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
4721 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
4722 == void_list_node
)))
4724 /* [basic.stc.dynamic.allocation]
4726 An allocation function can be a function
4727 template. ... Template allocation functions shall
4728 have two or more parameters. */
4729 error ("invalid template declaration of %qD", decl
);
4730 return error_mark_node
;
4733 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4734 && CLASS_TYPE_P (TREE_TYPE (decl
)))
4736 else if (TREE_CODE (decl
) == TYPE_DECL
4737 && TYPE_DECL_ALIAS_P (decl
))
4738 /* alias-declaration */
4739 gcc_assert (!DECL_ARTIFICIAL (decl
));
4742 error ("template declaration of %q#D", decl
);
4743 return error_mark_node
;
4747 /* Check to see that the rules regarding the use of default
4748 arguments are not being violated. */
4749 check_default_tmpl_args (decl
, current_template_parms
,
4750 is_primary
, is_partial
, /*is_friend_decl=*/0);
4752 /* Ensure that there are no parameter packs in the type of this
4753 declaration that have not been expanded. */
4754 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4756 /* Check each of the arguments individually to see if there are
4757 any bare parameter packs. */
4758 tree type
= TREE_TYPE (decl
);
4759 tree arg
= DECL_ARGUMENTS (decl
);
4760 tree argtype
= TYPE_ARG_TYPES (type
);
4762 while (arg
&& argtype
)
4764 if (!DECL_PACK_P (arg
)
4765 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
4767 /* This is a PARM_DECL that contains unexpanded parameter
4768 packs. We have already complained about this in the
4769 check_for_bare_parameter_packs call, so just replace
4770 these types with ERROR_MARK_NODE. */
4771 TREE_TYPE (arg
) = error_mark_node
;
4772 TREE_VALUE (argtype
) = error_mark_node
;
4775 arg
= DECL_CHAIN (arg
);
4776 argtype
= TREE_CHAIN (argtype
);
4779 /* Check for bare parameter packs in the return type and the
4780 exception specifiers. */
4781 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
4782 /* Errors were already issued, set return type to int
4783 as the frontend doesn't expect error_mark_node as
4785 TREE_TYPE (type
) = integer_type_node
;
4786 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
4787 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
4789 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
4790 && TYPE_DECL_ALIAS_P (decl
))
4791 ? DECL_ORIGINAL_TYPE (decl
)
4792 : TREE_TYPE (decl
)))
4794 TREE_TYPE (decl
) = error_mark_node
;
4795 return error_mark_node
;
4799 return process_partial_specialization (decl
);
4801 args
= current_template_args ();
4804 || TREE_CODE (ctx
) == FUNCTION_DECL
4805 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
4806 || (TREE_CODE (decl
) == TYPE_DECL
4807 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4808 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
4810 if (DECL_LANG_SPECIFIC (decl
)
4811 && DECL_TEMPLATE_INFO (decl
)
4812 && DECL_TI_TEMPLATE (decl
))
4813 tmpl
= DECL_TI_TEMPLATE (decl
);
4814 /* If DECL is a TYPE_DECL for a class-template, then there won't
4815 be DECL_LANG_SPECIFIC. The information equivalent to
4816 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4817 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4818 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
4819 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
4821 /* Since a template declaration already existed for this
4822 class-type, we must be redeclaring it here. Make sure
4823 that the redeclaration is valid. */
4824 redeclare_class_template (TREE_TYPE (decl
),
4825 current_template_parms
);
4826 /* We don't need to create a new TEMPLATE_DECL; just use the
4827 one we already had. */
4828 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
4832 tmpl
= build_template_decl (decl
, current_template_parms
,
4836 if (DECL_LANG_SPECIFIC (decl
)
4837 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4839 /* A specialization of a member template of a template
4841 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4842 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
4843 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
4849 tree a
, t
, current
, parms
;
4851 tree tinfo
= get_template_info (decl
);
4855 error ("template definition of non-template %q#D", decl
);
4856 return error_mark_node
;
4859 tmpl
= TI_TEMPLATE (tinfo
);
4861 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
4862 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
4863 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4864 && DECL_MEMBER_TEMPLATE_P (tmpl
))
4868 /* The declaration is a specialization of a member
4869 template, declared outside the class. Therefore, the
4870 innermost template arguments will be NULL, so we
4871 replace them with the arguments determined by the
4872 earlier call to check_explicit_specialization. */
4873 args
= DECL_TI_ARGS (decl
);
4876 = build_template_decl (decl
, current_template_parms
,
4878 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
4879 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
4880 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
4881 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
4882 DECL_TEMPLATE_INFO (new_tmpl
)
4883 = build_template_info (tmpl
, args
);
4885 register_specialization (new_tmpl
,
4886 most_general_template (tmpl
),
4892 /* Make sure the template headers we got make sense. */
4894 parms
= DECL_TEMPLATE_PARMS (tmpl
);
4895 i
= TMPL_PARMS_DEPTH (parms
);
4896 if (TMPL_ARGS_DEPTH (args
) != i
)
4898 error ("expected %d levels of template parms for %q#D, got %d",
4899 i
, decl
, TMPL_ARGS_DEPTH (args
));
4900 DECL_INTERFACE_KNOWN (decl
) = 1;
4901 return error_mark_node
;
4904 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
4906 a
= TMPL_ARGS_LEVEL (args
, i
);
4907 t
= INNERMOST_TEMPLATE_PARMS (parms
);
4909 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
4911 if (current
== decl
)
4912 error ("got %d template parameters for %q#D",
4913 TREE_VEC_LENGTH (a
), decl
);
4915 error ("got %d template parameters for %q#T",
4916 TREE_VEC_LENGTH (a
), current
);
4917 error (" but %d required", TREE_VEC_LENGTH (t
));
4918 /* Avoid crash in import_export_decl. */
4919 DECL_INTERFACE_KNOWN (decl
) = 1;
4920 return error_mark_node
;
4923 if (current
== decl
)
4925 else if (current
== NULL_TREE
)
4926 /* Can happen in erroneous input. */
4929 current
= get_containing_scope (current
);
4932 /* Check that the parms are used in the appropriate qualifying scopes
4933 in the declarator. */
4934 if (!comp_template_args
4936 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
4939 template arguments to %qD do not match original template %qD",
4940 decl
, DECL_TEMPLATE_RESULT (tmpl
));
4941 if (!uses_template_parms (TI_ARGS (tinfo
)))
4942 inform (input_location
, "use template<> for an explicit specialization");
4943 /* Avoid crash in import_export_decl. */
4944 DECL_INTERFACE_KNOWN (decl
) = 1;
4945 return error_mark_node
;
4949 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4950 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
4952 /* Push template declarations for global functions and types. Note
4953 that we do not try to push a global template friend declared in a
4954 template class; such a thing may well depend on the template
4955 parameters of the class. */
4956 if (new_template_p
&& !ctx
4957 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
4959 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
4960 if (tmpl
== error_mark_node
)
4961 return error_mark_node
;
4963 /* Hide template friend classes that haven't been declared yet. */
4964 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
4966 DECL_ANTICIPATED (tmpl
) = 1;
4967 DECL_FRIEND_P (tmpl
) = 1;
4973 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
4976 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
4977 if (DECL_CONV_FN_P (tmpl
))
4979 int depth
= TMPL_PARMS_DEPTH (parms
);
4981 /* It is a conversion operator. See if the type converted to
4982 depends on innermost template operands. */
4984 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
4986 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
4989 /* Give template template parms a DECL_CONTEXT of the template
4990 for which they are a parameter. */
4991 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
4992 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
4994 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
4995 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
4996 DECL_CONTEXT (parm
) = tmpl
;
5000 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5001 back to its most general template. If TMPL is a specialization,
5002 ARGS may only have the innermost set of arguments. Add the missing
5003 argument levels if necessary. */
5004 if (DECL_TEMPLATE_INFO (tmpl
))
5005 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5007 info
= build_template_info (tmpl
, args
);
5009 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5010 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5013 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5014 retrofit_lang_decl (decl
);
5015 if (DECL_LANG_SPECIFIC (decl
))
5016 DECL_TEMPLATE_INFO (decl
) = info
;
5019 return DECL_TEMPLATE_RESULT (tmpl
);
5023 push_template_decl (tree decl
)
5025 return push_template_decl_real (decl
, false);
5028 /* FN is an inheriting constructor that inherits from the constructor
5029 template INHERITED; turn FN into a constructor template with a matching
5033 add_inherited_template_parms (tree fn
, tree inherited
)
5036 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5037 inner_parms
= copy_node (inner_parms
);
5039 = tree_cons (size_int (processing_template_decl
+ 1),
5040 inner_parms
, current_template_parms
);
5041 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5042 tree args
= template_parms_to_args (parms
);
5043 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5044 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5045 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5046 DECL_ARTIFICIAL (tmpl
) = true;
5047 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5051 /* Called when a class template TYPE is redeclared with the indicated
5052 template PARMS, e.g.:
5054 template <class T> struct S;
5055 template <class T> struct S {}; */
5058 redeclare_class_template (tree type
, tree parms
)
5064 if (!TYPE_TEMPLATE_INFO (type
))
5066 error ("%qT is not a template type", type
);
5070 tmpl
= TYPE_TI_TEMPLATE (type
);
5071 if (!PRIMARY_TEMPLATE_P (tmpl
))
5072 /* The type is nested in some template class. Nothing to worry
5073 about here; there are no new template parameters for the nested
5079 error ("template specifiers not specified in declaration of %qD",
5084 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5085 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5087 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5089 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5090 "redeclared with %d template parameter",
5091 "redeclared with %d template parameters",
5092 TREE_VEC_LENGTH (parms
));
5093 inform_n (input_location
, TREE_VEC_LENGTH (tmpl_parms
),
5094 "previous declaration %q+D used %d template parameter",
5095 "previous declaration %q+D used %d template parameters",
5096 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5100 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5107 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5108 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5111 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5112 if (error_operand_p (tmpl_parm
))
5115 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5116 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5117 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5119 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5121 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5122 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5123 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5124 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5125 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5126 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5127 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5128 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5129 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5131 error ("template parameter %q+#D", tmpl_parm
);
5132 error ("redeclared here as %q#D", parm
);
5136 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5138 /* We have in [temp.param]:
5140 A template-parameter may not be given default arguments
5141 by two different declarations in the same scope. */
5142 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5143 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5144 "original definition appeared here");
5148 if (parm_default
!= NULL_TREE
)
5149 /* Update the previous template parameters (which are the ones
5150 that will really count) with the new default value. */
5151 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5152 else if (tmpl_default
!= NULL_TREE
)
5153 /* Update the new parameters, too; they'll be used as the
5154 parameters for any members. */
5155 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5161 /* Simplify EXPR if it is a non-dependent expression. Returns the
5162 (possibly simplified) expression. */
5165 fold_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5167 if (expr
== NULL_TREE
)
5170 /* If we're in a template, but EXPR isn't value dependent, simplify
5171 it. We're supposed to treat:
5173 template <typename T> void f(T[1 + 1]);
5174 template <typename T> void f(T[2]);
5176 as two declarations of the same function, for example. */
5177 if (processing_template_decl
5178 && !instantiation_dependent_expression_p (expr
)
5179 && potential_constant_expression (expr
))
5181 HOST_WIDE_INT saved_processing_template_decl
;
5183 saved_processing_template_decl
= processing_template_decl
;
5184 processing_template_decl
= 0;
5185 expr
= tsubst_copy_and_build (expr
,
5188 /*in_decl=*/NULL_TREE
,
5189 /*function_p=*/false,
5190 /*integral_constant_expression_p=*/true);
5191 processing_template_decl
= saved_processing_template_decl
;
5197 fold_non_dependent_expr (tree expr
)
5199 return fold_non_dependent_expr_sfinae (expr
, tf_error
);
5202 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5203 template declaration, or a TYPE_DECL for an alias declaration. */
5206 alias_type_or_template_p (tree t
)
5210 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5213 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5214 || DECL_ALIAS_TEMPLATE_P (t
));
5217 /* Return TRUE iff is a specialization of an alias template. */
5220 alias_template_specialization_p (const_tree t
)
5226 && TYPE_TEMPLATE_INFO (t
)
5227 && PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (t
))
5228 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (t
)));
5231 /* Return the number of innermost template parameters in TMPL. */
5234 num_innermost_template_parms (tree tmpl
)
5236 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5237 return TREE_VEC_LENGTH (parms
);
5240 /* Return either TMPL or another template that it is equivalent to under DR
5241 1286: An alias that just changes the name of a template is equivalent to
5242 the other template. */
5245 get_underlying_template (tree tmpl
)
5247 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5248 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5250 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5251 if (TYPE_TEMPLATE_INFO (result
))
5253 tree sub
= TYPE_TI_TEMPLATE (result
);
5254 if (PRIMARY_TEMPLATE_P (sub
)
5255 && (num_innermost_template_parms (tmpl
)
5256 == num_innermost_template_parms (sub
)))
5258 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5259 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5260 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5262 /* The alias type is equivalent to the pattern of the
5263 underlying template, so strip the alias. */
5273 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5274 must be a function or a pointer-to-function type, as specified
5275 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5276 and check that the resulting function has external linkage. */
5279 convert_nontype_argument_function (tree type
, tree expr
,
5280 tsubst_flags_t complain
)
5284 linkage_kind linkage
;
5286 fn
= instantiate_type (type
, fns
, tf_none
);
5287 if (fn
== error_mark_node
)
5288 return error_mark_node
;
5291 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5292 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5293 if (BASELINK_P (fn_no_ptr
))
5294 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5296 /* [temp.arg.nontype]/1
5298 A template-argument for a non-type, non-template template-parameter
5301 -- the address of an object or function with external [C++11: or
5302 internal] linkage. */
5304 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5306 if (complain
& tf_error
)
5308 error ("%qE is not a valid template argument for type %qT",
5310 if (TYPE_PTR_P (type
))
5311 error ("it must be the address of a function with "
5312 "external linkage");
5314 error ("it must be the name of a function with "
5315 "external linkage");
5320 linkage
= decl_linkage (fn_no_ptr
);
5321 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5323 if (complain
& tf_error
)
5325 if (cxx_dialect
>= cxx11
)
5326 error ("%qE is not a valid template argument for type %qT "
5327 "because %qD has no linkage",
5328 expr
, type
, fn_no_ptr
);
5330 error ("%qE is not a valid template argument for type %qT "
5331 "because %qD does not have external linkage",
5332 expr
, type
, fn_no_ptr
);
5340 /* Subroutine of convert_nontype_argument.
5341 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5342 Emit an error otherwise. */
5345 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5346 tsubst_flags_t complain
)
5349 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5351 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5353 if (complain
& tf_error
)
5355 error ("%qE is not a valid template argument for type %qT",
5357 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5362 /* Returns TRUE iff the address of OP is value-dependent.
5364 14.6.2.4 [temp.dep.temp]:
5365 A non-integral non-type template-argument is dependent if its type is
5366 dependent or it has either of the following forms
5369 and contains a nested-name-specifier which specifies a class-name that
5370 names a dependent type.
5372 We generalize this to just say that the address of a member of a
5373 dependent class is value-dependent; the above doesn't cover the
5374 address of a static data member named with an unqualified-id. */
5377 has_value_dependent_address (tree op
)
5379 /* We could use get_inner_reference here, but there's no need;
5380 this is only relevant for template non-type arguments, which
5381 can only be expressed as &id-expression. */
5384 tree ctx
= CP_DECL_CONTEXT (op
);
5385 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5392 /* The next set of functions are used for providing helpful explanatory
5393 diagnostics for failed overload resolution. Their messages should be
5394 indented by two spaces for consistency with the messages in
5398 unify_success (bool /*explain_p*/)
5404 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5407 inform (input_location
,
5408 " couldn't deduce template parameter %qD", parm
);
5413 unify_invalid (bool /*explain_p*/)
5419 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5422 inform (input_location
,
5423 " types %qT and %qT have incompatible cv-qualifiers",
5429 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5432 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5437 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5440 inform (input_location
,
5441 " template parameter %qD is not a parameter pack, but "
5448 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5451 inform (input_location
,
5452 " template argument %qE does not match "
5453 "pointer-to-member constant %qE",
5459 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5462 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5467 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5470 inform (input_location
,
5471 " inconsistent parameter pack deduction with %qT and %qT",
5477 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5482 inform (input_location
,
5483 " deduced conflicting types for parameter %qT (%qT and %qT)",
5484 parm
, first
, second
);
5486 inform (input_location
,
5487 " deduced conflicting values for non-type parameter "
5488 "%qE (%qE and %qE)", parm
, first
, second
);
5494 unify_vla_arg (bool explain_p
, tree arg
)
5497 inform (input_location
,
5498 " variable-sized array type %qT is not "
5499 "a valid template argument",
5505 unify_method_type_error (bool explain_p
, tree arg
)
5508 inform (input_location
,
5509 " member function type %qT is not a valid template argument",
5515 unify_arity (bool explain_p
, int have
, int wanted
)
5518 inform_n (input_location
, wanted
,
5519 " candidate expects %d argument, %d provided",
5520 " candidate expects %d arguments, %d provided",
5526 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5528 return unify_arity (explain_p
, have
, wanted
);
5532 unify_too_few_arguments (bool explain_p
, int have
, int wanted
)
5534 return unify_arity (explain_p
, have
, wanted
);
5538 unify_arg_conversion (bool explain_p
, tree to_type
,
5539 tree from_type
, tree arg
)
5542 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5543 " cannot convert %qE (type %qT) to type %qT",
5544 arg
, from_type
, to_type
);
5549 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5550 tree parm
, tree arg
)
5555 case tbr_ambiguous_baseclass
:
5556 inform (input_location
, " %qT is an ambiguous base class of %qT",
5560 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5567 unify_inconsistent_template_template_parameters (bool explain_p
)
5570 inform (input_location
,
5571 " template parameters of a template template argument are "
5572 "inconsistent with other deduced template arguments");
5577 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5580 inform (input_location
,
5581 " can't deduce a template for %qT from non-template type %qT",
5587 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5590 inform (input_location
,
5591 " template argument %qE does not match %qD", arg
, parm
);
5596 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5599 inform (input_location
,
5600 " could not resolve address from overloaded function %qE",
5605 /* Attempt to convert the non-type template parameter EXPR to the
5606 indicated TYPE. If the conversion is successful, return the
5607 converted value. If the conversion is unsuccessful, return
5608 NULL_TREE if we issued an error message, or error_mark_node if we
5609 did not. We issue error messages for out-and-out bad template
5610 parameters, but not simply because the conversion failed, since we
5611 might be just trying to do argument deduction. Both TYPE and EXPR
5612 must be non-dependent.
5614 The conversion follows the special rules described in
5615 [temp.arg.nontype], and it is much more strict than an implicit
5618 This function is called twice for each template argument (see
5619 lookup_template_class for a more accurate description of this
5620 problem). This means that we need to handle expressions which
5621 are not valid in a C++ source, but can be created from the
5622 first call (for instance, casts to perform conversions). These
5623 hacks can go away after we fix the double coercion problem. */
5626 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5630 /* Detect immediately string literals as invalid non-type argument.
5631 This special-case is not needed for correctness (we would easily
5632 catch this later), but only to provide better diagnostic for this
5633 common user mistake. As suggested by DR 100, we do not mention
5634 linkage issues in the diagnostic as this is not the point. */
5635 /* FIXME we're making this OK. */
5636 if (TREE_CODE (expr
) == STRING_CST
)
5638 if (complain
& tf_error
)
5639 error ("%qE is not a valid template argument for type %qT "
5640 "because string literals can never be used in this context",
5645 /* Add the ADDR_EXPR now for the benefit of
5646 value_dependent_expression_p. */
5647 if (TYPE_PTROBV_P (type
)
5648 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5650 expr
= decay_conversion (expr
, complain
);
5651 if (expr
== error_mark_node
)
5652 return error_mark_node
;
5655 /* If we are in a template, EXPR may be non-dependent, but still
5656 have a syntactic, rather than semantic, form. For example, EXPR
5657 might be a SCOPE_REF, rather than the VAR_DECL to which the
5658 SCOPE_REF refers. Preserving the qualifying scope is necessary
5659 so that access checking can be performed when the template is
5660 instantiated -- but here we need the resolved form so that we can
5661 convert the argument. */
5662 if (TYPE_REF_OBJ_P (type
)
5663 && has_value_dependent_address (expr
))
5664 /* If we want the address and it's value-dependent, don't fold. */;
5665 else if (!type_unknown_p (expr
))
5666 expr
= fold_non_dependent_expr_sfinae (expr
, complain
);
5667 if (error_operand_p (expr
))
5668 return error_mark_node
;
5669 expr_type
= TREE_TYPE (expr
);
5670 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5671 expr
= mark_lvalue_use (expr
);
5673 expr
= mark_rvalue_use (expr
);
5675 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5676 to a non-type argument of "nullptr". */
5677 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5678 expr
= convert (type
, expr
);
5680 /* In C++11, integral or enumeration non-type template arguments can be
5681 arbitrary constant expressions. Pointer and pointer to
5682 member arguments can be general constant expressions that evaluate
5683 to a null value, but otherwise still need to be of a specific form. */
5684 if (cxx_dialect
>= cxx11
)
5686 if (TREE_CODE (expr
) == PTRMEM_CST
)
5687 /* A PTRMEM_CST is already constant, and a valid template
5688 argument for a parameter of pointer to member type, we just want
5689 to leave it in that form rather than lower it to a
5691 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5692 expr
= maybe_constant_value (expr
);
5693 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5695 tree folded
= maybe_constant_value (expr
);
5696 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5697 : null_member_pointer_value_p (folded
))
5702 /* HACK: Due to double coercion, we can get a
5703 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5704 which is the tree that we built on the first call (see
5705 below when coercing to reference to object or to reference to
5706 function). We just strip everything and get to the arg.
5707 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5709 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5711 tree probe_type
, probe
= expr
;
5712 if (REFERENCE_REF_P (probe
))
5713 probe
= TREE_OPERAND (probe
, 0);
5714 probe_type
= TREE_TYPE (probe
);
5715 if (TREE_CODE (probe
) == NOP_EXPR
)
5717 /* ??? Maybe we could use convert_from_reference here, but we
5718 would need to relax its constraints because the NOP_EXPR
5719 could actually change the type to something more cv-qualified,
5720 and this is not folded by convert_from_reference. */
5721 tree addr
= TREE_OPERAND (probe
, 0);
5722 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5723 && TREE_CODE (addr
) == ADDR_EXPR
5724 && TYPE_PTR_P (TREE_TYPE (addr
))
5725 && (same_type_ignoring_top_level_qualifiers_p
5726 (TREE_TYPE (probe_type
),
5727 TREE_TYPE (TREE_TYPE (addr
)))))
5729 expr
= TREE_OPERAND (addr
, 0);
5730 expr_type
= TREE_TYPE (probe_type
);
5735 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5736 parameter is a pointer to object, through decay and
5737 qualification conversion. Let's strip everything. */
5738 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5742 if (TREE_CODE (probe
) == ADDR_EXPR
5743 && TYPE_PTR_P (TREE_TYPE (probe
)))
5745 /* Skip the ADDR_EXPR only if it is part of the decay for
5746 an array. Otherwise, it is part of the original argument
5747 in the source code. */
5748 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5749 probe
= TREE_OPERAND (probe
, 0);
5751 expr_type
= TREE_TYPE (expr
);
5755 /* [temp.arg.nontype]/5, bullet 1
5757 For a non-type template-parameter of integral or enumeration type,
5758 integral promotions (_conv.prom_) and integral conversions
5759 (_conv.integral_) are applied. */
5760 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5762 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5763 t
= maybe_constant_value (t
);
5764 if (t
!= error_mark_node
)
5767 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5768 return error_mark_node
;
5770 /* Notice that there are constant expressions like '4 % 0' which
5771 do not fold into integer constants. */
5772 if (TREE_CODE (expr
) != INTEGER_CST
)
5774 if (complain
& tf_error
)
5776 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
5777 if (processing_template_decl
5778 && !require_potential_constant_expression (expr
))
5780 expr
= cxx_constant_value (expr
);
5781 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
5782 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
5783 "in template argument for type %qT ", type
);
5784 if (expr
== error_mark_node
)
5786 /* else cxx_constant_value complained but gave us
5787 a real constant, so go ahead. */
5788 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
5794 /* Avoid typedef problems. */
5795 if (TREE_TYPE (expr
) != type
)
5796 expr
= fold_convert (type
, expr
);
5798 /* [temp.arg.nontype]/5, bullet 2
5800 For a non-type template-parameter of type pointer to object,
5801 qualification conversions (_conv.qual_) and the array-to-pointer
5802 conversion (_conv.array_) are applied. */
5803 else if (TYPE_PTROBV_P (type
))
5805 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5807 A template-argument for a non-type, non-template template-parameter
5808 shall be one of: [...]
5810 -- the name of a non-type template-parameter;
5811 -- the address of an object or function with external linkage, [...]
5812 expressed as "& id-expression" where the & is optional if the name
5813 refers to a function or array, or if the corresponding
5814 template-parameter is a reference.
5816 Here, we do not care about functions, as they are invalid anyway
5817 for a parameter of type pointer-to-object. */
5819 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
5820 /* Non-type template parameters are OK. */
5822 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5823 /* Null pointer values are OK in C++11. */;
5824 else if (TREE_CODE (expr
) != ADDR_EXPR
5825 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
5829 if (complain
& tf_error
)
5830 error ("%qD is not a valid template argument "
5831 "because %qD is a variable, not the address of "
5832 "a variable", expr
, expr
);
5835 if (POINTER_TYPE_P (expr_type
))
5837 if (complain
& tf_error
)
5838 error ("%qE is not a valid template argument for %qT "
5839 "because it is not the address of a variable",
5843 /* Other values, like integer constants, might be valid
5844 non-type arguments of some other type. */
5845 return error_mark_node
;
5851 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
5852 ? TREE_OPERAND (expr
, 0) : expr
);
5855 if (complain
& tf_error
)
5856 error ("%qE is not a valid template argument of type %qT "
5857 "because %qE is not a variable", expr
, type
, decl
);
5860 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
5862 if (complain
& tf_error
)
5863 error ("%qE is not a valid template argument of type %qT "
5864 "because %qD does not have external linkage",
5868 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
5870 if (complain
& tf_error
)
5871 error ("%qE is not a valid template argument of type %qT "
5872 "because %qD has no linkage", expr
, type
, decl
);
5877 expr
= decay_conversion (expr
, complain
);
5878 if (expr
== error_mark_node
)
5879 return error_mark_node
;
5881 expr
= perform_qualification_conversions (type
, expr
);
5882 if (expr
== error_mark_node
)
5883 return error_mark_node
;
5885 /* [temp.arg.nontype]/5, bullet 3
5887 For a non-type template-parameter of type reference to object, no
5888 conversions apply. The type referred to by the reference may be more
5889 cv-qualified than the (otherwise identical) type of the
5890 template-argument. The template-parameter is bound directly to the
5891 template-argument, which must be an lvalue. */
5892 else if (TYPE_REF_OBJ_P (type
))
5894 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
5896 return error_mark_node
;
5898 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
5900 if (complain
& tf_error
)
5901 error ("%qE is not a valid template argument for type %qT "
5902 "because of conflicts in cv-qualification", expr
, type
);
5906 if (!real_lvalue_p (expr
))
5908 if (complain
& tf_error
)
5909 error ("%qE is not a valid template argument for type %qT "
5910 "because it is not an lvalue", expr
, type
);
5914 /* [temp.arg.nontype]/1
5916 A template-argument for a non-type, non-template template-parameter
5917 shall be one of: [...]
5919 -- the address of an object or function with external linkage. */
5920 if (INDIRECT_REF_P (expr
)
5921 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
5923 expr
= TREE_OPERAND (expr
, 0);
5926 if (complain
& tf_error
)
5927 error ("%q#D is not a valid template argument for type %qT "
5928 "because a reference variable does not have a constant "
5929 "address", expr
, type
);
5936 if (complain
& tf_error
)
5937 error ("%qE is not a valid template argument for type %qT "
5938 "because it is not an object with external linkage",
5943 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
5945 if (complain
& tf_error
)
5946 error ("%qE is not a valid template argument for type %qT "
5947 "because object %qD has not external linkage",
5952 expr
= build_nop (type
, build_address (expr
));
5954 /* [temp.arg.nontype]/5, bullet 4
5956 For a non-type template-parameter of type pointer to function, only
5957 the function-to-pointer conversion (_conv.func_) is applied. If the
5958 template-argument represents a set of overloaded functions (or a
5959 pointer to such), the matching function is selected from the set
5961 else if (TYPE_PTRFN_P (type
))
5963 /* If the argument is a template-id, we might not have enough
5964 context information to decay the pointer. */
5965 if (!type_unknown_p (expr_type
))
5967 expr
= decay_conversion (expr
, complain
);
5968 if (expr
== error_mark_node
)
5969 return error_mark_node
;
5972 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5973 /* Null pointer values are OK in C++11. */
5974 return perform_qualification_conversions (type
, expr
);
5976 expr
= convert_nontype_argument_function (type
, expr
, complain
);
5977 if (!expr
|| expr
== error_mark_node
)
5980 /* [temp.arg.nontype]/5, bullet 5
5982 For a non-type template-parameter of type reference to function, no
5983 conversions apply. If the template-argument represents a set of
5984 overloaded functions, the matching function is selected from the set
5986 else if (TYPE_REFFN_P (type
))
5988 if (TREE_CODE (expr
) == ADDR_EXPR
)
5990 if (complain
& tf_error
)
5992 error ("%qE is not a valid template argument for type %qT "
5993 "because it is a pointer", expr
, type
);
5994 inform (input_location
, "try using %qE instead",
5995 TREE_OPERAND (expr
, 0));
6000 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6001 if (!expr
|| expr
== error_mark_node
)
6004 expr
= build_nop (type
, build_address (expr
));
6006 /* [temp.arg.nontype]/5, bullet 6
6008 For a non-type template-parameter of type pointer to member function,
6009 no conversions apply. If the template-argument represents a set of
6010 overloaded member functions, the matching member function is selected
6011 from the set (_over.over_). */
6012 else if (TYPE_PTRMEMFUNC_P (type
))
6014 expr
= instantiate_type (type
, expr
, tf_none
);
6015 if (expr
== error_mark_node
)
6016 return error_mark_node
;
6018 /* [temp.arg.nontype] bullet 1 says the pointer to member
6019 expression must be a pointer-to-member constant. */
6020 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6021 return error_mark_node
;
6023 /* There is no way to disable standard conversions in
6024 resolve_address_of_overloaded_function (called by
6025 instantiate_type). It is possible that the call succeeded by
6026 converting &B::I to &D::I (where B is a base of D), so we need
6027 to reject this conversion here.
6029 Actually, even if there was a way to disable standard conversions,
6030 it would still be better to reject them here so that we can
6031 provide a superior diagnostic. */
6032 if (!same_type_p (TREE_TYPE (expr
), type
))
6034 if (complain
& tf_error
)
6036 error ("%qE is not a valid template argument for type %qT "
6037 "because it is of type %qT", expr
, type
,
6039 /* If we are just one standard conversion off, explain. */
6040 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6041 inform (input_location
,
6042 "standard conversions are not allowed in this context");
6047 /* [temp.arg.nontype]/5, bullet 7
6049 For a non-type template-parameter of type pointer to data member,
6050 qualification conversions (_conv.qual_) are applied. */
6051 else if (TYPE_PTRDATAMEM_P (type
))
6053 /* [temp.arg.nontype] bullet 1 says the pointer to member
6054 expression must be a pointer-to-member constant. */
6055 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6056 return error_mark_node
;
6058 expr
= perform_qualification_conversions (type
, expr
);
6059 if (expr
== error_mark_node
)
6062 else if (NULLPTR_TYPE_P (type
))
6064 if (expr
!= nullptr_node
)
6066 if (complain
& tf_error
)
6067 error ("%qE is not a valid template argument for type %qT "
6068 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6073 /* A template non-type parameter must be one of the above. */
6077 /* Sanity check: did we actually convert the argument to the
6079 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6080 (type
, TREE_TYPE (expr
)));
6084 /* Subroutine of coerce_template_template_parms, which returns 1 if
6085 PARM_PARM and ARG_PARM match using the rule for the template
6086 parameters of template template parameters. Both PARM and ARG are
6087 template parameters; the rest of the arguments are the same as for
6088 coerce_template_template_parms.
6091 coerce_template_template_parm (tree parm
,
6093 tsubst_flags_t complain
,
6097 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6098 || parm
== NULL_TREE
|| error_operand_p (parm
))
6101 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6104 switch (TREE_CODE (parm
))
6107 /* We encounter instantiations of templates like
6108 template <template <template <class> class> class TT>
6111 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6112 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6114 if (!coerce_template_template_parms
6115 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6121 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6122 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6123 /* Argument is a parameter pack but parameter is not. */
6128 /* The tsubst call is used to handle cases such as
6130 template <int> class C {};
6131 template <class T, template <T> class TT> class D {};
6134 i.e. the parameter list of TT depends on earlier parameters. */
6135 if (!uses_template_parms (TREE_TYPE (arg
))
6137 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6141 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6142 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6143 /* Argument is a parameter pack but parameter is not. */
6156 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6157 template template parameters. Both PARM_PARMS and ARG_PARMS are
6158 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6161 Consider the example:
6162 template <class T> class A;
6163 template<template <class U> class TT> class B;
6165 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6166 the parameters to A, and OUTER_ARGS contains A. */
6169 coerce_template_template_parms (tree parm_parms
,
6171 tsubst_flags_t complain
,
6175 int nparms
, nargs
, i
;
6179 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6180 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6182 nparms
= TREE_VEC_LENGTH (parm_parms
);
6183 nargs
= TREE_VEC_LENGTH (arg_parms
);
6185 /* Determine whether we have a parameter pack at the end of the
6186 template template parameter's template parameter list. */
6187 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6189 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6191 if (error_operand_p (parm
))
6194 switch (TREE_CODE (parm
))
6198 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6203 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6213 && !(variadic_p
&& nargs
>= nparms
- 1))
6216 /* Check all of the template parameters except the parameter pack at
6217 the end (if any). */
6218 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6220 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6221 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6224 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6225 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6227 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6235 /* Check each of the template parameters in the template
6236 argument against the template parameter pack at the end of
6237 the template template parameter. */
6238 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6241 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6243 for (; i
< nargs
; ++i
)
6245 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6248 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6250 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6259 /* Verifies that the deduced template arguments (in TARGS) for the
6260 template template parameters (in TPARMS) represent valid bindings,
6261 by comparing the template parameter list of each template argument
6262 to the template parameter list of its corresponding template
6263 template parameter, in accordance with DR150. This
6264 routine can only be called after all template arguments have been
6265 deduced. It will return TRUE if all of the template template
6266 parameter bindings are okay, FALSE otherwise. */
6268 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6270 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6273 /* We're dealing with template parms in this process. */
6274 ++processing_template_decl
;
6276 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6278 for (i
= 0; i
< ntparms
; ++i
)
6280 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6281 tree targ
= TREE_VEC_ELT (targs
, i
);
6283 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6285 tree packed_args
= NULL_TREE
;
6288 if (ARGUMENT_PACK_P (targ
))
6290 /* Look inside the argument pack. */
6291 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6292 len
= TREE_VEC_LENGTH (packed_args
);
6295 for (idx
= 0; idx
< len
; ++idx
)
6297 tree targ_parms
= NULL_TREE
;
6300 /* Extract the next argument from the argument
6302 targ
= TREE_VEC_ELT (packed_args
, idx
);
6304 if (PACK_EXPANSION_P (targ
))
6305 /* Look at the pattern of the pack expansion. */
6306 targ
= PACK_EXPANSION_PATTERN (targ
);
6308 /* Extract the template parameters from the template
6310 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6311 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6312 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6313 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6315 /* Verify that we can coerce the template template
6316 parameters from the template argument to the template
6317 parameter. This requires an exact match. */
6319 && !coerce_template_template_parms
6320 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6335 --processing_template_decl
;
6339 /* Since type attributes aren't mangled, we need to strip them from
6340 template type arguments. */
6343 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6346 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6348 mv
= TYPE_MAIN_VARIANT (arg
);
6349 arg
= strip_typedefs (arg
);
6350 if (TYPE_ALIGN (arg
) != TYPE_ALIGN (mv
)
6351 || TYPE_ATTRIBUTES (arg
) != TYPE_ATTRIBUTES (mv
))
6353 if (complain
& tf_warning
)
6354 warning (0, "ignoring attributes on template argument %qT", arg
);
6355 arg
= build_aligned_type (arg
, TYPE_ALIGN (mv
));
6356 arg
= cp_build_type_attribute_variant (arg
, TYPE_ATTRIBUTES (mv
));
6361 /* Convert the indicated template ARG as necessary to match the
6362 indicated template PARM. Returns the converted ARG, or
6363 error_mark_node if the conversion was unsuccessful. Error and
6364 warning messages are issued under control of COMPLAIN. This
6365 conversion is for the Ith parameter in the parameter list. ARGS is
6366 the full set of template arguments deduced so far. */
6369 convert_template_argument (tree parm
,
6372 tsubst_flags_t complain
,
6378 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6380 if (TREE_CODE (arg
) == TREE_LIST
6381 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6383 /* The template argument was the name of some
6384 member function. That's usually
6385 invalid, but static members are OK. In any
6386 case, grab the underlying fields/functions
6387 and issue an error later if required. */
6388 orig_arg
= TREE_VALUE (arg
);
6389 TREE_TYPE (arg
) = unknown_type_node
;
6394 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6395 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6396 || requires_tmpl_type
);
6398 /* When determining whether an argument pack expansion is a template,
6399 look at the pattern. */
6400 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6401 arg
= PACK_EXPANSION_PATTERN (arg
);
6403 /* Deal with an injected-class-name used as a template template arg. */
6404 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6406 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6407 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6409 if (cxx_dialect
>= cxx11
)
6410 /* OK under DR 1004. */;
6411 else if (complain
& tf_warning_or_error
)
6412 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6413 " used as template template argument", TYPE_NAME (arg
));
6414 else if (flag_pedantic_errors
)
6422 ((TREE_CODE (arg
) == TEMPLATE_DECL
6423 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6424 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6425 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6426 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6429 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6430 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6431 arg
= TYPE_STUB_DECL (arg
);
6433 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6435 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6436 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6438 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6440 if (complain
& tf_error
)
6441 error ("invalid use of destructor %qE as a type", orig_arg
);
6442 return error_mark_node
;
6445 permerror (input_location
,
6446 "to refer to a type member of a template parameter, "
6447 "use %<typename %E%>", orig_arg
);
6449 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6450 TREE_OPERAND (arg
, 1),
6456 if (is_type
!= requires_type
)
6460 if (complain
& tf_error
)
6462 error ("type/value mismatch at argument %d in template "
6463 "parameter list for %qD",
6466 error (" expected a constant of type %qT, got %qT",
6468 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6469 else if (requires_tmpl_type
)
6470 error (" expected a class template, got %qE", orig_arg
);
6472 error (" expected a type, got %qE", orig_arg
);
6475 return error_mark_node
;
6477 if (is_tmpl_type
^ requires_tmpl_type
)
6479 if (in_decl
&& (complain
& tf_error
))
6481 error ("type/value mismatch at argument %d in template "
6482 "parameter list for %qD",
6485 error (" expected a type, got %qT", DECL_NAME (arg
));
6487 error (" expected a class template, got %qT", orig_arg
);
6489 return error_mark_node
;
6494 if (requires_tmpl_type
)
6496 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6498 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6499 /* The number of argument required is not known yet.
6500 Just accept it for now. */
6501 val
= TREE_TYPE (arg
);
6504 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6507 /* Strip alias templates that are equivalent to another
6509 arg
= get_underlying_template (arg
);
6510 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6512 if (coerce_template_template_parms (parmparm
, argparm
,
6518 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6520 if (val
!= error_mark_node
)
6522 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6523 val
= TREE_TYPE (val
);
6524 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6525 val
= make_pack_expansion (val
);
6530 if (in_decl
&& (complain
& tf_error
))
6532 error ("type/value mismatch at argument %d in "
6533 "template parameter list for %qD",
6535 error (" expected a template of type %qD, got %qT",
6539 val
= error_mark_node
;
6545 /* We only form one instance of each template specialization.
6546 Therefore, if we use a non-canonical variant (i.e., a
6547 typedef), any future messages referring to the type will use
6548 the typedef, which is confusing if those future uses do not
6549 themselves also use the typedef. */
6551 val
= canonicalize_type_argument (val
, complain
);
6555 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6557 if (invalid_nontype_parm_type_p (t
, complain
))
6558 return error_mark_node
;
6560 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6562 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6566 /* Not sure if this is reachable, but it doesn't hurt
6568 error ("type mismatch in nontype parameter pack");
6569 val
= error_mark_node
;
6572 else if (!dependent_template_arg_p (orig_arg
)
6573 && !uses_template_parms (t
))
6574 /* We used to call digest_init here. However, digest_init
6575 will report errors, which we don't want when complain
6576 is zero. More importantly, digest_init will try too
6577 hard to convert things: for example, `0' should not be
6578 converted to pointer type at this point according to
6579 the standard. Accepting this is not merely an
6580 extension, since deciding whether or not these
6581 conversions can occur is part of determining which
6582 function template to call, or whether a given explicit
6583 argument specification is valid. */
6584 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6586 val
= strip_typedefs_expr (orig_arg
);
6588 if (val
== NULL_TREE
)
6589 val
= error_mark_node
;
6590 else if (val
== error_mark_node
&& (complain
& tf_error
))
6591 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6593 if (TREE_CODE (val
) == SCOPE_REF
)
6595 /* Strip typedefs from the SCOPE_REF. */
6596 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6597 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6599 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6600 QUALIFIED_NAME_IS_TEMPLATE (val
));
6607 /* Coerces the remaining template arguments in INNER_ARGS (from
6608 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6609 Returns the coerced argument pack. PARM_IDX is the position of this
6610 parameter in the template parameter list. ARGS is the original
6611 template argument list. */
6613 coerce_template_parameter_pack (tree parms
,
6621 tsubst_flags_t complain
)
6623 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6624 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6627 tree packed_parms
= NULL_TREE
;
6629 if (arg_idx
> nargs
)
6632 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6634 /* When the template parameter is a non-type template parameter pack
6635 or template template parameter pack whose type or template
6636 parameters use parameter packs, we know exactly how many arguments
6637 we are looking for. Build a vector of the instantiated decls for
6638 these template parameters in PACKED_PARMS. */
6639 /* We can't use make_pack_expansion here because it would interpret a
6640 _DECL as a use rather than a declaration. */
6641 tree decl
= TREE_VALUE (parm
);
6642 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6643 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6644 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6645 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6647 TREE_VEC_LENGTH (args
)--;
6648 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6649 TREE_VEC_LENGTH (args
)++;
6651 if (packed_parms
== error_mark_node
)
6652 return error_mark_node
;
6654 /* If we're doing a partial instantiation of a member template,
6655 verify that all of the types used for the non-type
6656 template parameter pack are, in fact, valid for non-type
6657 template parameters. */
6659 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6661 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6662 for (j
= 0; j
< len
; ++j
)
6664 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6665 if (invalid_nontype_parm_type_p (t
, complain
))
6666 return error_mark_node
;
6670 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6673 packed_args
= make_tree_vec (nargs
- arg_idx
);
6675 /* Convert the remaining arguments, which will be a part of the
6676 parameter pack "parm". */
6677 for (; arg_idx
< nargs
; ++arg_idx
)
6679 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6680 tree actual_parm
= TREE_VALUE (parm
);
6681 int pack_idx
= arg_idx
- parm_idx
;
6685 /* Once we've packed as many args as we have types, stop. */
6686 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6688 else if (PACK_EXPANSION_P (arg
))
6689 /* We don't know how many args we have yet, just
6690 use the unconverted ones for now. */
6693 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6696 if (arg
== error_mark_node
)
6698 if (complain
& tf_error
)
6699 error ("template argument %d is invalid", arg_idx
+ 1);
6702 arg
= convert_template_argument (actual_parm
,
6703 arg
, new_args
, complain
, parm_idx
,
6705 if (arg
== error_mark_node
)
6707 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6710 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6711 && TREE_VEC_LENGTH (packed_args
) > 0)
6713 if (complain
& tf_error
)
6714 error ("wrong number of template arguments (%d, should be %d)",
6715 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6716 return error_mark_node
;
6719 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6720 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6721 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6724 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6725 TREE_TYPE (argument_pack
)
6726 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6727 TREE_CONSTANT (argument_pack
) = 1;
6730 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6731 #ifdef ENABLE_CHECKING
6732 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6733 TREE_VEC_LENGTH (packed_args
));
6735 return argument_pack
;
6738 /* Returns the number of pack expansions in the template argument vector
6742 pack_expansion_args_count (tree args
)
6747 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6749 tree elt
= TREE_VEC_ELT (args
, i
);
6750 if (elt
&& PACK_EXPANSION_P (elt
))
6756 /* Convert all template arguments to their appropriate types, and
6757 return a vector containing the innermost resulting template
6758 arguments. If any error occurs, return error_mark_node. Error and
6759 warning messages are issued under control of COMPLAIN.
6761 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6762 for arguments not specified in ARGS. Otherwise, if
6763 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6764 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6765 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6769 coerce_template_parms (tree parms
,
6772 tsubst_flags_t complain
,
6773 bool require_all_args
,
6774 bool use_default_args
)
6776 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6777 tree orig_inner_args
;
6780 tree new_inner_args
;
6781 int saved_unevaluated_operand
;
6782 int saved_inhibit_evaluation_warnings
;
6784 /* When used as a boolean value, indicates whether this is a
6785 variadic template parameter list. Since it's an int, we can also
6786 subtract it from nparms to get the number of non-variadic
6789 int variadic_args_p
= 0;
6790 int post_variadic_parms
= 0;
6792 if (args
== error_mark_node
)
6793 return error_mark_node
;
6795 nparms
= TREE_VEC_LENGTH (parms
);
6797 /* Determine if there are any parameter packs. */
6798 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
6800 tree tparm
= TREE_VALUE (TREE_VEC_ELT (parms
, parm_idx
));
6802 ++post_variadic_parms
;
6803 if (template_parameter_pack_p (tparm
))
6807 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
6808 /* If there are no parameters that follow a parameter pack, we need to
6809 expand any argument packs so that we can deduce a parameter pack from
6810 some non-packed args followed by an argument pack, as in variadic85.C.
6811 If there are such parameters, we need to leave argument packs intact
6812 so the arguments are assigned properly. This can happen when dealing
6813 with a nested class inside a partial specialization of a class
6814 template, as in variadic92.C, or when deducing a template parameter pack
6815 from a sub-declarator, as in variadic114.C. */
6816 if (!post_variadic_parms
)
6817 inner_args
= expand_template_argument_pack (inner_args
);
6819 /* Count any pack expansion args. */
6820 variadic_args_p
= pack_expansion_args_count (inner_args
);
6822 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6823 if ((nargs
> nparms
&& !variadic_p
)
6824 || (nargs
< nparms
- variadic_p
6827 && (!use_default_args
6828 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
6829 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
6831 if (complain
& tf_error
)
6835 nparms
-= variadic_p
;
6836 error ("wrong number of template arguments "
6837 "(%d, should be %d or more)", nargs
, nparms
);
6840 error ("wrong number of template arguments "
6841 "(%d, should be %d)", nargs
, nparms
);
6844 error ("provided for %q+D", in_decl
);
6847 return error_mark_node
;
6849 /* We can't pass a pack expansion to a non-pack parameter of an alias
6850 template (DR 1430). */
6851 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
6853 && nargs
- variadic_args_p
< nparms
- variadic_p
)
6855 if (complain
& tf_error
)
6857 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
6859 tree arg
= TREE_VEC_ELT (inner_args
, i
);
6860 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
6862 if (PACK_EXPANSION_P (arg
)
6863 && !template_parameter_pack_p (parm
))
6865 error ("pack expansion argument for non-pack parameter "
6866 "%qD of alias template %qD", parm
, in_decl
);
6867 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
6874 return error_mark_node
;
6877 /* We need to evaluate the template arguments, even though this
6878 template-id may be nested within a "sizeof". */
6879 saved_unevaluated_operand
= cp_unevaluated_operand
;
6880 cp_unevaluated_operand
= 0;
6881 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6882 c_inhibit_evaluation_warnings
= 0;
6883 new_inner_args
= make_tree_vec (nparms
);
6884 new_args
= add_outermost_template_args (args
, new_inner_args
);
6885 int pack_adjust
= 0;
6886 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
6891 /* Get the Ith template parameter. */
6892 parm
= TREE_VEC_ELT (parms
, parm_idx
);
6894 if (parm
== error_mark_node
)
6896 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
6900 /* Calculate the next argument. */
6901 if (arg_idx
< nargs
)
6902 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6906 if (template_parameter_pack_p (TREE_VALUE (parm
))
6907 && !(arg
&& ARGUMENT_PACK_P (arg
)))
6909 /* Some arguments will be placed in the
6910 template parameter pack PARM. */
6911 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
6912 inner_args
, arg_idx
,
6916 if (arg
== NULL_TREE
)
6918 /* We don't know how many args we have yet, just use the
6919 unconverted (and still packed) ones for now. */
6920 new_inner_args
= orig_inner_args
;
6925 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
6927 /* Store this argument. */
6928 if (arg
== error_mark_node
)
6931 /* We are done with all of the arguments. */
6936 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
6937 arg_idx
+= pack_adjust
;
6944 if (PACK_EXPANSION_P (arg
))
6946 /* "If every valid specialization of a variadic template
6947 requires an empty template parameter pack, the template is
6948 ill-formed, no diagnostic required." So check that the
6949 pattern works with this parameter. */
6950 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
6951 tree conv
= convert_template_argument (TREE_VALUE (parm
),
6955 if (conv
== error_mark_node
)
6957 inform (input_location
, "so any instantiation with a "
6958 "non-empty parameter pack would be ill-formed");
6961 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
6962 /* Recover from missing typename. */
6963 TREE_VEC_ELT (inner_args
, arg_idx
)
6964 = make_pack_expansion (conv
);
6966 /* We don't know how many args we have yet, just
6967 use the unconverted ones for now. */
6968 new_inner_args
= inner_args
;
6973 else if (require_all_args
)
6975 /* There must be a default arg in this case. */
6976 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
6978 /* The position of the first default template argument,
6979 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6981 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
6982 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
6983 arg_idx
- pack_adjust
);
6988 if (arg
== error_mark_node
)
6990 if (complain
& tf_error
)
6991 error ("template argument %d is invalid", arg_idx
+ 1);
6994 /* This only occurs if there was an error in the template
6995 parameter list itself (which we would already have
6996 reported) that we are trying to recover from, e.g., a class
6997 template with a parameter list such as
6998 template<typename..., typename>. */
7001 arg
= convert_template_argument (TREE_VALUE (parm
),
7002 arg
, new_args
, complain
,
7005 if (arg
== error_mark_node
)
7007 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7009 cp_unevaluated_operand
= saved_unevaluated_operand
;
7010 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7012 if (variadic_p
&& arg_idx
< nargs
)
7014 if (complain
& tf_error
)
7016 error ("wrong number of template arguments "
7017 "(%d, should be %d)", nargs
, arg_idx
);
7019 error ("provided for %q+D", in_decl
);
7021 return error_mark_node
;
7025 return error_mark_node
;
7027 #ifdef ENABLE_CHECKING
7028 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7029 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7030 TREE_VEC_LENGTH (new_inner_args
));
7033 return new_inner_args
;
7036 /* Like coerce_template_parms. If PARMS represents all template
7037 parameters levels, this function returns a vector of vectors
7038 representing all the resulting argument levels. Note that in this
7039 case, only the innermost arguments are coerced because the
7040 outermost ones are supposed to have been coerced already.
7042 Otherwise, if PARMS represents only (the innermost) vector of
7043 parameters, this function returns a vector containing just the
7044 innermost resulting arguments. */
7047 coerce_innermost_template_parms (tree parms
,
7050 tsubst_flags_t complain
,
7051 bool require_all_args
,
7052 bool use_default_args
)
7054 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7055 int args_depth
= TMPL_ARGS_DEPTH (args
);
7058 if (parms_depth
> 1)
7060 coerced_args
= make_tree_vec (parms_depth
);
7064 for (level
= parms
, cur_depth
= parms_depth
;
7065 parms_depth
> 0 && level
!= NULL_TREE
;
7066 level
= TREE_CHAIN (level
), --cur_depth
)
7069 if (cur_depth
== args_depth
)
7070 l
= coerce_template_parms (TREE_VALUE (level
),
7071 args
, in_decl
, complain
,
7075 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7077 if (l
== error_mark_node
)
7078 return error_mark_node
;
7080 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7084 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7085 args
, in_decl
, complain
,
7088 return coerced_args
;
7091 /* Returns 1 if template args OT and NT are equivalent. */
7094 template_args_equal (tree ot
, tree nt
)
7098 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7101 if (TREE_CODE (nt
) == TREE_VEC
)
7102 /* For member templates */
7103 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7104 else if (PACK_EXPANSION_P (ot
))
7105 return (PACK_EXPANSION_P (nt
)
7106 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7107 PACK_EXPANSION_PATTERN (nt
))
7108 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7109 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7110 else if (ARGUMENT_PACK_P (ot
))
7115 if (!ARGUMENT_PACK_P (nt
))
7118 opack
= ARGUMENT_PACK_ARGS (ot
);
7119 npack
= ARGUMENT_PACK_ARGS (nt
);
7120 len
= TREE_VEC_LENGTH (opack
);
7121 if (TREE_VEC_LENGTH (npack
) != len
)
7123 for (i
= 0; i
< len
; ++i
)
7124 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7125 TREE_VEC_ELT (npack
, i
)))
7129 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7131 /* We get here probably because we are in the middle of substituting
7132 into the pattern of a pack expansion. In that case the
7133 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7134 interested in. So we want to use the initial pack argument for
7136 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7137 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7138 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7139 return template_args_equal (ot
, nt
);
7141 else if (TYPE_P (nt
))
7142 return TYPE_P (ot
) && same_type_p (ot
, nt
);
7143 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7146 return cp_tree_equal (ot
, nt
);
7149 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7150 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7151 NEWARG_PTR with the offending arguments if they are non-NULL. */
7154 comp_template_args_with_info (tree oldargs
, tree newargs
,
7155 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7159 if (oldargs
== newargs
)
7162 if (!oldargs
|| !newargs
)
7165 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7168 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7170 tree nt
= TREE_VEC_ELT (newargs
, i
);
7171 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7173 if (! template_args_equal (ot
, nt
))
7175 if (oldarg_ptr
!= NULL
)
7177 if (newarg_ptr
!= NULL
)
7185 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7186 of template arguments. Returns 0 otherwise. */
7189 comp_template_args (tree oldargs
, tree newargs
)
7191 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7195 add_pending_template (tree d
)
7197 tree ti
= (TYPE_P (d
)
7198 ? CLASSTYPE_TEMPLATE_INFO (d
)
7199 : DECL_TEMPLATE_INFO (d
));
7200 struct pending_template
*pt
;
7203 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7206 /* We are called both from instantiate_decl, where we've already had a
7207 tinst_level pushed, and instantiate_template, where we haven't.
7209 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7212 push_tinst_level (d
);
7214 pt
= ggc_alloc
<pending_template
> ();
7216 pt
->tinst
= current_tinst_level
;
7217 if (last_pending_template
)
7218 last_pending_template
->next
= pt
;
7220 pending_templates
= pt
;
7222 last_pending_template
= pt
;
7224 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7231 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7232 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7233 documentation for TEMPLATE_ID_EXPR. */
7236 lookup_template_function (tree fns
, tree arglist
)
7240 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7241 return error_mark_node
;
7243 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7245 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7247 error ("%q#D is not a function template", fns
);
7248 return error_mark_node
;
7251 if (BASELINK_P (fns
))
7253 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7255 BASELINK_FUNCTIONS (fns
),
7260 type
= TREE_TYPE (fns
);
7261 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7262 type
= unknown_type_node
;
7264 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7267 /* Within the scope of a template class S<T>, the name S gets bound
7268 (in build_self_reference) to a TYPE_DECL for the class, not a
7269 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7270 or one of its enclosing classes, and that type is a template,
7271 return the associated TEMPLATE_DECL. Otherwise, the original
7274 Also handle the case when DECL is a TREE_LIST of ambiguous
7275 injected-class-names from different bases. */
7278 maybe_get_template_decl_from_type_decl (tree decl
)
7280 if (decl
== NULL_TREE
)
7283 /* DR 176: A lookup that finds an injected-class-name (10.2
7284 [class.member.lookup]) can result in an ambiguity in certain cases
7285 (for example, if it is found in more than one base class). If all of
7286 the injected-class-names that are found refer to specializations of
7287 the same class template, and if the name is followed by a
7288 template-argument-list, the reference refers to the class template
7289 itself and not a specialization thereof, and is not ambiguous. */
7290 if (TREE_CODE (decl
) == TREE_LIST
)
7292 tree t
, tmpl
= NULL_TREE
;
7293 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7295 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7298 else if (tmpl
!= elt
)
7301 if (tmpl
&& t
== NULL_TREE
)
7307 return (decl
!= NULL_TREE
7308 && DECL_SELF_REFERENCE_P (decl
)
7309 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7310 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7313 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7314 parameters, find the desired type.
7316 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7318 IN_DECL, if non-NULL, is the template declaration we are trying to
7321 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7322 the class we are looking up.
7324 Issue error and warning messages under control of COMPLAIN.
7326 If the template class is really a local class in a template
7327 function, then the FUNCTION_CONTEXT is the function in which it is
7330 ??? Note that this function is currently called *twice* for each
7331 template-id: the first time from the parser, while creating the
7332 incomplete type (finish_template_type), and the second type during the
7333 real instantiation (instantiate_template_class). This is surely something
7334 that we want to avoid. It also causes some problems with argument
7335 coercion (see convert_nontype_argument for more information on this). */
7338 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7339 int entering_scope
, tsubst_flags_t complain
)
7341 tree templ
= NULL_TREE
, parmlist
;
7348 if (identifier_p (d1
))
7350 tree value
= innermost_non_namespace_value (d1
);
7351 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7356 push_decl_namespace (context
);
7357 templ
= lookup_name (d1
);
7358 templ
= maybe_get_template_decl_from_type_decl (templ
);
7360 pop_decl_namespace ();
7363 context
= DECL_CONTEXT (templ
);
7365 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7367 tree type
= TREE_TYPE (d1
);
7369 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7370 an implicit typename for the second A. Deal with it. */
7371 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7372 type
= TREE_TYPE (type
);
7374 if (CLASSTYPE_TEMPLATE_INFO (type
))
7376 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7377 d1
= DECL_NAME (templ
);
7380 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7381 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7383 templ
= TYPE_TI_TEMPLATE (d1
);
7384 d1
= DECL_NAME (templ
);
7386 else if (TREE_CODE (d1
) == TEMPLATE_DECL
7387 && DECL_TEMPLATE_RESULT (d1
)
7388 && TREE_CODE (DECL_TEMPLATE_RESULT (d1
)) == TYPE_DECL
)
7391 d1
= DECL_NAME (templ
);
7392 context
= DECL_CONTEXT (templ
);
7394 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7397 d1
= DECL_NAME (templ
);
7400 /* Issue an error message if we didn't find a template. */
7403 if (complain
& tf_error
)
7404 error ("%qT is not a template", d1
);
7405 return error_mark_node
;
7408 if (TREE_CODE (templ
) != TEMPLATE_DECL
7409 /* Make sure it's a user visible template, if it was named by
7411 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7412 && !PRIMARY_TEMPLATE_P (templ
)))
7414 if (complain
& tf_error
)
7416 error ("non-template type %qT used as a template", d1
);
7418 error ("for template declaration %q+D", in_decl
);
7420 return error_mark_node
;
7423 complain
&= ~tf_user
;
7425 /* An alias that just changes the name of a template is equivalent to the
7426 other template, so if any of the arguments are pack expansions, strip
7427 the alias to avoid problems with a pack expansion passed to a non-pack
7428 alias template parameter (DR 1430). */
7429 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7430 templ
= get_underlying_template (templ
);
7432 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7434 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7435 template arguments */
7441 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7443 /* Consider an example where a template template parameter declared as
7445 template <class T, class U = std::allocator<T> > class TT
7447 The template parameter level of T and U are one level larger than
7448 of TT. To proper process the default argument of U, say when an
7449 instantiation `TT<int>' is seen, we need to build the full
7450 arguments containing {int} as the innermost level. Outer levels,
7451 available when not appearing as default template argument, can be
7452 obtained from the arguments of the enclosing template.
7454 Suppose that TT is later substituted with std::vector. The above
7455 instantiation is `TT<int, std::allocator<T> >' with TT at
7456 level 1, and T at level 2, while the template arguments at level 1
7457 becomes {std::vector} and the inner level 2 is {int}. */
7459 outer
= DECL_CONTEXT (templ
);
7461 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7462 else if (current_template_parms
)
7463 /* This is an argument of the current template, so we haven't set
7464 DECL_CONTEXT yet. */
7465 outer
= current_template_args ();
7468 arglist
= add_to_template_args (outer
, arglist
);
7470 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7472 /*require_all_args=*/true,
7473 /*use_default_args=*/true);
7474 if (arglist2
== error_mark_node
7475 || (!uses_template_parms (arglist2
)
7476 && check_instantiated_args (templ
, arglist2
, complain
)))
7477 return error_mark_node
;
7479 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7484 tree template_type
= TREE_TYPE (templ
);
7487 tree found
= NULL_TREE
;
7490 int is_dependent_type
;
7491 int use_partial_inst_tmpl
= false;
7493 if (template_type
== error_mark_node
)
7494 /* An error occurred while building the template TEMPL, and a
7495 diagnostic has most certainly been emitted for that
7496 already. Let's propagate that error. */
7497 return error_mark_node
;
7499 gen_tmpl
= most_general_template (templ
);
7500 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7501 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7502 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7504 if (arg_depth
== 1 && parm_depth
> 1)
7506 /* We've been given an incomplete set of template arguments.
7509 template <class T> struct S1 {
7510 template <class U> struct S2 {};
7511 template <class U> struct S2<U*> {};
7514 we will be called with an ARGLIST of `U*', but the
7515 TEMPLATE will be `template <class T> template
7516 <class U> struct S1<T>::S2'. We must fill in the missing
7519 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7521 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7524 /* Now we should have enough arguments. */
7525 gcc_assert (parm_depth
== arg_depth
);
7527 /* From here on, we're only interested in the most general
7530 /* Calculate the BOUND_ARGS. These will be the args that are
7531 actually tsubst'd into the definition to create the
7535 /* We have multiple levels of arguments to coerce, at once. */
7537 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
7539 tree bound_args
= make_tree_vec (parm_depth
);
7541 for (i
= saved_depth
,
7542 t
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7543 i
> 0 && t
!= NULL_TREE
;
7544 --i
, t
= TREE_CHAIN (t
))
7547 if (i
== saved_depth
)
7548 a
= coerce_template_parms (TREE_VALUE (t
),
7551 /*require_all_args=*/true,
7552 /*use_default_args=*/true);
7554 /* Outer levels should have already been coerced. */
7555 a
= TMPL_ARGS_LEVEL (arglist
, i
);
7557 /* Don't process further if one of the levels fails. */
7558 if (a
== error_mark_node
)
7560 /* Restore the ARGLIST to its full size. */
7561 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7562 return error_mark_node
;
7565 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
7567 /* We temporarily reduce the length of the ARGLIST so
7568 that coerce_template_parms will see only the arguments
7569 corresponding to the template parameters it is
7571 TREE_VEC_LENGTH (arglist
)--;
7574 /* Restore the ARGLIST to its full size. */
7575 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7577 arglist
= bound_args
;
7581 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
7582 INNERMOST_TEMPLATE_ARGS (arglist
),
7585 /*require_all_args=*/true,
7586 /*use_default_args=*/true);
7588 if (arglist
== error_mark_node
)
7589 /* We were unable to bind the arguments. */
7590 return error_mark_node
;
7592 /* In the scope of a template class, explicit references to the
7593 template class refer to the type of the template, not any
7594 instantiation of it. For example, in:
7596 template <class T> class C { void f(C<T>); }
7598 the `C<T>' is just the same as `C'. Outside of the
7599 class, however, such a reference is an instantiation. */
7601 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7602 || currently_open_class (template_type
))
7603 /* comp_template_args is expensive, check it last. */
7604 && comp_template_args (TYPE_TI_ARGS (template_type
),
7606 return template_type
;
7608 /* If we already have this specialization, return it. */
7609 elt
.tmpl
= gen_tmpl
;
7611 hash
= hash_specialization (&elt
);
7612 entry
= (spec_entry
*) htab_find_with_hash (type_specializations
,
7618 is_dependent_type
= uses_template_parms (arglist
);
7620 /* If the deduced arguments are invalid, then the binding
7622 if (!is_dependent_type
7623 && check_instantiated_args (gen_tmpl
,
7624 INNERMOST_TEMPLATE_ARGS (arglist
),
7626 return error_mark_node
;
7628 if (!is_dependent_type
7629 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7630 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7631 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7633 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7634 DECL_NAME (gen_tmpl
),
7635 /*tag_scope=*/ts_global
);
7639 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7641 if (context
== error_mark_node
)
7642 return error_mark_node
;
7645 context
= global_namespace
;
7647 /* Create the type. */
7648 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7650 /* The user referred to a specialization of an alias
7651 template represented by GEN_TMPL.
7653 [temp.alias]/2 says:
7655 When a template-id refers to the specialization of an
7656 alias template, it is equivalent to the associated
7657 type obtained by substitution of its
7658 template-arguments for the template-parameters in the
7659 type-id of the alias template. */
7661 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7662 /* Note that the call above (by indirectly calling
7663 register_specialization in tsubst_decl) registers the
7664 TYPE_DECL representing the specialization of the alias
7665 template. So next time someone substitutes ARGLIST for
7666 the template parms into the alias template (GEN_TMPL),
7667 she'll get that TYPE_DECL back. */
7669 if (t
== error_mark_node
)
7672 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7674 if (!is_dependent_type
)
7676 set_current_access_from_decl (TYPE_NAME (template_type
));
7677 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7678 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7679 arglist
, complain
, in_decl
),
7680 SCOPED_ENUM_P (template_type
), NULL
);
7682 if (t
== error_mark_node
)
7687 /* We don't want to call start_enum for this type, since
7688 the values for the enumeration constants may involve
7689 template parameters. And, no one should be interested
7690 in the enumeration constants for such a type. */
7691 t
= cxx_make_type (ENUMERAL_TYPE
);
7692 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7694 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7695 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7696 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7698 else if (CLASS_TYPE_P (template_type
))
7700 t
= make_class_type (TREE_CODE (template_type
));
7701 CLASSTYPE_DECLARED_CLASS (t
)
7702 = CLASSTYPE_DECLARED_CLASS (template_type
);
7703 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7704 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7706 /* A local class. Make sure the decl gets registered properly. */
7707 if (context
== current_function_decl
)
7708 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7710 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7711 /* This instantiation is another name for the primary
7712 template type. Set the TYPE_CANONICAL field
7714 TYPE_CANONICAL (t
) = template_type
;
7715 else if (any_template_arguments_need_structural_equality_p (arglist
))
7716 /* Some of the template arguments require structural
7717 equality testing, so this template class requires
7718 structural equality testing. */
7719 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7724 /* If we called start_enum or pushtag above, this information
7725 will already be set up. */
7728 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7730 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7731 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7732 DECL_SOURCE_LOCATION (type_decl
)
7733 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7736 type_decl
= TYPE_NAME (t
);
7738 if (CLASS_TYPE_P (template_type
))
7740 TREE_PRIVATE (type_decl
)
7741 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7742 TREE_PROTECTED (type_decl
)
7743 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7744 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7746 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7747 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7751 /* Let's consider the explicit specialization of a member
7752 of a class template specialization that is implicitly instantiated,
7757 template<class U> struct M {}; //#0
7762 struct S<int>::M<char> //#1
7766 [temp.expl.spec]/4 says this is valid.
7768 In this case, when we write:
7771 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7774 When we encounter #1, we want to store the partial instantiation
7775 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7777 For all cases other than this "explicit specialization of member of a
7778 class template", we just want to store the most general template into
7779 the CLASSTYPE_TI_TEMPLATE of M.
7781 This case of "explicit specialization of member of a class template"
7783 1/ the enclosing class is an instantiation of, and therefore not
7784 the same as, the context of the most general template, and
7785 2/ we aren't looking at the partial instantiation itself, i.e.
7786 the innermost arguments are not the same as the innermost parms of
7787 the most general template.
7789 So it's only when 1/ and 2/ happens that we want to use the partial
7790 instantiation of the member template in lieu of its most general
7793 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
7794 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
7795 /* the enclosing class must be an instantiation... */
7796 && CLASS_TYPE_P (context
)
7797 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
7799 tree partial_inst_args
;
7800 TREE_VEC_LENGTH (arglist
)--;
7801 ++processing_template_decl
;
7803 tsubst (INNERMOST_TEMPLATE_ARGS
7804 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
7805 arglist
, complain
, NULL_TREE
);
7806 --processing_template_decl
;
7807 TREE_VEC_LENGTH (arglist
)++;
7808 use_partial_inst_tmpl
=
7809 /*...and we must not be looking at the partial instantiation
7811 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
7815 if (!use_partial_inst_tmpl
)
7816 /* This case is easy; there are no member templates involved. */
7820 /* This is a full instantiation of a member template. Find
7821 the partial instantiation of which this is an instance. */
7823 /* Temporarily reduce by one the number of levels in the ARGLIST
7824 so as to avoid comparing the last set of arguments. */
7825 TREE_VEC_LENGTH (arglist
)--;
7826 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
7827 TREE_VEC_LENGTH (arglist
)++;
7828 /* FOUND is either a proper class type, or an alias
7829 template specialization. In the later case, it's a
7830 TYPE_DECL, resulting from the substituting of arguments
7831 for parameters in the TYPE_DECL of the alias template
7832 done earlier. So be careful while getting the template
7834 found
= TREE_CODE (found
) == TYPE_DECL
7835 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
7836 : CLASSTYPE_TI_TEMPLATE (found
);
7839 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
7842 slot
= htab_find_slot_with_hash (type_specializations
,
7843 &elt
, hash
, INSERT
);
7844 entry
= ggc_alloc
<spec_entry
> ();
7848 /* Note this use of the partial instantiation so we can check it
7849 later in maybe_process_partial_specialization. */
7850 DECL_TEMPLATE_INSTANTIATIONS (found
)
7851 = tree_cons (arglist
, t
,
7852 DECL_TEMPLATE_INSTANTIATIONS (found
));
7854 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
7855 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7856 /* Now that the type has been registered on the instantiations
7857 list, we set up the enumerators. Because the enumeration
7858 constants may involve the enumeration type itself, we make
7859 sure to register the type first, and then create the
7860 constants. That way, doing tsubst_expr for the enumeration
7861 constants won't result in recursive calls here; we'll find
7862 the instantiation and exit above. */
7863 tsubst_enum (template_type
, t
, arglist
);
7865 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
7866 /* If the type makes use of template parameters, the
7867 code that generates debugging information will crash. */
7868 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
7870 /* Possibly limit visibility based on template args. */
7871 TREE_PUBLIC (type_decl
) = 1;
7872 determine_visibility (type_decl
);
7878 /* Wrapper for lookup_template_class_1. */
7881 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
7882 int entering_scope
, tsubst_flags_t complain
)
7885 timevar_push (TV_TEMPLATE_INST
);
7886 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
7887 entering_scope
, complain
);
7888 timevar_pop (TV_TEMPLATE_INST
);
7896 /* True when we should also visit template parameters that occur in
7897 non-deduced contexts. */
7898 bool include_nondeduced_p
;
7899 struct pointer_set_t
*visited
;
7902 /* Called from for_each_template_parm via walk_tree. */
7905 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
7908 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
7909 tree_fn_t fn
= pfd
->fn
;
7910 void *data
= pfd
->data
;
7913 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
7914 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
7915 pfd
->include_nondeduced_p
))
7916 return error_mark_node
;
7918 switch (TREE_CODE (t
))
7921 if (TYPE_PTRMEMFUNC_P (t
))
7927 if (!TYPE_TEMPLATE_INFO (t
))
7929 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
7930 fn
, data
, pfd
->visited
,
7931 pfd
->include_nondeduced_p
))
7932 return error_mark_node
;
7936 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
7937 fn
, data
, pfd
->visited
,
7938 pfd
->include_nondeduced_p
)
7939 || for_each_template_parm (TYPE_MAX_VALUE (t
),
7940 fn
, data
, pfd
->visited
,
7941 pfd
->include_nondeduced_p
))
7942 return error_mark_node
;
7946 /* Since we're not going to walk subtrees, we have to do this
7948 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
7949 pfd
->visited
, pfd
->include_nondeduced_p
))
7950 return error_mark_node
;
7954 /* Check the return type. */
7955 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
7956 pfd
->include_nondeduced_p
))
7957 return error_mark_node
;
7959 /* Check the parameter types. Since default arguments are not
7960 instantiated until they are needed, the TYPE_ARG_TYPES may
7961 contain expressions that involve template parameters. But,
7962 no-one should be looking at them yet. And, once they're
7963 instantiated, they don't contain template parameters, so
7964 there's no point in looking at them then, either. */
7968 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
7969 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
7970 pfd
->visited
, pfd
->include_nondeduced_p
))
7971 return error_mark_node
;
7973 /* Since we've already handled the TYPE_ARG_TYPES, we don't
7974 want walk_tree walking into them itself. */
7980 case UNDERLYING_TYPE
:
7981 if (pfd
->include_nondeduced_p
7982 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
7984 pfd
->include_nondeduced_p
))
7985 return error_mark_node
;
7990 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
7991 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
7992 pfd
->visited
, pfd
->include_nondeduced_p
))
7993 return error_mark_node
;
7998 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
7999 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
8000 pfd
->visited
, pfd
->include_nondeduced_p
))
8001 return error_mark_node
;
8002 if (DECL_CONTEXT (t
)
8003 && pfd
->include_nondeduced_p
8004 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
8005 pfd
->visited
, pfd
->include_nondeduced_p
))
8006 return error_mark_node
;
8009 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8010 /* Record template parameters such as `T' inside `TT<T>'. */
8011 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
8012 pfd
->include_nondeduced_p
))
8013 return error_mark_node
;
8016 case TEMPLATE_TEMPLATE_PARM
:
8017 case TEMPLATE_TYPE_PARM
:
8018 case TEMPLATE_PARM_INDEX
:
8019 if (fn
&& (*fn
)(t
, data
))
8020 return error_mark_node
;
8022 return error_mark_node
;
8026 /* A template template parameter is encountered. */
8027 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
8028 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8029 pfd
->include_nondeduced_p
))
8030 return error_mark_node
;
8032 /* Already substituted template template parameter */
8038 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8040 pfd
->include_nondeduced_p
))
8041 return error_mark_node
;
8045 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8046 && pfd
->include_nondeduced_p
8047 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8048 (TREE_TYPE (t
)), fn
, data
,
8049 pfd
->visited
, pfd
->include_nondeduced_p
))
8050 return error_mark_node
;
8055 /* If there's no type, then this thing must be some expression
8056 involving template parameters. */
8057 if (!fn
&& !TREE_TYPE (t
))
8058 return error_mark_node
;
8063 case IMPLICIT_CONV_EXPR
:
8064 case REINTERPRET_CAST_EXPR
:
8065 case CONST_CAST_EXPR
:
8066 case STATIC_CAST_EXPR
:
8067 case DYNAMIC_CAST_EXPR
:
8071 case PSEUDO_DTOR_EXPR
:
8073 return error_mark_node
;
8080 /* We didn't find any template parameters we liked. */
8084 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8085 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8086 call FN with the parameter and the DATA.
8087 If FN returns nonzero, the iteration is terminated, and
8088 for_each_template_parm returns 1. Otherwise, the iteration
8089 continues. If FN never returns a nonzero value, the value
8090 returned by for_each_template_parm is 0. If FN is NULL, it is
8091 considered to be the function which always returns 1.
8093 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8094 parameters that occur in non-deduced contexts. When false, only
8095 visits those template parameters that can be deduced. */
8098 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8099 struct pointer_set_t
*visited
,
8100 bool include_nondeduced_p
)
8102 struct pair_fn_data pfd
;
8108 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8110 /* Walk the tree. (Conceptually, we would like to walk without
8111 duplicates, but for_each_template_parm_r recursively calls
8112 for_each_template_parm, so we would need to reorganize a fair
8113 bit to use walk_tree_without_duplicates, so we keep our own
8116 pfd
.visited
= visited
;
8118 pfd
.visited
= pointer_set_create ();
8119 result
= cp_walk_tree (&t
,
8120 for_each_template_parm_r
,
8122 pfd
.visited
) != NULL_TREE
;
8127 pointer_set_destroy (pfd
.visited
);
8134 /* Returns true if T depends on any template parameter. */
8137 uses_template_parms (tree t
)
8140 int saved_processing_template_decl
;
8142 saved_processing_template_decl
= processing_template_decl
;
8143 if (!saved_processing_template_decl
)
8144 processing_template_decl
= 1;
8146 dependent_p
= dependent_type_p (t
);
8147 else if (TREE_CODE (t
) == TREE_VEC
)
8148 dependent_p
= any_dependent_template_arguments_p (t
);
8149 else if (TREE_CODE (t
) == TREE_LIST
)
8150 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8151 || uses_template_parms (TREE_CHAIN (t
)));
8152 else if (TREE_CODE (t
) == TYPE_DECL
)
8153 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8156 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8157 || TREE_CODE (t
) == OVERLOAD
8160 || TREE_CODE (t
) == TRAIT_EXPR
8161 || TREE_CODE (t
) == CONSTRUCTOR
8162 || CONSTANT_CLASS_P (t
))
8163 dependent_p
= (type_dependent_expression_p (t
)
8164 || value_dependent_expression_p (t
));
8167 gcc_assert (t
== error_mark_node
);
8168 dependent_p
= false;
8171 processing_template_decl
= saved_processing_template_decl
;
8176 /* Returns true iff current_function_decl is an incompletely instantiated
8177 template. Useful instead of processing_template_decl because the latter
8178 is set to 0 during fold_non_dependent_expr. */
8181 in_template_function (void)
8183 tree fn
= current_function_decl
;
8185 ++processing_template_decl
;
8186 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8187 && DECL_TEMPLATE_INFO (fn
)
8188 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8189 --processing_template_decl
;
8193 /* Returns true if T depends on any template parameter with level LEVEL. */
8196 uses_template_parms_level (tree t
, int level
)
8198 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8199 /*include_nondeduced_p=*/true);
8202 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8203 ill-formed translation unit, i.e. a variable or function that isn't
8204 usable in a constant expression. */
8207 neglectable_inst_p (tree d
)
8210 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8211 : decl_maybe_constant_var_p (d
)));
8214 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8215 neglectable and instantiated from within an erroneous instantiation. */
8218 limit_bad_template_recursion (tree decl
)
8220 struct tinst_level
*lev
= current_tinst_level
;
8221 int errs
= errorcount
+ sorrycount
;
8222 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8225 for (; lev
; lev
= lev
->next
)
8226 if (neglectable_inst_p (lev
->decl
))
8229 return (lev
&& errs
> lev
->errors
);
8232 static int tinst_depth
;
8233 extern int max_tinst_depth
;
8236 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8238 /* We're starting to instantiate D; record the template instantiation context
8239 for diagnostics and to restore it later. */
8242 push_tinst_level (tree d
)
8244 struct tinst_level
*new_level
;
8246 if (tinst_depth
>= max_tinst_depth
)
8248 last_error_tinst_level
= current_tinst_level
;
8249 if (TREE_CODE (d
) == TREE_LIST
)
8250 error ("template instantiation depth exceeds maximum of %d (use "
8251 "-ftemplate-depth= to increase the maximum) substituting %qS",
8252 max_tinst_depth
, d
);
8254 error ("template instantiation depth exceeds maximum of %d (use "
8255 "-ftemplate-depth= to increase the maximum) instantiating %qD",
8256 max_tinst_depth
, d
);
8258 print_instantiation_context ();
8263 /* If the current instantiation caused problems, don't let it instantiate
8264 anything else. Do allow deduction substitution and decls usable in
8265 constant expressions. */
8266 if (limit_bad_template_recursion (d
))
8269 new_level
= ggc_alloc
<tinst_level
> ();
8270 new_level
->decl
= d
;
8271 new_level
->locus
= input_location
;
8272 new_level
->errors
= errorcount
+sorrycount
;
8273 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8274 new_level
->next
= current_tinst_level
;
8275 current_tinst_level
= new_level
;
8278 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8279 depth_reached
= tinst_depth
;
8284 /* We're done instantiating this template; return to the instantiation
8288 pop_tinst_level (void)
8290 /* Restore the filename and line number stashed away when we started
8291 this instantiation. */
8292 input_location
= current_tinst_level
->locus
;
8293 current_tinst_level
= current_tinst_level
->next
;
8297 /* We're instantiating a deferred template; restore the template
8298 instantiation context in which the instantiation was requested, which
8299 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8302 reopen_tinst_level (struct tinst_level
*level
)
8304 struct tinst_level
*t
;
8307 for (t
= level
; t
; t
= t
->next
)
8310 current_tinst_level
= level
;
8312 if (current_tinst_level
)
8313 current_tinst_level
->errors
= errorcount
+sorrycount
;
8317 /* Returns the TINST_LEVEL which gives the original instantiation
8320 struct tinst_level
*
8321 outermost_tinst_level (void)
8323 struct tinst_level
*level
= current_tinst_level
;
8326 level
= level
->next
;
8330 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8331 vector of template arguments, as for tsubst.
8333 Returns an appropriate tsubst'd friend declaration. */
8336 tsubst_friend_function (tree decl
, tree args
)
8340 if (TREE_CODE (decl
) == FUNCTION_DECL
8341 && DECL_TEMPLATE_INSTANTIATION (decl
)
8342 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8343 /* This was a friend declared with an explicit template
8344 argument list, e.g.:
8348 to indicate that f was a template instantiation, not a new
8349 function declaration. Now, we have to figure out what
8350 instantiation of what template. */
8352 tree template_id
, arglist
, fns
;
8355 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8357 /* Friend functions are looked up in the containing namespace scope.
8358 We must enter that scope, to avoid finding member functions of the
8359 current class with same name. */
8360 push_nested_namespace (ns
);
8361 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8362 tf_warning_or_error
, NULL_TREE
,
8363 /*integral_constant_expression_p=*/false);
8364 pop_nested_namespace (ns
);
8365 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8366 tf_warning_or_error
, NULL_TREE
);
8367 template_id
= lookup_template_function (fns
, arglist
);
8369 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8370 tmpl
= determine_specialization (template_id
, new_friend
,
8372 /*need_member_template=*/0,
8373 TREE_VEC_LENGTH (args
),
8375 return instantiate_template (tmpl
, new_args
, tf_error
);
8378 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8380 /* The NEW_FRIEND will look like an instantiation, to the
8381 compiler, but is not an instantiation from the point of view of
8382 the language. For example, we might have had:
8384 template <class T> struct S {
8385 template <class U> friend void f(T, U);
8388 Then, in S<int>, template <class U> void f(int, U) is not an
8389 instantiation of anything. */
8390 if (new_friend
== error_mark_node
)
8391 return error_mark_node
;
8393 DECL_USE_TEMPLATE (new_friend
) = 0;
8394 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8396 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8397 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8398 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8401 /* The mangled name for the NEW_FRIEND is incorrect. The function
8402 is not a template instantiation and should not be mangled like
8403 one. Therefore, we forget the mangling here; we'll recompute it
8404 later if we need it. */
8405 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8407 SET_DECL_RTL (new_friend
, NULL
);
8408 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8411 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8414 tree new_friend_template_info
;
8415 tree new_friend_result_template_info
;
8417 int new_friend_is_defn
;
8419 /* We must save some information from NEW_FRIEND before calling
8420 duplicate decls since that function will free NEW_FRIEND if
8422 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8423 new_friend_is_defn
=
8424 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8425 (template_for_substitution (new_friend
)))
8427 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8429 /* This declaration is a `primary' template. */
8430 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8432 new_friend_result_template_info
8433 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8436 new_friend_result_template_info
= NULL_TREE
;
8438 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8439 if (new_friend_is_defn
)
8440 DECL_INITIAL (new_friend
) = error_mark_node
;
8442 /* Inside pushdecl_namespace_level, we will push into the
8443 current namespace. However, the friend function should go
8444 into the namespace of the template. */
8445 ns
= decl_namespace_context (new_friend
);
8446 push_nested_namespace (ns
);
8447 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8448 pop_nested_namespace (ns
);
8450 if (old_decl
== error_mark_node
)
8451 return error_mark_node
;
8453 if (old_decl
!= new_friend
)
8455 /* This new friend declaration matched an existing
8456 declaration. For example, given:
8458 template <class T> void f(T);
8459 template <class U> class C {
8460 template <class T> friend void f(T) {}
8463 the friend declaration actually provides the definition
8464 of `f', once C has been instantiated for some type. So,
8465 old_decl will be the out-of-class template declaration,
8466 while new_friend is the in-class definition.
8468 But, if `f' was called before this point, the
8469 instantiation of `f' will have DECL_TI_ARGS corresponding
8470 to `T' but not to `U', references to which might appear
8471 in the definition of `f'. Previously, the most general
8472 template for an instantiation of `f' was the out-of-class
8473 version; now it is the in-class version. Therefore, we
8474 run through all specialization of `f', adding to their
8475 DECL_TI_ARGS appropriately. In particular, they need a
8476 new set of outer arguments, corresponding to the
8477 arguments for this class instantiation.
8479 The same situation can arise with something like this:
8482 template <class T> class C {
8486 when `C<int>' is instantiated. Now, `f(int)' is defined
8489 if (!new_friend_is_defn
)
8490 /* On the other hand, if the in-class declaration does
8491 *not* provide a definition, then we don't want to alter
8492 existing definitions. We can just leave everything
8497 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8498 tree new_args
= TI_ARGS (new_friend_template_info
);
8500 /* Overwrite whatever template info was there before, if
8501 any, with the new template information pertaining to
8503 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8505 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8507 /* We should have called reregister_specialization in
8509 gcc_assert (retrieve_specialization (new_template
,
8513 /* Instantiate it if the global has already been used. */
8514 if (DECL_ODR_USED (old_decl
))
8515 instantiate_decl (old_decl
, /*defer_ok=*/true,
8516 /*expl_inst_class_mem_p=*/false);
8522 /* Indicate that the old function template is a partial
8524 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8525 = new_friend_result_template_info
;
8527 gcc_assert (new_template
8528 == most_general_template (new_template
));
8529 gcc_assert (new_template
!= old_decl
);
8531 /* Reassign any specializations already in the hash table
8532 to the new more general template, and add the
8533 additional template args. */
8534 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8538 tree spec
= TREE_VALUE (t
);
8541 elt
.tmpl
= old_decl
;
8542 elt
.args
= DECL_TI_ARGS (spec
);
8543 elt
.spec
= NULL_TREE
;
8545 htab_remove_elt (decl_specializations
, &elt
);
8548 = add_outermost_template_args (new_args
,
8549 DECL_TI_ARGS (spec
));
8551 register_specialization
8552 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8555 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8559 /* The information from NEW_FRIEND has been merged into OLD_DECL
8560 by duplicate_decls. */
8561 new_friend
= old_decl
;
8566 tree context
= DECL_CONTEXT (new_friend
);
8570 template <class T> class C {
8571 template <class U> friend void C1<U>::f (); // case 1
8572 friend void C2<T>::f (); // case 2
8574 we only need to make sure CONTEXT is a complete type for
8575 case 2. To distinguish between the two cases, we note that
8576 CONTEXT of case 1 remains dependent type after tsubst while
8577 this isn't true for case 2. */
8578 ++processing_template_decl
;
8579 dependent_p
= dependent_type_p (context
);
8580 --processing_template_decl
;
8583 && !complete_type_or_else (context
, NULL_TREE
))
8584 return error_mark_node
;
8586 if (COMPLETE_TYPE_P (context
))
8588 tree fn
= new_friend
;
8589 /* do_friend adds the TEMPLATE_DECL for any member friend
8590 template even if it isn't a member template, i.e.
8591 template <class T> friend A<T>::f();
8592 Look through it in that case. */
8593 if (TREE_CODE (fn
) == TEMPLATE_DECL
8594 && !PRIMARY_TEMPLATE_P (fn
))
8595 fn
= DECL_TEMPLATE_RESULT (fn
);
8596 /* Check to see that the declaration is really present, and,
8597 possibly obtain an improved declaration. */
8598 fn
= check_classfn (context
, fn
, NULL_TREE
);
8608 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8609 template arguments, as for tsubst.
8611 Returns an appropriate tsubst'd friend type or error_mark_node on
8615 tsubst_friend_class (tree friend_tmpl
, tree args
)
8621 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8623 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8624 return TREE_TYPE (t
);
8627 context
= CP_DECL_CONTEXT (friend_tmpl
);
8629 if (context
!= global_namespace
)
8631 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8632 push_nested_namespace (context
);
8634 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8637 /* Look for a class template declaration. We look for hidden names
8638 because two friend declarations of the same template are the
8639 same. For example, in:
8642 template <typename> friend class F;
8644 template <typename> struct B {
8645 template <typename> friend class F;
8648 both F templates are the same. */
8649 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8650 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8652 /* But, if we don't find one, it might be because we're in a
8653 situation like this:
8661 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8662 for `S<int>', not the TEMPLATE_DECL. */
8663 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8665 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8666 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8669 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8671 /* The friend template has already been declared. Just
8672 check to see that the declarations match, and install any new
8673 default parameters. We must tsubst the default parameters,
8674 of course. We only need the innermost template parameters
8675 because that is all that redeclare_class_template will look
8677 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8678 > TMPL_ARGS_DEPTH (args
))
8681 location_t saved_input_location
;
8682 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8683 args
, tf_warning_or_error
);
8685 saved_input_location
= input_location
;
8686 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8687 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8688 input_location
= saved_input_location
;
8692 friend_type
= TREE_TYPE (tmpl
);
8696 /* The friend template has not already been declared. In this
8697 case, the instantiation of the template class will cause the
8698 injection of this template into the global scope. */
8699 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8700 if (tmpl
== error_mark_node
)
8701 return error_mark_node
;
8703 /* The new TMPL is not an instantiation of anything, so we
8704 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8705 the new type because that is supposed to be the corresponding
8706 template decl, i.e., TMPL. */
8707 DECL_USE_TEMPLATE (tmpl
) = 0;
8708 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8709 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8710 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8711 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8713 /* Inject this template into the global scope. */
8714 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8717 if (context
!= global_namespace
)
8719 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8720 pop_nested_namespace (context
);
8722 pop_nested_class ();
8728 /* Returns zero if TYPE cannot be completed later due to circularity.
8729 Otherwise returns one. */
8732 can_complete_type_without_circularity (tree type
)
8734 if (type
== NULL_TREE
|| type
== error_mark_node
)
8736 else if (COMPLETE_TYPE_P (type
))
8738 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8739 return can_complete_type_without_circularity (TREE_TYPE (type
));
8740 else if (CLASS_TYPE_P (type
)
8741 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
8747 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
8749 /* Apply any attributes which had to be deferred until instantiation
8750 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8751 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8754 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
8755 tree args
, tsubst_flags_t complain
, tree in_decl
)
8757 tree last_dep
= NULL_TREE
;
8761 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
8762 if (ATTR_IS_DEPENDENT (t
))
8765 attributes
= copy_list (attributes
);
8769 if (DECL_P (*decl_p
))
8771 if (TREE_TYPE (*decl_p
) == error_mark_node
)
8773 p
= &DECL_ATTRIBUTES (*decl_p
);
8776 p
= &TYPE_ATTRIBUTES (*decl_p
);
8780 tree late_attrs
= NULL_TREE
;
8781 tree
*q
= &late_attrs
;
8783 for (*p
= attributes
; *p
; )
8786 if (ATTR_IS_DEPENDENT (t
))
8788 *p
= TREE_CHAIN (t
);
8789 TREE_CHAIN (t
) = NULL_TREE
;
8790 if ((flag_openmp
|| flag_cilkplus
)
8791 && is_attribute_p ("omp declare simd",
8792 get_attribute_name (t
))
8795 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
8796 clauses
= tsubst_omp_clauses (clauses
, true, args
,
8798 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
8799 clauses
= finish_omp_clauses (clauses
);
8800 tree parms
= DECL_ARGUMENTS (*decl_p
);
8802 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
8804 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
8806 TREE_VALUE (t
) = NULL_TREE
;
8808 /* If the first attribute argument is an identifier, don't
8809 pass it through tsubst. Attributes like mode, format,
8810 cleanup and several target specific attributes expect it
8812 else if (attribute_takes_identifier_p (get_attribute_name (t
))
8816 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
8818 /*integral_constant_expression_p=*/false);
8819 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
8821 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
8826 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
8827 /*integral_constant_expression_p=*/false);
8829 q
= &TREE_CHAIN (t
);
8832 p
= &TREE_CHAIN (t
);
8835 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
8839 /* Perform (or defer) access check for typedefs that were referenced
8840 from within the template TMPL code.
8841 This is a subroutine of instantiate_decl and instantiate_class_template.
8842 TMPL is the template to consider and TARGS is the list of arguments of
8846 perform_typedefs_access_check (tree tmpl
, tree targs
)
8848 location_t saved_location
;
8850 qualified_typedef_usage_t
*iter
;
8853 || (!CLASS_TYPE_P (tmpl
)
8854 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
8857 saved_location
= input_location
;
8858 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
8860 tree type_decl
= iter
->typedef_decl
;
8861 tree type_scope
= iter
->context
;
8863 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
8866 if (uses_template_parms (type_decl
))
8867 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
8868 if (uses_template_parms (type_scope
))
8869 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
8871 /* Make access check error messages point to the location
8872 of the use of the typedef. */
8873 input_location
= iter
->locus
;
8874 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
8875 type_decl
, type_decl
,
8876 tf_warning_or_error
);
8878 input_location
= saved_location
;
8882 instantiate_class_template_1 (tree type
)
8884 tree templ
, args
, pattern
, t
, member
;
8888 unsigned int saved_maximum_field_alignment
;
8891 if (type
== error_mark_node
)
8892 return error_mark_node
;
8894 if (COMPLETE_OR_OPEN_TYPE_P (type
)
8895 || uses_template_parms (type
))
8898 /* Figure out which template is being instantiated. */
8899 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
8900 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
8902 /* Determine what specialization of the original template to
8904 t
= most_specialized_class (type
, tf_warning_or_error
);
8905 if (t
== error_mark_node
)
8907 TYPE_BEING_DEFINED (type
) = 1;
8908 return error_mark_node
;
8912 /* This TYPE is actually an instantiation of a partial
8913 specialization. We replace the innermost set of ARGS with
8914 the arguments appropriate for substitution. For example,
8917 template <class T> struct S {};
8918 template <class T> struct S<T*> {};
8920 and supposing that we are instantiating S<int*>, ARGS will
8921 presently be {int*} -- but we need {int}. */
8922 pattern
= TREE_TYPE (t
);
8923 args
= TREE_PURPOSE (t
);
8927 pattern
= TREE_TYPE (templ
);
8928 args
= CLASSTYPE_TI_ARGS (type
);
8931 /* If the template we're instantiating is incomplete, then clearly
8932 there's nothing we can do. */
8933 if (!COMPLETE_TYPE_P (pattern
))
8936 /* If we've recursively instantiated too many templates, stop. */
8937 if (! push_tinst_level (type
))
8940 /* Now we're really doing the instantiation. Mark the type as in
8941 the process of being defined. */
8942 TYPE_BEING_DEFINED (type
) = 1;
8944 /* We may be in the middle of deferred access check. Disable
8946 push_deferring_access_checks (dk_no_deferred
);
8948 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
8949 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
8950 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
8951 fn_context
= error_mark_node
;
8953 push_to_top_level ();
8954 /* Use #pragma pack from the template context. */
8955 saved_maximum_field_alignment
= maximum_field_alignment
;
8956 maximum_field_alignment
= TYPE_PRECISION (pattern
);
8958 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
8960 /* Set the input location to the most specialized template definition.
8961 This is needed if tsubsting causes an error. */
8962 typedecl
= TYPE_MAIN_DECL (pattern
);
8963 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
8964 DECL_SOURCE_LOCATION (typedecl
);
8966 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
8967 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
8968 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
8969 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
8970 if (ANON_AGGR_TYPE_P (pattern
))
8971 SET_ANON_AGGR_TYPE_P (type
);
8972 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
8974 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
8975 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
8976 /* Adjust visibility for template arguments. */
8977 determine_visibility (TYPE_MAIN_DECL (type
));
8979 if (CLASS_TYPE_P (type
))
8980 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
8982 pbinfo
= TYPE_BINFO (pattern
);
8984 /* We should never instantiate a nested class before its enclosing
8985 class; we need to look up the nested class by name before we can
8986 instantiate it, and that lookup should instantiate the enclosing
8988 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
8989 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
8991 base_list
= NULL_TREE
;
8992 if (BINFO_N_BASE_BINFOS (pbinfo
))
8998 /* We must enter the scope containing the type, as that is where
8999 the accessibility of types named in dependent bases are
9001 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9003 /* Substitute into each of the bases to determine the actual
9005 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9008 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9009 tree expanded_bases
= NULL_TREE
;
9012 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9015 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9016 args
, tf_error
, NULL_TREE
);
9017 if (expanded_bases
== error_mark_node
)
9020 len
= TREE_VEC_LENGTH (expanded_bases
);
9023 for (idx
= 0; idx
< len
; idx
++)
9026 /* Extract the already-expanded base class. */
9027 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9029 /* Substitute to figure out the base class. */
9030 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9033 if (base
== error_mark_node
)
9036 base_list
= tree_cons (access
, base
, base_list
);
9037 if (BINFO_VIRTUAL_P (pbase_binfo
))
9038 TREE_TYPE (base_list
) = integer_type_node
;
9042 /* The list is now in reverse order; correct that. */
9043 base_list
= nreverse (base_list
);
9046 pop_scope (pushed_scope
);
9048 /* Now call xref_basetypes to set up all the base-class
9050 xref_basetypes (type
, base_list
);
9052 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9053 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9054 args
, tf_error
, NULL_TREE
);
9055 fixup_attribute_variants (type
);
9057 /* Now that our base classes are set up, enter the scope of the
9058 class, so that name lookups into base classes, etc. will work
9059 correctly. This is precisely analogous to what we do in
9060 begin_class_definition when defining an ordinary non-template
9061 class, except we also need to push the enclosing classes. */
9062 push_nested_class (type
);
9064 /* Now members are processed in the order of declaration. */
9065 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9066 member
; member
= TREE_CHAIN (member
))
9068 tree t
= TREE_VALUE (member
);
9070 if (TREE_PURPOSE (member
))
9074 /* Build new CLASSTYPE_NESTED_UTDS. */
9077 bool class_template_p
;
9079 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9080 && TYPE_LANG_SPECIFIC (t
)
9081 && CLASSTYPE_IS_TEMPLATE (t
));
9082 /* If the member is a class template, then -- even after
9083 substitution -- there may be dependent types in the
9084 template argument list for the class. We increment
9085 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9086 that function will assume that no types are dependent
9087 when outside of a template. */
9088 if (class_template_p
)
9089 ++processing_template_decl
;
9090 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9091 if (class_template_p
)
9092 --processing_template_decl
;
9093 if (newtag
== error_mark_node
)
9096 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9098 tree name
= TYPE_IDENTIFIER (t
);
9100 if (class_template_p
)
9101 /* Unfortunately, lookup_template_class sets
9102 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9103 instantiation (i.e., for the type of a member
9104 template class nested within a template class.)
9105 This behavior is required for
9106 maybe_process_partial_specialization to work
9107 correctly, but is not accurate in this case;
9108 the TAG is not an instantiation of anything.
9109 (The corresponding TEMPLATE_DECL is an
9110 instantiation, but the TYPE is not.) */
9111 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9113 /* Now, we call pushtag to put this NEWTAG into the scope of
9114 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9115 pushtag calling push_template_decl. We don't have to do
9116 this for enums because it will already have been done in
9119 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9120 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9123 else if (DECL_DECLARES_FUNCTION_P (t
))
9125 /* Build new TYPE_METHODS. */
9128 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9129 ++processing_template_decl
;
9130 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9131 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9132 --processing_template_decl
;
9133 set_current_access_from_decl (r
);
9134 finish_member_declaration (r
);
9135 /* Instantiate members marked with attribute used. */
9136 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9138 if (TREE_CODE (r
) == FUNCTION_DECL
9139 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9140 cp_check_omp_declare_reduction (r
);
9144 /* Build new TYPE_FIELDS. */
9145 if (TREE_CODE (t
) == STATIC_ASSERT
)
9149 ++c_inhibit_evaluation_warnings
;
9151 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9152 tf_warning_or_error
, NULL_TREE
,
9153 /*integral_constant_expression_p=*/true);
9154 --c_inhibit_evaluation_warnings
;
9156 finish_static_assert (condition
,
9157 STATIC_ASSERT_MESSAGE (t
),
9158 STATIC_ASSERT_SOURCE_LOCATION (t
),
9161 else if (TREE_CODE (t
) != CONST_DECL
)
9164 tree vec
= NULL_TREE
;
9167 /* The file and line for this declaration, to
9168 assist in error message reporting. Since we
9169 called push_tinst_level above, we don't need to
9171 input_location
= DECL_SOURCE_LOCATION (t
);
9173 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9174 ++processing_template_decl
;
9175 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9176 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9177 --processing_template_decl
;
9179 if (TREE_CODE (r
) == TREE_VEC
)
9181 /* A capture pack became multiple fields. */
9183 len
= TREE_VEC_LENGTH (vec
);
9186 for (int i
= 0; i
< len
; ++i
)
9189 r
= TREE_VEC_ELT (vec
, i
);
9194 [t]he initialization (and any associated
9195 side-effects) of a static data member does
9196 not occur unless the static data member is
9197 itself used in a way that requires the
9198 definition of the static data member to
9201 Therefore, we do not substitute into the
9202 initialized for the static data member here. */
9203 finish_static_data_member_decl
9206 /*init_const_expr_p=*/false,
9207 /*asmspec_tree=*/NULL_TREE
,
9209 /* Instantiate members marked with attribute used. */
9210 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9213 else if (TREE_CODE (r
) == FIELD_DECL
)
9215 /* Determine whether R has a valid type and can be
9216 completed later. If R is invalid, then its type
9217 is replaced by error_mark_node. */
9218 tree rtype
= TREE_TYPE (r
);
9219 if (can_complete_type_without_circularity (rtype
))
9220 complete_type (rtype
);
9222 if (!COMPLETE_TYPE_P (rtype
))
9224 cxx_incomplete_type_error (r
, rtype
);
9225 TREE_TYPE (r
) = error_mark_node
;
9229 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9230 such a thing will already have been added to the field
9231 list by tsubst_enum in finish_member_declaration in the
9232 CLASSTYPE_NESTED_UTDS case above. */
9233 if (!(TREE_CODE (r
) == TYPE_DECL
9234 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9235 && DECL_ARTIFICIAL (r
)))
9237 set_current_access_from_decl (r
);
9238 finish_member_declaration (r
);
9246 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9247 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9249 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9251 tree friend_type
= t
;
9252 bool adjust_processing_template_decl
= false;
9254 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9256 /* template <class T> friend class C; */
9257 friend_type
= tsubst_friend_class (friend_type
, args
);
9258 adjust_processing_template_decl
= true;
9260 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9262 /* template <class T> friend class C::D; */
9263 friend_type
= tsubst (friend_type
, args
,
9264 tf_warning_or_error
, NULL_TREE
);
9265 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9266 friend_type
= TREE_TYPE (friend_type
);
9267 adjust_processing_template_decl
= true;
9269 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9270 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9272 /* This could be either
9276 when dependent_type_p is false or
9278 template <class U> friend class T::C;
9281 friend_type
= tsubst (friend_type
, args
,
9282 tf_warning_or_error
, NULL_TREE
);
9283 /* Bump processing_template_decl for correct
9284 dependent_type_p calculation. */
9285 ++processing_template_decl
;
9286 if (dependent_type_p (friend_type
))
9287 adjust_processing_template_decl
= true;
9288 --processing_template_decl
;
9290 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9291 && hidden_name_p (TYPE_NAME (friend_type
)))
9295 where C hasn't been declared yet. Let's lookup name
9296 from namespace scope directly, bypassing any name that
9297 come from dependent base class. */
9298 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9300 /* The call to xref_tag_from_type does injection for friend
9302 push_nested_namespace (ns
);
9304 xref_tag_from_type (friend_type
, NULL_TREE
,
9305 /*tag_scope=*/ts_current
);
9306 pop_nested_namespace (ns
);
9308 else if (uses_template_parms (friend_type
))
9309 /* friend class C<T>; */
9310 friend_type
= tsubst (friend_type
, args
,
9311 tf_warning_or_error
, NULL_TREE
);
9316 where C is already declared or
9318 friend class C<int>;
9320 We don't have to do anything in these cases. */
9322 if (adjust_processing_template_decl
)
9323 /* Trick make_friend_class into realizing that the friend
9324 we're adding is a template, not an ordinary class. It's
9325 important that we use make_friend_class since it will
9326 perform some error-checking and output cross-reference
9328 ++processing_template_decl
;
9330 if (friend_type
!= error_mark_node
)
9331 make_friend_class (type
, friend_type
, /*complain=*/false);
9333 if (adjust_processing_template_decl
)
9334 --processing_template_decl
;
9338 /* Build new DECL_FRIENDLIST. */
9341 /* The file and line for this declaration, to
9342 assist in error message reporting. Since we
9343 called push_tinst_level above, we don't need to
9345 input_location
= DECL_SOURCE_LOCATION (t
);
9347 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9349 ++processing_template_decl
;
9350 push_deferring_access_checks (dk_no_check
);
9353 r
= tsubst_friend_function (t
, args
);
9354 add_friend (type
, r
, /*complain=*/false);
9355 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9357 pop_deferring_access_checks ();
9358 --processing_template_decl
;
9364 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9366 tree decl
= lambda_function (type
);
9369 if (!DECL_TEMPLATE_INFO (decl
)
9370 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9371 instantiate_decl (decl
, false, false);
9373 /* We need to instantiate the capture list from the template
9374 after we've instantiated the closure members, but before we
9375 consider adding the conversion op. Also keep any captures
9376 that may have been added during instantiation of the op(). */
9377 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9379 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9380 args
, tf_warning_or_error
, NULL_TREE
,
9383 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9384 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9386 maybe_add_lambda_conv_op (type
);
9389 gcc_assert (errorcount
);
9392 /* Set the file and line number information to whatever is given for
9393 the class itself. This puts error messages involving generated
9394 implicit functions at a predictable point, and the same point
9395 that would be used for non-template classes. */
9396 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9398 unreverse_member_declarations (type
);
9399 finish_struct_1 (type
);
9400 TYPE_BEING_DEFINED (type
) = 0;
9402 /* We don't instantiate default arguments for member functions. 14.7.1:
9404 The implicit instantiation of a class template specialization causes
9405 the implicit instantiation of the declarations, but not of the
9406 definitions or default arguments, of the class member functions,
9407 member classes, static data members and member templates.... */
9409 /* Some typedefs referenced from within the template code need to be access
9410 checked at template instantiation time, i.e now. These types were
9411 added to the template at parsing time. Let's get those and perform
9412 the access checks then. */
9413 perform_typedefs_access_check (pattern
, args
);
9414 perform_deferred_access_checks (tf_warning_or_error
);
9415 pop_nested_class ();
9416 maximum_field_alignment
= saved_maximum_field_alignment
;
9418 pop_from_top_level ();
9419 pop_deferring_access_checks ();
9422 /* The vtable for a template class can be emitted in any translation
9423 unit in which the class is instantiated. When there is no key
9424 method, however, finish_struct_1 will already have added TYPE to
9425 the keyed_classes list. */
9426 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9427 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9432 /* Wrapper for instantiate_class_template_1. */
9435 instantiate_class_template (tree type
)
9438 timevar_push (TV_TEMPLATE_INST
);
9439 ret
= instantiate_class_template_1 (type
);
9440 timevar_pop (TV_TEMPLATE_INST
);
9445 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9451 else if (TYPE_P (t
))
9452 r
= tsubst (t
, args
, complain
, in_decl
);
9455 if (!(complain
& tf_warning
))
9456 ++c_inhibit_evaluation_warnings
;
9457 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9458 /*integral_constant_expression_p=*/true);
9459 if (!(complain
& tf_warning
))
9460 --c_inhibit_evaluation_warnings
;
9465 /* Given a function parameter pack TMPL_PARM and some function parameters
9466 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9467 and set *SPEC_P to point at the next point in the list. */
9470 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9472 /* Collect all of the extra "packed" parameters into an
9476 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9477 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9478 tree spec_parm
= *spec_p
;
9481 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9483 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9486 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9487 parmvec
= make_tree_vec (len
);
9488 parmtypevec
= make_tree_vec (len
);
9489 spec_parm
= *spec_p
;
9490 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9492 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9493 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9496 /* Build the argument packs. */
9497 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9498 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9499 TREE_TYPE (argpack
) = argtypepack
;
9500 *spec_p
= spec_parm
;
9505 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9506 NONTYPE_ARGUMENT_PACK. */
9509 make_fnparm_pack (tree spec_parm
)
9511 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9514 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9518 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9520 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9521 if (i
>= TREE_VEC_LENGTH (vec
))
9523 return PACK_EXPANSION_P (TREE_VEC_ELT (vec
, i
));
9527 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9530 make_argument_pack_select (tree arg_pack
, unsigned index
)
9532 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9534 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9535 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9540 /* This is a subroutine of tsubst_pack_expansion.
9542 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9543 mechanism to store the (non complete list of) arguments of the
9544 substitution and return a non substituted pack expansion, in order
9545 to wait for when we have enough arguments to really perform the
9549 use_pack_expansion_extra_args_p (tree parm_packs
,
9553 /* If one pack has an expansion and another pack has a normal
9554 argument or if one pack has an empty argument and an another
9555 one hasn't then tsubst_pack_expansion cannot perform the
9556 substitution and need to fall back on the
9557 PACK_EXPANSION_EXTRA mechanism. */
9558 if (parm_packs
== NULL_TREE
)
9560 else if (has_empty_arg
)
9563 bool has_expansion_arg
= false;
9564 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9566 bool has_non_expansion_arg
= false;
9567 for (tree parm_pack
= parm_packs
;
9569 parm_pack
= TREE_CHAIN (parm_pack
))
9571 tree arg
= TREE_VALUE (parm_pack
);
9573 if (argument_pack_element_is_expansion_p (arg
, i
))
9574 has_expansion_arg
= true;
9576 has_non_expansion_arg
= true;
9579 if (has_expansion_arg
&& has_non_expansion_arg
)
9585 /* [temp.variadic]/6 says that:
9587 The instantiation of a pack expansion [...]
9588 produces a list E1,E2, ..., En, where N is the number of elements
9589 in the pack expansion parameters.
9591 This subroutine of tsubst_pack_expansion produces one of these Ei.
9593 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9594 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9595 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9596 INDEX is the index 'i' of the element Ei to produce. ARGS,
9597 COMPLAIN, and IN_DECL are the same parameters as for the
9598 tsubst_pack_expansion function.
9600 The function returns the resulting Ei upon successful completion,
9603 Note that this function possibly modifies the ARGS parameter, so
9604 it's the responsibility of the caller to restore it. */
9607 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9610 tree args
/* This parm gets
9612 tsubst_flags_t complain
,
9616 bool ith_elem_is_expansion
= false;
9618 /* For each parameter pack, change the substitution of the parameter
9619 pack to the ith argument in its argument pack, then expand the
9621 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9623 tree parm
= TREE_PURPOSE (pack
);
9624 tree arg_pack
= TREE_VALUE (pack
);
9625 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9627 ith_elem_is_expansion
|=
9628 argument_pack_element_is_expansion_p (arg_pack
, index
);
9630 /* Select the Ith argument from the pack. */
9631 if (TREE_CODE (parm
) == PARM_DECL
9632 || TREE_CODE (parm
) == FIELD_DECL
)
9636 aps
= make_argument_pack_select (arg_pack
, index
);
9638 register_local_specialization (aps
, parm
);
9641 aps
= retrieve_local_specialization (parm
);
9646 template_parm_level_and_index (parm
, &level
, &idx
);
9650 aps
= make_argument_pack_select (arg_pack
, index
);
9651 /* Update the corresponding argument. */
9652 TMPL_ARG (args
, level
, idx
) = aps
;
9655 /* Re-use the ARGUMENT_PACK_SELECT. */
9656 aps
= TMPL_ARG (args
, level
, idx
);
9658 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9661 /* Substitute into the PATTERN with the (possibly altered)
9663 if (pattern
== in_decl
)
9664 /* Expanding a fixed parameter pack from
9665 coerce_template_parameter_pack. */
9666 t
= tsubst_decl (pattern
, args
, complain
);
9667 else if (!TYPE_P (pattern
))
9668 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9669 /*integral_constant_expression_p=*/false);
9671 t
= tsubst (pattern
, args
, complain
, in_decl
);
9673 /* If the Ith argument pack element is a pack expansion, then
9674 the Ith element resulting from the substituting is going to
9675 be a pack expansion as well. */
9676 if (ith_elem_is_expansion
)
9677 t
= make_pack_expansion (t
);
9682 /* Substitute ARGS into T, which is an pack expansion
9683 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9684 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9685 (if only a partial substitution could be performed) or
9686 ERROR_MARK_NODE if there was an error. */
9688 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9692 tree pack
, packs
= NULL_TREE
;
9693 bool unsubstituted_packs
= false;
9696 struct pointer_map_t
*saved_local_specializations
= NULL
;
9697 bool need_local_specializations
= false;
9700 gcc_assert (PACK_EXPANSION_P (t
));
9701 pattern
= PACK_EXPANSION_PATTERN (t
);
9703 /* Add in any args remembered from an earlier partial instantiation. */
9704 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9706 levels
= TMPL_ARGS_DEPTH (args
);
9708 /* Determine the argument packs that will instantiate the parameter
9709 packs used in the expansion expression. While we're at it,
9710 compute the number of arguments to be expanded and make sure it
9712 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
9713 pack
= TREE_CHAIN (pack
))
9715 tree parm_pack
= TREE_VALUE (pack
);
9716 tree arg_pack
= NULL_TREE
;
9717 tree orig_arg
= NULL_TREE
;
9720 if (TREE_CODE (parm_pack
) == BASES
)
9722 if (BASES_DIRECT (parm_pack
))
9723 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9724 args
, complain
, in_decl
, false));
9726 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9727 args
, complain
, in_decl
, false));
9729 if (TREE_CODE (parm_pack
) == PARM_DECL
)
9731 if (PACK_EXPANSION_LOCAL_P (t
))
9732 arg_pack
= retrieve_local_specialization (parm_pack
);
9735 /* We can't rely on local_specializations for a parameter
9736 name used later in a function declaration (such as in a
9737 late-specified return type). Even if it exists, it might
9738 have the wrong value for a recursive call. Just make a
9739 dummy decl, since it's only used for its type. */
9740 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
9741 if (arg_pack
&& DECL_PACK_P (arg_pack
))
9742 /* Partial instantiation of the parm_pack, we can't build
9743 up an argument pack yet. */
9744 arg_pack
= NULL_TREE
;
9746 arg_pack
= make_fnparm_pack (arg_pack
);
9747 need_local_specializations
= true;
9750 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
9751 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
9755 template_parm_level_and_index (parm_pack
, &level
, &idx
);
9757 if (level
<= levels
)
9758 arg_pack
= TMPL_ARG (args
, level
, idx
);
9761 orig_arg
= arg_pack
;
9762 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
9763 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
9765 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
9766 /* This can only happen if we forget to expand an argument
9767 pack somewhere else. Just return an error, silently. */
9769 result
= make_tree_vec (1);
9770 TREE_VEC_ELT (result
, 0) = error_mark_node
;
9777 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
9779 /* Don't bother trying to do a partial substitution with
9780 incomplete packs; we'll try again after deduction. */
9781 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
9786 else if (len
!= my_len
)
9788 if (!(complain
& tf_error
))
9789 /* Fail quietly. */;
9790 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
9791 error ("mismatched argument pack lengths while expanding "
9795 error ("mismatched argument pack lengths while expanding "
9798 return error_mark_node
;
9801 /* Keep track of the parameter packs and their corresponding
9803 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
9804 TREE_TYPE (packs
) = orig_arg
;
9808 /* We can't substitute for this parameter pack. We use a flag as
9809 well as the missing_level counter because function parameter
9810 packs don't have a level. */
9811 unsubstituted_packs
= true;
9815 /* We cannot expand this expansion expression, because we don't have
9816 all of the argument packs we need. */
9817 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
9819 /* We got some full packs, but we can't substitute them in until we
9820 have values for all the packs. So remember these until then. */
9822 t
= make_pack_expansion (pattern
);
9823 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
9826 else if (unsubstituted_packs
)
9828 /* There were no real arguments, we're just replacing a parameter
9829 pack with another version of itself. Substitute into the
9830 pattern and return a PACK_EXPANSION_*. The caller will need to
9832 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
9833 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9834 /*integral_constant_expression_p=*/false);
9836 t
= tsubst (pattern
, args
, complain
, in_decl
);
9837 t
= make_pack_expansion (t
);
9841 gcc_assert (len
>= 0);
9843 if (need_local_specializations
)
9845 /* We're in a late-specified return type, so create our own local
9846 specializations map; the current map is either NULL or (in the
9847 case of recursive unification) might have bindings that we don't
9848 want to use or alter. */
9849 saved_local_specializations
= local_specializations
;
9850 local_specializations
= pointer_map_create ();
9853 /* For each argument in each argument pack, substitute into the
9855 result
= make_tree_vec (len
);
9856 for (i
= 0; i
< len
; ++i
)
9858 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
9862 TREE_VEC_ELT (result
, i
) = t
;
9863 if (t
== error_mark_node
)
9865 result
= error_mark_node
;
9870 /* Update ARGS to restore the substitution from parameter packs to
9871 their argument packs. */
9872 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
9874 tree parm
= TREE_PURPOSE (pack
);
9876 if (TREE_CODE (parm
) == PARM_DECL
9877 || TREE_CODE (parm
) == FIELD_DECL
)
9878 register_local_specialization (TREE_TYPE (pack
), parm
);
9883 if (TREE_VALUE (pack
) == NULL_TREE
)
9886 template_parm_level_and_index (parm
, &level
, &idx
);
9888 /* Update the corresponding argument. */
9889 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
9890 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
9893 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
9897 if (need_local_specializations
)
9899 pointer_map_destroy (local_specializations
);
9900 local_specializations
= saved_local_specializations
;
9906 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
9907 TMPL. We do this using DECL_PARM_INDEX, which should work even with
9908 parameter packs; all parms generated from a function parameter pack will
9909 have the same DECL_PARM_INDEX. */
9912 get_pattern_parm (tree parm
, tree tmpl
)
9914 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
9917 if (DECL_ARTIFICIAL (parm
))
9919 for (patparm
= DECL_ARGUMENTS (pattern
);
9920 patparm
; patparm
= DECL_CHAIN (patparm
))
9921 if (DECL_ARTIFICIAL (patparm
)
9922 && DECL_NAME (parm
) == DECL_NAME (patparm
))
9927 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
9928 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
9929 gcc_assert (DECL_PARM_INDEX (patparm
)
9930 == DECL_PARM_INDEX (parm
));
9936 /* Substitute ARGS into the vector or list of template arguments T. */
9939 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9942 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
9945 if (t
== error_mark_node
)
9946 return error_mark_node
;
9948 len
= TREE_VEC_LENGTH (t
);
9949 elts
= XALLOCAVEC (tree
, len
);
9951 for (i
= 0; i
< len
; i
++)
9953 tree orig_arg
= TREE_VEC_ELT (t
, i
);
9956 if (TREE_CODE (orig_arg
) == TREE_VEC
)
9957 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
9958 else if (PACK_EXPANSION_P (orig_arg
))
9960 /* Substitute into an expansion expression. */
9961 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
9963 if (TREE_CODE (new_arg
) == TREE_VEC
)
9964 /* Add to the expanded length adjustment the number of
9965 expanded arguments. We subtract one from this
9966 measurement, because the argument pack expression
9967 itself is already counted as 1 in
9968 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
9969 the argument pack is empty. */
9970 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
9972 else if (ARGUMENT_PACK_P (orig_arg
))
9974 /* Substitute into each of the arguments. */
9975 new_arg
= TYPE_P (orig_arg
)
9976 ? cxx_make_type (TREE_CODE (orig_arg
))
9977 : make_node (TREE_CODE (orig_arg
));
9979 SET_ARGUMENT_PACK_ARGS (
9981 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
9982 args
, complain
, in_decl
));
9984 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
9985 new_arg
= error_mark_node
;
9987 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
9988 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
9990 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
9992 if (TREE_TYPE (new_arg
) == error_mark_node
)
9993 new_arg
= error_mark_node
;
9997 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
9999 if (new_arg
== error_mark_node
)
10000 return error_mark_node
;
10003 if (new_arg
!= orig_arg
)
10010 /* Make space for the expanded arguments coming from template
10012 t
= make_tree_vec (len
+ expanded_len_adjust
);
10013 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10014 arguments for a member template.
10015 In that case each TREE_VEC in ORIG_T represents a level of template
10016 arguments, and ORIG_T won't carry any non defaulted argument count.
10017 It will rather be the nested TREE_VECs that will carry one.
10018 In other words, ORIG_T carries a non defaulted argument count only
10019 if it doesn't contain any nested TREE_VEC. */
10020 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
10022 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
10023 count
+= expanded_len_adjust
;
10024 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
10026 for (i
= 0, out
= 0; i
< len
; i
++)
10028 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
10029 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
10030 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10034 /* Now expand the template argument pack "in place". */
10035 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10036 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10040 TREE_VEC_ELT (t
, out
) = elts
[i
];
10048 /* Return the result of substituting ARGS into the template parameters
10049 given by PARMS. If there are m levels of ARGS and m + n levels of
10050 PARMS, then the result will contain n levels of PARMS. For
10051 example, if PARMS is `template <class T> template <class U>
10052 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10053 result will be `template <int*, double, class V>'. */
10056 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10058 tree r
= NULL_TREE
;
10061 /* When substituting into a template, we must set
10062 PROCESSING_TEMPLATE_DECL as the template parameters may be
10063 dependent if they are based on one-another, and the dependency
10064 predicates are short-circuit outside of templates. */
10065 ++processing_template_decl
;
10067 for (new_parms
= &r
;
10068 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10069 new_parms
= &(TREE_CHAIN (*new_parms
)),
10070 parms
= TREE_CHAIN (parms
))
10073 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10076 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10080 if (parms
== error_mark_node
)
10083 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10085 if (tuple
== error_mark_node
)
10088 TREE_VEC_ELT (new_vec
, i
) =
10089 tsubst_template_parm (tuple
, args
, complain
);
10093 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10094 - TMPL_ARGS_DEPTH (args
)),
10095 new_vec
, NULL_TREE
);
10098 --processing_template_decl
;
10103 /* Return the result of substituting ARGS into one template parameter
10104 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10105 parameter and which TREE_PURPOSE is the default argument of the
10106 template parameter. */
10109 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10111 tree default_value
, parm_decl
;
10113 if (args
== NULL_TREE
10115 || t
== error_mark_node
)
10118 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10120 default_value
= TREE_PURPOSE (t
);
10121 parm_decl
= TREE_VALUE (t
);
10123 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10124 if (TREE_CODE (parm_decl
) == PARM_DECL
10125 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10126 parm_decl
= error_mark_node
;
10127 default_value
= tsubst_template_arg (default_value
, args
,
10128 complain
, NULL_TREE
);
10130 return build_tree_list (default_value
, parm_decl
);
10133 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10134 type T. If T is not an aggregate or enumeration type, it is
10135 handled as if by tsubst. IN_DECL is as for tsubst. If
10136 ENTERING_SCOPE is nonzero, T is the context for a template which
10137 we are presently tsubst'ing. Return the substituted value. */
10140 tsubst_aggr_type (tree t
,
10142 tsubst_flags_t complain
,
10144 int entering_scope
)
10146 if (t
== NULL_TREE
)
10149 switch (TREE_CODE (t
))
10152 if (TYPE_PTRMEMFUNC_P (t
))
10153 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10155 /* Else fall through. */
10156 case ENUMERAL_TYPE
:
10158 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10163 int saved_unevaluated_operand
;
10164 int saved_inhibit_evaluation_warnings
;
10166 /* In "sizeof(X<I>)" we need to evaluate "I". */
10167 saved_unevaluated_operand
= cp_unevaluated_operand
;
10168 cp_unevaluated_operand
= 0;
10169 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10170 c_inhibit_evaluation_warnings
= 0;
10172 /* First, determine the context for the type we are looking
10174 context
= TYPE_CONTEXT (t
);
10175 if (context
&& TYPE_P (context
))
10177 context
= tsubst_aggr_type (context
, args
, complain
,
10178 in_decl
, /*entering_scope=*/1);
10179 /* If context is a nested class inside a class template,
10180 it may still need to be instantiated (c++/33959). */
10181 context
= complete_type (context
);
10184 /* Then, figure out what arguments are appropriate for the
10185 type we are trying to find. For example, given:
10187 template <class T> struct S;
10188 template <class T, class U> void f(T, U) { S<U> su; }
10190 and supposing that we are instantiating f<int, double>,
10191 then our ARGS will be {int, double}, but, when looking up
10192 S we only want {double}. */
10193 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10194 complain
, in_decl
);
10195 if (argvec
== error_mark_node
)
10196 r
= error_mark_node
;
10199 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10200 entering_scope
, complain
);
10201 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10204 cp_unevaluated_operand
= saved_unevaluated_operand
;
10205 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10210 /* This is not a template type, so there's nothing to do. */
10214 return tsubst (t
, args
, complain
, in_decl
);
10218 /* Substitute into the default argument ARG (a default argument for
10219 FN), which has the indicated TYPE. */
10222 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10224 tree saved_class_ptr
= NULL_TREE
;
10225 tree saved_class_ref
= NULL_TREE
;
10226 int errs
= errorcount
+ sorrycount
;
10228 /* This can happen in invalid code. */
10229 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10232 /* This default argument came from a template. Instantiate the
10233 default argument here, not in tsubst. In the case of
10242 we must be careful to do name lookup in the scope of S<T>,
10243 rather than in the current class. */
10244 push_access_scope (fn
);
10245 /* The "this" pointer is not valid in a default argument. */
10248 saved_class_ptr
= current_class_ptr
;
10249 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10250 saved_class_ref
= current_class_ref
;
10251 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10254 push_deferring_access_checks(dk_no_deferred
);
10255 /* The default argument expression may cause implicitly defined
10256 member functions to be synthesized, which will result in garbage
10257 collection. We must treat this situation as if we were within
10258 the body of function so as to avoid collecting live data on the
10261 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10262 complain
, NULL_TREE
,
10263 /*integral_constant_expression_p=*/false);
10265 pop_deferring_access_checks();
10267 /* Restore the "this" pointer. */
10270 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10271 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10274 if (errorcount
+sorrycount
> errs
10275 && (complain
& tf_warning_or_error
))
10276 inform (input_location
,
10277 " when instantiating default argument for call to %D", fn
);
10279 /* Make sure the default argument is reasonable. */
10280 arg
= check_default_argument (type
, arg
, complain
);
10282 pop_access_scope (fn
);
10287 /* Substitute into all the default arguments for FN. */
10290 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10295 tmpl_args
= DECL_TI_ARGS (fn
);
10297 /* If this function is not yet instantiated, we certainly don't need
10298 its default arguments. */
10299 if (uses_template_parms (tmpl_args
))
10301 /* Don't do this again for clones. */
10302 if (DECL_CLONED_FUNCTION_P (fn
))
10305 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10307 arg
= TREE_CHAIN (arg
))
10308 if (TREE_PURPOSE (arg
))
10309 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10311 TREE_PURPOSE (arg
),
10315 /* Substitute the ARGS into the T, which is a _DECL. Return the
10316 result of the substitution. Issue error and warning messages under
10317 control of COMPLAIN. */
10320 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10322 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10323 location_t saved_loc
;
10324 tree r
= NULL_TREE
;
10326 hashval_t hash
= 0;
10328 /* Set the filename and linenumber to improve error-reporting. */
10329 saved_loc
= input_location
;
10330 input_location
= DECL_SOURCE_LOCATION (t
);
10332 switch (TREE_CODE (t
))
10334 case TEMPLATE_DECL
:
10336 /* We can get here when processing a member function template,
10337 member class template, or template template parameter. */
10338 tree decl
= DECL_TEMPLATE_RESULT (t
);
10343 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10345 /* Template template parameter is treated here. */
10346 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10347 if (new_type
== error_mark_node
)
10348 RETURN (error_mark_node
);
10349 /* If we get a real template back, return it. This can happen in
10350 the context of most_specialized_class. */
10351 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10355 DECL_CHAIN (r
) = NULL_TREE
;
10356 TREE_TYPE (r
) = new_type
;
10357 DECL_TEMPLATE_RESULT (r
)
10358 = build_decl (DECL_SOURCE_LOCATION (decl
),
10359 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10360 DECL_TEMPLATE_PARMS (r
)
10361 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10363 TYPE_NAME (new_type
) = r
;
10367 /* We might already have an instance of this template.
10368 The ARGS are for the surrounding class type, so the
10369 full args contain the tsubst'd args for the context,
10370 plus the innermost args from the template decl. */
10371 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10372 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10373 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10374 /* Because this is a template, the arguments will still be
10375 dependent, even after substitution. If
10376 PROCESSING_TEMPLATE_DECL is not set, the dependency
10377 predicates will short-circuit. */
10378 ++processing_template_decl
;
10379 full_args
= tsubst_template_args (tmpl_args
, args
,
10380 complain
, in_decl
);
10381 --processing_template_decl
;
10382 if (full_args
== error_mark_node
)
10383 RETURN (error_mark_node
);
10385 /* If this is a default template template argument,
10386 tsubst might not have changed anything. */
10387 if (full_args
== tmpl_args
)
10390 hash
= hash_tmpl_and_args (t
, full_args
);
10391 spec
= retrieve_specialization (t
, full_args
, hash
);
10392 if (spec
!= NULL_TREE
)
10398 /* Make a new template decl. It will be similar to the
10399 original, but will record the current template arguments.
10400 We also create a new function declaration, which is just
10401 like the old one, but points to this new template, rather
10402 than the old one. */
10404 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10405 DECL_CHAIN (r
) = NULL_TREE
;
10407 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10409 if (TREE_CODE (decl
) == TYPE_DECL
10410 && !TYPE_DECL_ALIAS_P (decl
))
10413 ++processing_template_decl
;
10414 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10415 --processing_template_decl
;
10416 if (new_type
== error_mark_node
)
10417 RETURN (error_mark_node
);
10419 TREE_TYPE (r
) = new_type
;
10420 /* For a partial specialization, we need to keep pointing to
10421 the primary template. */
10422 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10423 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10424 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10425 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10426 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10431 ++processing_template_decl
;
10432 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10433 --processing_template_decl
;
10434 if (new_decl
== error_mark_node
)
10435 RETURN (error_mark_node
);
10437 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10438 DECL_TI_TEMPLATE (new_decl
) = r
;
10439 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10440 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10441 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10444 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10445 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10446 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10448 /* The template parameters for this new template are all the
10449 template parameters for the old template, except the
10450 outermost level of parameters. */
10451 DECL_TEMPLATE_PARMS (r
)
10452 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10455 if (PRIMARY_TEMPLATE_P (t
))
10456 DECL_PRIMARY_TEMPLATE (r
) = r
;
10458 if (TREE_CODE (decl
) != TYPE_DECL
)
10459 /* Record this non-type partial instantiation. */
10460 register_specialization (r
, t
,
10461 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10466 case FUNCTION_DECL
:
10469 tree argvec
= NULL_TREE
;
10477 /* Nobody should be tsubst'ing into non-template functions. */
10478 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10480 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10485 /* If T is not dependent, just return it. We have to
10486 increment PROCESSING_TEMPLATE_DECL because
10487 value_dependent_expression_p assumes that nothing is
10488 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10489 ++processing_template_decl
;
10490 dependent_p
= value_dependent_expression_p (t
);
10491 --processing_template_decl
;
10495 /* Calculate the most general template of which R is a
10496 specialization, and the complete set of arguments used to
10498 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10499 argvec
= tsubst_template_args (DECL_TI_ARGS
10500 (DECL_TEMPLATE_RESULT
10501 (DECL_TI_TEMPLATE (t
))),
10502 args
, complain
, in_decl
);
10503 if (argvec
== error_mark_node
)
10504 RETURN (error_mark_node
);
10506 /* Check to see if we already have this specialization. */
10507 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10508 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10516 /* We can see more levels of arguments than parameters if
10517 there was a specialization of a member template, like
10520 template <class T> struct S { template <class U> void f(); }
10521 template <> template <class U> void S<int>::f(U);
10523 Here, we'll be substituting into the specialization,
10524 because that's where we can find the code we actually
10525 want to generate, but we'll have enough arguments for
10526 the most general template.
10528 We also deal with the peculiar case:
10530 template <class T> struct S {
10531 template <class U> friend void f();
10533 template <class U> void f() {}
10535 template void f<double>();
10537 Here, the ARGS for the instantiation of will be {int,
10538 double}. But, we only need as many ARGS as there are
10539 levels of template parameters in CODE_PATTERN. We are
10540 careful not to get fooled into reducing the ARGS in
10543 template <class T> struct S { template <class U> void f(U); }
10544 template <class T> template <> void S<T>::f(int) {}
10546 which we can spot because the pattern will be a
10547 specialization in this case. */
10548 args_depth
= TMPL_ARGS_DEPTH (args
);
10550 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10551 if (args_depth
> parms_depth
10552 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10553 args
= get_innermost_template_args (args
, parms_depth
);
10557 /* This special case arises when we have something like this:
10559 template <class T> struct S {
10560 friend void f<int>(int, double);
10563 Here, the DECL_TI_TEMPLATE for the friend declaration
10564 will be an IDENTIFIER_NODE. We are being called from
10565 tsubst_friend_function, and we want only to create a
10566 new decl (R) with appropriate types so that we can call
10567 determine_specialization. */
10568 gen_tmpl
= NULL_TREE
;
10571 if (DECL_CLASS_SCOPE_P (t
))
10573 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10577 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10578 complain
, t
, /*entering_scope=*/1);
10583 ctx
= DECL_CONTEXT (t
);
10585 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10586 if (type
== error_mark_node
)
10587 RETURN (error_mark_node
);
10589 /* If we hit excessive deduction depth, the type is bogus even if
10590 it isn't error_mark_node, so don't build a decl. */
10591 if (excessive_deduction_depth
)
10592 RETURN (error_mark_node
);
10594 /* We do NOT check for matching decls pushed separately at this
10595 point, as they may not represent instantiations of this
10596 template, and in any case are considered separate under the
10599 DECL_USE_TEMPLATE (r
) = 0;
10600 TREE_TYPE (r
) = type
;
10601 /* Clear out the mangled name and RTL for the instantiation. */
10602 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10603 SET_DECL_RTL (r
, NULL
);
10604 /* Leave DECL_INITIAL set on deleted instantiations. */
10605 if (!DECL_DELETED_FN (r
))
10606 DECL_INITIAL (r
) = NULL_TREE
;
10607 DECL_CONTEXT (r
) = ctx
;
10609 /* OpenMP UDRs have the only argument a reference to the declared
10610 type. We want to diagnose if the declared type is a reference,
10611 which is invalid, but as references to references are usually
10612 quietly merged, diagnose it here. */
10613 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10616 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10617 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10618 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10619 error_at (DECL_SOURCE_LOCATION (t
),
10620 "reference type %qT in "
10621 "%<#pragma omp declare reduction%>", argtype
);
10622 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10623 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10627 if (member
&& DECL_CONV_FN_P (r
))
10628 /* Type-conversion operator. Reconstruct the name, in
10629 case it's the name of one of the template's parameters. */
10630 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10632 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10634 DECL_RESULT (r
) = NULL_TREE
;
10636 TREE_STATIC (r
) = 0;
10637 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10638 DECL_EXTERNAL (r
) = 1;
10639 /* If this is an instantiation of a function with internal
10640 linkage, we already know what object file linkage will be
10641 assigned to the instantiation. */
10642 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10643 DECL_DEFER_OUTPUT (r
) = 0;
10644 DECL_CHAIN (r
) = NULL_TREE
;
10645 DECL_PENDING_INLINE_INFO (r
) = 0;
10646 DECL_PENDING_INLINE_P (r
) = 0;
10647 DECL_SAVED_TREE (r
) = NULL_TREE
;
10648 DECL_STRUCT_FUNCTION (r
) = NULL
;
10650 /* We'll re-clone as appropriate in instantiate_template. */
10651 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10653 /* If we aren't complaining now, return on error before we register
10654 the specialization so that we'll complain eventually. */
10655 if ((complain
& tf_error
) == 0
10656 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10657 && !grok_op_properties (r
, /*complain=*/false))
10658 RETURN (error_mark_node
);
10660 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10661 this in the special friend case mentioned above where
10662 GEN_TMPL is NULL. */
10665 DECL_TEMPLATE_INFO (r
)
10666 = build_template_info (gen_tmpl
, argvec
);
10667 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10670 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10672 /* We instantiated this while substituting into
10673 the type earlier (template/friend54.C). */
10676 /* We're not supposed to instantiate default arguments
10677 until they are called, for a template. But, for a
10680 template <class T> void f ()
10681 { extern void g(int i = T()); }
10683 we should do the substitution when the template is
10684 instantiated. We handle the member function case in
10685 instantiate_class_template since the default arguments
10686 might refer to other members of the class. */
10688 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10689 && !uses_template_parms (argvec
))
10690 tsubst_default_arguments (r
, complain
);
10693 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10695 /* Copy the list of befriending classes. */
10696 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10698 friends
= &TREE_CHAIN (*friends
))
10700 *friends
= copy_node (*friends
);
10701 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
10706 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
10708 maybe_retrofit_in_chrg (r
);
10709 if (DECL_CONSTRUCTOR_P (r
))
10710 grok_ctor_properties (ctx
, r
);
10711 if (DECL_INHERITED_CTOR_BASE (r
))
10712 deduce_inheriting_ctor (r
);
10713 /* If this is an instantiation of a member template, clone it.
10714 If it isn't, that'll be handled by
10715 clone_constructors_and_destructors. */
10716 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
10717 clone_function_decl (r
, /*update_method_vec_p=*/0);
10719 else if ((complain
& tf_error
) != 0
10720 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10721 && !grok_op_properties (r
, /*complain=*/true))
10722 RETURN (error_mark_node
);
10724 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
10725 SET_DECL_FRIEND_CONTEXT (r
,
10726 tsubst (DECL_FRIEND_CONTEXT (t
),
10727 args
, complain
, in_decl
));
10729 /* Possibly limit visibility based on template args. */
10730 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10731 if (DECL_VISIBILITY_SPECIFIED (t
))
10733 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10734 DECL_ATTRIBUTES (r
)
10735 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10737 determine_visibility (r
);
10738 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
10739 && !processing_template_decl
)
10740 defaulted_late_check (r
);
10742 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10743 args
, complain
, in_decl
);
10749 tree type
= NULL_TREE
;
10751 tree expanded_types
= NULL_TREE
;
10752 tree prev_r
= NULL_TREE
;
10753 tree first_r
= NULL_TREE
;
10755 if (DECL_PACK_P (t
))
10757 /* If there is a local specialization that isn't a
10758 parameter pack, it means that we're doing a "simple"
10759 substitution from inside tsubst_pack_expansion. Just
10760 return the local specialization (which will be a single
10762 tree spec
= retrieve_local_specialization (t
);
10764 && TREE_CODE (spec
) == PARM_DECL
10765 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
10768 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10769 the parameters in this function parameter pack. */
10770 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10771 complain
, in_decl
);
10772 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10774 len
= TREE_VEC_LENGTH (expanded_types
);
10776 /* Zero-length parameter packs are boring. Just substitute
10779 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
10784 /* All we did was update the type. Make a note of that. */
10785 type
= expanded_types
;
10786 expanded_types
= NULL_TREE
;
10790 /* Loop through all of the parameters we'll build. When T is
10791 a function parameter pack, LEN is the number of expanded
10792 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10794 for (i
= 0; i
< len
; ++i
)
10798 if (DECL_TEMPLATE_PARM_P (t
))
10799 SET_DECL_TEMPLATE_PARM_P (r
);
10801 if (expanded_types
)
10802 /* We're on the Ith parameter of the function parameter
10805 /* Get the Ith type. */
10806 type
= TREE_VEC_ELT (expanded_types
, i
);
10808 /* Rename the parameter to include the index. */
10810 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10813 /* We're dealing with a normal parameter. */
10814 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10816 type
= type_decays_to (type
);
10817 TREE_TYPE (r
) = type
;
10818 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10820 if (DECL_INITIAL (r
))
10822 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
10823 DECL_INITIAL (r
) = TREE_TYPE (r
);
10825 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
10826 complain
, in_decl
);
10829 DECL_CONTEXT (r
) = NULL_TREE
;
10831 if (!DECL_TEMPLATE_PARM_P (r
))
10832 DECL_ARG_TYPE (r
) = type_passed_as (type
);
10834 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10835 args
, complain
, in_decl
);
10837 /* Keep track of the first new parameter we
10838 generate. That's what will be returned to the
10843 /* Build a proper chain of parameters when substituting
10844 into a function parameter pack. */
10846 DECL_CHAIN (prev_r
) = r
;
10849 /* If cp_unevaluated_operand is set, we're just looking for a
10850 single dummy parameter, so don't keep going. */
10851 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
10852 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
10853 complain
, DECL_CHAIN (t
));
10855 /* FIRST_R contains the start of the chain we've built. */
10862 tree type
= NULL_TREE
;
10863 tree vec
= NULL_TREE
;
10864 tree expanded_types
= NULL_TREE
;
10867 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
10869 /* This field is a lambda capture pack. Return a TREE_VEC of
10870 the expanded fields to instantiate_class_template_1 and
10871 store them in the specializations hash table as a
10872 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
10873 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10874 complain
, in_decl
);
10875 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10877 len
= TREE_VEC_LENGTH (expanded_types
);
10878 vec
= make_tree_vec (len
);
10882 /* All we did was update the type. Make a note of that. */
10883 type
= expanded_types
;
10884 expanded_types
= NULL_TREE
;
10888 for (int i
= 0; i
< len
; ++i
)
10891 if (expanded_types
)
10893 type
= TREE_VEC_ELT (expanded_types
, i
);
10895 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10898 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10900 if (type
== error_mark_node
)
10901 RETURN (error_mark_node
);
10902 TREE_TYPE (r
) = type
;
10903 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10905 if (DECL_C_BIT_FIELD (r
))
10906 /* For bit-fields, DECL_INITIAL gives the number of bits. For
10907 non-bit-fields DECL_INITIAL is a non-static data member
10908 initializer, which gets deferred instantiation. */
10910 = tsubst_expr (DECL_INITIAL (t
), args
,
10912 /*integral_constant_expression_p=*/true);
10913 else if (DECL_INITIAL (t
))
10915 /* Set up DECL_TEMPLATE_INFO so that we can get at the
10916 NSDMI in perform_member_init. Still set DECL_INITIAL
10917 so that we know there is one. */
10918 DECL_INITIAL (r
) = void_node
;
10919 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
10920 retrofit_lang_decl (r
);
10921 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10923 /* We don't have to set DECL_CONTEXT here; it is set by
10924 finish_member_declaration. */
10925 DECL_CHAIN (r
) = NULL_TREE
;
10927 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10928 args
, complain
, in_decl
);
10931 TREE_VEC_ELT (vec
, i
) = r
;
10937 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
10938 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
10939 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
10940 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
10941 TREE_TYPE (pack
) = tpack
;
10942 register_specialization (pack
, t
, args
, false, 0);
10948 /* We reach here only for member using decls. We also need to check
10949 uses_template_parms because DECL_DEPENDENT_P is not set for a
10950 using-declaration that designates a member of the current
10951 instantiation (c++/53549). */
10952 if (DECL_DEPENDENT_P (t
)
10953 || uses_template_parms (USING_DECL_SCOPE (t
)))
10955 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
10956 complain
, in_decl
);
10957 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
10958 r
= do_class_using_decl (inst_scope
, name
);
10960 r
= error_mark_node
;
10963 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
10964 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
10970 DECL_CHAIN (r
) = NULL_TREE
;
10977 tree argvec
= NULL_TREE
;
10978 tree gen_tmpl
= NULL_TREE
;
10980 tree tmpl
= NULL_TREE
;
10982 tree type
= NULL_TREE
;
10985 if (TREE_TYPE (t
) == error_mark_node
)
10986 RETURN (error_mark_node
);
10988 if (TREE_CODE (t
) == TYPE_DECL
10989 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
10991 /* If this is the canonical decl, we don't have to
10992 mess with instantiations, and often we can't (for
10993 typename, template type parms and such). Note that
10994 TYPE_NAME is not correct for the above test if
10995 we've copied the type for a typedef. */
10996 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10997 if (type
== error_mark_node
)
10998 RETURN (error_mark_node
);
10999 r
= TYPE_NAME (type
);
11003 /* Check to see if we already have the specialization we
11006 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
11008 /* T is a static data member or namespace-scope entity.
11009 We have to substitute into namespace-scope variables
11010 (even though such entities are never templates) because
11013 template <class T> void f() { extern T t; }
11015 where the entity referenced is not known until
11016 instantiation time. */
11018 ctx
= DECL_CONTEXT (t
);
11019 if (DECL_CLASS_SCOPE_P (t
))
11021 ctx
= tsubst_aggr_type (ctx
, args
,
11023 in_decl
, /*entering_scope=*/1);
11024 /* If CTX is unchanged, then T is in fact the
11025 specialization we want. That situation occurs when
11026 referencing a static data member within in its own
11027 class. We can use pointer equality, rather than
11028 same_type_p, because DECL_CONTEXT is always
11030 if (ctx
== DECL_CONTEXT (t
)
11031 && (TREE_CODE (t
) != TYPE_DECL
11032 /* ... unless T is a member template; in which
11033 case our caller can be willing to create a
11034 specialization of that template represented
11036 || !(DECL_TI_TEMPLATE (t
)
11037 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))))
11043 tmpl
= DECL_TI_TEMPLATE (t
);
11044 gen_tmpl
= most_general_template (tmpl
);
11045 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11046 if (argvec
== error_mark_node
)
11047 RETURN (error_mark_node
);
11048 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11049 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11054 /* A local variable. */
11056 /* Subsequent calls to pushdecl will fill this in. */
11058 spec
= retrieve_local_specialization (t
);
11060 /* If we already have the specialization we need, there is
11061 nothing more to do. */
11068 /* Create a new node for the specialization we need. */
11070 if (type
== NULL_TREE
)
11072 if (is_typedef_decl (t
))
11073 type
= DECL_ORIGINAL_TYPE (t
);
11075 type
= TREE_TYPE (t
);
11077 && VAR_HAD_UNKNOWN_BOUND (t
)
11078 && type
!= error_mark_node
)
11079 type
= strip_array_domain (type
);
11080 type
= tsubst (type
, args
, complain
, in_decl
);
11084 /* Even if the original location is out of scope, the
11085 newly substituted one is not. */
11086 DECL_DEAD_FOR_LOCAL (r
) = 0;
11087 DECL_INITIALIZED_P (r
) = 0;
11088 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11089 if (type
== error_mark_node
)
11090 RETURN (error_mark_node
);
11091 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11093 /* It may seem that this case cannot occur, since:
11098 declares a function, not a variable. However:
11101 template <typename T> void g() { T t; }
11102 template void g<f>();
11104 is an attempt to declare a variable with function
11106 error ("variable %qD has function type",
11107 /* R is not yet sufficiently initialized, so we
11108 just use its name. */
11110 RETURN (error_mark_node
);
11112 type
= complete_type (type
);
11113 /* Wait until cp_finish_decl to set this again, to handle
11114 circular dependency (template/instantiate6.C). */
11115 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11116 type
= check_var_type (DECL_NAME (r
), type
);
11118 if (DECL_HAS_VALUE_EXPR_P (t
))
11120 tree ve
= DECL_VALUE_EXPR (t
);
11121 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11122 /*constant_expression_p=*/false);
11123 if (REFERENCE_REF_P (ve
))
11125 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11126 ve
= TREE_OPERAND (ve
, 0);
11128 SET_DECL_VALUE_EXPR (r
, ve
);
11131 else if (DECL_SELF_REFERENCE_P (t
))
11132 SET_DECL_SELF_REFERENCE_P (r
);
11133 TREE_TYPE (r
) = type
;
11134 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11135 DECL_CONTEXT (r
) = ctx
;
11136 /* Clear out the mangled name and RTL for the instantiation. */
11137 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11138 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11139 SET_DECL_RTL (r
, NULL
);
11140 /* The initializer must not be expanded until it is required;
11141 see [temp.inst]. */
11142 DECL_INITIAL (r
) = NULL_TREE
;
11143 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11144 SET_DECL_RTL (r
, NULL
);
11145 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11148 /* Possibly limit visibility based on template args. */
11149 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11150 if (DECL_VISIBILITY_SPECIFIED (t
))
11152 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11153 DECL_ATTRIBUTES (r
)
11154 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11156 determine_visibility (r
);
11161 /* A static data member declaration is always marked
11162 external when it is declared in-class, even if an
11163 initializer is present. We mimic the non-template
11164 processing here. */
11165 DECL_EXTERNAL (r
) = 1;
11167 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11168 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11169 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11171 else if (!cp_unevaluated_operand
)
11172 register_local_specialization (r
, t
);
11174 DECL_CHAIN (r
) = NULL_TREE
;
11176 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11178 args
, complain
, in_decl
);
11180 /* Preserve a typedef that names a type. */
11181 if (is_typedef_decl (r
))
11183 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11184 set_underlying_type (r
);
11187 layout_decl (r
, 0);
11192 gcc_unreachable ();
11197 /* Restore the file and line information. */
11198 input_location
= saved_loc
;
11203 /* Substitute into the ARG_TYPES of a function type.
11204 If END is a TREE_CHAIN, leave it and any following types
11208 tsubst_arg_types (tree arg_types
,
11211 tsubst_flags_t complain
,
11214 tree remaining_arg_types
;
11215 tree type
= NULL_TREE
;
11217 tree expanded_args
= NULL_TREE
;
11220 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11223 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11224 args
, end
, complain
, in_decl
);
11225 if (remaining_arg_types
== error_mark_node
)
11226 return error_mark_node
;
11228 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11230 /* For a pack expansion, perform substitution on the
11231 entire expression. Later on, we'll handle the arguments
11233 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11234 args
, complain
, in_decl
);
11236 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11237 /* So that we'll spin through the parameters, one by one. */
11238 i
= TREE_VEC_LENGTH (expanded_args
);
11241 /* We only partially substituted into the parameter
11242 pack. Our type is TYPE_PACK_EXPANSION. */
11243 type
= expanded_args
;
11244 expanded_args
= NULL_TREE
;
11252 type
= TREE_VEC_ELT (expanded_args
, i
);
11254 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11256 if (type
== error_mark_node
)
11257 return error_mark_node
;
11258 if (VOID_TYPE_P (type
))
11260 if (complain
& tf_error
)
11262 error ("invalid parameter type %qT", type
);
11264 error ("in declaration %q+D", in_decl
);
11266 return error_mark_node
;
11269 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11270 return error_mark_node
;
11272 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11273 top-level qualifiers as required. */
11274 type
= cv_unqualified (type_decays_to (type
));
11276 /* We do not substitute into default arguments here. The standard
11277 mandates that they be instantiated only when needed, which is
11278 done in build_over_call. */
11279 default_arg
= TREE_PURPOSE (arg_types
);
11281 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11283 /* We've instantiated a template before its default arguments
11284 have been parsed. This can happen for a nested template
11285 class, and is not an error unless we require the default
11286 argument in a call of this function. */
11287 remaining_arg_types
=
11288 tree_cons (default_arg
, type
, remaining_arg_types
);
11289 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11292 remaining_arg_types
=
11293 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11296 return remaining_arg_types
;
11299 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11300 *not* handle the exception-specification for FNTYPE, because the
11301 initial substitution of explicitly provided template parameters
11302 during argument deduction forbids substitution into the
11303 exception-specification:
11307 All references in the function type of the function template to the
11308 corresponding template parameters are replaced by the specified tem-
11309 plate argument values. If a substitution in a template parameter or
11310 in the function type of the function template results in an invalid
11311 type, type deduction fails. [Note: The equivalent substitution in
11312 exception specifications is done only when the function is instanti-
11313 ated, at which point a program is ill-formed if the substitution
11314 results in an invalid type.] */
11317 tsubst_function_type (tree t
,
11319 tsubst_flags_t complain
,
11323 tree arg_types
= NULL_TREE
;
11326 /* The TYPE_CONTEXT is not used for function/method types. */
11327 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11329 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11331 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11333 if (late_return_type_p
)
11335 /* Substitute the argument types. */
11336 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11337 complain
, in_decl
);
11338 if (arg_types
== error_mark_node
)
11339 return error_mark_node
;
11341 tree save_ccp
= current_class_ptr
;
11342 tree save_ccr
= current_class_ref
;
11343 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11344 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11345 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11348 /* DR 1207: 'this' is in scope in the trailing return type. */
11349 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11352 /* Substitute the return type. */
11353 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11357 current_class_ptr
= save_ccp
;
11358 current_class_ref
= save_ccr
;
11362 /* Substitute the return type. */
11363 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11365 if (return_type
== error_mark_node
)
11366 return error_mark_node
;
11367 /* DR 486 clarifies that creation of a function type with an
11368 invalid return type is a deduction failure. */
11369 if (TREE_CODE (return_type
) == ARRAY_TYPE
11370 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11372 if (complain
& tf_error
)
11374 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11375 error ("function returning an array");
11377 error ("function returning a function");
11379 return error_mark_node
;
11382 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11383 return error_mark_node
;
11385 if (!late_return_type_p
)
11387 /* Substitute the argument types. */
11388 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11389 complain
, in_decl
);
11390 if (arg_types
== error_mark_node
)
11391 return error_mark_node
;
11394 /* Construct a new type node and return it. */
11395 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11397 fntype
= build_function_type (return_type
, arg_types
);
11398 fntype
= apply_memfn_quals (fntype
,
11399 type_memfn_quals (t
),
11400 type_memfn_rqual (t
));
11404 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11405 /* Don't pick up extra function qualifiers from the basetype. */
11406 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11407 if (! MAYBE_CLASS_TYPE_P (r
))
11411 Type deduction may fail for any of the following
11414 -- Attempting to create "pointer to member of T" when T
11415 is not a class type. */
11416 if (complain
& tf_error
)
11417 error ("creating pointer to member function of non-class type %qT",
11419 return error_mark_node
;
11422 fntype
= build_method_type_directly (r
, return_type
,
11423 TREE_CHAIN (arg_types
));
11424 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11426 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11428 if (late_return_type_p
)
11429 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11434 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11435 ARGS into that specification, and return the substituted
11436 specification. If there is no specification, return NULL_TREE. */
11439 tsubst_exception_specification (tree fntype
,
11441 tsubst_flags_t complain
,
11448 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11449 new_specs
= NULL_TREE
;
11450 if (specs
&& TREE_PURPOSE (specs
))
11452 /* A noexcept-specifier. */
11453 tree expr
= TREE_PURPOSE (specs
);
11454 if (TREE_CODE (expr
) == INTEGER_CST
)
11458 /* Defer instantiation of noexcept-specifiers to avoid
11459 excessive instantiations (c++/49107). */
11460 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11461 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11463 /* We already partially instantiated this member template,
11464 so combine the new args with the old. */
11465 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11466 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11467 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11468 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11472 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11473 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11477 new_specs
= tsubst_copy_and_build
11478 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11479 /*integral_constant_expression_p=*/true);
11480 new_specs
= build_noexcept_spec (new_specs
, complain
);
11484 if (! TREE_VALUE (specs
))
11491 tree expanded_specs
= NULL_TREE
;
11493 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11495 /* Expand the pack expansion type. */
11496 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11500 if (expanded_specs
== error_mark_node
)
11501 return error_mark_node
;
11502 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11503 len
= TREE_VEC_LENGTH (expanded_specs
);
11506 /* We're substituting into a member template, so
11507 we got a TYPE_PACK_EXPANSION back. Add that
11508 expansion and move on. */
11509 gcc_assert (TREE_CODE (expanded_specs
)
11510 == TYPE_PACK_EXPANSION
);
11511 new_specs
= add_exception_specifier (new_specs
,
11514 specs
= TREE_CHAIN (specs
);
11519 for (i
= 0; i
< len
; ++i
)
11521 if (expanded_specs
)
11522 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11524 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11525 if (spec
== error_mark_node
)
11527 new_specs
= add_exception_specifier (new_specs
, spec
,
11531 specs
= TREE_CHAIN (specs
);
11537 /* Take the tree structure T and replace template parameters used
11538 therein with the argument vector ARGS. IN_DECL is an associated
11539 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11540 Issue error and warning messages under control of COMPLAIN. Note
11541 that we must be relatively non-tolerant of extensions here, in
11542 order to preserve conformance; if we allow substitutions that
11543 should not be allowed, we may allow argument deductions that should
11544 not succeed, and therefore report ambiguous overload situations
11545 where there are none. In theory, we could allow the substitution,
11546 but indicate that it should have failed, and allow our caller to
11547 make sure that the right thing happens, but we don't try to do this
11550 This function is used for dealing with types, decls and the like;
11551 for expressions, use tsubst_expr or tsubst_copy. */
11554 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11556 enum tree_code code
;
11557 tree type
, r
= NULL_TREE
;
11559 if (t
== NULL_TREE
|| t
== error_mark_node
11560 || t
== integer_type_node
11561 || t
== void_type_node
11562 || t
== char_type_node
11563 || t
== unknown_type_node
11564 || TREE_CODE (t
) == NAMESPACE_DECL
11565 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11569 return tsubst_decl (t
, args
, complain
);
11571 if (args
== NULL_TREE
)
11574 code
= TREE_CODE (t
);
11576 if (code
== IDENTIFIER_NODE
)
11577 type
= IDENTIFIER_TYPE_VALUE (t
);
11579 type
= TREE_TYPE (t
);
11581 gcc_assert (type
!= unknown_type_node
);
11583 /* Reuse typedefs. We need to do this to handle dependent attributes,
11584 such as attribute aligned. */
11586 && typedef_variant_p (t
))
11588 tree decl
= TYPE_NAME (t
);
11590 if (alias_template_specialization_p (t
))
11592 /* DECL represents an alias template and we want to
11594 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11595 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11596 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11598 else if (DECL_CLASS_SCOPE_P (decl
)
11599 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11600 && uses_template_parms (DECL_CONTEXT (decl
)))
11602 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11603 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11604 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11606 else if (DECL_FUNCTION_SCOPE_P (decl
)
11607 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11608 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11609 r
= retrieve_local_specialization (decl
);
11611 /* The typedef is from a non-template context. */
11617 r
= cp_build_qualified_type_real
11618 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11619 complain
| tf_ignore_bad_quals
);
11624 /* We don't have an instantiation yet, so drop the typedef. */
11625 int quals
= cp_type_quals (t
);
11626 t
= DECL_ORIGINAL_TYPE (decl
);
11627 t
= cp_build_qualified_type_real (t
, quals
,
11628 complain
| tf_ignore_bad_quals
);
11633 && code
!= TYPENAME_TYPE
11634 && code
!= TEMPLATE_TYPE_PARM
11635 && code
!= IDENTIFIER_NODE
11636 && code
!= FUNCTION_TYPE
11637 && code
!= METHOD_TYPE
)
11638 type
= tsubst (type
, args
, complain
, in_decl
);
11639 if (type
== error_mark_node
)
11640 return error_mark_node
;
11646 case ENUMERAL_TYPE
:
11647 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11648 /*entering_scope=*/0);
11651 case IDENTIFIER_NODE
:
11662 if (t
== integer_type_node
)
11665 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11666 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11670 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11672 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11673 /*integral_constant_expression_p=*/false);
11675 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11677 if (TREE_CODE (max
) == NOP_EXPR
11678 && TREE_SIDE_EFFECTS (omax
)
11679 && !TREE_TYPE (max
))
11680 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11682 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11683 with TREE_SIDE_EFFECTS that indicates this is not an integral
11684 constant expression. */
11685 if (processing_template_decl
11686 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11688 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11689 TREE_SIDE_EFFECTS (max
) = 1;
11692 return compute_array_index_type (NULL_TREE
, max
, complain
);
11695 case TEMPLATE_TYPE_PARM
:
11696 case TEMPLATE_TEMPLATE_PARM
:
11697 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11698 case TEMPLATE_PARM_INDEX
:
11703 tree arg
= NULL_TREE
;
11707 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
11708 template_parm_level_and_index (t
, &level
, &idx
);
11710 levels
= TMPL_ARGS_DEPTH (args
);
11711 if (level
<= levels
)
11713 arg
= TMPL_ARG (args
, level
, idx
);
11715 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
11717 /* See through ARGUMENT_PACK_SELECT arguments. */
11718 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
11719 /* If the selected argument is an expansion E, that most
11720 likely means we were called from
11721 gen_elem_of_pack_expansion_instantiation during the
11722 substituting of pack an argument pack (which Ith
11723 element is a pack expansion, where I is
11724 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11725 In this case, the Ith element resulting from this
11726 substituting is going to be a pack expansion, which
11727 pattern is the pattern of E. Let's return the
11729 gen_elem_of_pack_expansion_instantiation will
11730 build the resulting pack expansion from it. */
11731 if (PACK_EXPANSION_P (arg
))
11732 arg
= PACK_EXPANSION_PATTERN (arg
);
11736 if (arg
== error_mark_node
)
11737 return error_mark_node
;
11738 else if (arg
!= NULL_TREE
)
11740 if (ARGUMENT_PACK_P (arg
))
11741 /* If ARG is an argument pack, we don't actually want to
11742 perform a substitution here, because substitutions
11743 for argument packs are only done
11744 element-by-element. We can get to this point when
11745 substituting the type of a non-type template
11746 parameter pack, when that type actually contains
11747 template parameter packs from an outer template, e.g.,
11749 template<typename... Types> struct A {
11750 template<Types... Values> struct B { };
11754 if (code
== TEMPLATE_TYPE_PARM
)
11757 gcc_assert (TYPE_P (arg
));
11759 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
11761 return cp_build_qualified_type_real
11762 (arg
, quals
, complain
| tf_ignore_bad_quals
);
11764 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11766 /* We are processing a type constructed from a
11767 template template parameter. */
11768 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
11769 args
, complain
, in_decl
);
11770 if (argvec
== error_mark_node
)
11771 return error_mark_node
;
11773 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
11774 || TREE_CODE (arg
) == TEMPLATE_DECL
11775 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
11777 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
11778 /* Consider this code:
11780 template <template <class> class Template>
11782 template <class Arg> using Bind = Template<Arg>;
11785 template <template <class> class Template, class Arg>
11786 using Instantiate = Template<Arg>; //#0
11788 template <template <class> class Template,
11791 Instantiate<Internal<Template>::template Bind,
11794 When #1 is parsed, the
11795 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11796 parameter `Template' in #0 matches the
11797 UNBOUND_CLASS_TEMPLATE representing the argument
11798 `Internal<Template>::template Bind'; We then want
11799 to assemble the type `Bind<Argument>' that can't
11800 be fully created right now, because
11801 `Internal<Template>' not being complete, the Bind
11802 template cannot be looked up in that context. So
11803 we need to "store" `Bind<Argument>' for later
11804 when the context of Bind becomes complete. Let's
11805 store that in a TYPENAME_TYPE. */
11806 return make_typename_type (TYPE_CONTEXT (arg
),
11807 build_nt (TEMPLATE_ID_EXPR
,
11808 TYPE_IDENTIFIER (arg
),
11813 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11814 are resolving nested-types in the signature of a
11815 member function templates. Otherwise ARG is a
11816 TEMPLATE_DECL and is the real template to be
11818 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11819 arg
= TYPE_NAME (arg
);
11821 r
= lookup_template_class (arg
,
11823 DECL_CONTEXT (arg
),
11824 /*entering_scope=*/0,
11826 return cp_build_qualified_type_real
11827 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
11830 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11831 return convert_from_reference (unshare_expr (arg
));
11835 /* This can happen during the attempted tsubst'ing in
11836 unify. This means that we don't yet have any information
11837 about the template parameter in question. */
11840 /* Early in template argument deduction substitution, we don't
11841 want to reduce the level of 'auto', or it will be confused
11842 with a normal template parm in subsequent deduction. */
11843 if (is_auto (t
) && (complain
& tf_partial
))
11846 /* If we get here, we must have been looking at a parm for a
11847 more deeply nested template. Make a new version of this
11848 template parameter, but with a lower level. */
11851 case TEMPLATE_TYPE_PARM
:
11852 case TEMPLATE_TEMPLATE_PARM
:
11853 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11854 if (cp_type_quals (t
))
11856 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
11857 r
= cp_build_qualified_type_real
11858 (r
, cp_type_quals (t
),
11859 complain
| (code
== TEMPLATE_TYPE_PARM
11860 ? tf_ignore_bad_quals
: 0));
11865 TEMPLATE_TYPE_PARM_INDEX (r
)
11866 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
11867 r
, levels
, args
, complain
);
11868 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
11869 TYPE_MAIN_VARIANT (r
) = r
;
11870 TYPE_POINTER_TO (r
) = NULL_TREE
;
11871 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
11873 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
11874 /* We have reduced the level of the template
11875 template parameter, but not the levels of its
11876 template parameters, so canonical_type_parameter
11877 will not be able to find the canonical template
11878 template parameter for this level. Thus, we
11879 require structural equality checking to compare
11880 TEMPLATE_TEMPLATE_PARMs. */
11881 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11882 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
11883 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11885 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
11887 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11889 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
11890 complain
, in_decl
);
11891 if (argvec
== error_mark_node
)
11892 return error_mark_node
;
11894 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
11895 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
11900 case TEMPLATE_PARM_INDEX
:
11901 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
11905 gcc_unreachable ();
11913 tree purpose
, value
, chain
;
11915 if (t
== void_list_node
)
11918 purpose
= TREE_PURPOSE (t
);
11921 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
11922 if (purpose
== error_mark_node
)
11923 return error_mark_node
;
11925 value
= TREE_VALUE (t
);
11928 value
= tsubst (value
, args
, complain
, in_decl
);
11929 if (value
== error_mark_node
)
11930 return error_mark_node
;
11932 chain
= TREE_CHAIN (t
);
11933 if (chain
&& chain
!= void_type_node
)
11935 chain
= tsubst (chain
, args
, complain
, in_decl
);
11936 if (chain
== error_mark_node
)
11937 return error_mark_node
;
11939 if (purpose
== TREE_PURPOSE (t
)
11940 && value
== TREE_VALUE (t
)
11941 && chain
== TREE_CHAIN (t
))
11943 return hash_tree_cons (purpose
, value
, chain
);
11947 /* We should never be tsubsting a binfo. */
11948 gcc_unreachable ();
11951 /* A vector of template arguments. */
11952 gcc_assert (!type
);
11953 return tsubst_template_args (t
, args
, complain
, in_decl
);
11956 case REFERENCE_TYPE
:
11958 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
11963 Type deduction may fail for any of the following
11966 -- Attempting to create a pointer to reference type.
11967 -- Attempting to create a reference to a reference type or
11968 a reference to void.
11970 Core issue 106 says that creating a reference to a reference
11971 during instantiation is no longer a cause for failure. We
11972 only enforce this check in strict C++98 mode. */
11973 if ((TREE_CODE (type
) == REFERENCE_TYPE
11974 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
11975 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
11977 static location_t last_loc
;
11979 /* We keep track of the last time we issued this error
11980 message to avoid spewing a ton of messages during a
11981 single bad template instantiation. */
11982 if (complain
& tf_error
11983 && last_loc
!= input_location
)
11985 if (VOID_TYPE_P (type
))
11986 error ("forming reference to void");
11987 else if (code
== POINTER_TYPE
)
11988 error ("forming pointer to reference type %qT", type
);
11990 error ("forming reference to reference type %qT", type
);
11991 last_loc
= input_location
;
11994 return error_mark_node
;
11996 else if (TREE_CODE (type
) == FUNCTION_TYPE
11997 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
11998 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12000 if (complain
& tf_error
)
12002 if (code
== POINTER_TYPE
)
12003 error ("forming pointer to qualified function type %qT",
12006 error ("forming reference to qualified function type %qT",
12009 return error_mark_node
;
12011 else if (code
== POINTER_TYPE
)
12013 r
= build_pointer_type (type
);
12014 if (TREE_CODE (type
) == METHOD_TYPE
)
12015 r
= build_ptrmemfunc_type (r
);
12017 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12018 /* In C++0x, during template argument substitution, when there is an
12019 attempt to create a reference to a reference type, reference
12020 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12022 "If a template-argument for a template-parameter T names a type
12023 that is a reference to a type A, an attempt to create the type
12024 'lvalue reference to cv T' creates the type 'lvalue reference to
12025 A,' while an attempt to create the type type rvalue reference to
12026 cv T' creates the type T"
12028 r
= cp_build_reference_type
12030 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12032 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12033 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12035 if (cxx_dialect
>= cxx1y
12036 && !(TREE_CODE (t
) == REFERENCE_TYPE
&& REFERENCE_VLA_OK (t
))
12037 && array_of_runtime_bound_p (type
)
12038 && (flag_iso
|| warn_vla
> 0))
12040 if (complain
& tf_warning_or_error
)
12042 (input_location
, OPT_Wvla
,
12043 code
== REFERENCE_TYPE
12044 ? G_("cannot declare reference to array of runtime bound")
12045 : G_("cannot declare pointer to array of runtime bound"));
12047 r
= error_mark_node
;
12050 if (r
!= error_mark_node
)
12051 /* Will this ever be needed for TYPE_..._TO values? */
12058 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12059 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12063 Type deduction may fail for any of the following
12066 -- Attempting to create "pointer to member of T" when T
12067 is not a class type. */
12068 if (complain
& tf_error
)
12069 error ("creating pointer to member of non-class type %qT", r
);
12070 return error_mark_node
;
12072 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12074 if (complain
& tf_error
)
12075 error ("creating pointer to member reference type %qT", type
);
12076 return error_mark_node
;
12078 if (VOID_TYPE_P (type
))
12080 if (complain
& tf_error
)
12081 error ("creating pointer to member of type void");
12082 return error_mark_node
;
12084 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12085 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12087 /* The type of the implicit object parameter gets its
12088 cv-qualifiers from the FUNCTION_TYPE. */
12091 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12092 type_memfn_rqual (type
));
12093 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12094 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12098 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12102 case FUNCTION_TYPE
:
12107 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12108 if (fntype
== error_mark_node
)
12109 return error_mark_node
;
12111 /* Substitute the exception specification. */
12112 specs
= tsubst_exception_specification (t
, args
, complain
,
12113 in_decl
, /*defer_ok*/true);
12114 if (specs
== error_mark_node
)
12115 return error_mark_node
;
12117 fntype
= build_exception_variant (fntype
, specs
);
12122 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12123 if (domain
== error_mark_node
)
12124 return error_mark_node
;
12126 /* As an optimization, we avoid regenerating the array type if
12127 it will obviously be the same as T. */
12128 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12131 /* These checks should match the ones in create_array_type_for_decl.
12135 The deduction may fail for any of the following reasons:
12137 -- Attempting to create an array with an element type that
12138 is void, a function type, or a reference type, or [DR337]
12139 an abstract class type. */
12140 if (VOID_TYPE_P (type
)
12141 || TREE_CODE (type
) == FUNCTION_TYPE
12142 || (TREE_CODE (type
) == ARRAY_TYPE
12143 && TYPE_DOMAIN (type
) == NULL_TREE
)
12144 || TREE_CODE (type
) == REFERENCE_TYPE
)
12146 if (complain
& tf_error
)
12147 error ("creating array of %qT", type
);
12148 return error_mark_node
;
12151 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12152 return error_mark_node
;
12154 r
= build_cplus_array_type (type
, domain
);
12156 if (TYPE_USER_ALIGN (t
))
12158 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12159 TYPE_USER_ALIGN (r
) = 1;
12165 case TYPENAME_TYPE
:
12167 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12168 in_decl
, /*entering_scope=*/1);
12169 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12170 complain
, in_decl
);
12172 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12173 return error_mark_node
;
12175 if (!MAYBE_CLASS_TYPE_P (ctx
))
12177 if (complain
& tf_error
)
12178 error ("%qT is not a class, struct, or union type", ctx
);
12179 return error_mark_node
;
12181 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12183 /* Normally, make_typename_type does not require that the CTX
12184 have complete type in order to allow things like:
12186 template <class T> struct S { typename S<T>::X Y; };
12188 But, such constructs have already been resolved by this
12189 point, so here CTX really should have complete type, unless
12190 it's a partial instantiation. */
12191 ctx
= complete_type (ctx
);
12192 if (!COMPLETE_TYPE_P (ctx
))
12194 if (complain
& tf_error
)
12195 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12196 return error_mark_node
;
12200 f
= make_typename_type (ctx
, f
, typename_type
,
12201 complain
| tf_keep_type_decl
);
12202 if (f
== error_mark_node
)
12204 if (TREE_CODE (f
) == TYPE_DECL
)
12206 complain
|= tf_ignore_bad_quals
;
12210 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12212 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12214 if (complain
& tf_error
)
12215 error ("%qT resolves to %qT, which is not an enumeration type",
12218 return error_mark_node
;
12220 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12222 if (complain
& tf_error
)
12223 error ("%qT resolves to %qT, which is is not a class type",
12226 return error_mark_node
;
12230 return cp_build_qualified_type_real
12231 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12234 case UNBOUND_CLASS_TEMPLATE
:
12236 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12237 in_decl
, /*entering_scope=*/1);
12238 tree name
= TYPE_IDENTIFIER (t
);
12239 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12241 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12242 return error_mark_node
;
12245 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12246 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12253 ++cp_unevaluated_operand
;
12254 ++c_inhibit_evaluation_warnings
;
12256 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12258 /*integral_constant_expression_p=*/false);
12260 --cp_unevaluated_operand
;
12261 --c_inhibit_evaluation_warnings
;
12263 type
= finish_typeof (type
);
12264 return cp_build_qualified_type_real (type
,
12266 | cp_type_quals (type
),
12270 case DECLTYPE_TYPE
:
12274 ++cp_unevaluated_operand
;
12275 ++c_inhibit_evaluation_warnings
;
12277 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12278 complain
|tf_decltype
, in_decl
,
12279 /*function_p*/false,
12280 /*integral_constant_expression*/false);
12282 --cp_unevaluated_operand
;
12283 --c_inhibit_evaluation_warnings
;
12285 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12286 type
= lambda_capture_field_type (type
,
12287 DECLTYPE_FOR_INIT_CAPTURE (t
));
12288 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12289 type
= lambda_proxy_type (type
);
12292 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12293 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12295 /* In a template ~id could be either a complement expression
12296 or an unqualified-id naming a destructor; if instantiating
12297 it produces an expression, it's not an id-expression or
12300 type
= finish_decltype_type (type
, id
, complain
);
12302 return cp_build_qualified_type_real (type
,
12304 | cp_type_quals (type
),
12308 case UNDERLYING_TYPE
:
12310 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12311 complain
, in_decl
);
12312 return finish_underlying_type (type
);
12315 case TYPE_ARGUMENT_PACK
:
12316 case NONTYPE_ARGUMENT_PACK
:
12318 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12320 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12324 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12326 /* For template nontype argument packs, also substitute into
12328 if (code
== NONTYPE_ARGUMENT_PACK
)
12329 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12348 /* We should use one of the expression tsubsts for these codes. */
12349 gcc_unreachable ();
12352 sorry ("use of %qs in template", get_tree_code_name (code
));
12353 return error_mark_node
;
12357 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12358 type of the expression on the left-hand side of the "." or "->"
12362 tsubst_baselink (tree baselink
, tree object_type
,
12363 tree args
, tsubst_flags_t complain
, tree in_decl
)
12366 tree qualifying_scope
;
12369 tree template_args
= 0;
12370 bool template_id_p
= false;
12371 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12373 /* A baselink indicates a function from a base class. Both the
12374 BASELINK_ACCESS_BINFO and the base class referenced may
12375 indicate bases of the template class, rather than the
12376 instantiated class. In addition, lookups that were not
12377 ambiguous before may be ambiguous now. Therefore, we perform
12378 the lookup again. */
12379 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12380 qualifying_scope
= tsubst (qualifying_scope
, args
,
12381 complain
, in_decl
);
12382 fns
= BASELINK_FUNCTIONS (baselink
);
12383 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12384 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12386 template_id_p
= true;
12387 template_args
= TREE_OPERAND (fns
, 1);
12388 fns
= TREE_OPERAND (fns
, 0);
12390 template_args
= tsubst_template_args (template_args
, args
,
12391 complain
, in_decl
);
12393 name
= DECL_NAME (get_first_fn (fns
));
12394 if (IDENTIFIER_TYPENAME_P (name
))
12395 name
= mangle_conv_op_name_for_type (optype
);
12396 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12398 return error_mark_node
;
12400 /* If lookup found a single function, mark it as used at this
12401 point. (If it lookup found multiple functions the one selected
12402 later by overload resolution will be marked as used at that
12404 if (BASELINK_P (baselink
))
12405 fns
= BASELINK_FUNCTIONS (baselink
);
12406 if (!template_id_p
&& !really_overloaded_fn (fns
))
12407 mark_used (OVL_CURRENT (fns
));
12409 /* Add back the template arguments, if present. */
12410 if (BASELINK_P (baselink
) && template_id_p
)
12411 BASELINK_FUNCTIONS (baselink
)
12412 = build_nt (TEMPLATE_ID_EXPR
,
12413 BASELINK_FUNCTIONS (baselink
),
12415 /* Update the conversion operator type. */
12416 BASELINK_OPTYPE (baselink
) = optype
;
12419 object_type
= current_class_type
;
12422 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12428 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12429 true if the qualified-id will be a postfix-expression in-and-of
12430 itself; false if more of the postfix-expression follows the
12431 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12435 tsubst_qualified_id (tree qualified_id
, tree args
,
12436 tsubst_flags_t complain
, tree in_decl
,
12437 bool done
, bool address_p
)
12443 tree template_args
;
12444 location_t loc
= UNKNOWN_LOCATION
;
12446 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12448 /* Figure out what name to look up. */
12449 name
= TREE_OPERAND (qualified_id
, 1);
12450 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12452 is_template
= true;
12453 loc
= EXPR_LOCATION (name
);
12454 template_args
= TREE_OPERAND (name
, 1);
12456 template_args
= tsubst_template_args (template_args
, args
,
12457 complain
, in_decl
);
12458 name
= TREE_OPERAND (name
, 0);
12462 is_template
= false;
12463 template_args
= NULL_TREE
;
12466 /* Substitute into the qualifying scope. When there are no ARGS, we
12467 are just trying to simplify a non-dependent expression. In that
12468 case the qualifying scope may be dependent, and, in any case,
12469 substituting will not help. */
12470 scope
= TREE_OPERAND (qualified_id
, 0);
12473 scope
= tsubst (scope
, args
, complain
, in_decl
);
12474 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12479 if (dependent_scope_p (scope
))
12482 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12483 return build_qualified_name (NULL_TREE
, scope
, expr
,
12484 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12487 if (!BASELINK_P (name
) && !DECL_P (expr
))
12489 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12491 /* A BIT_NOT_EXPR is used to represent a destructor. */
12492 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12494 error ("qualifying type %qT does not match destructor name ~%qT",
12495 scope
, TREE_OPERAND (expr
, 0));
12496 expr
= error_mark_node
;
12499 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12500 /*is_type_p=*/0, false);
12503 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12504 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12505 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12507 if (complain
& tf_error
)
12509 error ("dependent-name %qE is parsed as a non-type, but "
12510 "instantiation yields a type", qualified_id
);
12511 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12513 return error_mark_node
;
12519 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12521 /* Remember that there was a reference to this entity. */
12525 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12527 if (complain
& tf_error
)
12528 qualified_name_lookup_error (scope
,
12529 TREE_OPERAND (qualified_id
, 1),
12530 expr
, input_location
);
12531 return error_mark_node
;
12535 expr
= lookup_template_function (expr
, template_args
);
12537 if (expr
== error_mark_node
&& complain
& tf_error
)
12538 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12539 expr
, input_location
);
12540 else if (TYPE_P (scope
))
12542 expr
= (adjust_result_of_qualified_name_lookup
12543 (expr
, scope
, current_nonlambda_class_type ()));
12544 expr
= (finish_qualified_id_expr
12545 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12546 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12547 /*template_arg_p=*/false, complain
));
12550 /* Expressions do not generally have reference type. */
12551 if (TREE_CODE (expr
) != SCOPE_REF
12552 /* However, if we're about to form a pointer-to-member, we just
12553 want the referenced member referenced. */
12554 && TREE_CODE (expr
) != OFFSET_REF
)
12555 expr
= convert_from_reference (expr
);
12560 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12561 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12565 tsubst_init (tree init
, tree decl
, tree args
,
12566 tsubst_flags_t complain
, tree in_decl
)
12571 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12575 /* If we had an initializer but it
12576 instantiated to nothing,
12577 value-initialize the object. This will
12578 only occur when the initializer was a
12579 pack expansion where the parameter packs
12580 used in that expansion were of length
12582 init
= build_value_init (TREE_TYPE (decl
),
12584 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12585 init
= get_target_expr_sfinae (init
, complain
);
12591 /* Like tsubst, but deals with expressions. This function just replaces
12592 template parms; to finish processing the resultant expression, use
12593 tsubst_copy_and_build or tsubst_expr. */
12596 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12598 enum tree_code code
;
12601 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12604 code
= TREE_CODE (t
);
12609 r
= retrieve_local_specialization (t
);
12611 if (r
== NULL_TREE
)
12613 /* We get here for a use of 'this' in an NSDMI. */
12614 if (DECL_NAME (t
) == this_identifier
12615 && current_function_decl
12616 && DECL_CONSTRUCTOR_P (current_function_decl
))
12617 return current_class_ptr
;
12619 /* This can happen for a parameter name used later in a function
12620 declaration (such as in a late-specified return type). Just
12621 make a dummy decl, since it's only used for its type. */
12622 gcc_assert (cp_unevaluated_operand
!= 0);
12623 r
= tsubst_decl (t
, args
, complain
);
12624 /* Give it the template pattern as its context; its true context
12625 hasn't been instantiated yet and this is good enough for
12627 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12630 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12631 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12640 if (DECL_TEMPLATE_PARM_P (t
))
12641 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12642 /* There is no need to substitute into namespace-scope
12644 if (DECL_NAMESPACE_SCOPE_P (t
))
12646 /* If ARGS is NULL, then T is known to be non-dependent. */
12647 if (args
== NULL_TREE
)
12648 return integral_constant_value (t
);
12650 /* Unfortunately, we cannot just call lookup_name here.
12653 template <int I> int f() {
12655 struct S { void g() { E e = a; } };
12658 When we instantiate f<7>::S::g(), say, lookup_name is not
12659 clever enough to find f<7>::a. */
12661 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12662 /*entering_scope=*/0);
12664 for (v
= TYPE_VALUES (enum_type
);
12666 v
= TREE_CHAIN (v
))
12667 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12668 return TREE_VALUE (v
);
12670 /* We didn't find the name. That should never happen; if
12671 name-lookup found it during preliminary parsing, we
12672 should find it again here during instantiation. */
12673 gcc_unreachable ();
12678 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12680 /* Check for a local specialization set up by
12681 tsubst_pack_expansion. */
12682 if (tree r
= retrieve_local_specialization (t
))
12684 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12685 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12689 /* When retrieving a capture pack from a generic lambda, remove the
12690 lambda call op's own template argument list from ARGS. Only the
12691 template arguments active for the closure type should be used to
12692 retrieve the pack specialization. */
12693 if (LAMBDA_FUNCTION_P (current_function_decl
)
12694 && (template_class_depth (DECL_CONTEXT (t
))
12695 != TMPL_ARGS_DEPTH (args
)))
12696 args
= strip_innermost_template_args (args
, 1);
12698 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12699 tsubst_decl put in the hash table. */
12700 return retrieve_specialization (t
, args
, 0);
12703 if (DECL_CONTEXT (t
))
12707 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12708 /*entering_scope=*/1);
12709 if (ctx
!= DECL_CONTEXT (t
))
12711 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
12714 if (complain
& tf_error
)
12715 error ("using invalid field %qD", t
);
12716 return error_mark_node
;
12725 case FUNCTION_DECL
:
12726 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
12727 r
= tsubst (t
, args
, complain
, in_decl
);
12728 else if (local_variable_p (t
))
12730 r
= retrieve_local_specialization (t
);
12731 if (r
== NULL_TREE
)
12733 if (DECL_ANON_UNION_VAR_P (t
))
12735 /* Just use name lookup to find a member alias for an
12736 anonymous union, but then add it to the hash table. */
12737 r
= lookup_name (DECL_NAME (t
));
12738 gcc_assert (DECL_ANON_UNION_VAR_P (r
));
12739 register_local_specialization (r
, t
);
12743 /* This can happen for a variable used in a
12744 late-specified return type of a local lambda, or for a
12745 local static or constant. Building a new VAR_DECL
12746 should be OK in all those cases. */
12747 r
= tsubst_decl (t
, args
, complain
);
12748 if (decl_maybe_constant_var_p (r
))
12750 /* We can't call cp_finish_decl, so handle the
12751 initializer by hand. */
12752 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
12753 complain
, in_decl
);
12754 if (!processing_template_decl
)
12755 init
= maybe_constant_init (init
);
12756 if (processing_template_decl
12757 ? potential_constant_expression (init
)
12758 : reduced_constant_expression_p (init
))
12759 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
12760 = TREE_CONSTANT (r
) = true;
12761 DECL_INITIAL (r
) = init
;
12763 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
12764 || decl_constant_var_p (r
)
12765 || errorcount
|| sorrycount
);
12766 if (!processing_template_decl
)
12768 if (TREE_STATIC (r
))
12769 rest_of_decl_compilation (r
, toplevel_bindings_p (),
12771 else if (decl_constant_var_p (r
))
12772 /* A use of a local constant decays to its value.
12773 FIXME update for core DR 696. */
12774 return integral_constant_value (r
);
12785 case NAMESPACE_DECL
:
12789 /* An OVERLOAD will always be a non-dependent overload set; an
12790 overload set from function scope will just be represented with an
12791 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12792 gcc_assert (!uses_template_parms (t
));
12796 return tsubst_baselink (t
, current_nonlambda_class_type (),
12797 args
, complain
, in_decl
);
12799 case TEMPLATE_DECL
:
12800 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12801 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
12802 args
, complain
, in_decl
);
12803 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
12804 return tsubst (t
, args
, complain
, in_decl
);
12805 else if (DECL_CLASS_SCOPE_P (t
)
12806 && uses_template_parms (DECL_CONTEXT (t
)))
12808 /* Template template argument like the following example need
12811 template <template <class> class TT> struct C {};
12812 template <class T> struct D {
12813 template <class U> struct E {};
12818 We are processing the template argument `E' in #1 for
12819 the template instantiation #2. Originally, `E' is a
12820 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12821 have to substitute this with one having context `D<int>'. */
12823 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
12824 return lookup_field (context
, DECL_NAME(t
), 0, false);
12827 /* Ordinary template template argument. */
12831 case REINTERPRET_CAST_EXPR
:
12832 case CONST_CAST_EXPR
:
12833 case STATIC_CAST_EXPR
:
12834 case DYNAMIC_CAST_EXPR
:
12835 case IMPLICIT_CONV_EXPR
:
12839 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12840 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12841 return build1 (code
, type
, op0
);
12845 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
12848 tree expanded
, op
= TREE_OPERAND (t
, 0);
12851 if (SIZEOF_EXPR_TYPE_P (t
))
12852 op
= TREE_TYPE (op
);
12854 ++cp_unevaluated_operand
;
12855 ++c_inhibit_evaluation_warnings
;
12856 /* We only want to compute the number of arguments. */
12857 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
12858 --cp_unevaluated_operand
;
12859 --c_inhibit_evaluation_warnings
;
12861 if (TREE_CODE (expanded
) == TREE_VEC
)
12862 len
= TREE_VEC_LENGTH (expanded
);
12864 if (expanded
== error_mark_node
)
12865 return error_mark_node
;
12866 else if (PACK_EXPANSION_P (expanded
)
12867 || (TREE_CODE (expanded
) == TREE_VEC
12869 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
12871 if (TREE_CODE (expanded
) == TREE_VEC
)
12872 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
12874 if (TYPE_P (expanded
))
12875 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
12876 complain
& tf_error
);
12878 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
12879 complain
& tf_error
);
12882 return build_int_cst (size_type_node
, len
);
12884 if (SIZEOF_EXPR_TYPE_P (t
))
12886 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
12887 args
, complain
, in_decl
);
12888 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
12889 r
= build1 (SIZEOF_EXPR
,
12890 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
12891 SIZEOF_EXPR_TYPE_P (r
) = 1;
12898 case TRUTH_NOT_EXPR
:
12901 case UNARY_PLUS_EXPR
: /* Unary + */
12903 case AT_ENCODE_EXPR
:
12907 case REALPART_EXPR
:
12908 case IMAGPART_EXPR
:
12911 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12912 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12913 return build1 (code
, type
, op0
);
12916 case COMPONENT_REF
:
12921 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12922 name
= TREE_OPERAND (t
, 1);
12923 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
12925 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12926 complain
, in_decl
);
12927 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12929 else if (TREE_CODE (name
) == SCOPE_REF
12930 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
12932 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12933 complain
, in_decl
);
12934 name
= TREE_OPERAND (name
, 1);
12935 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12936 complain
, in_decl
);
12937 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12938 name
= build_qualified_name (/*type=*/NULL_TREE
,
12940 /*template_p=*/false);
12942 else if (BASELINK_P (name
))
12943 name
= tsubst_baselink (name
,
12944 non_reference (TREE_TYPE (object
)),
12948 name
= tsubst_copy (name
, args
, complain
, in_decl
);
12949 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
12955 case TRUNC_DIV_EXPR
:
12956 case CEIL_DIV_EXPR
:
12957 case FLOOR_DIV_EXPR
:
12958 case ROUND_DIV_EXPR
:
12959 case EXACT_DIV_EXPR
:
12963 case TRUNC_MOD_EXPR
:
12964 case FLOOR_MOD_EXPR
:
12965 case TRUTH_ANDIF_EXPR
:
12966 case TRUTH_ORIF_EXPR
:
12967 case TRUTH_AND_EXPR
:
12968 case TRUTH_OR_EXPR
:
12981 case COMPOUND_EXPR
:
12984 case PREDECREMENT_EXPR
:
12985 case PREINCREMENT_EXPR
:
12986 case POSTDECREMENT_EXPR
:
12987 case POSTINCREMENT_EXPR
:
12989 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12990 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
12991 return build_nt (code
, op0
, op1
);
12996 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12997 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
12998 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
12999 QUALIFIED_NAME_IS_TEMPLATE (t
));
13004 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13005 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13006 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13011 int n
= VL_EXP_OPERAND_LENGTH (t
);
13012 tree result
= build_vl_exp (CALL_EXPR
, n
);
13014 for (i
= 0; i
< n
; i
++)
13015 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13016 complain
, in_decl
);
13022 case PSEUDO_DTOR_EXPR
:
13023 case VEC_PERM_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 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13028 r
= build_nt (code
, op0
, op1
, op2
);
13029 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13035 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13036 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13037 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13038 r
= build_nt (code
, op0
, op1
, op2
);
13039 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13045 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13046 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13047 r
= build_nt (code
, op0
, op1
);
13048 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13049 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13053 case TEMPLATE_ID_EXPR
:
13055 /* Substituted template arguments */
13056 tree fn
= TREE_OPERAND (t
, 0);
13057 tree targs
= TREE_OPERAND (t
, 1);
13059 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13061 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13063 return lookup_template_function (fn
, targs
);
13068 tree purpose
, value
, chain
;
13070 if (t
== void_list_node
)
13073 purpose
= TREE_PURPOSE (t
);
13075 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13076 value
= TREE_VALUE (t
);
13078 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13079 chain
= TREE_CHAIN (t
);
13080 if (chain
&& chain
!= void_type_node
)
13081 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13082 if (purpose
== TREE_PURPOSE (t
)
13083 && value
== TREE_VALUE (t
)
13084 && chain
== TREE_CHAIN (t
))
13086 return tree_cons (purpose
, value
, chain
);
13091 case ENUMERAL_TYPE
:
13093 case TEMPLATE_TYPE_PARM
:
13094 case TEMPLATE_TEMPLATE_PARM
:
13095 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13096 case TEMPLATE_PARM_INDEX
:
13098 case REFERENCE_TYPE
:
13100 case FUNCTION_TYPE
:
13103 case TYPENAME_TYPE
:
13104 case UNBOUND_CLASS_TEMPLATE
:
13106 case DECLTYPE_TYPE
:
13108 return tsubst (t
, args
, complain
, in_decl
);
13112 /* Fall through. */
13113 case IDENTIFIER_NODE
:
13114 if (IDENTIFIER_TYPENAME_P (t
))
13116 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13117 return mangle_conv_op_name_for_type (new_type
);
13123 /* This is handled by tsubst_copy_and_build. */
13124 gcc_unreachable ();
13128 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13129 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13130 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13133 case CLEANUP_POINT_EXPR
:
13134 /* We shouldn't have built any of these during initial template
13135 generation. Instead, they should be built during instantiation
13136 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13137 gcc_unreachable ();
13141 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13142 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13143 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13144 r
= build2 (code
, type
, op0
, op1
);
13145 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13146 mark_used (TREE_OPERAND (r
, 1));
13150 case EXPR_PACK_EXPANSION
:
13151 error ("invalid use of pack expansion expression");
13152 return error_mark_node
;
13154 case NONTYPE_ARGUMENT_PACK
:
13155 error ("use %<...%> to expand argument pack");
13156 return error_mark_node
;
13159 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13167 /* Instantiate any typedefs in the type. */
13168 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13169 r
= fold_convert (type
, t
);
13170 gcc_assert (TREE_CODE (r
) == code
);
13175 /* These can sometimes show up in a partial instantiation, but never
13176 involve template parms. */
13177 gcc_assert (!uses_template_parms (t
));
13181 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13182 gcc_checking_assert (false);
13187 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13190 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13191 tree args
, tsubst_flags_t complain
, tree in_decl
)
13193 tree new_clauses
= NULL
, nc
, oc
;
13195 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13197 nc
= copy_node (oc
);
13198 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13201 switch (OMP_CLAUSE_CODE (nc
))
13203 case OMP_CLAUSE_LASTPRIVATE
:
13204 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13206 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13207 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13208 in_decl
, /*integral_constant_expression_p=*/false);
13209 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13210 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13213 case OMP_CLAUSE_PRIVATE
:
13214 case OMP_CLAUSE_SHARED
:
13215 case OMP_CLAUSE_FIRSTPRIVATE
:
13216 case OMP_CLAUSE_COPYIN
:
13217 case OMP_CLAUSE_COPYPRIVATE
:
13218 case OMP_CLAUSE_IF
:
13219 case OMP_CLAUSE_NUM_THREADS
:
13220 case OMP_CLAUSE_SCHEDULE
:
13221 case OMP_CLAUSE_COLLAPSE
:
13222 case OMP_CLAUSE_FINAL
:
13223 case OMP_CLAUSE_DEPEND
:
13224 case OMP_CLAUSE_FROM
:
13225 case OMP_CLAUSE_TO
:
13226 case OMP_CLAUSE_UNIFORM
:
13227 case OMP_CLAUSE_MAP
:
13228 case OMP_CLAUSE_DEVICE
:
13229 case OMP_CLAUSE_DIST_SCHEDULE
:
13230 case OMP_CLAUSE_NUM_TEAMS
:
13231 case OMP_CLAUSE_THREAD_LIMIT
:
13232 case OMP_CLAUSE_SAFELEN
:
13233 case OMP_CLAUSE_SIMDLEN
:
13234 OMP_CLAUSE_OPERAND (nc
, 0)
13235 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13236 in_decl
, /*integral_constant_expression_p=*/false);
13238 case OMP_CLAUSE_REDUCTION
:
13239 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13241 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13242 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13244 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13245 complain
, in_decl
);
13246 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13247 = build_qualified_name (NULL_TREE
, scope
,
13248 TREE_OPERAND (placeholder
, 1),
13252 gcc_assert (identifier_p (placeholder
));
13254 OMP_CLAUSE_OPERAND (nc
, 0)
13255 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13256 in_decl
, /*integral_constant_expression_p=*/false);
13258 case OMP_CLAUSE_LINEAR
:
13259 case OMP_CLAUSE_ALIGNED
:
13260 OMP_CLAUSE_OPERAND (nc
, 0)
13261 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13262 in_decl
, /*integral_constant_expression_p=*/false);
13263 OMP_CLAUSE_OPERAND (nc
, 1)
13264 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13265 in_decl
, /*integral_constant_expression_p=*/false);
13268 case OMP_CLAUSE_NOWAIT
:
13269 case OMP_CLAUSE_ORDERED
:
13270 case OMP_CLAUSE_DEFAULT
:
13271 case OMP_CLAUSE_UNTIED
:
13272 case OMP_CLAUSE_MERGEABLE
:
13273 case OMP_CLAUSE_INBRANCH
:
13274 case OMP_CLAUSE_NOTINBRANCH
:
13275 case OMP_CLAUSE_PROC_BIND
:
13276 case OMP_CLAUSE_FOR
:
13277 case OMP_CLAUSE_PARALLEL
:
13278 case OMP_CLAUSE_SECTIONS
:
13279 case OMP_CLAUSE_TASKGROUP
:
13282 gcc_unreachable ();
13286 new_clauses
= nreverse (new_clauses
);
13288 new_clauses
= finish_omp_clauses (new_clauses
);
13289 return new_clauses
;
13292 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13295 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13298 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13300 tree purpose
, value
, chain
;
13305 if (TREE_CODE (t
) != TREE_LIST
)
13306 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13307 /*function_p=*/false,
13308 /*integral_constant_expression_p=*/false);
13310 if (t
== void_list_node
)
13313 purpose
= TREE_PURPOSE (t
);
13315 purpose
= RECUR (purpose
);
13316 value
= TREE_VALUE (t
);
13319 if (TREE_CODE (value
) != LABEL_DECL
)
13320 value
= RECUR (value
);
13323 value
= lookup_label (DECL_NAME (value
));
13324 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13325 TREE_USED (value
) = 1;
13328 chain
= TREE_CHAIN (t
);
13329 if (chain
&& chain
!= void_type_node
)
13330 chain
= RECUR (chain
);
13331 return tree_cons (purpose
, value
, chain
);
13335 /* Substitute one OMP_FOR iterator. */
13338 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13339 tree condv
, tree incrv
, tree
*clauses
,
13340 tree args
, tsubst_flags_t complain
, tree in_decl
,
13341 bool integral_constant_expression_p
)
13343 #define RECUR(NODE) \
13344 tsubst_expr ((NODE), args, complain, in_decl, \
13345 integral_constant_expression_p)
13346 tree decl
, init
, cond
, incr
;
13348 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13349 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13350 decl
= TREE_OPERAND (init
, 0);
13351 init
= TREE_OPERAND (init
, 1);
13352 tree decl_expr
= NULL_TREE
;
13353 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13355 /* We need to jump through some hoops to handle declarations in the
13356 for-init-statement, since we might need to handle auto deduction,
13357 but we need to keep control of initialization. */
13359 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13360 decl
= tsubst_decl (decl
, args
, complain
);
13363 decl
= RECUR (decl
);
13364 init
= RECUR (init
);
13366 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13367 if (auto_node
&& init
)
13369 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13371 gcc_assert (!type_dependent_expression_p (decl
));
13373 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13377 /* Declare the variable, but don't let that initialize it. */
13378 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13379 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13381 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13384 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13385 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13386 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13388 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13389 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13390 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13391 NOP_EXPR
, rhs
, complain
);
13394 incr
= RECUR (incr
);
13395 TREE_VEC_ELT (declv
, i
) = decl
;
13396 TREE_VEC_ELT (initv
, i
) = init
;
13397 TREE_VEC_ELT (condv
, i
) = cond
;
13398 TREE_VEC_ELT (incrv
, i
) = incr
;
13404 /* Declare and initialize the variable. */
13411 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13413 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13414 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13415 && OMP_CLAUSE_DECL (c
) == decl
)
13417 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13418 && OMP_CLAUSE_DECL (c
) == decl
)
13419 error ("iteration variable %qD should not be firstprivate", decl
);
13420 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13421 && OMP_CLAUSE_DECL (c
) == decl
)
13422 error ("iteration variable %qD should not be reduction", decl
);
13426 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13427 OMP_CLAUSE_DECL (c
) = decl
;
13428 c
= finish_omp_clauses (c
);
13431 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13436 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13437 if (COMPARISON_CLASS_P (cond
))
13439 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13440 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13441 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13444 cond
= RECUR (cond
);
13445 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13446 switch (TREE_CODE (incr
))
13448 case PREINCREMENT_EXPR
:
13449 case PREDECREMENT_EXPR
:
13450 case POSTINCREMENT_EXPR
:
13451 case POSTDECREMENT_EXPR
:
13452 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13453 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13456 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13457 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13459 tree rhs
= TREE_OPERAND (incr
, 1);
13460 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13461 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13462 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13463 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13464 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13468 incr
= RECUR (incr
);
13471 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13472 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13474 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13475 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13476 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13477 TREE_TYPE (decl
), lhs
,
13478 RECUR (TREE_OPERAND (incr
, 2))));
13480 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13481 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13482 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13484 tree rhs
= TREE_OPERAND (incr
, 2);
13485 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13486 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13487 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13488 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13489 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13493 incr
= RECUR (incr
);
13496 incr
= RECUR (incr
);
13500 TREE_VEC_ELT (declv
, i
) = decl
;
13501 TREE_VEC_ELT (initv
, i
) = init
;
13502 TREE_VEC_ELT (condv
, i
) = cond
;
13503 TREE_VEC_ELT (incrv
, i
) = incr
;
13507 /* Like tsubst_copy for expressions, etc. but also does semantic
13511 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13512 bool integral_constant_expression_p
)
13514 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13515 #define RECUR(NODE) \
13516 tsubst_expr ((NODE), args, complain, in_decl, \
13517 integral_constant_expression_p)
13523 if (t
== NULL_TREE
|| t
== error_mark_node
)
13526 loc
= input_location
;
13527 if (EXPR_HAS_LOCATION (t
))
13528 input_location
= EXPR_LOCATION (t
);
13529 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13530 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13532 switch (TREE_CODE (t
))
13534 case STATEMENT_LIST
:
13536 tree_stmt_iterator i
;
13537 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13538 RECUR (tsi_stmt (i
));
13542 case CTOR_INITIALIZER
:
13543 finish_mem_initializers (tsubst_initializer_list
13544 (TREE_OPERAND (t
, 0), args
));
13548 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13552 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13553 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13554 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13556 finish_expr_stmt (tmp
);
13560 do_using_directive (USING_STMT_NAMESPACE (t
));
13565 tree decl
, pattern_decl
;
13568 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13569 if (TREE_CODE (decl
) == LABEL_DECL
)
13570 finish_label_decl (DECL_NAME (decl
));
13571 else if (TREE_CODE (decl
) == USING_DECL
)
13573 tree scope
= USING_DECL_SCOPE (decl
);
13574 tree name
= DECL_NAME (decl
);
13577 scope
= tsubst (scope
, args
, complain
, in_decl
);
13578 decl
= lookup_qualified_name (scope
, name
,
13579 /*is_type_p=*/false,
13580 /*complain=*/false);
13581 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13582 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13584 do_local_using_decl (decl
, scope
, name
);
13586 else if (DECL_PACK_P (decl
))
13588 /* Don't build up decls for a variadic capture proxy, we'll
13589 instantiate the elements directly as needed. */
13594 init
= DECL_INITIAL (decl
);
13595 decl
= tsubst (decl
, args
, complain
, in_decl
);
13596 if (decl
!= error_mark_node
)
13598 /* By marking the declaration as instantiated, we avoid
13599 trying to instantiate it. Since instantiate_decl can't
13600 handle local variables, and since we've already done
13601 all that needs to be done, that's the right thing to
13604 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13606 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13607 /* Anonymous aggregates are a special case. */
13608 finish_anon_union (decl
);
13609 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13611 DECL_CONTEXT (decl
) = current_function_decl
;
13612 if (DECL_NAME (decl
) == this_identifier
)
13614 tree lam
= DECL_CONTEXT (current_function_decl
);
13615 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13616 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13618 insert_capture_proxy (decl
);
13620 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13621 /* We already did a pushtag. */;
13622 else if (TREE_CODE (decl
) == FUNCTION_DECL
13623 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13624 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13626 DECL_CONTEXT (decl
) = NULL_TREE
;
13628 DECL_CONTEXT (decl
) = current_function_decl
;
13629 cp_check_omp_declare_reduction (decl
);
13633 int const_init
= false;
13634 maybe_push_decl (decl
);
13636 && DECL_PRETTY_FUNCTION_P (decl
))
13638 /* For __PRETTY_FUNCTION__ we have to adjust the
13640 const char *const name
13641 = cxx_printable_name (current_function_decl
, 2);
13642 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13645 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
13648 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13650 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13659 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13660 RECUR (FOR_INIT_STMT (t
));
13661 finish_for_init_stmt (stmt
);
13662 tmp
= RECUR (FOR_COND (t
));
13663 finish_for_cond (tmp
, stmt
, false);
13664 tmp
= RECUR (FOR_EXPR (t
));
13665 finish_for_expr (tmp
, stmt
);
13666 RECUR (FOR_BODY (t
));
13667 finish_for_stmt (stmt
);
13670 case RANGE_FOR_STMT
:
13673 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13674 decl
= RANGE_FOR_DECL (t
);
13675 decl
= tsubst (decl
, args
, complain
, in_decl
);
13676 maybe_push_decl (decl
);
13677 expr
= RECUR (RANGE_FOR_EXPR (t
));
13678 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13679 RECUR (RANGE_FOR_BODY (t
));
13680 finish_for_stmt (stmt
);
13685 stmt
= begin_while_stmt ();
13686 tmp
= RECUR (WHILE_COND (t
));
13687 finish_while_stmt_cond (tmp
, stmt
, false);
13688 RECUR (WHILE_BODY (t
));
13689 finish_while_stmt (stmt
);
13693 stmt
= begin_do_stmt ();
13694 RECUR (DO_BODY (t
));
13695 finish_do_body (stmt
);
13696 tmp
= RECUR (DO_COND (t
));
13697 finish_do_stmt (tmp
, stmt
, false);
13701 stmt
= begin_if_stmt ();
13702 tmp
= RECUR (IF_COND (t
));
13703 finish_if_stmt_cond (tmp
, stmt
);
13704 RECUR (THEN_CLAUSE (t
));
13705 finish_then_clause (stmt
);
13707 if (ELSE_CLAUSE (t
))
13709 begin_else_clause (stmt
);
13710 RECUR (ELSE_CLAUSE (t
));
13711 finish_else_clause (stmt
);
13714 finish_if_stmt (stmt
);
13718 if (BIND_EXPR_BODY_BLOCK (t
))
13719 stmt
= begin_function_body ();
13721 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
13722 ? BCS_TRY_BLOCK
: 0);
13724 RECUR (BIND_EXPR_BODY (t
));
13726 if (BIND_EXPR_BODY_BLOCK (t
))
13727 finish_function_body (stmt
);
13729 finish_compound_stmt (stmt
);
13733 finish_break_stmt ();
13736 case CONTINUE_STMT
:
13737 finish_continue_stmt ();
13741 stmt
= begin_switch_stmt ();
13742 tmp
= RECUR (SWITCH_STMT_COND (t
));
13743 finish_switch_cond (tmp
, stmt
);
13744 RECUR (SWITCH_STMT_BODY (t
));
13745 finish_switch_stmt (stmt
);
13748 case CASE_LABEL_EXPR
:
13750 tree low
= RECUR (CASE_LOW (t
));
13751 tree high
= RECUR (CASE_HIGH (t
));
13752 finish_case_label (EXPR_LOCATION (t
), low
, high
);
13758 tree decl
= LABEL_EXPR_LABEL (t
);
13761 label
= finish_label_stmt (DECL_NAME (decl
));
13762 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13763 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13768 tmp
= GOTO_DESTINATION (t
);
13769 if (TREE_CODE (tmp
) != LABEL_DECL
)
13770 /* Computed goto's must be tsubst'd into. On the other hand,
13771 non-computed gotos must not be; the identifier in question
13772 will have no binding. */
13775 tmp
= DECL_NAME (tmp
);
13776 finish_goto_stmt (tmp
);
13781 tree string
= RECUR (ASM_STRING (t
));
13782 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
13783 complain
, in_decl
);
13784 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
13785 complain
, in_decl
);
13786 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
13787 complain
, in_decl
);
13788 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
13789 complain
, in_decl
);
13790 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
13792 tree asm_expr
= tmp
;
13793 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
13794 asm_expr
= TREE_OPERAND (asm_expr
, 0);
13795 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
13802 stmt
= begin_try_block ();
13803 RECUR (TRY_STMTS (t
));
13804 finish_cleanup_try_block (stmt
);
13805 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
13809 tree compound_stmt
= NULL_TREE
;
13811 if (FN_TRY_BLOCK_P (t
))
13812 stmt
= begin_function_try_block (&compound_stmt
);
13814 stmt
= begin_try_block ();
13816 RECUR (TRY_STMTS (t
));
13818 if (FN_TRY_BLOCK_P (t
))
13819 finish_function_try_block (stmt
);
13821 finish_try_block (stmt
);
13823 RECUR (TRY_HANDLERS (t
));
13824 if (FN_TRY_BLOCK_P (t
))
13825 finish_function_handler_sequence (stmt
, compound_stmt
);
13827 finish_handler_sequence (stmt
);
13833 tree decl
= HANDLER_PARMS (t
);
13837 decl
= tsubst (decl
, args
, complain
, in_decl
);
13838 /* Prevent instantiate_decl from trying to instantiate
13839 this variable. We've already done all that needs to be
13841 if (decl
!= error_mark_node
)
13842 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13844 stmt
= begin_handler ();
13845 finish_handler_parms (decl
, stmt
);
13846 RECUR (HANDLER_BODY (t
));
13847 finish_handler (stmt
);
13852 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
13853 if (CLASS_TYPE_P (tmp
))
13855 /* Local classes are not independent templates; they are
13856 instantiated along with their containing function. And this
13857 way we don't have to deal with pushing out of one local class
13858 to instantiate a member of another local class. */
13860 /* Closures are handled by the LAMBDA_EXPR. */
13861 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
13862 complete_type (tmp
);
13863 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
13864 if (!DECL_ARTIFICIAL (fn
))
13865 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
13869 case STATIC_ASSERT
:
13873 ++c_inhibit_evaluation_warnings
;
13875 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
13878 /*integral_constant_expression_p=*/true);
13879 --c_inhibit_evaluation_warnings
;
13881 finish_static_assert (condition
,
13882 STATIC_ASSERT_MESSAGE (t
),
13883 STATIC_ASSERT_SOURCE_LOCATION (t
),
13884 /*member_p=*/false);
13889 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
13890 args
, complain
, in_decl
);
13891 stmt
= begin_omp_parallel ();
13892 RECUR (OMP_PARALLEL_BODY (t
));
13893 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
13894 = OMP_PARALLEL_COMBINED (t
);
13898 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
13899 args
, complain
, in_decl
);
13900 stmt
= begin_omp_task ();
13901 RECUR (OMP_TASK_BODY (t
));
13902 finish_omp_task (tmp
, stmt
);
13908 case OMP_DISTRIBUTE
:
13910 tree clauses
, body
, pre_body
;
13911 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
13912 tree incrv
= NULL_TREE
;
13915 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
13916 args
, complain
, in_decl
);
13917 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13919 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13920 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13921 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13922 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13925 stmt
= begin_omp_structured_block ();
13927 pre_body
= push_stmt_list ();
13928 RECUR (OMP_FOR_PRE_BODY (t
));
13929 pre_body
= pop_stmt_list (pre_body
);
13931 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13932 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
13933 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
13934 &clauses
, args
, complain
, in_decl
,
13935 integral_constant_expression_p
);
13937 body
= push_stmt_list ();
13938 RECUR (OMP_FOR_BODY (t
));
13939 body
= pop_stmt_list (body
);
13941 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13942 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
13943 condv
, incrv
, body
, pre_body
, clauses
);
13946 t
= make_node (TREE_CODE (t
));
13947 TREE_TYPE (t
) = void_type_node
;
13948 OMP_FOR_BODY (t
) = body
;
13949 OMP_FOR_PRE_BODY (t
) = pre_body
;
13950 OMP_FOR_CLAUSES (t
) = clauses
;
13951 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
13955 add_stmt (finish_omp_structured_block (stmt
));
13962 case OMP_TARGET_DATA
:
13964 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
13965 args
, complain
, in_decl
);
13966 stmt
= push_stmt_list ();
13967 RECUR (OMP_BODY (t
));
13968 stmt
= pop_stmt_list (stmt
);
13971 OMP_BODY (t
) = stmt
;
13972 OMP_CLAUSES (t
) = tmp
;
13976 case OMP_TARGET_UPDATE
:
13977 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
13978 args
, complain
, in_decl
);
13980 OMP_CLAUSES (t
) = tmp
;
13987 case OMP_TASKGROUP
:
13989 stmt
= push_stmt_list ();
13990 RECUR (OMP_BODY (t
));
13991 stmt
= pop_stmt_list (stmt
);
13994 OMP_BODY (t
) = stmt
;
13999 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14000 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14002 tree op1
= TREE_OPERAND (t
, 1);
14003 tree rhs1
= NULL_TREE
;
14005 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14007 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14008 op1
= TREE_OPERAND (op1
, 1);
14010 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14011 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14012 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14013 NULL_TREE
, NULL_TREE
, rhs1
,
14014 OMP_ATOMIC_SEQ_CST (t
));
14018 tree op1
= TREE_OPERAND (t
, 1);
14019 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14020 tree rhs1
= NULL_TREE
;
14021 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14022 enum tree_code opcode
= NOP_EXPR
;
14023 if (code
== OMP_ATOMIC_READ
)
14025 v
= RECUR (TREE_OPERAND (op1
, 0));
14026 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14028 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14029 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14031 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14032 v
= RECUR (TREE_OPERAND (op1
, 0));
14033 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14034 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14036 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14037 op11
= TREE_OPERAND (op11
, 1);
14039 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14040 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14041 opcode
= TREE_CODE (op11
);
14042 if (opcode
== MODIFY_EXPR
)
14048 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14049 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14051 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14052 OMP_ATOMIC_SEQ_CST (t
));
14056 case TRANSACTION_EXPR
:
14059 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14060 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14062 if (TRANSACTION_EXPR_IS_STMT (t
))
14064 tree body
= TRANSACTION_EXPR_BODY (t
);
14065 tree noex
= NULL_TREE
;
14066 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14068 noex
= MUST_NOT_THROW_COND (body
);
14069 if (noex
== NULL_TREE
)
14070 noex
= boolean_true_node
;
14071 body
= TREE_OPERAND (body
, 0);
14073 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14075 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14079 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14080 RECUR (TRANSACTION_EXPR_BODY (t
)),
14087 case MUST_NOT_THROW_EXPR
:
14089 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14090 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14091 RETURN (build_must_not_throw_expr (op0
, cond
));
14094 case EXPR_PACK_EXPANSION
:
14095 error ("invalid use of pack expansion expression");
14096 RETURN (error_mark_node
);
14098 case NONTYPE_ARGUMENT_PACK
:
14099 error ("use %<...%> to expand argument pack");
14100 RETURN (error_mark_node
);
14102 case CILK_SPAWN_STMT
:
14103 cfun
->calls_cilk_spawn
= 1;
14104 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14106 case CILK_SYNC_STMT
:
14107 RETURN (build_cilk_sync ());
14109 case COMPOUND_EXPR
:
14110 tmp
= RECUR (TREE_OPERAND (t
, 0));
14111 if (tmp
== NULL_TREE
)
14112 /* If the first operand was a statement, we're done with it. */
14113 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14114 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14115 RECUR (TREE_OPERAND (t
, 1)),
14118 case ANNOTATE_EXPR
:
14119 tmp
= RECUR (TREE_OPERAND (t
, 0));
14120 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14121 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14124 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14126 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14127 /*function_p=*/false,
14128 integral_constant_expression_p
));
14131 RETURN (NULL_TREE
);
14133 input_location
= loc
;
14139 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14140 function. For description of the body see comment above
14141 cp_parser_omp_declare_reduction_exprs. */
14144 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14146 if (t
== NULL_TREE
|| t
== error_mark_node
)
14149 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14151 tree_stmt_iterator tsi
;
14154 memset (stmts
, 0, sizeof stmts
);
14155 for (i
= 0, tsi
= tsi_start (t
);
14156 i
< 7 && !tsi_end_p (tsi
);
14157 i
++, tsi_next (&tsi
))
14158 stmts
[i
] = tsi_stmt (tsi
);
14159 gcc_assert (tsi_end_p (tsi
));
14163 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14164 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14165 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14166 args
, complain
, in_decl
);
14167 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14168 args
, complain
, in_decl
);
14169 DECL_CONTEXT (omp_out
) = current_function_decl
;
14170 DECL_CONTEXT (omp_in
) = current_function_decl
;
14171 keep_next_level (true);
14172 tree block
= begin_omp_structured_block ();
14173 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14174 block
= finish_omp_structured_block (block
);
14175 block
= maybe_cleanup_point_expr_void (block
);
14176 add_decl_expr (omp_out
);
14177 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14178 TREE_NO_WARNING (omp_out
) = 1;
14179 add_decl_expr (omp_in
);
14180 finish_expr_stmt (block
);
14184 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14185 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14186 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14187 args
, complain
, in_decl
);
14188 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14189 args
, complain
, in_decl
);
14190 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14191 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14192 keep_next_level (true);
14193 tree block
= begin_omp_structured_block ();
14194 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14195 block
= finish_omp_structured_block (block
);
14196 block
= maybe_cleanup_point_expr_void (block
);
14197 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14198 add_decl_expr (omp_priv
);
14199 add_decl_expr (omp_orig
);
14200 finish_expr_stmt (block
);
14202 add_decl_expr (omp_orig
);
14206 /* T is a postfix-expression that is not being used in a function
14207 call. Return the substituted version of T. */
14210 tsubst_non_call_postfix_expression (tree t
, tree args
,
14211 tsubst_flags_t complain
,
14214 if (TREE_CODE (t
) == SCOPE_REF
)
14215 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14216 /*done=*/false, /*address_p=*/false);
14218 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14219 /*function_p=*/false,
14220 /*integral_constant_expression_p=*/false);
14225 /* Sentinel to disable certain warnings during template substitution. */
14227 struct warning_sentinel
{
14230 warning_sentinel(int& flag
, bool suppress
=true)
14231 : flag(flag
), val(flag
) { if (suppress
) flag
= 0; }
14232 ~warning_sentinel() { flag
= val
; }
14235 /* Like tsubst but deals with expressions and performs semantic
14236 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14239 tsubst_copy_and_build (tree t
,
14241 tsubst_flags_t complain
,
14244 bool integral_constant_expression_p
)
14246 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14247 #define RECUR(NODE) \
14248 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14249 /*function_p=*/false, \
14250 integral_constant_expression_p)
14255 if (t
== NULL_TREE
|| t
== error_mark_node
)
14258 loc
= input_location
;
14259 if (EXPR_HAS_LOCATION (t
))
14260 input_location
= EXPR_LOCATION (t
);
14262 /* N3276 decltype magic only applies to calls at the top level or on the
14263 right side of a comma. */
14264 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14265 complain
&= ~tf_decltype
;
14267 switch (TREE_CODE (t
))
14271 /* Fall through. */
14272 case IDENTIFIER_NODE
:
14276 bool non_integral_constant_expression_p
;
14277 const char *error_msg
;
14279 if (IDENTIFIER_TYPENAME_P (t
))
14281 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14282 t
= mangle_conv_op_name_for_type (new_type
);
14285 /* Look up the name. */
14286 decl
= lookup_name (t
);
14288 /* By convention, expressions use ERROR_MARK_NODE to indicate
14289 failure, not NULL_TREE. */
14290 if (decl
== NULL_TREE
)
14291 decl
= error_mark_node
;
14293 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14295 integral_constant_expression_p
,
14296 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14297 &non_integral_constant_expression_p
,
14298 /*template_p=*/false,
14300 /*address_p=*/false,
14301 /*template_arg_p=*/false,
14306 if (!function_p
&& identifier_p (decl
))
14308 if (complain
& tf_error
)
14309 unqualified_name_lookup_error (decl
);
14310 decl
= error_mark_node
;
14315 case TEMPLATE_ID_EXPR
:
14318 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14319 tree targs
= TREE_OPERAND (t
, 1);
14322 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14324 if (TREE_CODE (templ
) == COMPONENT_REF
)
14326 object
= TREE_OPERAND (templ
, 0);
14327 templ
= TREE_OPERAND (templ
, 1);
14330 object
= NULL_TREE
;
14331 templ
= lookup_template_function (templ
, targs
);
14334 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14335 object
, templ
, NULL_TREE
));
14337 RETURN (baselink_for_fns (templ
));
14342 tree r
= RECUR (TREE_OPERAND (t
, 0));
14344 if (REFERENCE_REF_P (t
))
14346 /* A type conversion to reference type will be enclosed in
14347 such an indirect ref, but the substitution of the cast
14348 will have also added such an indirect ref. */
14349 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14350 r
= convert_from_reference (r
);
14353 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14354 complain
|decltype_flag
);
14360 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14361 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14362 RETURN (build_nop (type
, op0
));
14365 case IMPLICIT_CONV_EXPR
:
14367 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14368 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14369 int flags
= LOOKUP_IMPLICIT
;
14370 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14371 flags
= LOOKUP_NORMAL
;
14372 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14378 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14379 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14380 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14384 case REINTERPRET_CAST_EXPR
:
14385 case CONST_CAST_EXPR
:
14386 case DYNAMIC_CAST_EXPR
:
14387 case STATIC_CAST_EXPR
:
14390 tree op
, r
= NULL_TREE
;
14392 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14393 if (integral_constant_expression_p
14394 && !cast_valid_in_integral_constant_expression_p (type
))
14396 if (complain
& tf_error
)
14397 error ("a cast to a type other than an integral or "
14398 "enumeration type cannot appear in a constant-expression");
14399 RETURN (error_mark_node
);
14402 op
= RECUR (TREE_OPERAND (t
, 0));
14404 warning_sentinel
s(warn_useless_cast
);
14405 switch (TREE_CODE (t
))
14408 r
= build_functional_cast (type
, op
, complain
);
14410 case REINTERPRET_CAST_EXPR
:
14411 r
= build_reinterpret_cast (type
, op
, complain
);
14413 case CONST_CAST_EXPR
:
14414 r
= build_const_cast (type
, op
, complain
);
14416 case DYNAMIC_CAST_EXPR
:
14417 r
= build_dynamic_cast (type
, op
, complain
);
14419 case STATIC_CAST_EXPR
:
14420 r
= build_static_cast (type
, op
, complain
);
14423 gcc_unreachable ();
14429 case POSTDECREMENT_EXPR
:
14430 case POSTINCREMENT_EXPR
:
14431 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14432 args
, complain
, in_decl
);
14433 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14434 complain
|decltype_flag
));
14436 case PREDECREMENT_EXPR
:
14437 case PREINCREMENT_EXPR
:
14441 case TRUTH_NOT_EXPR
:
14442 case UNARY_PLUS_EXPR
: /* Unary + */
14443 case REALPART_EXPR
:
14444 case IMAGPART_EXPR
:
14445 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14446 RECUR (TREE_OPERAND (t
, 0)),
14447 complain
|decltype_flag
));
14449 case FIX_TRUNC_EXPR
:
14450 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14454 op1
= TREE_OPERAND (t
, 0);
14455 if (TREE_CODE (op1
) == LABEL_DECL
)
14456 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14457 EXPR_LOCATION (op1
)));
14458 if (TREE_CODE (op1
) == SCOPE_REF
)
14459 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14460 /*done=*/true, /*address_p=*/true);
14462 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14464 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14465 complain
|decltype_flag
));
14470 case TRUNC_DIV_EXPR
:
14471 case CEIL_DIV_EXPR
:
14472 case FLOOR_DIV_EXPR
:
14473 case ROUND_DIV_EXPR
:
14474 case EXACT_DIV_EXPR
:
14478 case TRUNC_MOD_EXPR
:
14479 case FLOOR_MOD_EXPR
:
14480 case TRUTH_ANDIF_EXPR
:
14481 case TRUTH_ORIF_EXPR
:
14482 case TRUTH_AND_EXPR
:
14483 case TRUTH_OR_EXPR
:
14499 warning_sentinel
s1(warn_type_limits
);
14500 warning_sentinel
s2(warn_div_by_zero
);
14501 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14502 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14503 tree r
= build_x_binary_op
14504 (input_location
, TREE_CODE (t
),
14506 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14508 : TREE_CODE (TREE_OPERAND (t
, 0))),
14510 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14512 : TREE_CODE (TREE_OPERAND (t
, 1))),
14514 complain
|decltype_flag
);
14515 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14516 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14521 case POINTER_PLUS_EXPR
:
14523 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14524 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14525 return fold_build_pointer_plus (op0
, op1
);
14529 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14530 /*address_p=*/false));
14532 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14533 args
, complain
, in_decl
);
14534 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14535 RECUR (TREE_OPERAND (t
, 1)),
14536 complain
|decltype_flag
));
14538 case ARRAY_NOTATION_REF
:
14540 tree start_index
, length
, stride
;
14541 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14542 args
, complain
, in_decl
);
14543 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14544 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14545 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14546 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14547 length
, stride
, TREE_TYPE (op1
)));
14550 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14551 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14558 op1
= TREE_OPERAND (t
, 0);
14559 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14560 op1
= TREE_TYPE (op1
);
14563 /* When there are no ARGS, we are trying to evaluate a
14564 non-dependent expression from the parser. Trying to do
14565 the substitutions may not work. */
14567 op1
= TREE_TYPE (op1
);
14571 ++cp_unevaluated_operand
;
14572 ++c_inhibit_evaluation_warnings
;
14574 op1
= tsubst (op1
, args
, complain
, in_decl
);
14576 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14577 /*function_p=*/false,
14578 /*integral_constant_expression_p=*/
14580 --cp_unevaluated_operand
;
14581 --c_inhibit_evaluation_warnings
;
14584 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14585 complain
& tf_error
);
14587 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14588 complain
& tf_error
);
14589 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14591 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14593 if (!processing_template_decl
&& TYPE_P (op1
))
14595 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14596 build1 (NOP_EXPR
, op1
, error_mark_node
));
14597 SIZEOF_EXPR_TYPE_P (r
) = 1;
14600 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14601 TREE_SIDE_EFFECTS (r
) = 0;
14602 TREE_READONLY (r
) = 1;
14604 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14609 case AT_ENCODE_EXPR
:
14611 op1
= TREE_OPERAND (t
, 0);
14612 ++cp_unevaluated_operand
;
14613 ++c_inhibit_evaluation_warnings
;
14614 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14615 /*function_p=*/false,
14616 /*integral_constant_expression_p=*/false);
14617 --cp_unevaluated_operand
;
14618 --c_inhibit_evaluation_warnings
;
14619 RETURN (objc_build_encode_expr (op1
));
14622 case NOEXCEPT_EXPR
:
14623 op1
= TREE_OPERAND (t
, 0);
14624 ++cp_unevaluated_operand
;
14625 ++c_inhibit_evaluation_warnings
;
14626 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14627 /*function_p=*/false,
14628 /*integral_constant_expression_p=*/false);
14629 --cp_unevaluated_operand
;
14630 --c_inhibit_evaluation_warnings
;
14631 RETURN (finish_noexcept_expr (op1
, complain
));
14635 warning_sentinel
s(warn_div_by_zero
);
14636 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
14637 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
14638 tree r
= build_x_modify_expr
14639 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
14640 complain
|decltype_flag
);
14641 /* TREE_NO_WARNING must be set if either the expression was
14642 parenthesized or it uses an operator such as >>= rather
14643 than plain assignment. In the former case, it was already
14644 set and must be copied. In the latter case,
14645 build_x_modify_expr sets it and it must not be reset
14647 if (TREE_NO_WARNING (t
))
14648 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14654 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14655 args
, complain
, in_decl
);
14656 /* Remember that there was a reference to this entity. */
14659 RETURN (build_x_arrow (input_location
, op1
, complain
));
14663 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14664 tree init
= RECUR (TREE_OPERAND (t
, 3));
14665 vec
<tree
, va_gc
> *placement_vec
;
14666 vec
<tree
, va_gc
> *init_vec
;
14669 if (placement
== NULL_TREE
)
14670 placement_vec
= NULL
;
14673 placement_vec
= make_tree_vector ();
14674 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14675 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14678 /* If there was an initializer in the original tree, but it
14679 instantiated to an empty list, then we should pass a
14680 non-NULL empty vector to tell build_new that it was an
14681 empty initializer() rather than no initializer. This can
14682 only happen when the initializer is a pack expansion whose
14683 parameter packs are of length zero. */
14684 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
14688 init_vec
= make_tree_vector ();
14689 if (init
== void_node
)
14690 gcc_assert (init_vec
!= NULL
);
14693 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
14694 vec_safe_push (init_vec
, TREE_VALUE (init
));
14698 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14699 tree op2
= RECUR (TREE_OPERAND (t
, 2));
14700 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
14701 NEW_EXPR_USE_GLOBAL (t
),
14704 if (placement_vec
!= NULL
)
14705 release_tree_vector (placement_vec
);
14706 if (init_vec
!= NULL
)
14707 release_tree_vector (init_vec
);
14714 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14715 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14716 RETURN (delete_sanity (op0
, op1
,
14717 DELETE_EXPR_USE_VEC (t
),
14718 DELETE_EXPR_USE_GLOBAL (t
),
14722 case COMPOUND_EXPR
:
14724 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
14725 complain
& ~tf_decltype
, in_decl
,
14726 /*function_p=*/false,
14727 integral_constant_expression_p
);
14728 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
14730 RECUR (TREE_OPERAND (t
, 1)),
14731 complain
|decltype_flag
));
14737 vec
<tree
, va_gc
> *call_args
;
14738 unsigned int nargs
, i
;
14743 function
= CALL_EXPR_FN (t
);
14744 /* When we parsed the expression, we determined whether or
14745 not Koenig lookup should be performed. */
14746 koenig_p
= KOENIG_LOOKUP_P (t
);
14747 if (TREE_CODE (function
) == SCOPE_REF
)
14749 qualified_p
= true;
14750 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
14752 /*address_p=*/false);
14754 else if (koenig_p
&& identifier_p (function
))
14756 /* Do nothing; calling tsubst_copy_and_build on an identifier
14757 would incorrectly perform unqualified lookup again.
14759 Note that we can also have an IDENTIFIER_NODE if the earlier
14760 unqualified lookup found a member function; in that case
14761 koenig_p will be false and we do want to do the lookup
14762 again to find the instantiated member function.
14764 FIXME but doing that causes c++/15272, so we need to stop
14765 using IDENTIFIER_NODE in that situation. */
14766 qualified_p
= false;
14770 if (TREE_CODE (function
) == COMPONENT_REF
)
14772 tree op
= TREE_OPERAND (function
, 1);
14774 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
14775 || (BASELINK_P (op
)
14776 && BASELINK_QUALIFIED_P (op
)));
14779 qualified_p
= false;
14781 if (TREE_CODE (function
) == ADDR_EXPR
14782 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
14783 /* Avoid error about taking the address of a constructor. */
14784 function
= TREE_OPERAND (function
, 0);
14786 function
= tsubst_copy_and_build (function
, args
, complain
,
14789 integral_constant_expression_p
);
14791 if (BASELINK_P (function
))
14792 qualified_p
= true;
14795 nargs
= call_expr_nargs (t
);
14796 call_args
= make_tree_vector ();
14797 for (i
= 0; i
< nargs
; ++i
)
14799 tree arg
= CALL_EXPR_ARG (t
, i
);
14801 if (!PACK_EXPANSION_P (arg
))
14802 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
14805 /* Expand the pack expansion and push each entry onto
14807 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
14808 if (TREE_CODE (arg
) == TREE_VEC
)
14810 unsigned int len
, j
;
14812 len
= TREE_VEC_LENGTH (arg
);
14813 for (j
= 0; j
< len
; ++j
)
14815 tree value
= TREE_VEC_ELT (arg
, j
);
14816 if (value
!= NULL_TREE
)
14817 value
= convert_from_reference (value
);
14818 vec_safe_push (call_args
, value
);
14823 /* A partial substitution. Add one entry. */
14824 vec_safe_push (call_args
, arg
);
14829 /* We do not perform argument-dependent lookup if normal
14830 lookup finds a non-function, in accordance with the
14831 expected resolution of DR 218. */
14833 && ((is_overloaded_fn (function
)
14834 /* If lookup found a member function, the Koenig lookup is
14835 not appropriate, even if an unqualified-name was used
14836 to denote the function. */
14837 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
14838 || identifier_p (function
))
14839 /* Only do this when substitution turns a dependent call
14840 into a non-dependent call. */
14841 && type_dependent_expression_p_push (t
)
14842 && !any_type_dependent_arguments_p (call_args
))
14843 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
14845 if (identifier_p (function
)
14846 && !any_type_dependent_arguments_p (call_args
))
14848 if (koenig_p
&& (complain
& tf_warning_or_error
))
14850 /* For backwards compatibility and good diagnostics, try
14851 the unqualified lookup again if we aren't in SFINAE
14853 tree unq
= (tsubst_copy_and_build
14854 (function
, args
, complain
, in_decl
, true,
14855 integral_constant_expression_p
));
14856 if (unq
== error_mark_node
)
14857 RETURN (error_mark_node
);
14859 if (unq
!= function
)
14862 if (INDIRECT_REF_P (fn
))
14863 fn
= TREE_OPERAND (fn
, 0);
14864 if (TREE_CODE (fn
) == COMPONENT_REF
)
14865 fn
= TREE_OPERAND (fn
, 1);
14866 if (is_overloaded_fn (fn
))
14867 fn
= get_first_fn (fn
);
14868 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
14869 "%qD was not declared in this scope, "
14870 "and no declarations were found by "
14871 "argument-dependent lookup at the point "
14872 "of instantiation", function
))
14875 /* Can't say anything more. */;
14876 else if (DECL_CLASS_SCOPE_P (fn
))
14878 location_t loc
= EXPR_LOC_OR_LOC (t
,
14881 "declarations in dependent base %qT are "
14882 "not found by unqualified lookup",
14883 DECL_CLASS_CONTEXT (fn
));
14884 if (current_class_ptr
)
14886 "use %<this->%D%> instead", function
);
14889 "use %<%T::%D%> instead",
14890 current_class_name
, function
);
14893 inform (0, "%q+D declared here, later in the "
14894 "translation unit", fn
);
14899 if (identifier_p (function
))
14901 if (complain
& tf_error
)
14902 unqualified_name_lookup_error (function
);
14903 release_tree_vector (call_args
);
14904 RETURN (error_mark_node
);
14908 /* Remember that there was a reference to this entity. */
14909 if (DECL_P (function
))
14910 mark_used (function
);
14912 /* Put back tf_decltype for the actual call. */
14913 complain
|= decltype_flag
;
14915 if (TREE_CODE (function
) == OFFSET_REF
)
14916 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
14918 else if (TREE_CODE (function
) == COMPONENT_REF
)
14920 tree instance
= TREE_OPERAND (function
, 0);
14921 tree fn
= TREE_OPERAND (function
, 1);
14923 if (processing_template_decl
14924 && (type_dependent_expression_p (instance
)
14925 || (!BASELINK_P (fn
)
14926 && TREE_CODE (fn
) != FIELD_DECL
)
14927 || type_dependent_expression_p (fn
)
14928 || any_type_dependent_arguments_p (call_args
)))
14929 ret
= build_nt_call_vec (function
, call_args
);
14930 else if (!BASELINK_P (fn
))
14931 ret
= finish_call_expr (function
, &call_args
,
14932 /*disallow_virtual=*/false,
14933 /*koenig_p=*/false,
14936 ret
= (build_new_method_call
14938 &call_args
, NULL_TREE
,
14939 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
14944 ret
= finish_call_expr (function
, &call_args
,
14945 /*disallow_virtual=*/qualified_p
,
14949 release_tree_vector (call_args
);
14956 tree cond
= RECUR (TREE_OPERAND (t
, 0));
14959 if (TREE_CODE (cond
) == INTEGER_CST
)
14961 if (integer_zerop (cond
))
14963 ++c_inhibit_evaluation_warnings
;
14964 exp1
= RECUR (TREE_OPERAND (t
, 1));
14965 --c_inhibit_evaluation_warnings
;
14966 exp2
= RECUR (TREE_OPERAND (t
, 2));
14970 exp1
= RECUR (TREE_OPERAND (t
, 1));
14971 ++c_inhibit_evaluation_warnings
;
14972 exp2
= RECUR (TREE_OPERAND (t
, 2));
14973 --c_inhibit_evaluation_warnings
;
14978 exp1
= RECUR (TREE_OPERAND (t
, 1));
14979 exp2
= RECUR (TREE_OPERAND (t
, 2));
14982 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
14983 cond
, exp1
, exp2
, complain
));
14986 case PSEUDO_DTOR_EXPR
:
14988 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14989 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14990 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
14991 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
14997 tree purpose
, value
, chain
;
14999 if (t
== void_list_node
)
15002 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15003 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15005 /* We have pack expansions, so expand those and
15006 create a new list out of it. */
15007 tree purposevec
= NULL_TREE
;
15008 tree valuevec
= NULL_TREE
;
15012 /* Expand the argument expressions. */
15013 if (TREE_PURPOSE (t
))
15014 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15015 complain
, in_decl
);
15016 if (TREE_VALUE (t
))
15017 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15018 complain
, in_decl
);
15020 /* Build the rest of the list. */
15021 chain
= TREE_CHAIN (t
);
15022 if (chain
&& chain
!= void_type_node
)
15023 chain
= RECUR (chain
);
15025 /* Determine the number of arguments. */
15026 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15028 len
= TREE_VEC_LENGTH (purposevec
);
15029 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15031 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15032 len
= TREE_VEC_LENGTH (valuevec
);
15035 /* Since we only performed a partial substitution into
15036 the argument pack, we only RETURN (a single list
15038 if (purposevec
== TREE_PURPOSE (t
)
15039 && valuevec
== TREE_VALUE (t
)
15040 && chain
== TREE_CHAIN (t
))
15043 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15046 /* Convert the argument vectors into a TREE_LIST */
15050 /* Grab the Ith values. */
15052 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15055 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15058 /* Build the list (backwards). */
15059 chain
= tree_cons (purpose
, value
, chain
);
15065 purpose
= TREE_PURPOSE (t
);
15067 purpose
= RECUR (purpose
);
15068 value
= TREE_VALUE (t
);
15070 value
= RECUR (value
);
15071 chain
= TREE_CHAIN (t
);
15072 if (chain
&& chain
!= void_type_node
)
15073 chain
= RECUR (chain
);
15074 if (purpose
== TREE_PURPOSE (t
)
15075 && value
== TREE_VALUE (t
)
15076 && chain
== TREE_CHAIN (t
))
15078 RETURN (tree_cons (purpose
, value
, chain
));
15081 case COMPONENT_REF
:
15088 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15089 args
, complain
, in_decl
);
15090 /* Remember that there was a reference to this entity. */
15091 if (DECL_P (object
))
15092 mark_used (object
);
15093 object_type
= TREE_TYPE (object
);
15095 member
= TREE_OPERAND (t
, 1);
15096 if (BASELINK_P (member
))
15097 member
= tsubst_baselink (member
,
15098 non_reference (TREE_TYPE (object
)),
15099 args
, complain
, in_decl
);
15101 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15102 if (member
== error_mark_node
)
15103 RETURN (error_mark_node
);
15105 if (type_dependent_expression_p (object
))
15106 /* We can't do much here. */;
15107 else if (!CLASS_TYPE_P (object_type
))
15109 if (scalarish_type_p (object_type
))
15111 tree s
= NULL_TREE
;
15112 tree dtor
= member
;
15114 if (TREE_CODE (dtor
) == SCOPE_REF
)
15116 s
= TREE_OPERAND (dtor
, 0);
15117 dtor
= TREE_OPERAND (dtor
, 1);
15119 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15121 dtor
= TREE_OPERAND (dtor
, 0);
15123 RETURN (finish_pseudo_destructor_expr
15124 (object
, s
, dtor
, input_location
));
15128 else if (TREE_CODE (member
) == SCOPE_REF
15129 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15131 /* Lookup the template functions now that we know what the
15133 tree scope
= TREE_OPERAND (member
, 0);
15134 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15135 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15136 member
= lookup_qualified_name (scope
, tmpl
,
15137 /*is_type_p=*/false,
15138 /*complain=*/false);
15139 if (BASELINK_P (member
))
15141 BASELINK_FUNCTIONS (member
)
15142 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15144 member
= (adjust_result_of_qualified_name_lookup
15145 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15150 qualified_name_lookup_error (scope
, tmpl
, member
,
15152 RETURN (error_mark_node
);
15155 else if (TREE_CODE (member
) == SCOPE_REF
15156 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15157 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15159 if (complain
& tf_error
)
15161 if (TYPE_P (TREE_OPERAND (member
, 0)))
15162 error ("%qT is not a class or namespace",
15163 TREE_OPERAND (member
, 0));
15165 error ("%qD is not a class or namespace",
15166 TREE_OPERAND (member
, 0));
15168 RETURN (error_mark_node
);
15170 else if (TREE_CODE (member
) == FIELD_DECL
)
15172 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15173 if (TREE_CODE (r
) == COMPONENT_REF
)
15174 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15178 r
= finish_class_member_access_expr (object
, member
,
15179 /*template_p=*/false,
15181 if (TREE_CODE (r
) == COMPONENT_REF
)
15182 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15187 RETURN (build_throw
15188 (RECUR (TREE_OPERAND (t
, 0))));
15192 vec
<constructor_elt
, va_gc
> *n
;
15193 constructor_elt
*ce
;
15194 unsigned HOST_WIDE_INT idx
;
15195 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15196 bool process_index_p
;
15198 bool need_copy_p
= false;
15201 if (type
== error_mark_node
)
15202 RETURN (error_mark_node
);
15204 /* digest_init will do the wrong thing if we let it. */
15205 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15208 /* We do not want to process the index of aggregate
15209 initializers as they are identifier nodes which will be
15210 looked up by digest_init. */
15211 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15213 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15214 newlen
= vec_safe_length (n
);
15215 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15217 if (ce
->index
&& process_index_p
15218 /* An identifier index is looked up in the type
15219 being initialized, not the current scope. */
15220 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15221 ce
->index
= RECUR (ce
->index
);
15223 if (PACK_EXPANSION_P (ce
->value
))
15225 /* Substitute into the pack expansion. */
15226 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15229 if (ce
->value
== error_mark_node
15230 || PACK_EXPANSION_P (ce
->value
))
15232 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15233 /* Just move the argument into place. */
15234 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15237 /* Update the length of the final CONSTRUCTOR
15238 arguments vector, and note that we will need to
15240 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15241 need_copy_p
= true;
15245 ce
->value
= RECUR (ce
->value
);
15250 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15252 vec_alloc (n
, newlen
);
15253 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15255 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15257 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15258 for (i
= 0; i
< len
; ++i
)
15259 CONSTRUCTOR_APPEND_ELT (n
, 0,
15260 TREE_VEC_ELT (ce
->value
, i
));
15263 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15267 r
= build_constructor (init_list_type_node
, n
);
15268 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15270 if (TREE_HAS_CONSTRUCTOR (t
))
15271 RETURN (finish_compound_literal (type
, r
, complain
));
15273 TREE_TYPE (r
) = type
;
15279 tree operand_0
= TREE_OPERAND (t
, 0);
15280 if (TYPE_P (operand_0
))
15282 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15283 RETURN (get_typeid (operand_0
, complain
));
15287 operand_0
= RECUR (operand_0
);
15288 RETURN (build_typeid (operand_0
, complain
));
15295 else if (DECL_PACK_P (t
))
15297 /* We don't build decls for an instantiation of a
15298 variadic capture proxy, we instantiate the elements
15300 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15301 return RECUR (DECL_VALUE_EXPR (t
));
15307 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15309 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15310 /* If the original type was a reference, we'll be wrapped in
15311 the appropriate INDIRECT_REF. */
15312 r
= convert_from_reference (r
);
15318 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15319 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15320 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15323 case OFFSETOF_EXPR
:
15324 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0))));
15328 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15329 complain
, in_decl
);
15331 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15333 type2
= tsubst (type2
, args
, complain
, in_decl
);
15335 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15340 tree old_stmt_expr
= cur_stmt_expr
;
15341 tree stmt_expr
= begin_stmt_expr ();
15343 cur_stmt_expr
= stmt_expr
;
15344 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15345 integral_constant_expression_p
);
15346 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15347 cur_stmt_expr
= old_stmt_expr
;
15349 /* If the resulting list of expression statement is empty,
15350 fold it further into void_node. */
15351 if (empty_expr_stmt_p (stmt_expr
))
15352 stmt_expr
= void_node
;
15354 RETURN (stmt_expr
);
15359 tree r
= build_lambda_expr ();
15361 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15362 LAMBDA_EXPR_CLOSURE (r
) = type
;
15363 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15365 LAMBDA_EXPR_LOCATION (r
)
15366 = LAMBDA_EXPR_LOCATION (t
);
15367 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15368 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15369 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15370 LAMBDA_EXPR_DISCRIMINATOR (r
)
15371 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15372 /* For a function scope, we want to use tsubst so that we don't
15373 complain about referring to an auto function before its return
15374 type has been deduced. Otherwise, we want to use tsubst_copy so
15375 that we look up the existing field/parameter/variable rather
15376 than build a new one. */
15377 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15378 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15379 scope
= tsubst (scope
, args
, complain
, in_decl
);
15380 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15382 /* Look up the parameter we want directly, as tsubst_copy
15383 doesn't do what we need. */
15384 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15385 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15386 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15387 parm
= DECL_CHAIN (parm
);
15389 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15390 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15391 DECL_CONTEXT (scope
) = fn
;
15394 scope
= RECUR (scope
);
15395 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15396 LAMBDA_EXPR_RETURN_TYPE (r
)
15397 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15399 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15400 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15402 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15403 determine_visibility (TYPE_NAME (type
));
15404 /* Now that we know visibility, instantiate the type so we have a
15405 declaration of the op() for later calls to lambda_function. */
15406 complete_type (type
);
15408 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15410 RETURN (build_lambda_object (r
));
15414 /* We can get here for a constant initializer of non-dependent type.
15415 FIXME stop folding in cp_parser_initializer_clause. */
15417 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15422 case TRANSACTION_EXPR
:
15423 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15424 integral_constant_expression_p
));
15427 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15429 case VEC_PERM_EXPR
:
15431 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15432 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15433 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15434 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15439 /* Handle Objective-C++ constructs, if appropriate. */
15442 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15443 in_decl
, /*function_p=*/false);
15447 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15453 input_location
= loc
;
15457 /* Verify that the instantiated ARGS are valid. For type arguments,
15458 make sure that the type's linkage is ok. For non-type arguments,
15459 make sure they are constants if they are integral or enumerations.
15460 Emit an error under control of COMPLAIN, and return TRUE on error. */
15463 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15465 if (dependent_template_arg_p (t
))
15467 if (ARGUMENT_PACK_P (t
))
15469 tree vec
= ARGUMENT_PACK_ARGS (t
);
15470 int len
= TREE_VEC_LENGTH (vec
);
15471 bool result
= false;
15474 for (i
= 0; i
< len
; ++i
)
15475 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15479 else if (TYPE_P (t
))
15481 /* [basic.link]: A name with no linkage (notably, the name
15482 of a class or enumeration declared in a local scope)
15483 shall not be used to declare an entity with linkage.
15484 This implies that names with no linkage cannot be used as
15487 DR 757 relaxes this restriction for C++0x. */
15488 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15489 : no_linkage_check (t
, /*relaxed_p=*/false));
15493 /* DR 488 makes use of a type with no linkage cause
15494 type deduction to fail. */
15495 if (complain
& tf_error
)
15497 if (TYPE_ANONYMOUS_P (nt
))
15498 error ("%qT is/uses anonymous type", t
);
15500 error ("template argument for %qD uses local type %qT",
15505 /* In order to avoid all sorts of complications, we do not
15506 allow variably-modified types as template arguments. */
15507 else if (variably_modified_type_p (t
, NULL_TREE
))
15509 if (complain
& tf_error
)
15510 error ("%qT is a variably modified type", t
);
15514 /* Class template and alias template arguments should be OK. */
15515 else if (DECL_TYPE_TEMPLATE_P (t
))
15517 /* A non-type argument of integral or enumerated type must be a
15519 else if (TREE_TYPE (t
)
15520 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15521 && !TREE_CONSTANT (t
))
15523 if (complain
& tf_error
)
15524 error ("integral expression %qE is not constant", t
);
15531 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15533 int ix
, len
= DECL_NTPARMS (tmpl
);
15534 bool result
= false;
15536 for (ix
= 0; ix
!= len
; ix
++)
15538 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15541 if (result
&& (complain
& tf_error
))
15542 error (" trying to instantiate %qD", tmpl
);
15546 /* We're out of SFINAE context now, so generate diagnostics for the access
15547 errors we saw earlier when instantiating D from TMPL and ARGS. */
15550 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15552 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15553 tree type
= TREE_TYPE (pattern
);
15554 location_t loc
= input_location
;
15556 push_access_scope (d
);
15557 push_deferring_access_checks (dk_no_deferred
);
15558 input_location
= DECL_SOURCE_LOCATION (pattern
);
15559 tsubst (type
, args
, tf_warning_or_error
, d
);
15560 input_location
= loc
;
15561 pop_deferring_access_checks ();
15562 pop_access_scope (d
);
15565 /* Instantiate the indicated variable, function, or alias template TMPL with
15566 the template arguments in TARG_PTR. */
15569 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15571 tree targ_ptr
= orig_args
;
15575 bool access_ok
= true;
15577 if (tmpl
== error_mark_node
)
15578 return error_mark_node
;
15580 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15582 /* If this function is a clone, handle it specially. */
15583 if (DECL_CLONED_FUNCTION_P (tmpl
))
15588 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15589 DECL_CLONED_FUNCTION. */
15590 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15591 targ_ptr
, complain
);
15592 if (spec
== error_mark_node
)
15593 return error_mark_node
;
15595 /* Look for the clone. */
15596 FOR_EACH_CLONE (clone
, spec
)
15597 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15599 /* We should always have found the clone by now. */
15600 gcc_unreachable ();
15604 if (targ_ptr
== error_mark_node
)
15605 return error_mark_node
;
15607 /* Check to see if we already have this specialization. */
15608 gen_tmpl
= most_general_template (tmpl
);
15609 if (tmpl
!= gen_tmpl
)
15610 /* The TMPL is a partial instantiation. To get a full set of
15611 arguments we must add the arguments used to perform the
15612 partial instantiation. */
15613 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15616 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15617 but it doesn't seem to be on the hot path. */
15618 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15620 gcc_assert (tmpl
== gen_tmpl
15621 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15623 || fndecl
== NULL_TREE
);
15625 if (spec
!= NULL_TREE
)
15627 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15629 if (complain
& tf_error
)
15630 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15631 return error_mark_node
;
15636 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15638 return error_mark_node
;
15640 /* We are building a FUNCTION_DECL, during which the access of its
15641 parameters and return types have to be checked. However this
15642 FUNCTION_DECL which is the desired context for access checking
15643 is not built yet. We solve this chicken-and-egg problem by
15644 deferring all checks until we have the FUNCTION_DECL. */
15645 push_deferring_access_checks (dk_deferred
);
15647 /* Instantiation of the function happens in the context of the function
15648 template, not the context of the overload resolution we're doing. */
15649 push_to_top_level ();
15650 /* If there are dependent arguments, e.g. because we're doing partial
15651 ordering, make sure processing_template_decl stays set. */
15652 if (uses_template_parms (targ_ptr
))
15653 ++processing_template_decl
;
15654 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15656 tree ctx
= tsubst (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15657 complain
, gen_tmpl
);
15658 push_nested_class (ctx
);
15660 /* Substitute template parameters to obtain the specialization. */
15661 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
15662 targ_ptr
, complain
, gen_tmpl
);
15663 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15664 pop_nested_class ();
15665 pop_from_top_level ();
15667 if (fndecl
== error_mark_node
)
15669 pop_deferring_access_checks ();
15670 return error_mark_node
;
15673 /* The DECL_TI_TEMPLATE should always be the immediate parent
15674 template, not the most general template. */
15675 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
15677 /* Now we know the specialization, compute access previously
15679 push_access_scope (fndecl
);
15680 if (!perform_deferred_access_checks (complain
))
15682 pop_access_scope (fndecl
);
15683 pop_deferring_access_checks ();
15685 /* If we've just instantiated the main entry point for a function,
15686 instantiate all the alternate entry points as well. We do this
15687 by cloning the instantiation of the main entry point, not by
15688 instantiating the template clones. */
15689 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
15690 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
15694 if (!(complain
& tf_error
))
15696 /* Remember to reinstantiate when we're out of SFINAE so the user
15697 can see the errors. */
15698 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
15700 return error_mark_node
;
15705 /* Wrapper for instantiate_template_1. */
15708 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15711 timevar_push (TV_TEMPLATE_INST
);
15712 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
15713 timevar_pop (TV_TEMPLATE_INST
);
15717 /* Instantiate the alias template TMPL with ARGS. Also push a template
15718 instantiation level, which instantiate_template doesn't do because
15719 functions and variables have sufficient context established by the
15723 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
15725 struct pending_template
*old_last_pend
= last_pending_template
;
15726 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15727 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
15728 return error_mark_node
;
15729 tree tinst
= build_tree_list (tmpl
, args
);
15730 if (!push_tinst_level (tinst
))
15733 return error_mark_node
;
15737 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
15738 args
, tmpl
, complain
,
15739 /*require_all_args=*/true,
15740 /*use_default_args=*/true);
15742 tree r
= instantiate_template (tmpl
, args
, complain
);
15743 pop_tinst_level ();
15744 /* We can't free this if a pending_template entry or last_error_tinst_level
15745 is pointing at it. */
15746 if (last_pending_template
== old_last_pend
15747 && last_error_tinst_level
== old_error_tinst
)
15753 /* PARM is a template parameter pack for FN. Returns true iff
15754 PARM is used in a deducible way in the argument list of FN. */
15757 pack_deducible_p (tree parm
, tree fn
)
15759 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
15760 for (; t
; t
= TREE_CHAIN (t
))
15762 tree type
= TREE_VALUE (t
);
15764 if (!PACK_EXPANSION_P (type
))
15766 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
15767 packs
; packs
= TREE_CHAIN (packs
))
15768 if (TREE_VALUE (packs
) == parm
)
15770 /* The template parameter pack is used in a function parameter
15771 pack. If this is the end of the parameter list, the
15772 template parameter pack is deducible. */
15773 if (TREE_CHAIN (t
) == void_list_node
)
15776 /* Otherwise, not. Well, it could be deduced from
15777 a non-pack parameter, but doing so would end up with
15778 a deduction mismatch, so don't bother. */
15782 /* The template parameter pack isn't used in any function parameter
15783 packs, but it might be used deeper, e.g. tuple<Args...>. */
15787 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
15788 NARGS elements of the arguments that are being used when calling
15789 it. TARGS is a vector into which the deduced template arguments
15792 Returns either a FUNCTION_DECL for the matching specialization of FN or
15793 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
15794 true, diagnostics will be printed to explain why it failed.
15796 If FN is a conversion operator, or we are trying to produce a specific
15797 specialization, RETURN_TYPE is the return type desired.
15799 The EXPLICIT_TARGS are explicit template arguments provided via a
15802 The parameter STRICT is one of:
15805 We are deducing arguments for a function call, as in
15806 [temp.deduct.call].
15809 We are deducing arguments for a conversion function, as in
15810 [temp.deduct.conv].
15813 We are deducing arguments when doing an explicit instantiation
15814 as in [temp.explicit], when determining an explicit specialization
15815 as in [temp.expl.spec], or when taking the address of a function
15816 template, as in [temp.deduct.funcaddr]. */
15819 fn_type_unification (tree fn
,
15820 tree explicit_targs
,
15823 unsigned int nargs
,
15825 unification_kind_t strict
,
15832 tree decl
= NULL_TREE
;
15833 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
15835 static int deduction_depth
;
15836 struct pending_template
*old_last_pend
= last_pending_template
;
15837 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15838 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
15840 tree r
= error_mark_node
;
15843 complain
|= tf_decltype
;
15845 /* In C++0x, it's possible to have a function template whose type depends
15846 on itself recursively. This is most obvious with decltype, but can also
15847 occur with enumeration scope (c++/48969). So we need to catch infinite
15848 recursion and reject the substitution at deduction time; this function
15849 will return error_mark_node for any repeated substitution.
15851 This also catches excessive recursion such as when f<N> depends on
15852 f<N-1> across all integers, and returns error_mark_node for all the
15853 substitutions back up to the initial one.
15855 This is, of course, not reentrant. */
15856 if (excessive_deduction_depth
)
15857 return error_mark_node
;
15858 tinst
= build_tree_list (fn
, NULL_TREE
);
15861 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
15863 fntype
= TREE_TYPE (fn
);
15864 if (explicit_targs
)
15868 The specified template arguments must match the template
15869 parameters in kind (i.e., type, nontype, template), and there
15870 must not be more arguments than there are parameters;
15871 otherwise type deduction fails.
15873 Nontype arguments must match the types of the corresponding
15874 nontype template parameters, or must be convertible to the
15875 types of the corresponding nontype parameters as specified in
15876 _temp.arg.nontype_, otherwise type deduction fails.
15878 All references in the function type of the function template
15879 to the corresponding template parameters are replaced by the
15880 specified template argument values. If a substitution in a
15881 template parameter or in the function type of the function
15882 template results in an invalid type, type deduction fails. */
15883 int i
, len
= TREE_VEC_LENGTH (tparms
);
15884 location_t loc
= input_location
;
15885 bool incomplete
= false;
15887 /* Adjust any explicit template arguments before entering the
15888 substitution context. */
15890 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
15892 /*require_all_args=*/false,
15893 /*use_default_args=*/false));
15894 if (explicit_targs
== error_mark_node
)
15897 /* Substitute the explicit args into the function type. This is
15898 necessary so that, for instance, explicitly declared function
15899 arguments can match null pointed constants. If we were given
15900 an incomplete set of explicit args, we must not do semantic
15901 processing during substitution as we could create partial
15903 for (i
= 0; i
< len
; i
++)
15905 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
15906 bool parameter_pack
= false;
15907 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
15909 /* Dig out the actual parm. */
15910 if (TREE_CODE (parm
) == TYPE_DECL
15911 || TREE_CODE (parm
) == TEMPLATE_DECL
)
15913 parm
= TREE_TYPE (parm
);
15914 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
15916 else if (TREE_CODE (parm
) == PARM_DECL
)
15918 parm
= DECL_INITIAL (parm
);
15919 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
15922 if (!parameter_pack
&& targ
== NULL_TREE
)
15923 /* No explicit argument for this template parameter. */
15926 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
15928 /* Mark the argument pack as "incomplete". We could
15929 still deduce more arguments during unification.
15930 We remove this mark in type_unification_real. */
15933 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
15934 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
15935 = ARGUMENT_PACK_ARGS (targ
);
15938 /* We have some incomplete argument packs. */
15943 TREE_VALUE (tinst
) = explicit_targs
;
15944 if (!push_tinst_level (tinst
))
15946 excessive_deduction_depth
= true;
15949 processing_template_decl
+= incomplete
;
15950 input_location
= DECL_SOURCE_LOCATION (fn
);
15951 /* Ignore any access checks; we'll see them again in
15952 instantiate_template and they might have the wrong
15953 access path at this point. */
15954 push_deferring_access_checks (dk_deferred
);
15955 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
15956 complain
| tf_partial
, NULL_TREE
);
15957 pop_deferring_access_checks ();
15958 input_location
= loc
;
15959 processing_template_decl
-= incomplete
;
15960 pop_tinst_level ();
15962 if (fntype
== error_mark_node
)
15965 /* Place the explicitly specified arguments in TARGS. */
15966 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
15967 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
15970 /* Never do unification on the 'this' parameter. */
15971 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
15977 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
15978 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
15979 new_args
[0] = return_type
;
15980 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
15985 /* We allow incomplete unification without an error message here
15986 because the standard doesn't seem to explicitly prohibit it. Our
15987 callers must be ready to deal with unification failures in any
15990 TREE_VALUE (tinst
) = targs
;
15991 /* If we aren't explaining yet, push tinst context so we can see where
15992 any errors (e.g. from class instantiations triggered by instantiation
15993 of default template arguments) come from. If we are explaining, this
15994 context is redundant. */
15995 if (!explain_p
&& !push_tinst_level (tinst
))
15997 excessive_deduction_depth
= true;
16001 /* type_unification_real will pass back any access checks from default
16002 template argument substitution. */
16003 vec
<deferred_access_check
, va_gc
> *checks
;
16006 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16007 targs
, parms
, args
, nargs
, /*subr=*/0,
16008 strict
, flags
, &checks
, explain_p
);
16010 pop_tinst_level ();
16014 /* Now that we have bindings for all of the template arguments,
16015 ensure that the arguments deduced for the template template
16016 parameters have compatible template parameter lists. We cannot
16017 check this property before we have deduced all template
16018 arguments, because the template parameter types of a template
16019 template parameter might depend on prior template parameters
16020 deduced after the template template parameter. The following
16021 ill-formed example illustrates this issue:
16023 template<typename T, template<T> class C> void f(C<5>, T);
16025 template<int N> struct X {};
16028 f(X<5>(), 5l); // error: template argument deduction fails
16031 The template parameter list of 'C' depends on the template type
16032 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16033 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16034 time that we deduce 'C'. */
16035 if (!template_template_parm_bindings_ok_p
16036 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16038 unify_inconsistent_template_template_parameters (explain_p
);
16042 /* All is well so far. Now, check:
16046 When all template arguments have been deduced, all uses of
16047 template parameters in nondeduced contexts are replaced with
16048 the corresponding deduced argument values. If the
16049 substitution results in an invalid type, as described above,
16050 type deduction fails. */
16051 TREE_VALUE (tinst
) = targs
;
16052 if (!push_tinst_level (tinst
))
16054 excessive_deduction_depth
= true;
16058 /* Also collect access checks from the instantiation. */
16059 reopen_deferring_access_checks (checks
);
16061 decl
= instantiate_template (fn
, targs
, complain
);
16063 checks
= get_deferred_access_checks ();
16064 pop_deferring_access_checks ();
16066 pop_tinst_level ();
16068 if (decl
== error_mark_node
)
16071 /* Now perform any access checks encountered during substitution. */
16072 push_access_scope (decl
);
16073 ok
= perform_access_checks (checks
, complain
);
16074 pop_access_scope (decl
);
16078 /* If we're looking for an exact match, check that what we got
16079 is indeed an exact match. It might not be if some template
16080 parameters are used in non-deduced contexts. But don't check
16081 for an exact match if we have dependent template arguments;
16082 in that case we're doing partial ordering, and we already know
16083 that we have two candidates that will provide the actual type. */
16084 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16086 tree substed
= TREE_TYPE (decl
);
16090 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16092 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16093 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16094 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16096 unify_type_mismatch (explain_p
, args
[i
],
16097 TREE_VALUE (sarg
));
16106 if (excessive_deduction_depth
)
16108 if (deduction_depth
== 0)
16109 /* Reset once we're all the way out. */
16110 excessive_deduction_depth
= false;
16113 /* We can't free this if a pending_template entry or last_error_tinst_level
16114 is pointing at it. */
16115 if (last_pending_template
== old_last_pend
16116 && last_error_tinst_level
== old_error_tinst
)
16122 /* Adjust types before performing type deduction, as described in
16123 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16124 sections are symmetric. PARM is the type of a function parameter
16125 or the return type of the conversion function. ARG is the type of
16126 the argument passed to the call, or the type of the value
16127 initialized with the result of the conversion function.
16128 ARG_EXPR is the original argument expression, which may be null. */
16131 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16145 /* Swap PARM and ARG throughout the remainder of this
16146 function; the handling is precisely symmetric since PARM
16147 will initialize ARG rather than vice versa. */
16155 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16156 too, but here handle it by stripping the reference from PARM
16157 rather than by adding it to ARG. */
16158 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16159 && TYPE_REF_IS_RVALUE (*parm
)
16160 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16161 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16162 && TREE_CODE (*arg
) == REFERENCE_TYPE
16163 && !TYPE_REF_IS_RVALUE (*arg
))
16164 *parm
= TREE_TYPE (*parm
);
16165 /* Nothing else to do in this case. */
16169 gcc_unreachable ();
16172 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16174 /* [temp.deduct.call]
16176 If P is not a reference type:
16178 --If A is an array type, the pointer type produced by the
16179 array-to-pointer standard conversion (_conv.array_) is
16180 used in place of A for type deduction; otherwise,
16182 --If A is a function type, the pointer type produced by
16183 the function-to-pointer standard conversion
16184 (_conv.func_) is used in place of A for type deduction;
16187 --If A is a cv-qualified type, the top level
16188 cv-qualifiers of A's type are ignored for type
16190 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16191 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16192 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16193 *arg
= build_pointer_type (*arg
);
16195 *arg
= TYPE_MAIN_VARIANT (*arg
);
16198 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16199 of the form T&&, where T is a template parameter, and the argument
16200 is an lvalue, T is deduced as A& */
16201 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16202 && TYPE_REF_IS_RVALUE (*parm
)
16203 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16204 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16205 && (arg_expr
? real_lvalue_p (arg_expr
)
16206 /* try_one_overload doesn't provide an arg_expr, but
16207 functions are always lvalues. */
16208 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16209 *arg
= build_reference_type (*arg
);
16211 /* [temp.deduct.call]
16213 If P is a cv-qualified type, the top level cv-qualifiers
16214 of P's type are ignored for type deduction. If P is a
16215 reference type, the type referred to by P is used for
16217 *parm
= TYPE_MAIN_VARIANT (*parm
);
16218 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16220 *parm
= TREE_TYPE (*parm
);
16221 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16224 /* DR 322. For conversion deduction, remove a reference type on parm
16225 too (which has been swapped into ARG). */
16226 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16227 *arg
= TREE_TYPE (*arg
);
16232 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16233 template which does contain any deducible template parameters; check if
16234 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16235 unify_one_argument. */
16238 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16239 int flags
, bool explain_p
)
16244 type
= TREE_TYPE (arg
);
16248 if (same_type_p (parm
, type
))
16249 return unify_success (explain_p
);
16251 if (strict
== DEDUCE_CONV
)
16253 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16254 explain_p
? tf_warning_or_error
: tf_none
))
16255 return unify_success (explain_p
);
16257 else if (strict
!= DEDUCE_EXACT
)
16259 if (can_convert_arg (parm
, type
,
16260 TYPE_P (arg
) ? NULL_TREE
: arg
,
16261 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16262 return unify_success (explain_p
);
16265 if (strict
== DEDUCE_EXACT
)
16266 return unify_type_mismatch (explain_p
, parm
, arg
);
16268 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16271 static bool uses_deducible_template_parms (tree type
);
16273 /* Returns true iff the expression EXPR is one from which a template
16274 argument can be deduced. In other words, if it's an undecorated
16275 use of a template non-type parameter. */
16278 deducible_expression (tree expr
)
16280 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16283 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16284 deducible way; that is, if it has a max value of <PARM> - 1. */
16287 deducible_array_bound (tree domain
)
16289 if (domain
== NULL_TREE
)
16292 tree max
= TYPE_MAX_VALUE (domain
);
16293 if (TREE_CODE (max
) != MINUS_EXPR
)
16296 return deducible_expression (TREE_OPERAND (max
, 0));
16299 /* Returns true iff the template arguments ARGS use a template parameter
16300 in a deducible way. */
16303 deducible_template_args (tree args
)
16305 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16308 tree elt
= TREE_VEC_ELT (args
, i
);
16309 if (ARGUMENT_PACK_P (elt
))
16310 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16313 if (PACK_EXPANSION_P (elt
))
16314 elt
= PACK_EXPANSION_PATTERN (elt
);
16315 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16317 else if (TYPE_P (elt
))
16318 deducible
= uses_deducible_template_parms (elt
);
16320 deducible
= deducible_expression (elt
);
16328 /* Returns true iff TYPE contains any deducible references to template
16329 parameters, as per 14.8.2.5. */
16332 uses_deducible_template_parms (tree type
)
16334 if (PACK_EXPANSION_P (type
))
16335 type
= PACK_EXPANSION_PATTERN (type
);
16342 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16343 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16349 if (POINTER_TYPE_P (type
))
16350 return uses_deducible_template_parms (TREE_TYPE (type
));
16352 /* T[integer-constant ]
16354 if (TREE_CODE (type
) == ARRAY_TYPE
)
16355 return (uses_deducible_template_parms (TREE_TYPE (type
))
16356 || deducible_array_bound (TYPE_DOMAIN (type
)));
16368 if (TYPE_PTRMEM_P (type
))
16369 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16370 || (uses_deducible_template_parms
16371 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16373 /* template-name <T> (where template-name refers to a class template)
16374 template-name <i> (where template-name refers to a class template) */
16375 if (CLASS_TYPE_P (type
)
16376 && CLASSTYPE_TEMPLATE_INFO (type
)
16377 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16378 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16379 (CLASSTYPE_TI_ARGS (type
)));
16384 if (TREE_CODE (type
) == FUNCTION_TYPE
16385 || TREE_CODE (type
) == METHOD_TYPE
)
16387 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16389 tree parm
= TYPE_ARG_TYPES (type
);
16390 if (TREE_CODE (type
) == METHOD_TYPE
)
16391 parm
= TREE_CHAIN (parm
);
16392 for (; parm
; parm
= TREE_CHAIN (parm
))
16393 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16400 /* Subroutine of type_unification_real and unify_pack_expansion to
16401 handle unification of a single P/A pair. Parameters are as
16402 for those functions. */
16405 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16406 int subr
, unification_kind_t strict
, int flags
,
16409 tree arg_expr
= NULL_TREE
;
16412 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16413 return unify_invalid (explain_p
);
16414 if (arg
== unknown_type_node
)
16415 /* We can't deduce anything from this, but we might get all the
16416 template args from other function args. */
16417 return unify_success (explain_p
);
16419 /* Implicit conversions (Clause 4) will be performed on a function
16420 argument to convert it to the type of the corresponding function
16421 parameter if the parameter type contains no template-parameters that
16422 participate in template argument deduction. */
16423 if (TYPE_P (parm
) && !uses_template_parms (parm
))
16424 /* For function parameters that contain no template-parameters at all,
16425 we have historically checked for convertibility in order to shortcut
16426 consideration of this candidate. */
16427 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
16429 else if (strict
== DEDUCE_CALL
16430 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16431 /* For function parameters with only non-deducible template parameters,
16433 return unify_success (explain_p
);
16438 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16439 | UNIFY_ALLOW_MORE_CV_QUAL
16440 | UNIFY_ALLOW_DERIVED
);
16444 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16448 arg_strict
= UNIFY_ALLOW_NONE
;
16452 gcc_unreachable ();
16455 /* We only do these transformations if this is the top-level
16456 parameter_type_list in a call or declaration matching; in other
16457 situations (nested function declarators, template argument lists) we
16458 won't be comparing a type to an expression, and we don't do any type
16464 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16465 if (type_unknown_p (arg
))
16467 /* [temp.deduct.type] A template-argument can be
16468 deduced from a pointer to function or pointer
16469 to member function argument if the set of
16470 overloaded functions does not contain function
16471 templates and at most one of a set of
16472 overloaded functions provides a unique
16475 if (resolve_overloaded_unification
16476 (tparms
, targs
, parm
, arg
, strict
,
16477 arg_strict
, explain_p
))
16478 return unify_success (explain_p
);
16479 return unify_overload_resolution_failure (explain_p
, arg
);
16483 arg
= unlowered_expr_type (arg
);
16484 if (arg
== error_mark_node
)
16485 return unify_invalid (explain_p
);
16489 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16492 gcc_assert ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16493 == (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
));
16495 /* For deduction from an init-list we need the actual list. */
16496 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16498 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16501 /* Most parms like fn_type_unification.
16503 If SUBR is 1, we're being called recursively (to unify the
16504 arguments of a function or method parameter of a function
16507 CHECKS is a pointer to a vector of access checks encountered while
16508 substituting default template arguments. */
16511 type_unification_real (tree tparms
,
16515 unsigned int xnargs
,
16517 unification_kind_t strict
,
16519 vec
<deferred_access_check
, va_gc
> **checks
,
16524 int ntparms
= TREE_VEC_LENGTH (tparms
);
16525 int saw_undeduced
= 0;
16528 unsigned int nargs
;
16531 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16532 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16533 gcc_assert (ntparms
> 0);
16535 /* Reset the number of non-defaulted template arguments contained
16537 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16545 while (parms
&& parms
!= void_list_node
16548 parm
= TREE_VALUE (parms
);
16550 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16551 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16552 /* For a function parameter pack that occurs at the end of the
16553 parameter-declaration-list, the type A of each remaining
16554 argument of the call is compared with the type P of the
16555 declarator-id of the function parameter pack. */
16558 parms
= TREE_CHAIN (parms
);
16560 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16561 /* For a function parameter pack that does not occur at the
16562 end of the parameter-declaration-list, the type of the
16563 parameter pack is a non-deduced context. */
16569 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16575 && parms
!= void_list_node
16576 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16578 /* Unify the remaining arguments with the pack expansion type. */
16580 tree parmvec
= make_tree_vec (1);
16582 /* Allocate a TREE_VEC and copy in all of the arguments */
16583 argvec
= make_tree_vec (nargs
- ia
);
16584 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16585 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16587 /* Copy the parameter into parmvec. */
16588 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16589 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16590 /*subr=*/subr
, explain_p
))
16593 /* Advance to the end of the list of parameters. */
16594 parms
= TREE_CHAIN (parms
);
16597 /* Fail if we've reached the end of the parm list, and more args
16598 are present, and the parm list isn't variadic. */
16599 if (ia
< nargs
&& parms
== void_list_node
)
16600 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16601 /* Fail if parms are left and they don't have default values. */
16602 if (parms
&& parms
!= void_list_node
16603 && TREE_PURPOSE (parms
) == NULL_TREE
)
16605 unsigned int count
= nargs
;
16607 while (p
&& p
!= void_list_node
)
16610 p
= TREE_CHAIN (p
);
16612 return unify_too_few_arguments (explain_p
, ia
, count
);
16617 tsubst_flags_t complain
= (explain_p
16618 ? tf_warning_or_error
16621 for (i
= 0; i
< ntparms
; i
++)
16623 tree targ
= TREE_VEC_ELT (targs
, i
);
16624 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16626 /* Clear the "incomplete" flags on all argument packs now so that
16627 substituting them into later default arguments works. */
16628 if (targ
&& ARGUMENT_PACK_P (targ
))
16630 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16631 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16634 if (targ
|| tparm
== error_mark_node
)
16636 tparm
= TREE_VALUE (tparm
);
16638 /* If this is an undeduced nontype parameter that depends on
16639 a type parameter, try another pass; its type may have been
16640 deduced from a later argument than the one from which
16641 this parameter can be deduced. */
16642 if (TREE_CODE (tparm
) == PARM_DECL
16643 && uses_template_parms (TREE_TYPE (tparm
))
16644 && !saw_undeduced
++)
16647 /* Core issue #226 (C++0x) [temp.deduct]:
16649 If a template argument has not been deduced, its
16650 default template argument, if any, is used.
16652 When we are in C++98 mode, TREE_PURPOSE will either
16653 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16654 to explicitly check cxx_dialect here. */
16655 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
16657 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16658 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
16659 reopen_deferring_access_checks (*checks
);
16660 location_t save_loc
= input_location
;
16662 input_location
= DECL_SOURCE_LOCATION (parm
);
16663 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
16664 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
16666 input_location
= save_loc
;
16667 *checks
= get_deferred_access_checks ();
16668 pop_deferring_access_checks ();
16669 if (arg
== error_mark_node
)
16673 TREE_VEC_ELT (targs
, i
) = arg
;
16674 /* The position of the first default template argument,
16675 is also the number of non-defaulted arguments in TARGS.
16677 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16678 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
16683 /* If the type parameter is a parameter pack, then it will
16684 be deduced to an empty parameter pack. */
16685 if (template_parameter_pack_p (tparm
))
16689 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
16691 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
16692 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
16693 TREE_CONSTANT (arg
) = 1;
16696 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16698 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
16700 TREE_VEC_ELT (targs
, i
) = arg
;
16704 return unify_parameter_deduction_failure (explain_p
, tparm
);
16707 #ifdef ENABLE_CHECKING
16708 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16709 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
16712 return unify_success (explain_p
);
16715 /* Subroutine of type_unification_real. Args are like the variables
16716 at the call site. ARG is an overloaded function (or template-id);
16717 we try deducing template args from each of the overloads, and if
16718 only one succeeds, we go with that. Modifies TARGS and returns
16719 true on success. */
16722 resolve_overloaded_unification (tree tparms
,
16726 unification_kind_t strict
,
16730 tree tempargs
= copy_node (targs
);
16732 tree goodfn
= NULL_TREE
;
16735 if (TREE_CODE (arg
) == ADDR_EXPR
)
16737 arg
= TREE_OPERAND (arg
, 0);
16743 if (TREE_CODE (arg
) == COMPONENT_REF
)
16744 /* Handle `&x' where `x' is some static or non-static member
16746 arg
= TREE_OPERAND (arg
, 1);
16748 if (TREE_CODE (arg
) == OFFSET_REF
)
16749 arg
= TREE_OPERAND (arg
, 1);
16751 /* Strip baselink information. */
16752 if (BASELINK_P (arg
))
16753 arg
= BASELINK_FUNCTIONS (arg
);
16755 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
16757 /* If we got some explicit template args, we need to plug them into
16758 the affected templates before we try to unify, in case the
16759 explicit args will completely resolve the templates in question. */
16762 tree expl_subargs
= TREE_OPERAND (arg
, 1);
16763 arg
= TREE_OPERAND (arg
, 0);
16765 for (; arg
; arg
= OVL_NEXT (arg
))
16767 tree fn
= OVL_CURRENT (arg
);
16768 tree subargs
, elem
;
16770 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16773 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16774 expl_subargs
, NULL_TREE
, tf_none
,
16775 /*require_all_args=*/true,
16776 /*use_default_args=*/true);
16777 if (subargs
!= error_mark_node
16778 && !any_dependent_template_arguments_p (subargs
))
16780 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
16781 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16782 elem
, strict
, sub_strict
, addr_p
, explain_p
)
16783 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
16792 /* If no templates (or more than one) are fully resolved by the
16793 explicit arguments, this template-id is a non-deduced context; it
16794 could still be OK if we deduce all template arguments for the
16795 enclosing call through other arguments. */
16799 else if (TREE_CODE (arg
) != OVERLOAD
16800 && TREE_CODE (arg
) != FUNCTION_DECL
)
16801 /* If ARG is, for example, "(0, &f)" then its type will be unknown
16802 -- but the deduction does not succeed because the expression is
16803 not just the function on its own. */
16806 for (; arg
; arg
= OVL_NEXT (arg
))
16807 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16808 TREE_TYPE (OVL_CURRENT (arg
)),
16809 strict
, sub_strict
, addr_p
, explain_p
)
16810 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
16812 goodfn
= OVL_CURRENT (arg
);
16816 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16817 to function or pointer to member function argument if the set of
16818 overloaded functions does not contain function templates and at most
16819 one of a set of overloaded functions provides a unique match.
16821 So if we found multiple possibilities, we return success but don't
16822 deduce anything. */
16826 int i
= TREE_VEC_LENGTH (targs
);
16828 if (TREE_VEC_ELT (tempargs
, i
))
16829 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
16837 /* Core DR 115: In contexts where deduction is done and fails, or in
16838 contexts where deduction is not done, if a template argument list is
16839 specified and it, along with any default template arguments, identifies
16840 a single function template specialization, then the template-id is an
16841 lvalue for the function template specialization. */
16844 resolve_nondeduced_context (tree orig_expr
)
16846 tree expr
, offset
, baselink
;
16849 if (!type_unknown_p (orig_expr
))
16854 offset
= NULL_TREE
;
16855 baselink
= NULL_TREE
;
16857 if (TREE_CODE (expr
) == ADDR_EXPR
)
16859 expr
= TREE_OPERAND (expr
, 0);
16862 if (TREE_CODE (expr
) == OFFSET_REF
)
16865 expr
= TREE_OPERAND (expr
, 1);
16867 if (BASELINK_P (expr
))
16870 expr
= BASELINK_FUNCTIONS (expr
);
16873 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
16876 tree goodfn
= NULL_TREE
;
16878 /* If we got some explicit template args, we need to plug them into
16879 the affected templates before we try to unify, in case the
16880 explicit args will completely resolve the templates in question. */
16882 tree expl_subargs
= TREE_OPERAND (expr
, 1);
16883 tree arg
= TREE_OPERAND (expr
, 0);
16884 tree badfn
= NULL_TREE
;
16885 tree badargs
= NULL_TREE
;
16887 for (; arg
; arg
= OVL_NEXT (arg
))
16889 tree fn
= OVL_CURRENT (arg
);
16890 tree subargs
, elem
;
16892 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16895 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16896 expl_subargs
, NULL_TREE
, tf_none
,
16897 /*require_all_args=*/true,
16898 /*use_default_args=*/true);
16899 if (subargs
!= error_mark_node
16900 && !any_dependent_template_arguments_p (subargs
))
16902 elem
= instantiate_template (fn
, subargs
, tf_none
);
16903 if (elem
== error_mark_node
)
16908 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
16917 mark_used (goodfn
);
16920 expr
= build_baselink (BASELINK_BINFO (baselink
),
16921 BASELINK_ACCESS_BINFO (baselink
),
16922 expr
, BASELINK_OPTYPE (baselink
));
16926 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
16927 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
16930 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
16933 else if (good
== 0 && badargs
)
16934 /* There were no good options and at least one bad one, so let the
16935 user know what the problem is. */
16936 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
16941 /* Subroutine of resolve_overloaded_unification; does deduction for a single
16942 overload. Fills TARGS with any deduced arguments, or error_mark_node if
16943 different overloads deduce different arguments for a given parm.
16944 ADDR_P is true if the expression for which deduction is being
16945 performed was of the form "& fn" rather than simply "fn".
16947 Returns 1 on success. */
16950 try_one_overload (tree tparms
,
16955 unification_kind_t strict
,
16964 if (arg
== error_mark_node
)
16967 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16968 to function or pointer to member function argument if the set of
16969 overloaded functions does not contain function templates and at most
16970 one of a set of overloaded functions provides a unique match.
16972 So if this is a template, just return success. */
16974 if (uses_template_parms (arg
))
16977 if (TREE_CODE (arg
) == METHOD_TYPE
)
16978 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
16980 arg
= build_pointer_type (arg
);
16982 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
16984 /* We don't copy orig_targs for this because if we have already deduced
16985 some template args from previous args, unify would complain when we
16986 try to deduce a template parameter for the same argument, even though
16987 there isn't really a conflict. */
16988 nargs
= TREE_VEC_LENGTH (targs
);
16989 tempargs
= make_tree_vec (nargs
);
16991 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
16994 /* First make sure we didn't deduce anything that conflicts with
16995 explicitly specified args. */
16996 for (i
= nargs
; i
--; )
16998 tree elt
= TREE_VEC_ELT (tempargs
, i
);
16999 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17003 else if (uses_template_parms (elt
))
17004 /* Since we're unifying against ourselves, we will fill in
17005 template args used in the function parm list with our own
17006 template parms. Discard them. */
17007 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17008 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17012 for (i
= nargs
; i
--; )
17014 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17017 TREE_VEC_ELT (targs
, i
) = elt
;
17023 /* PARM is a template class (perhaps with unbound template
17024 parameters). ARG is a fully instantiated type. If ARG can be
17025 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17026 TARGS are as for unify. */
17029 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17032 tree copy_of_targs
;
17034 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17035 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17036 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17039 /* We need to make a new template argument vector for the call to
17040 unify. If we used TARGS, we'd clutter it up with the result of
17041 the attempted unification, even if this class didn't work out.
17042 We also don't want to commit ourselves to all the unifications
17043 we've already done, since unification is supposed to be done on
17044 an argument-by-argument basis. In other words, consider the
17045 following pathological case:
17047 template <int I, int J, int K>
17050 template <int I, int J>
17051 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17053 template <int I, int J, int K>
17054 void f(S<I, J, K>, S<I, I, I>);
17063 Now, by the time we consider the unification involving `s2', we
17064 already know that we must have `f<0, 0, 0>'. But, even though
17065 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17066 because there are two ways to unify base classes of S<0, 1, 2>
17067 with S<I, I, I>. If we kept the already deduced knowledge, we
17068 would reject the possibility I=1. */
17069 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17071 /* If unification failed, we're done. */
17072 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17073 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17079 /* Given a template type PARM and a class type ARG, find the unique
17080 base type in ARG that is an instance of PARM. We do not examine
17081 ARG itself; only its base-classes. If there is not exactly one
17082 appropriate base class, return NULL_TREE. PARM may be the type of
17083 a partial specialization, as well as a plain template type. Used
17086 static enum template_base_result
17087 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17088 bool explain_p
, tree
*result
)
17090 tree rval
= NULL_TREE
;
17093 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17095 binfo
= TYPE_BINFO (complete_type (arg
));
17098 /* The type could not be completed. */
17099 *result
= NULL_TREE
;
17100 return tbr_incomplete_type
;
17103 /* Walk in inheritance graph order. The search order is not
17104 important, and this avoids multiple walks of virtual bases. */
17105 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17107 tree r
= try_class_unification (tparms
, targs
, parm
,
17108 BINFO_TYPE (binfo
), explain_p
);
17112 /* If there is more than one satisfactory baseclass, then:
17116 If they yield more than one possible deduced A, the type
17120 if (rval
&& !same_type_p (r
, rval
))
17122 *result
= NULL_TREE
;
17123 return tbr_ambiguous_baseclass
;
17131 return tbr_success
;
17134 /* Returns the level of DECL, which declares a template parameter. */
17137 template_decl_level (tree decl
)
17139 switch (TREE_CODE (decl
))
17142 case TEMPLATE_DECL
:
17143 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17146 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17149 gcc_unreachable ();
17154 /* Decide whether ARG can be unified with PARM, considering only the
17155 cv-qualifiers of each type, given STRICT as documented for unify.
17156 Returns nonzero iff the unification is OK on that basis. */
17159 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17161 int arg_quals
= cp_type_quals (arg
);
17162 int parm_quals
= cp_type_quals (parm
);
17164 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17165 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17167 /* Although a CVR qualifier is ignored when being applied to a
17168 substituted template parameter ([8.3.2]/1 for example), that
17169 does not allow us to unify "const T" with "int&" because both
17170 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17171 It is ok when we're allowing additional CV qualifiers
17172 at the outer level [14.8.2.1]/3,1st bullet. */
17173 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17174 || TREE_CODE (arg
) == FUNCTION_TYPE
17175 || TREE_CODE (arg
) == METHOD_TYPE
)
17176 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17179 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17180 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17184 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17185 && (arg_quals
& parm_quals
) != parm_quals
)
17188 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17189 && (parm_quals
& arg_quals
) != arg_quals
)
17195 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17197 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17199 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17200 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17201 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17203 *index
= TEMPLATE_TYPE_IDX (parm
);
17204 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17208 *index
= TEMPLATE_PARM_IDX (parm
);
17209 *level
= TEMPLATE_PARM_LEVEL (parm
);
17213 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17215 if (unify (TP, TA, P, A, S, EP)) \
17219 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17220 expansion at the end of PACKED_PARMS. Returns 0 if the type
17221 deduction succeeds, 1 otherwise. STRICT is the same as in
17222 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17223 call argument list. We'll need to adjust the arguments to make them
17224 types. SUBR tells us if this is from a recursive call to
17225 type_unification_real, or for comparing two template argument
17229 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17230 tree packed_args
, unification_kind_t strict
,
17231 bool subr
, bool explain_p
)
17234 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17235 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17236 tree pack
, packs
= NULL_TREE
;
17237 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17239 packed_args
= expand_template_argument_pack (packed_args
);
17241 int len
= TREE_VEC_LENGTH (packed_args
);
17243 /* Determine the parameter packs we will be deducing from the
17244 pattern, and record their current deductions. */
17245 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17246 pack
; pack
= TREE_CHAIN (pack
))
17248 tree parm_pack
= TREE_VALUE (pack
);
17251 /* Determine the index and level of this parameter pack. */
17252 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17254 /* Keep track of the parameter packs and their corresponding
17256 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17257 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17260 /* Loop through all of the arguments that have not yet been
17261 unified and unify each with the pattern. */
17262 for (i
= start
; i
< len
; i
++)
17265 bool any_explicit
= false;
17266 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17268 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17269 or the element of its argument pack at the current index if
17270 this argument was explicitly specified. */
17271 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17275 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17278 if (TREE_VALUE (pack
)
17279 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17280 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17282 any_explicit
= true;
17283 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17285 TMPL_ARG (targs
, level
, idx
) = arg
;
17288 /* If we had explicit template arguments, substitute them into the
17289 pattern before deduction. */
17292 /* Some arguments might still be unspecified or dependent. */
17294 ++processing_template_decl
;
17295 dependent
= any_dependent_template_arguments_p (targs
);
17297 --processing_template_decl
;
17298 parm
= tsubst (pattern
, targs
,
17299 explain_p
? tf_warning_or_error
: tf_none
,
17302 --processing_template_decl
;
17303 if (parm
== error_mark_node
)
17309 /* Unify the pattern with the current argument. */
17310 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17311 LOOKUP_IMPLICIT
, explain_p
))
17314 /* For each parameter pack, collect the deduced value. */
17315 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17318 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17320 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17321 TMPL_ARG (targs
, level
, idx
);
17325 /* Verify that the results of unification with the parameter packs
17326 produce results consistent with what we've seen before, and make
17327 the deduced argument packs available. */
17328 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17330 tree old_pack
= TREE_VALUE (pack
);
17331 tree new_args
= TREE_TYPE (pack
);
17332 int i
, len
= TREE_VEC_LENGTH (new_args
);
17334 bool nondeduced_p
= false;
17336 /* By default keep the original deduced argument pack.
17337 If necessary, more specific code is going to update the
17338 resulting deduced argument later down in this function. */
17339 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17340 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17342 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17343 actually deduce anything. */
17344 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17345 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17346 nondeduced_p
= true;
17350 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17352 /* If we had fewer function args than explicit template args,
17353 just use the explicits. */
17354 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17355 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17356 if (len
< explicit_len
)
17357 new_args
= explicit_args
;
17363 /* Build the deduced *_ARGUMENT_PACK. */
17364 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17366 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17367 TREE_TYPE (result
) =
17368 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17369 TREE_CONSTANT (result
) = 1;
17372 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17374 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17376 /* Note the deduced argument packs for this parameter
17378 TMPL_ARG (targs
, level
, idx
) = result
;
17380 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17381 && (ARGUMENT_PACK_ARGS (old_pack
)
17382 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17384 /* We only had the explicitly-provided arguments before, but
17385 now we have a complete set of arguments. */
17386 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17388 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17389 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17390 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17394 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17395 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17397 if (!comp_template_args_with_info (old_args
, new_args
,
17398 &bad_old_arg
, &bad_new_arg
))
17399 /* Inconsistent unification of this parameter pack. */
17400 return unify_parameter_pack_inconsistent (explain_p
,
17406 return unify_success (explain_p
);
17409 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17410 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17411 parameters and return value are as for unify. */
17414 unify_array_domain (tree tparms
, tree targs
,
17415 tree parm_dom
, tree arg_dom
,
17423 /* Our representation of array types uses "N - 1" as the
17424 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17425 not an integer constant. We cannot unify arbitrarily
17426 complex expressions, so we eliminate the MINUS_EXPRs
17428 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17429 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17432 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17433 parm_max
= TREE_OPERAND (parm_max
, 0);
17435 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17436 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17439 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17440 trying to unify the type of a variable with the type
17441 of a template parameter. For example:
17443 template <unsigned int N>
17444 void f (char (&) [N]);
17451 Here, the type of the ARG will be "int [g(i)]", and
17452 may be a SAVE_EXPR, etc. */
17453 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17454 return unify_vla_arg (explain_p
, arg_dom
);
17455 arg_max
= TREE_OPERAND (arg_max
, 0);
17458 /* If only one of the bounds used a MINUS_EXPR, compensate
17459 by adding one to the other bound. */
17460 if (parm_cst
&& !arg_cst
)
17461 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17465 else if (arg_cst
&& !parm_cst
)
17466 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17471 return unify (tparms
, targs
, parm_max
, arg_max
,
17472 UNIFY_ALLOW_INTEGER
, explain_p
);
17475 /* Deduce the value of template parameters. TPARMS is the (innermost)
17476 set of template parameters to a template. TARGS is the bindings
17477 for those template parameters, as determined thus far; TARGS may
17478 include template arguments for outer levels of template parameters
17479 as well. PARM is a parameter to a template function, or a
17480 subcomponent of that parameter; ARG is the corresponding argument.
17481 This function attempts to match PARM with ARG in a manner
17482 consistent with the existing assignments in TARGS. If more values
17483 are deduced, then TARGS is updated.
17485 Returns 0 if the type deduction succeeds, 1 otherwise. The
17486 parameter STRICT is a bitwise or of the following flags:
17489 Require an exact match between PARM and ARG.
17490 UNIFY_ALLOW_MORE_CV_QUAL:
17491 Allow the deduced ARG to be more cv-qualified (by qualification
17492 conversion) than ARG.
17493 UNIFY_ALLOW_LESS_CV_QUAL:
17494 Allow the deduced ARG to be less cv-qualified than ARG.
17495 UNIFY_ALLOW_DERIVED:
17496 Allow the deduced ARG to be a template base class of ARG,
17497 or a pointer to a template base class of the type pointed to by
17499 UNIFY_ALLOW_INTEGER:
17500 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17501 case for more information.
17502 UNIFY_ALLOW_OUTER_LEVEL:
17503 This is the outermost level of a deduction. Used to determine validity
17504 of qualification conversions. A valid qualification conversion must
17505 have const qualified pointers leading up to the inner type which
17506 requires additional CV quals, except at the outer level, where const
17507 is not required [conv.qual]. It would be normal to set this flag in
17508 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17509 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17510 This is the outermost level of a deduction, and PARM can be more CV
17511 qualified at this point.
17512 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17513 This is the outermost level of a deduction, and PARM can be less CV
17514 qualified at this point. */
17517 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17523 int strict_in
= strict
;
17525 /* I don't think this will do the right thing with respect to types.
17526 But the only case I've seen it in so far has been array bounds, where
17527 signedness is the only information lost, and I think that will be
17529 while (TREE_CODE (parm
) == NOP_EXPR
)
17530 parm
= TREE_OPERAND (parm
, 0);
17532 if (arg
== error_mark_node
)
17533 return unify_invalid (explain_p
);
17534 if (arg
== unknown_type_node
17535 || arg
== init_list_type_node
)
17536 /* We can't deduce anything from this, but we might get all the
17537 template args from other function args. */
17538 return unify_success (explain_p
);
17540 /* If PARM uses template parameters, then we can't bail out here,
17541 even if ARG == PARM, since we won't record unifications for the
17542 template parameters. We might need them if we're trying to
17543 figure out which of two things is more specialized. */
17544 if (arg
== parm
&& !uses_template_parms (parm
))
17545 return unify_success (explain_p
);
17547 /* Handle init lists early, so the rest of the function can assume
17548 we're dealing with a type. */
17549 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17553 tree orig_parm
= parm
;
17555 /* Replace T with std::initializer_list<T> for deduction. */
17556 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17557 && flag_deduce_init_list
)
17558 parm
= listify (parm
);
17560 if (!is_std_init_list (parm
)
17561 && TREE_CODE (parm
) != ARRAY_TYPE
)
17562 /* We can only deduce from an initializer list argument if the
17563 parameter is std::initializer_list or an array; otherwise this
17564 is a non-deduced context. */
17565 return unify_success (explain_p
);
17567 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17568 elttype
= TREE_TYPE (parm
);
17570 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17572 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
17574 int elt_strict
= strict
;
17576 if (elt
== error_mark_node
)
17577 return unify_invalid (explain_p
);
17579 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
17581 tree type
= TREE_TYPE (elt
);
17582 /* It should only be possible to get here for a call. */
17583 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
17584 elt_strict
|= maybe_adjust_types_for_deduction
17585 (DEDUCE_CALL
, &elttype
, &type
, elt
);
17589 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
17593 if (TREE_CODE (parm
) == ARRAY_TYPE
17594 && deducible_array_bound (TYPE_DOMAIN (parm
)))
17596 /* Also deduce from the length of the initializer list. */
17597 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
17598 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
17599 if (idx
== error_mark_node
)
17600 return unify_invalid (explain_p
);
17601 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17605 /* If the std::initializer_list<T> deduction worked, replace the
17606 deduced A with std::initializer_list<A>. */
17607 if (orig_parm
!= parm
)
17609 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
17610 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17611 targ
= listify (targ
);
17612 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
17614 return unify_success (explain_p
);
17617 /* Immediately reject some pairs that won't unify because of
17618 cv-qualification mismatches. */
17619 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17621 /* It is the elements of the array which hold the cv quals of an array
17622 type, and the elements might be template type parms. We'll check
17623 when we recurse. */
17624 && TREE_CODE (arg
) != ARRAY_TYPE
17625 /* We check the cv-qualifiers when unifying with template type
17626 parameters below. We want to allow ARG `const T' to unify with
17627 PARM `T' for example, when computing which of two templates
17628 is more specialized, for example. */
17629 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
17630 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
17631 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17633 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
17634 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
17635 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
17636 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
17637 strict
&= ~UNIFY_ALLOW_DERIVED
;
17638 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17639 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
17641 switch (TREE_CODE (parm
))
17643 case TYPENAME_TYPE
:
17645 case UNBOUND_CLASS_TEMPLATE
:
17646 /* In a type which contains a nested-name-specifier, template
17647 argument values cannot be deduced for template parameters used
17648 within the nested-name-specifier. */
17649 return unify_success (explain_p
);
17651 case TEMPLATE_TYPE_PARM
:
17652 case TEMPLATE_TEMPLATE_PARM
:
17653 case BOUND_TEMPLATE_TEMPLATE_PARM
:
17654 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17655 if (error_operand_p (tparm
))
17656 return unify_invalid (explain_p
);
17658 if (TEMPLATE_TYPE_LEVEL (parm
)
17659 != template_decl_level (tparm
))
17660 /* The PARM is not one we're trying to unify. Just check
17661 to see if it matches ARG. */
17663 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17664 && (is_auto (parm
) ? is_auto (arg
)
17665 : same_type_p (parm
, arg
)))
17666 return unify_success (explain_p
);
17668 return unify_type_mismatch (explain_p
, parm
, arg
);
17670 idx
= TEMPLATE_TYPE_IDX (parm
);
17671 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17672 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
17673 if (error_operand_p (tparm
))
17674 return unify_invalid (explain_p
);
17676 /* Check for mixed types and values. */
17677 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17678 && TREE_CODE (tparm
) != TYPE_DECL
)
17679 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17680 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
17681 gcc_unreachable ();
17683 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17685 /* ARG must be constructed from a template class or a template
17686 template parameter. */
17687 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
17688 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
17689 return unify_template_deduction_failure (explain_p
, parm
, arg
);
17691 tree parmvec
= TYPE_TI_ARGS (parm
);
17692 /* An alias template name is never deduced. */
17693 if (TYPE_ALIAS_P (arg
))
17694 arg
= strip_typedefs (arg
);
17695 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
17696 tree full_argvec
= add_to_template_args (targs
, argvec
);
17698 = DECL_INNERMOST_TEMPLATE_PARMS
17699 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
17701 int parm_variadic_p
= 0;
17703 /* The resolution to DR150 makes clear that default
17704 arguments for an N-argument may not be used to bind T
17705 to a template template parameter with fewer than N
17706 parameters. It is not safe to permit the binding of
17707 default arguments as an extension, as that may change
17708 the meaning of a conforming program. Consider:
17710 struct Dense { static const unsigned int dim = 1; };
17712 template <template <typename> class View,
17714 void operator+(float, View<Block> const&);
17716 template <typename Block,
17717 unsigned int Dim = Block::dim>
17718 struct Lvalue_proxy { operator float() const; };
17722 Lvalue_proxy<Dense> p;
17727 Here, if Lvalue_proxy is permitted to bind to View, then
17728 the global operator+ will be used; if they are not, the
17729 Lvalue_proxy will be converted to float. */
17730 if (coerce_template_parms (parm_parms
,
17732 TYPE_TI_TEMPLATE (parm
),
17734 ? tf_warning_or_error
17736 /*require_all_args=*/true,
17737 /*use_default_args=*/false)
17738 == error_mark_node
)
17741 /* Deduce arguments T, i from TT<T> or TT<i>.
17742 We check each element of PARMVEC and ARGVEC individually
17743 rather than the whole TREE_VEC since they can have
17744 different number of elements. */
17746 parmvec
= expand_template_argument_pack (parmvec
);
17747 argvec
= expand_template_argument_pack (argvec
);
17749 len
= TREE_VEC_LENGTH (parmvec
);
17751 /* Check if the parameters end in a pack, making them
17754 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
17755 parm_variadic_p
= 1;
17757 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17758 /* If the template argument list of P contains a pack
17759 expansion that is not the last template argument, the
17760 entire template argument list is a non-deduced
17762 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
17763 return unify_success (explain_p
);
17765 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
17766 return unify_too_few_arguments (explain_p
,
17767 TREE_VEC_LENGTH (argvec
), len
);
17769 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17771 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17772 TREE_VEC_ELT (parmvec
, i
),
17773 TREE_VEC_ELT (argvec
, i
),
17774 UNIFY_ALLOW_NONE
, explain_p
);
17777 if (parm_variadic_p
17778 && unify_pack_expansion (tparms
, targs
,
17781 /*subr=*/true, explain_p
))
17784 arg
= TYPE_TI_TEMPLATE (arg
);
17786 /* Fall through to deduce template name. */
17789 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17790 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17792 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
17794 /* Simple cases: Value already set, does match or doesn't. */
17795 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
17796 return unify_success (explain_p
);
17798 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17802 /* If PARM is `const T' and ARG is only `int', we don't have
17803 a match unless we are allowing additional qualification.
17804 If ARG is `const int' and PARM is just `T' that's OK;
17805 that binds `const int' to `T'. */
17806 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
17808 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17810 /* Consider the case where ARG is `const volatile int' and
17811 PARM is `const T'. Then, T should be `volatile int'. */
17812 arg
= cp_build_qualified_type_real
17813 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
17814 if (arg
== error_mark_node
)
17815 return unify_invalid (explain_p
);
17817 /* Simple cases: Value already set, does match or doesn't. */
17818 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
17819 return unify_success (explain_p
);
17821 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17823 /* Make sure that ARG is not a variable-sized array. (Note
17824 that were talking about variable-sized arrays (like
17825 `int[n]'), rather than arrays of unknown size (like
17826 `int[]').) We'll get very confused by such a type since
17827 the bound of the array is not constant, and therefore
17828 not mangleable. Besides, such types are not allowed in
17829 ISO C++, so we can do as we please here. We do allow
17830 them for 'auto' deduction, since that isn't ABI-exposed. */
17831 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
17832 return unify_vla_arg (explain_p
, arg
);
17834 /* Strip typedefs as in convert_template_argument. */
17835 arg
= canonicalize_type_argument (arg
, tf_none
);
17838 /* If ARG is a parameter pack or an expansion, we cannot unify
17839 against it unless PARM is also a parameter pack. */
17840 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17841 && !template_parameter_pack_p (parm
))
17842 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17844 /* If the argument deduction results is a METHOD_TYPE,
17845 then there is a problem.
17846 METHOD_TYPE doesn't map to any real C++ type the result of
17847 the deduction can not be of that type. */
17848 if (TREE_CODE (arg
) == METHOD_TYPE
)
17849 return unify_method_type_error (explain_p
, arg
);
17851 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17852 return unify_success (explain_p
);
17854 case TEMPLATE_PARM_INDEX
:
17855 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17856 if (error_operand_p (tparm
))
17857 return unify_invalid (explain_p
);
17859 if (TEMPLATE_PARM_LEVEL (parm
)
17860 != template_decl_level (tparm
))
17862 /* The PARM is not one we're trying to unify. Just check
17863 to see if it matches ARG. */
17864 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
17865 && cp_tree_equal (parm
, arg
));
17867 unify_expression_unequal (explain_p
, parm
, arg
);
17871 idx
= TEMPLATE_PARM_IDX (parm
);
17872 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17876 int x
= !cp_tree_equal (targ
, arg
);
17878 unify_inconsistency (explain_p
, parm
, targ
, arg
);
17882 /* [temp.deduct.type] If, in the declaration of a function template
17883 with a non-type template-parameter, the non-type
17884 template-parameter is used in an expression in the function
17885 parameter-list and, if the corresponding template-argument is
17886 deduced, the template-argument type shall match the type of the
17887 template-parameter exactly, except that a template-argument
17888 deduced from an array bound may be of any integral type.
17889 The non-type parameter might use already deduced type parameters. */
17890 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
17891 if (!TREE_TYPE (arg
))
17892 /* Template-parameter dependent expression. Just accept it for now.
17893 It will later be processed in convert_template_argument. */
17895 else if (same_type_p (TREE_TYPE (arg
), tparm
))
17897 else if ((strict
& UNIFY_ALLOW_INTEGER
)
17898 && CP_INTEGRAL_TYPE_P (tparm
))
17899 /* Convert the ARG to the type of PARM; the deduced non-type
17900 template argument must exactly match the types of the
17901 corresponding parameter. */
17902 arg
= fold (build_nop (tparm
, arg
));
17903 else if (uses_template_parms (tparm
))
17904 /* We haven't deduced the type of this parameter yet. Try again
17906 return unify_success (explain_p
);
17908 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
17910 /* If ARG is a parameter pack or an expansion, we cannot unify
17911 against it unless PARM is also a parameter pack. */
17912 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17913 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
17914 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17916 arg
= strip_typedefs_expr (arg
);
17917 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17918 return unify_success (explain_p
);
17922 /* A pointer-to-member constant can be unified only with
17923 another constant. */
17924 if (TREE_CODE (arg
) != PTRMEM_CST
)
17925 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
17927 /* Just unify the class member. It would be useless (and possibly
17928 wrong, depending on the strict flags) to unify also
17929 PTRMEM_CST_CLASS, because we want to be sure that both parm and
17930 arg refer to the same variable, even if through different
17931 classes. For instance:
17933 struct A { int x; };
17936 Unification of &A::x and &B::x must succeed. */
17937 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
17938 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
17943 if (!TYPE_PTR_P (arg
))
17944 return unify_type_mismatch (explain_p
, parm
, arg
);
17946 /* [temp.deduct.call]
17948 A can be another pointer or pointer to member type that can
17949 be converted to the deduced A via a qualification
17950 conversion (_conv.qual_).
17952 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
17953 This will allow for additional cv-qualification of the
17954 pointed-to types if appropriate. */
17956 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
17957 /* The derived-to-base conversion only persists through one
17958 level of pointers. */
17959 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
17961 return unify (tparms
, targs
, TREE_TYPE (parm
),
17962 TREE_TYPE (arg
), strict
, explain_p
);
17965 case REFERENCE_TYPE
:
17966 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
17967 return unify_type_mismatch (explain_p
, parm
, arg
);
17968 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
17969 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
17972 if (TREE_CODE (arg
) != ARRAY_TYPE
)
17973 return unify_type_mismatch (explain_p
, parm
, arg
);
17974 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
17975 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
17976 return unify_type_mismatch (explain_p
, parm
, arg
);
17977 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
17978 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
17979 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
17980 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17981 TYPE_DOMAIN (arg
), explain_p
);
17982 return unify_success (explain_p
);
17989 case ENUMERAL_TYPE
:
17992 if (TREE_CODE (arg
) != TREE_CODE (parm
))
17993 return unify_type_mismatch (explain_p
, parm
, arg
);
17995 /* We have already checked cv-qualification at the top of the
17997 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
17998 return unify_type_mismatch (explain_p
, parm
, arg
);
18000 /* As far as unification is concerned, this wins. Later checks
18001 will invalidate it if necessary. */
18002 return unify_success (explain_p
);
18004 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18005 /* Type INTEGER_CST can come from ordinary constant template args. */
18007 while (TREE_CODE (arg
) == NOP_EXPR
)
18008 arg
= TREE_OPERAND (arg
, 0);
18010 if (TREE_CODE (arg
) != INTEGER_CST
)
18011 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18012 return (tree_int_cst_equal (parm
, arg
)
18013 ? unify_success (explain_p
)
18014 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18018 int i
, len
, argslen
;
18019 int parm_variadic_p
= 0;
18021 if (TREE_CODE (arg
) != TREE_VEC
)
18022 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18024 len
= TREE_VEC_LENGTH (parm
);
18025 argslen
= TREE_VEC_LENGTH (arg
);
18027 /* Check for pack expansions in the parameters. */
18028 for (i
= 0; i
< len
; ++i
)
18030 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18033 /* We can unify against something with a trailing
18035 parm_variadic_p
= 1;
18037 /* [temp.deduct.type]/9: If the template argument list of
18038 P contains a pack expansion that is not the last
18039 template argument, the entire template argument list
18040 is a non-deduced context. */
18041 return unify_success (explain_p
);
18045 /* If we don't have enough arguments to satisfy the parameters
18046 (not counting the pack expression at the end), or we have
18047 too many arguments for a parameter list that doesn't end in
18048 a pack expression, we can't unify. */
18049 if (parm_variadic_p
18050 ? argslen
< len
- parm_variadic_p
18052 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18054 /* Unify all of the parameters that precede the (optional)
18055 pack expression. */
18056 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18058 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18059 TREE_VEC_ELT (parm
, i
),
18060 TREE_VEC_ELT (arg
, i
),
18061 UNIFY_ALLOW_NONE
, explain_p
);
18063 if (parm_variadic_p
)
18064 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18066 /*subr=*/true, explain_p
);
18067 return unify_success (explain_p
);
18072 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18073 return unify_type_mismatch (explain_p
, parm
, arg
);
18075 if (TYPE_PTRMEMFUNC_P (parm
))
18077 if (!TYPE_PTRMEMFUNC_P (arg
))
18078 return unify_type_mismatch (explain_p
, parm
, arg
);
18080 return unify (tparms
, targs
,
18081 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18082 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18083 strict
, explain_p
);
18086 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18088 tree t
= NULL_TREE
;
18090 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18092 /* First, we try to unify the PARM and ARG directly. */
18093 t
= try_class_unification (tparms
, targs
,
18094 parm
, arg
, explain_p
);
18098 /* Fallback to the special case allowed in
18099 [temp.deduct.call]:
18101 If P is a class, and P has the form
18102 template-id, then A can be a derived class of
18103 the deduced A. Likewise, if P is a pointer to
18104 a class of the form template-id, A can be a
18105 pointer to a derived class pointed to by the
18107 enum template_base_result r
;
18108 r
= get_template_base (tparms
, targs
, parm
, arg
,
18112 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18115 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18116 && (CLASSTYPE_TI_TEMPLATE (parm
)
18117 == CLASSTYPE_TI_TEMPLATE (arg
)))
18118 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18119 Then, we should unify `int' and `U'. */
18122 /* There's no chance of unification succeeding. */
18123 return unify_type_mismatch (explain_p
, parm
, arg
);
18125 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18126 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18128 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18129 return unify_type_mismatch (explain_p
, parm
, arg
);
18130 return unify_success (explain_p
);
18133 case FUNCTION_TYPE
:
18135 unsigned int nargs
;
18140 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18141 return unify_type_mismatch (explain_p
, parm
, arg
);
18143 /* CV qualifications for methods can never be deduced, they must
18144 match exactly. We need to check them explicitly here,
18145 because type_unification_real treats them as any other
18146 cv-qualified parameter. */
18147 if (TREE_CODE (parm
) == METHOD_TYPE
18148 && (!check_cv_quals_for_unify
18150 class_of_this_parm (arg
),
18151 class_of_this_parm (parm
))))
18152 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18154 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18155 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18157 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18158 args
= XALLOCAVEC (tree
, nargs
);
18159 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18160 a
!= NULL_TREE
&& a
!= void_list_node
;
18161 a
= TREE_CHAIN (a
), ++i
)
18162 args
[i
] = TREE_VALUE (a
);
18165 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18166 args
, nargs
, 1, DEDUCE_EXACT
,
18167 LOOKUP_NORMAL
, NULL
, explain_p
);
18171 /* Unify a pointer to member with a pointer to member function, which
18172 deduces the type of the member as a function type. */
18173 if (TYPE_PTRMEMFUNC_P (arg
))
18175 /* Check top-level cv qualifiers */
18176 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18177 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18179 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18180 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18181 UNIFY_ALLOW_NONE
, explain_p
);
18183 /* Determine the type of the function we are unifying against. */
18184 tree fntype
= static_fn_type (arg
);
18186 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18189 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18190 return unify_type_mismatch (explain_p
, parm
, arg
);
18191 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18192 TYPE_OFFSET_BASETYPE (arg
),
18193 UNIFY_ALLOW_NONE
, explain_p
);
18194 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18195 strict
, explain_p
);
18198 if (DECL_TEMPLATE_PARM_P (parm
))
18199 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18200 if (arg
!= integral_constant_value (parm
))
18201 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18202 return unify_success (explain_p
);
18205 case TEMPLATE_DECL
:
18206 /* Matched cases are handled by the ARG == PARM test above. */
18207 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18210 /* A non-type template parameter that is a variable should be a
18211 an integral constant, in which case, it whould have been
18212 folded into its (constant) value. So we should not be getting
18213 a variable here. */
18214 gcc_unreachable ();
18216 case TYPE_ARGUMENT_PACK
:
18217 case NONTYPE_ARGUMENT_PACK
:
18218 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18219 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18222 case DECLTYPE_TYPE
:
18223 case UNDERLYING_TYPE
:
18224 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18225 or UNDERLYING_TYPE nodes. */
18226 return unify_success (explain_p
);
18229 /* Unification fails if we hit an error node. */
18230 return unify_invalid (explain_p
);
18233 if (REFERENCE_REF_P (parm
))
18234 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18235 strict
, explain_p
);
18239 /* An unresolved overload is a nondeduced context. */
18240 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18241 return unify_success (explain_p
);
18242 gcc_assert (EXPR_P (parm
));
18244 /* We must be looking at an expression. This can happen with
18248 void foo(S<I>, S<I + 2>);
18250 This is a "nondeduced context":
18254 The nondeduced contexts are:
18256 --A type that is a template-id in which one or more of
18257 the template-arguments is an expression that references
18258 a template-parameter.
18260 In these cases, we assume deduction succeeded, but don't
18261 actually infer any unifications. */
18263 if (!uses_template_parms (parm
)
18264 && !template_args_equal (parm
, arg
))
18265 return unify_expression_unequal (explain_p
, parm
, arg
);
18267 return unify_success (explain_p
);
18270 #undef RECUR_AND_CHECK_FAILURE
18272 /* Note that DECL can be defined in this translation unit, if
18276 mark_definable (tree decl
)
18279 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18280 FOR_EACH_CLONE (clone
, decl
)
18281 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18284 /* Called if RESULT is explicitly instantiated, or is a member of an
18285 explicitly instantiated class. */
18288 mark_decl_instantiated (tree result
, int extern_p
)
18290 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18292 /* If this entity has already been written out, it's too late to
18293 make any modifications. */
18294 if (TREE_ASM_WRITTEN (result
))
18297 /* For anonymous namespace we don't need to do anything. */
18298 if (decl_anon_ns_mem_p (result
))
18300 gcc_assert (!TREE_PUBLIC (result
));
18304 if (TREE_CODE (result
) != FUNCTION_DECL
)
18305 /* The TREE_PUBLIC flag for function declarations will have been
18306 set correctly by tsubst. */
18307 TREE_PUBLIC (result
) = 1;
18309 /* This might have been set by an earlier implicit instantiation. */
18310 DECL_COMDAT (result
) = 0;
18313 DECL_NOT_REALLY_EXTERN (result
) = 0;
18316 mark_definable (result
);
18317 mark_needed (result
);
18318 /* Always make artificials weak. */
18319 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18320 comdat_linkage (result
);
18321 /* For WIN32 we also want to put explicit instantiations in
18322 linkonce sections. */
18323 else if (TREE_PUBLIC (result
))
18324 maybe_make_one_only (result
);
18327 /* If EXTERN_P, then this function will not be emitted -- unless
18328 followed by an explicit instantiation, at which point its linkage
18329 will be adjusted. If !EXTERN_P, then this function will be
18330 emitted here. In neither circumstance do we want
18331 import_export_decl to adjust the linkage. */
18332 DECL_INTERFACE_KNOWN (result
) = 1;
18335 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18336 important template arguments. If any are missing, we check whether
18337 they're important by using error_mark_node for substituting into any
18338 args that were used for partial ordering (the ones between ARGS and END)
18339 and seeing if it bubbles up. */
18342 check_undeduced_parms (tree targs
, tree args
, tree end
)
18344 bool found
= false;
18346 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18347 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18350 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18354 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18355 if (substed
== error_mark_node
)
18361 /* Given two function templates PAT1 and PAT2, return:
18363 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18364 -1 if PAT2 is more specialized than PAT1.
18365 0 if neither is more specialized.
18367 LEN indicates the number of parameters we should consider
18368 (defaulted parameters should not be considered).
18370 The 1998 std underspecified function template partial ordering, and
18371 DR214 addresses the issue. We take pairs of arguments, one from
18372 each of the templates, and deduce them against each other. One of
18373 the templates will be more specialized if all the *other*
18374 template's arguments deduce against its arguments and at least one
18375 of its arguments *does* *not* deduce against the other template's
18376 corresponding argument. Deduction is done as for class templates.
18377 The arguments used in deduction have reference and top level cv
18378 qualifiers removed. Iff both arguments were originally reference
18379 types *and* deduction succeeds in both directions, an lvalue reference
18380 wins against an rvalue reference and otherwise the template
18381 with the more cv-qualified argument wins for that pairing (if
18382 neither is more cv-qualified, they both are equal). Unlike regular
18383 deduction, after all the arguments have been deduced in this way,
18384 we do *not* verify the deduced template argument values can be
18385 substituted into non-deduced contexts.
18387 The logic can be a bit confusing here, because we look at deduce1 and
18388 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18389 can find template arguments for pat1 to make arg1 look like arg2, that
18390 means that arg2 is at least as specialized as arg1. */
18393 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18395 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18396 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18397 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18398 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18399 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18400 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18401 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18402 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18403 tree origs1
, origs2
;
18404 bool lose1
= false;
18405 bool lose2
= false;
18407 /* Remove the this parameter from non-static member functions. If
18408 one is a non-static member function and the other is not a static
18409 member function, remove the first parameter from that function
18410 also. This situation occurs for operator functions where we
18411 locate both a member function (with this pointer) and non-member
18412 operator (with explicit first operand). */
18413 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18415 len
--; /* LEN is the number of significant arguments for DECL1 */
18416 args1
= TREE_CHAIN (args1
);
18417 if (!DECL_STATIC_FUNCTION_P (decl2
))
18418 args2
= TREE_CHAIN (args2
);
18420 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18422 args2
= TREE_CHAIN (args2
);
18423 if (!DECL_STATIC_FUNCTION_P (decl1
))
18426 args1
= TREE_CHAIN (args1
);
18430 /* If only one is a conversion operator, they are unordered. */
18431 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18434 /* Consider the return type for a conversion function */
18435 if (DECL_CONV_FN_P (decl1
))
18437 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18438 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18442 processing_template_decl
++;
18448 /* Stop when an ellipsis is seen. */
18449 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18451 tree arg1
= TREE_VALUE (args1
);
18452 tree arg2
= TREE_VALUE (args2
);
18453 int deduce1
, deduce2
;
18459 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18460 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18462 /* When both arguments are pack expansions, we need only
18463 unify the patterns themselves. */
18464 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18465 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18467 /* This is the last comparison we need to do. */
18471 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18473 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18474 arg1
= TREE_TYPE (arg1
);
18475 quals1
= cp_type_quals (arg1
);
18478 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18480 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18481 arg2
= TREE_TYPE (arg2
);
18482 quals2
= cp_type_quals (arg2
);
18485 arg1
= TYPE_MAIN_VARIANT (arg1
);
18486 arg2
= TYPE_MAIN_VARIANT (arg2
);
18488 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18490 int i
, len2
= list_length (args2
);
18491 tree parmvec
= make_tree_vec (1);
18492 tree argvec
= make_tree_vec (len2
);
18495 /* Setup the parameter vector, which contains only ARG1. */
18496 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18498 /* Setup the argument vector, which contains the remaining
18500 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18501 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18503 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18504 argvec
, DEDUCE_EXACT
,
18505 /*subr=*/true, /*explain_p=*/false)
18508 /* We cannot deduce in the other direction, because ARG1 is
18509 a pack expansion but ARG2 is not. */
18512 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18514 int i
, len1
= list_length (args1
);
18515 tree parmvec
= make_tree_vec (1);
18516 tree argvec
= make_tree_vec (len1
);
18519 /* Setup the parameter vector, which contains only ARG1. */
18520 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18522 /* Setup the argument vector, which contains the remaining
18524 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18525 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18527 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18528 argvec
, DEDUCE_EXACT
,
18529 /*subr=*/true, /*explain_p=*/false)
18532 /* We cannot deduce in the other direction, because ARG2 is
18533 a pack expansion but ARG1 is not.*/
18539 /* The normal case, where neither argument is a pack
18541 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18542 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18544 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18545 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18549 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18550 arg2, then arg2 is not as specialized as arg1. */
18556 /* "If, for a given type, deduction succeeds in both directions
18557 (i.e., the types are identical after the transformations above)
18558 and both P and A were reference types (before being replaced with
18559 the type referred to above):
18560 - if the type from the argument template was an lvalue reference and
18561 the type from the parameter template was not, the argument type is
18562 considered to be more specialized than the other; otherwise,
18563 - if the type from the argument template is more cv-qualified
18564 than the type from the parameter template (as described above),
18565 the argument type is considered to be more specialized than the other;
18567 - neither type is more specialized than the other." */
18569 if (deduce1
&& deduce2
)
18571 if (ref1
&& ref2
&& ref1
!= ref2
)
18578 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
18580 if ((quals1
& quals2
) == quals2
)
18582 if ((quals1
& quals2
) == quals1
)
18587 if (lose1
&& lose2
)
18588 /* We've failed to deduce something in either direction.
18589 These must be unordered. */
18592 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18593 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18594 /* We have already processed all of the arguments in our
18595 handing of the pack expansion type. */
18598 args1
= TREE_CHAIN (args1
);
18599 args2
= TREE_CHAIN (args2
);
18602 /* "In most cases, all template parameters must have values in order for
18603 deduction to succeed, but for partial ordering purposes a template
18604 parameter may remain without a value provided it is not used in the
18605 types being used for partial ordering."
18607 Thus, if we are missing any of the targs1 we need to substitute into
18608 origs1, then pat2 is not as specialized as pat1. This can happen when
18609 there is a nondeduced context. */
18610 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
18612 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
18615 processing_template_decl
--;
18617 /* All things being equal, if the next argument is a pack expansion
18618 for one function but not for the other, prefer the
18619 non-variadic function. FIXME this is bogus; see c++/41958. */
18621 && args1
&& TREE_VALUE (args1
)
18622 && args2
&& TREE_VALUE (args2
))
18624 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
18625 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
18628 if (lose1
== lose2
)
18636 /* Determine which of two partial specializations of TMPL is more
18639 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18640 to the first partial specialization. The TREE_VALUE is the
18641 innermost set of template parameters for the partial
18642 specialization. PAT2 is similar, but for the second template.
18644 Return 1 if the first partial specialization is more specialized;
18645 -1 if the second is more specialized; 0 if neither is more
18648 See [temp.class.order] for information about determining which of
18649 two templates is more specialized. */
18652 more_specialized_class (tree tmpl
, tree pat1
, tree pat2
)
18657 bool any_deductions
= false;
18659 tmpl1
= TREE_TYPE (pat1
);
18660 tmpl2
= TREE_TYPE (pat2
);
18662 /* Just like what happens for functions, if we are ordering between
18663 different class template specializations, we may encounter dependent
18664 types in the arguments, and we need our dependency check functions
18665 to behave correctly. */
18666 ++processing_template_decl
;
18667 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat1
),
18668 CLASSTYPE_TI_ARGS (tmpl1
),
18669 CLASSTYPE_TI_ARGS (tmpl2
));
18673 any_deductions
= true;
18676 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat2
),
18677 CLASSTYPE_TI_ARGS (tmpl2
),
18678 CLASSTYPE_TI_ARGS (tmpl1
));
18682 any_deductions
= true;
18684 --processing_template_decl
;
18686 /* In the case of a tie where at least one of the class templates
18687 has a parameter pack at the end, the template with the most
18688 non-packed parameters wins. */
18691 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
18692 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
18694 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
18695 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
18696 int len1
= TREE_VEC_LENGTH (args1
);
18697 int len2
= TREE_VEC_LENGTH (args2
);
18699 /* We don't count the pack expansion at the end. */
18700 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
18702 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
18707 else if (len1
< len2
)
18714 /* Return the template arguments that will produce the function signature
18715 DECL from the function template FN, with the explicit template
18716 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18717 also match. Return NULL_TREE if no satisfactory arguments could be
18721 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
18723 int ntparms
= DECL_NTPARMS (fn
);
18724 tree targs
= make_tree_vec (ntparms
);
18725 tree decl_type
= TREE_TYPE (decl
);
18726 tree decl_arg_types
;
18728 unsigned int nargs
, ix
;
18731 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
18733 /* Never do unification on the 'this' parameter. */
18734 decl_arg_types
= skip_artificial_parms_for (decl
,
18735 TYPE_ARG_TYPES (decl_type
));
18737 nargs
= list_length (decl_arg_types
);
18738 args
= XALLOCAVEC (tree
, nargs
);
18739 for (arg
= decl_arg_types
, ix
= 0;
18740 arg
!= NULL_TREE
&& arg
!= void_list_node
;
18741 arg
= TREE_CHAIN (arg
), ++ix
)
18742 args
[ix
] = TREE_VALUE (arg
);
18744 if (fn_type_unification (fn
, explicit_args
, targs
,
18746 (check_rettype
|| DECL_CONV_FN_P (fn
)
18747 ? TREE_TYPE (decl_type
) : NULL_TREE
),
18748 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
18750 == error_mark_node
)
18756 /* Return the innermost template arguments that, when applied to a partial
18757 specialization of TMPL whose innermost template parameters are
18758 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
18761 For example, suppose we have:
18763 template <class T, class U> struct S {};
18764 template <class T> struct S<T*, int> {};
18766 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
18767 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
18768 int}. The resulting vector will be {double}, indicating that `T'
18769 is bound to `double'. */
18772 get_class_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
18774 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
18776 tree innermost_deduced_args
;
18778 innermost_deduced_args
= make_tree_vec (ntparms
);
18779 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18781 deduced_args
= copy_node (args
);
18782 SET_TMPL_ARGS_LEVEL (deduced_args
,
18783 TMPL_ARGS_DEPTH (deduced_args
),
18784 innermost_deduced_args
);
18787 deduced_args
= innermost_deduced_args
;
18789 if (unify (tparms
, deduced_args
,
18790 INNERMOST_TEMPLATE_ARGS (spec_args
),
18791 INNERMOST_TEMPLATE_ARGS (args
),
18792 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
18795 for (i
= 0; i
< ntparms
; ++i
)
18796 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
18799 /* Verify that nondeduced template arguments agree with the type
18800 obtained from argument deduction.
18804 struct A { typedef int X; };
18805 template <class T, class U> struct C {};
18806 template <class T> struct C<T, typename T::X> {};
18808 Then with the instantiation `C<A, int>', we can deduce that
18809 `T' is `A' but unify () does not check whether `typename T::X'
18811 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
18812 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
18814 tf_none
, false, false);
18815 if (spec_args
== error_mark_node
18816 /* We only need to check the innermost arguments; the other
18817 arguments will always agree. */
18818 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
18819 INNERMOST_TEMPLATE_ARGS (args
)))
18822 /* Now that we have bindings for all of the template arguments,
18823 ensure that the arguments deduced for the template template
18824 parameters have compatible template parameter lists. See the use
18825 of template_template_parm_bindings_ok_p in fn_type_unification
18826 for more information. */
18827 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
18830 return deduced_args
;
18833 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
18834 Return the TREE_LIST node with the most specialized template, if
18835 any. If there is no most specialized template, the error_mark_node
18838 Note that this function does not look at, or modify, the
18839 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
18840 returned is one of the elements of INSTANTIATIONS, callers may
18841 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
18842 and retrieve it from the value returned. */
18845 most_specialized_instantiation (tree templates
)
18849 ++processing_template_decl
;
18852 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
18856 if (get_bindings (TREE_VALUE (champ
),
18857 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18858 NULL_TREE
, /*check_ret=*/true))
18861 if (get_bindings (TREE_VALUE (fn
),
18862 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18863 NULL_TREE
, /*check_ret=*/true))
18870 /* Equally specialized, move to next function. If there
18871 is no next function, nothing's most specialized. */
18872 fn
= TREE_CHAIN (fn
);
18880 /* Now verify that champ is better than everything earlier in the
18881 instantiation list. */
18882 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
18883 if (get_bindings (TREE_VALUE (champ
),
18884 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18885 NULL_TREE
, /*check_ret=*/true)
18886 || !get_bindings (TREE_VALUE (fn
),
18887 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18888 NULL_TREE
, /*check_ret=*/true))
18894 processing_template_decl
--;
18897 return error_mark_node
;
18902 /* If DECL is a specialization of some template, return the most
18903 general such template. Otherwise, returns NULL_TREE.
18905 For example, given:
18907 template <class T> struct S { template <class U> void f(U); };
18909 if TMPL is `template <class U> void S<int>::f(U)' this will return
18910 the full template. This function will not trace past partial
18911 specializations, however. For example, given in addition:
18913 template <class T> struct S<T*> { template <class U> void f(U); };
18915 if TMPL is `template <class U> void S<int*>::f(U)' this will return
18916 `template <class T> template <class U> S<T*>::f(U)'. */
18919 most_general_template (tree decl
)
18921 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18923 if (tree tinfo
= get_template_info (decl
))
18924 decl
= TI_TEMPLATE (tinfo
);
18925 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
18926 template friend, or a FIELD_DECL for a capture pack. */
18927 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18931 /* Look for more and more general templates. */
18932 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
18934 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
18935 (See cp-tree.h for details.) */
18936 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
18939 if (CLASS_TYPE_P (TREE_TYPE (decl
))
18940 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
18943 /* Stop if we run into an explicitly specialized class template. */
18944 if (!DECL_NAMESPACE_SCOPE_P (decl
)
18945 && DECL_CONTEXT (decl
)
18946 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
18949 decl
= DECL_TI_TEMPLATE (decl
);
18955 /* Return the most specialized of the class template partial
18956 specializations which can produce TYPE, a specialization of some class
18957 template. The value returned is actually a TREE_LIST; the TREE_TYPE is
18958 a _TYPE node corresponding to the partial specialization, while the
18959 TREE_PURPOSE is the set of template arguments that must be
18960 substituted into the TREE_TYPE in order to generate TYPE.
18962 If the choice of partial specialization is ambiguous, a diagnostic
18963 is issued, and the error_mark_node is returned. If there are no
18964 partial specializations matching TYPE, then NULL_TREE is
18965 returned, indicating that the primary template should be used. */
18968 most_specialized_class (tree type
, tsubst_flags_t complain
)
18970 tree list
= NULL_TREE
;
18975 tree outer_args
= NULL_TREE
;
18977 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
18978 tree main_tmpl
= most_general_template (tmpl
);
18979 tree args
= CLASSTYPE_TI_ARGS (type
);
18981 /* For determining which partial specialization to use, only the
18982 innermost args are interesting. */
18983 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18985 outer_args
= strip_innermost_template_args (args
, 1);
18986 args
= INNERMOST_TEMPLATE_ARGS (args
);
18989 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
18991 tree partial_spec_args
;
18993 tree spec_tmpl
= TREE_VALUE (t
);
18994 tree orig_parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
18996 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
18998 ++processing_template_decl
;
19002 /* Discard the outer levels of args, and then substitute in the
19003 template args from the enclosing class. */
19004 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19005 partial_spec_args
= tsubst_template_args
19006 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19008 /* And the same for the partial specialization TEMPLATE_DECL. */
19009 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19012 partial_spec_args
=
19013 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19016 /*require_all_args=*/true,
19017 /*use_default_args=*/true);
19019 --processing_template_decl
;
19021 if (partial_spec_args
== error_mark_node
)
19022 return error_mark_node
;
19023 if (spec_tmpl
== error_mark_node
)
19024 return error_mark_node
;
19026 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19027 spec_args
= get_class_bindings (tmpl
, parms
,
19033 spec_args
= add_to_template_args (outer_args
, spec_args
);
19034 list
= tree_cons (spec_args
, orig_parms
, list
);
19035 TREE_TYPE (list
) = TREE_TYPE (t
);
19042 ambiguous_p
= false;
19045 t
= TREE_CHAIN (t
);
19046 for (; t
; t
= TREE_CHAIN (t
))
19048 fate
= more_specialized_class (tmpl
, champ
, t
);
19055 t
= TREE_CHAIN (t
);
19058 ambiguous_p
= true;
19067 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19069 fate
= more_specialized_class (tmpl
, champ
, t
);
19072 ambiguous_p
= true;
19080 char *spaces
= NULL
;
19081 if (!(complain
& tf_error
))
19082 return error_mark_node
;
19083 error ("ambiguous class template instantiation for %q#T", type
);
19084 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19085 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19087 error ("%s %+#T", spaces
? spaces
: str
, TREE_TYPE (t
));
19088 spaces
= spaces
? spaces
: get_spaces (str
);
19091 return error_mark_node
;
19097 /* Explicitly instantiate DECL. */
19100 do_decl_instantiation (tree decl
, tree storage
)
19102 tree result
= NULL_TREE
;
19105 if (!decl
|| decl
== error_mark_node
)
19106 /* An error occurred, for which grokdeclarator has already issued
19107 an appropriate message. */
19109 else if (! DECL_LANG_SPECIFIC (decl
))
19111 error ("explicit instantiation of non-template %q#D", decl
);
19114 else if (VAR_P (decl
))
19116 /* There is an asymmetry here in the way VAR_DECLs and
19117 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19118 the latter, the DECL we get back will be marked as a
19119 template instantiation, and the appropriate
19120 DECL_TEMPLATE_INFO will be set up. This does not happen for
19121 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19122 should handle VAR_DECLs as it currently handles
19124 if (!DECL_CLASS_SCOPE_P (decl
))
19126 error ("%qD is not a static data member of a class template", decl
);
19129 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19130 if (!result
|| !VAR_P (result
))
19132 error ("no matching template for %qD found", decl
);
19135 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19137 error ("type %qT for explicit instantiation %qD does not match "
19138 "declared type %qT", TREE_TYPE (result
), decl
,
19143 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
19145 error ("explicit instantiation of %q#D", decl
);
19151 /* Check for various error cases. Note that if the explicit
19152 instantiation is valid the RESULT will currently be marked as an
19153 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19154 until we get here. */
19156 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19158 /* DR 259 [temp.spec].
19160 Both an explicit instantiation and a declaration of an explicit
19161 specialization shall not appear in a program unless the explicit
19162 instantiation follows a declaration of the explicit specialization.
19164 For a given set of template parameters, if an explicit
19165 instantiation of a template appears after a declaration of an
19166 explicit specialization for that template, the explicit
19167 instantiation has no effect. */
19170 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19174 No program shall explicitly instantiate any template more
19177 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19178 the first instantiation was `extern' and the second is not,
19179 and EXTERN_P for the opposite case. */
19180 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19181 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19182 /* If an "extern" explicit instantiation follows an ordinary
19183 explicit instantiation, the template is instantiated. */
19187 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19189 error ("no matching template for %qD found", result
);
19192 else if (!DECL_TEMPLATE_INFO (result
))
19194 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19198 if (storage
== NULL_TREE
)
19200 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19202 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19203 pedwarn (input_location
, OPT_Wpedantic
,
19204 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19209 error ("storage class %qD applied to template instantiation", storage
);
19211 check_explicit_instantiation_namespace (result
);
19212 mark_decl_instantiated (result
, extern_p
);
19214 instantiate_decl (result
, /*defer_ok=*/1,
19215 /*expl_inst_class_mem_p=*/false);
19219 mark_class_instantiated (tree t
, int extern_p
)
19221 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19222 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19223 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19224 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19227 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19228 rest_of_type_compilation (t
, 1);
19232 /* Called from do_type_instantiation through binding_table_foreach to
19233 do recursive instantiation for the type bound in ENTRY. */
19235 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19237 tree storage
= *(tree
*) data
;
19239 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19240 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19241 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19244 /* Called from do_type_instantiation to instantiate a member
19245 (a member function or a static member variable) of an
19246 explicitly instantiated class template. */
19248 instantiate_class_member (tree decl
, int extern_p
)
19250 mark_decl_instantiated (decl
, extern_p
);
19252 instantiate_decl (decl
, /*defer_ok=*/1,
19253 /*expl_inst_class_mem_p=*/true);
19256 /* Perform an explicit instantiation of template class T. STORAGE, if
19257 non-null, is the RID for extern, inline or static. COMPLAIN is
19258 nonzero if this is called from the parser, zero if called recursively,
19259 since the standard is unclear (as detailed below). */
19262 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19267 int previous_instantiation_extern_p
= 0;
19269 if (TREE_CODE (t
) == TYPE_DECL
)
19272 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19275 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19277 error ("explicit instantiation of non-class template %qD", tmpl
);
19279 error ("explicit instantiation of non-template type %qT", t
);
19285 if (!COMPLETE_TYPE_P (t
))
19287 if (complain
& tf_error
)
19288 error ("explicit instantiation of %q#T before definition of template",
19293 if (storage
!= NULL_TREE
)
19295 if (!in_system_header_at (input_location
))
19297 if (storage
== ridpointers
[(int) RID_EXTERN
])
19299 if (cxx_dialect
== cxx98
)
19300 pedwarn (input_location
, OPT_Wpedantic
,
19301 "ISO C++ 1998 forbids the use of %<extern%> on "
19302 "explicit instantiations");
19305 pedwarn (input_location
, OPT_Wpedantic
,
19306 "ISO C++ forbids the use of %qE"
19307 " on explicit instantiations", storage
);
19310 if (storage
== ridpointers
[(int) RID_INLINE
])
19312 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19314 else if (storage
== ridpointers
[(int) RID_STATIC
])
19318 error ("storage class %qD applied to template instantiation",
19324 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19326 /* DR 259 [temp.spec].
19328 Both an explicit instantiation and a declaration of an explicit
19329 specialization shall not appear in a program unless the explicit
19330 instantiation follows a declaration of the explicit specialization.
19332 For a given set of template parameters, if an explicit
19333 instantiation of a template appears after a declaration of an
19334 explicit specialization for that template, the explicit
19335 instantiation has no effect. */
19338 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19342 No program shall explicitly instantiate any template more
19345 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19346 instantiation was `extern'. If EXTERN_P then the second is.
19347 These cases are OK. */
19348 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19350 if (!previous_instantiation_extern_p
&& !extern_p
19351 && (complain
& tf_error
))
19352 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19354 /* If we've already instantiated the template, just return now. */
19355 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19359 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19360 mark_class_instantiated (t
, extern_p
);
19368 /* In contrast to implicit instantiation, where only the
19369 declarations, and not the definitions, of members are
19370 instantiated, we have here:
19374 The explicit instantiation of a class template specialization
19375 implies the instantiation of all of its members not
19376 previously explicitly specialized in the translation unit
19377 containing the explicit instantiation.
19379 Of course, we can't instantiate member template classes, since
19380 we don't have any arguments for them. Note that the standard
19381 is unclear on whether the instantiation of the members are
19382 *explicit* instantiations or not. However, the most natural
19383 interpretation is that it should be an explicit instantiation. */
19386 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19387 if (TREE_CODE (tmp
) == FUNCTION_DECL
19388 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19389 instantiate_class_member (tmp
, extern_p
);
19391 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19392 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19393 instantiate_class_member (tmp
, extern_p
);
19395 if (CLASSTYPE_NESTED_UTDS (t
))
19396 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19397 bt_instantiate_type_proc
, &storage
);
19401 /* Given a function DECL, which is a specialization of TMPL, modify
19402 DECL to be a re-instantiation of TMPL with the same template
19403 arguments. TMPL should be the template into which tsubst'ing
19404 should occur for DECL, not the most general template.
19406 One reason for doing this is a scenario like this:
19409 void f(const T&, int i);
19411 void g() { f(3, 7); }
19414 void f(const T& t, const int i) { }
19416 Note that when the template is first instantiated, with
19417 instantiate_template, the resulting DECL will have no name for the
19418 first parameter, and the wrong type for the second. So, when we go
19419 to instantiate the DECL, we regenerate it. */
19422 regenerate_decl_from_template (tree decl
, tree tmpl
)
19424 /* The arguments used to instantiate DECL, from the most general
19429 args
= DECL_TI_ARGS (decl
);
19430 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19432 /* Make sure that we can see identifiers, and compute access
19434 push_access_scope (decl
);
19436 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19444 args_depth
= TMPL_ARGS_DEPTH (args
);
19445 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19446 if (args_depth
> parms_depth
)
19447 args
= get_innermost_template_args (args
, parms_depth
);
19449 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19450 args
, tf_error
, NULL_TREE
,
19451 /*defer_ok*/false);
19452 if (specs
&& specs
!= error_mark_node
)
19453 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19456 /* Merge parameter declarations. */
19457 decl_parm
= skip_artificial_parms_for (decl
,
19458 DECL_ARGUMENTS (decl
));
19460 = skip_artificial_parms_for (code_pattern
,
19461 DECL_ARGUMENTS (code_pattern
));
19462 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19467 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19468 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19469 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19471 parm_type
= type_decays_to (parm_type
);
19472 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19473 TREE_TYPE (decl_parm
) = parm_type
;
19474 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19475 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19477 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19478 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19480 decl_parm
= DECL_CHAIN (decl_parm
);
19481 pattern_parm
= DECL_CHAIN (pattern_parm
);
19483 /* Merge any parameters that match with the function parameter
19485 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19488 tree expanded_types
;
19489 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19490 the parameters in this function parameter pack. */
19491 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19492 args
, tf_error
, NULL_TREE
);
19493 len
= TREE_VEC_LENGTH (expanded_types
);
19494 for (i
= 0; i
< len
; i
++)
19499 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19500 /* Rename the parameter to include the index. */
19501 DECL_NAME (decl_parm
) =
19502 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19503 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19504 parm_type
= type_decays_to (parm_type
);
19505 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19506 TREE_TYPE (decl_parm
) = parm_type
;
19507 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19508 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19510 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19511 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19513 decl_parm
= DECL_CHAIN (decl_parm
);
19516 /* Merge additional specifiers from the CODE_PATTERN. */
19517 if (DECL_DECLARED_INLINE_P (code_pattern
)
19518 && !DECL_DECLARED_INLINE_P (decl
))
19519 DECL_DECLARED_INLINE_P (decl
) = 1;
19521 else if (VAR_P (decl
))
19523 DECL_INITIAL (decl
) =
19524 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19525 tf_error
, DECL_TI_TEMPLATE (decl
),
19526 /*integral_constant_expression_p=*/false);
19527 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19528 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19529 tf_error
, DECL_TI_TEMPLATE (decl
));
19532 gcc_unreachable ();
19534 pop_access_scope (decl
);
19537 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19538 substituted to get DECL. */
19541 template_for_substitution (tree decl
)
19543 tree tmpl
= DECL_TI_TEMPLATE (decl
);
19545 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19546 for the instantiation. This is not always the most general
19547 template. Consider, for example:
19550 struct S { template <class U> void f();
19551 template <> void f<int>(); };
19553 and an instantiation of S<double>::f<int>. We want TD to be the
19554 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19555 while (/* An instantiation cannot have a definition, so we need a
19556 more general template. */
19557 DECL_TEMPLATE_INSTANTIATION (tmpl
)
19558 /* We must also deal with friend templates. Given:
19560 template <class T> struct S {
19561 template <class U> friend void f() {};
19564 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19565 so far as the language is concerned, but that's still
19566 where we get the pattern for the instantiation from. On
19567 other hand, if the definition comes outside the class, say:
19569 template <class T> struct S {
19570 template <class U> friend void f();
19572 template <class U> friend void f() {}
19574 we don't need to look any further. That's what the check for
19575 DECL_INITIAL is for. */
19576 || (TREE_CODE (decl
) == FUNCTION_DECL
19577 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
19578 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
19580 /* The present template, TD, should not be a definition. If it
19581 were a definition, we should be using it! Note that we
19582 cannot restructure the loop to just keep going until we find
19583 a template with a definition, since that might go too far if
19584 a specialization was declared, but not defined. */
19585 gcc_assert (!VAR_P (decl
)
19586 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl
)));
19588 /* Fetch the more general template. */
19589 tmpl
= DECL_TI_TEMPLATE (tmpl
);
19595 /* Returns true if we need to instantiate this template instance even if we
19596 know we aren't going to emit it.. */
19599 always_instantiate_p (tree decl
)
19601 /* We always instantiate inline functions so that we can inline them. An
19602 explicit instantiation declaration prohibits implicit instantiation of
19603 non-inline functions. With high levels of optimization, we would
19604 normally inline non-inline functions -- but we're not allowed to do
19605 that for "extern template" functions. Therefore, we check
19606 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19607 return ((TREE_CODE (decl
) == FUNCTION_DECL
19608 && (DECL_DECLARED_INLINE_P (decl
)
19609 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
19610 /* And we need to instantiate static data members so that
19611 their initializers are available in integral constant
19614 && decl_maybe_constant_var_p (decl
)));
19617 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19618 instantiate it now, modifying TREE_TYPE (fn). */
19621 maybe_instantiate_noexcept (tree fn
)
19623 tree fntype
, spec
, noex
, clone
;
19625 /* Don't instantiate a noexcept-specification from template context. */
19626 if (processing_template_decl
)
19629 if (DECL_CLONED_FUNCTION_P (fn
))
19630 fn
= DECL_CLONED_FUNCTION (fn
);
19631 fntype
= TREE_TYPE (fn
);
19632 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
19634 if (!spec
|| !TREE_PURPOSE (spec
))
19637 noex
= TREE_PURPOSE (spec
);
19639 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
19641 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
19642 spec
= get_defaulted_eh_spec (fn
);
19643 else if (push_tinst_level (fn
))
19645 push_access_scope (fn
);
19646 push_deferring_access_checks (dk_no_deferred
);
19647 input_location
= DECL_SOURCE_LOCATION (fn
);
19648 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
19649 DEFERRED_NOEXCEPT_ARGS (noex
),
19650 tf_warning_or_error
, fn
,
19651 /*function_p=*/false,
19652 /*integral_constant_expression_p=*/true);
19653 pop_deferring_access_checks ();
19654 pop_access_scope (fn
);
19655 pop_tinst_level ();
19656 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
19657 if (spec
== error_mark_node
)
19658 spec
= noexcept_false_spec
;
19661 spec
= noexcept_false_spec
;
19663 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
19666 FOR_EACH_CLONE (clone
, fn
)
19668 if (TREE_TYPE (clone
) == fntype
)
19669 TREE_TYPE (clone
) = TREE_TYPE (fn
);
19671 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
19675 /* Produce the definition of D, a _DECL generated from a template. If
19676 DEFER_OK is nonzero, then we don't have to actually do the
19677 instantiation now; we just have to do it sometime. Normally it is
19678 an error if this is an explicit instantiation but D is undefined.
19679 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19680 explicitly instantiated class template. */
19683 instantiate_decl (tree d
, int defer_ok
,
19684 bool expl_inst_class_mem_p
)
19686 tree tmpl
= DECL_TI_TEMPLATE (d
);
19693 bool pattern_defined
;
19694 location_t saved_loc
= input_location
;
19695 int saved_unevaluated_operand
= cp_unevaluated_operand
;
19696 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
19702 /* This function should only be used to instantiate templates for
19703 functions and static member variables. */
19704 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
19706 /* Variables are never deferred; if instantiation is required, they
19707 are instantiated right away. That allows for better code in the
19708 case that an expression refers to the value of the variable --
19709 if the variable has a constant value the referring expression can
19710 take advantage of that fact. */
19712 || DECL_DECLARED_CONSTEXPR_P (d
))
19715 /* Don't instantiate cloned functions. Instead, instantiate the
19716 functions they cloned. */
19717 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
19718 d
= DECL_CLONED_FUNCTION (d
);
19720 if (DECL_TEMPLATE_INSTANTIATED (d
)
19721 || (TREE_CODE (d
) == FUNCTION_DECL
19722 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
19723 || DECL_TEMPLATE_SPECIALIZATION (d
))
19724 /* D has already been instantiated or explicitly specialized, so
19725 there's nothing for us to do here.
19727 It might seem reasonable to check whether or not D is an explicit
19728 instantiation, and, if so, stop here. But when an explicit
19729 instantiation is deferred until the end of the compilation,
19730 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
19731 the instantiation. */
19734 /* Check to see whether we know that this template will be
19735 instantiated in some other file, as with "extern template"
19737 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
19739 /* In general, we do not instantiate such templates. */
19740 if (external_p
&& !always_instantiate_p (d
))
19743 /* Any local class members should be instantiated from the TAG_DEFN
19744 with defer_ok == 0. */
19745 gcc_checking_assert (!defer_ok
|| !decl_function_context (d
)
19746 || LAMBDA_TYPE_P (DECL_CONTEXT (d
)));
19748 gen_tmpl
= most_general_template (tmpl
);
19749 gen_args
= DECL_TI_ARGS (d
);
19751 if (tmpl
!= gen_tmpl
)
19752 /* We should already have the extra args. */
19753 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
19754 == TMPL_ARGS_DEPTH (gen_args
));
19755 /* And what's in the hash table should match D. */
19756 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
19757 || spec
== NULL_TREE
);
19759 /* This needs to happen before any tsubsting. */
19760 if (! push_tinst_level (d
))
19763 timevar_push (TV_TEMPLATE_INST
);
19765 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
19766 for the instantiation. */
19767 td
= template_for_substitution (d
);
19768 code_pattern
= DECL_TEMPLATE_RESULT (td
);
19770 /* We should never be trying to instantiate a member of a class
19771 template or partial specialization. */
19772 gcc_assert (d
!= code_pattern
);
19774 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
19775 || DECL_TEMPLATE_SPECIALIZATION (td
))
19776 /* In the case of a friend template whose definition is provided
19777 outside the class, we may have too many arguments. Drop the
19778 ones we don't need. The same is true for specializations. */
19779 args
= get_innermost_template_args
19780 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
19784 if (TREE_CODE (d
) == FUNCTION_DECL
)
19786 deleted_p
= DECL_DELETED_FN (code_pattern
);
19787 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
19788 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
19794 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
19797 /* We may be in the middle of deferred access check. Disable it now. */
19798 push_deferring_access_checks (dk_no_deferred
);
19800 /* Unless an explicit instantiation directive has already determined
19801 the linkage of D, remember that a definition is available for
19803 if (pattern_defined
19804 && !DECL_INTERFACE_KNOWN (d
)
19805 && !DECL_NOT_REALLY_EXTERN (d
))
19806 mark_definable (d
);
19808 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
19809 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
19810 input_location
= DECL_SOURCE_LOCATION (d
);
19812 /* If D is a member of an explicitly instantiated class template,
19813 and no definition is available, treat it like an implicit
19815 if (!pattern_defined
&& expl_inst_class_mem_p
19816 && DECL_EXPLICIT_INSTANTIATION (d
))
19818 /* Leave linkage flags alone on instantiations with anonymous
19820 if (TREE_PUBLIC (d
))
19822 DECL_NOT_REALLY_EXTERN (d
) = 0;
19823 DECL_INTERFACE_KNOWN (d
) = 0;
19825 SET_DECL_IMPLICIT_INSTANTIATION (d
);
19828 /* Defer all other templates, unless we have been explicitly
19829 forbidden from doing so. */
19830 if (/* If there is no definition, we cannot instantiate the
19833 /* If it's OK to postpone instantiation, do so. */
19835 /* If this is a static data member that will be defined
19836 elsewhere, we don't want to instantiate the entire data
19837 member, but we do want to instantiate the initializer so that
19838 we can substitute that elsewhere. */
19839 || (external_p
&& VAR_P (d
))
19840 /* Handle here a deleted function too, avoid generating
19841 its body (c++/61080). */
19844 /* The definition of the static data member is now required so
19845 we must substitute the initializer. */
19847 && !DECL_INITIAL (d
)
19848 && DECL_INITIAL (code_pattern
))
19852 bool const_init
= false;
19854 ns
= decl_namespace_context (d
);
19855 push_nested_namespace (ns
);
19856 push_nested_class (DECL_CONTEXT (d
));
19857 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
19859 tf_warning_or_error
, NULL_TREE
,
19860 /*integral_constant_expression_p=*/false);
19861 /* Make sure the initializer is still constant, in case of
19862 circular dependency (template/instantiate6.C). */
19864 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19865 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
19866 /*asmspec_tree=*/NULL_TREE
,
19867 LOOKUP_ONLYCONVERTING
);
19868 pop_nested_class ();
19869 pop_nested_namespace (ns
);
19872 /* We restore the source position here because it's used by
19873 add_pending_template. */
19874 input_location
= saved_loc
;
19876 if (at_eof
&& !pattern_defined
19877 && DECL_EXPLICIT_INSTANTIATION (d
)
19878 && DECL_NOT_REALLY_EXTERN (d
))
19881 The definition of a non-exported function template, a
19882 non-exported member function template, or a non-exported
19883 member function or static data member of a class template
19884 shall be present in every translation unit in which it is
19885 explicitly instantiated. */
19886 permerror (input_location
, "explicit instantiation of %qD "
19887 "but no definition available", d
);
19889 /* If we're in unevaluated context, we just wanted to get the
19890 constant value; this isn't an odr use, so don't queue
19891 a full instantiation. */
19892 if (cp_unevaluated_operand
!= 0)
19894 /* ??? Historically, we have instantiated inline functions, even
19895 when marked as "extern template". */
19896 if (!(external_p
&& VAR_P (d
)))
19897 add_pending_template (d
);
19900 /* Tell the repository that D is available in this translation unit
19901 -- and see if it is supposed to be instantiated here. */
19902 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
19904 /* In a PCH file, despite the fact that the repository hasn't
19905 requested instantiation in the PCH it is still possible that
19906 an instantiation will be required in a file that includes the
19909 add_pending_template (d
);
19910 /* Instantiate inline functions so that the inliner can do its
19911 job, even though we'll not be emitting a copy of this
19913 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
19917 fn_context
= decl_function_context (d
);
19918 nested
= (current_function_decl
!= NULL_TREE
);
19920 push_to_top_level ();
19924 push_function_context ();
19925 cp_unevaluated_operand
= 0;
19926 c_inhibit_evaluation_warnings
= 0;
19929 /* Mark D as instantiated so that recursive calls to
19930 instantiate_decl do not try to instantiate it again. */
19931 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
19933 /* Regenerate the declaration in case the template has been modified
19934 by a subsequent redeclaration. */
19935 regenerate_decl_from_template (d
, td
);
19937 /* We already set the file and line above. Reset them now in case
19938 they changed as a result of calling regenerate_decl_from_template. */
19939 input_location
= DECL_SOURCE_LOCATION (d
);
19944 bool const_init
= false;
19946 /* Clear out DECL_RTL; whatever was there before may not be right
19947 since we've reset the type of the declaration. */
19948 SET_DECL_RTL (d
, NULL
);
19949 DECL_IN_AGGR_P (d
) = 0;
19951 /* The initializer is placed in DECL_INITIAL by
19952 regenerate_decl_from_template so we don't need to
19953 push/pop_access_scope again here. Pull it out so that
19954 cp_finish_decl can process it. */
19955 init
= DECL_INITIAL (d
);
19956 DECL_INITIAL (d
) = NULL_TREE
;
19957 DECL_INITIALIZED_P (d
) = 0;
19959 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
19960 initializer. That function will defer actual emission until
19961 we have a chance to determine linkage. */
19962 DECL_EXTERNAL (d
) = 0;
19964 /* Enter the scope of D so that access-checking works correctly. */
19965 push_nested_class (DECL_CONTEXT (d
));
19966 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19967 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
19968 pop_nested_class ();
19970 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
19971 synthesize_method (d
);
19972 else if (TREE_CODE (d
) == FUNCTION_DECL
)
19974 struct pointer_map_t
*saved_local_specializations
;
19978 tree block
= NULL_TREE
;
19980 /* Save away the current list, in case we are instantiating one
19981 template from within the body of another. */
19982 saved_local_specializations
= local_specializations
;
19984 /* Set up the list of local specializations. */
19985 local_specializations
= pointer_map_create ();
19987 /* Set up context. */
19988 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
19989 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
19990 block
= push_stmt_list ();
19992 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
19994 /* Some typedefs referenced from within the template code need to be
19995 access checked at template instantiation time, i.e now. These
19996 types were added to the template at parsing time. Let's get those
19997 and perform the access checks then. */
19998 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20001 /* Create substitution entries for the parameters. */
20002 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20003 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20004 spec_parm
= DECL_ARGUMENTS (d
);
20005 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20007 register_local_specialization (spec_parm
, tmpl_parm
);
20008 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20009 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20011 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20013 if (!DECL_PACK_P (tmpl_parm
))
20015 register_local_specialization (spec_parm
, tmpl_parm
);
20016 spec_parm
= DECL_CHAIN (spec_parm
);
20020 /* Register the (value) argument pack as a specialization of
20021 TMPL_PARM, then move on. */
20022 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20023 register_local_specialization (argpack
, tmpl_parm
);
20026 gcc_assert (!spec_parm
);
20028 /* Substitute into the body of the function. */
20029 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20030 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20031 tf_warning_or_error
, tmpl
);
20034 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20035 tf_warning_or_error
, tmpl
,
20036 /*integral_constant_expression_p=*/false);
20038 /* Set the current input_location to the end of the function
20039 so that finish_function knows where we are. */
20041 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20043 /* Remember if we saw an infinite loop in the template. */
20044 current_function_infinite_loop
20045 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20048 /* We don't need the local specializations any more. */
20049 pointer_map_destroy (local_specializations
);
20050 local_specializations
= saved_local_specializations
;
20052 /* Finish the function. */
20053 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20054 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20055 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20058 d
= finish_function (0);
20059 expand_or_defer_fn (d
);
20062 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20063 cp_check_omp_declare_reduction (d
);
20066 /* We're not deferring instantiation any more. */
20067 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20070 pop_from_top_level ();
20072 pop_function_context ();
20075 input_location
= saved_loc
;
20076 cp_unevaluated_operand
= saved_unevaluated_operand
;
20077 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20078 pop_deferring_access_checks ();
20079 pop_tinst_level ();
20081 timevar_pop (TV_TEMPLATE_INST
);
20086 /* Run through the list of templates that we wish we could
20087 instantiate, and instantiate any we can. RETRIES is the
20088 number of times we retry pending template instantiation. */
20091 instantiate_pending_templates (int retries
)
20094 location_t saved_loc
= input_location
;
20096 /* Instantiating templates may trigger vtable generation. This in turn
20097 may require further template instantiations. We place a limit here
20098 to avoid infinite loop. */
20099 if (pending_templates
&& retries
>= max_tinst_depth
)
20101 tree decl
= pending_templates
->tinst
->decl
;
20103 error ("template instantiation depth exceeds maximum of %d"
20104 " instantiating %q+D, possibly from virtual table generation"
20105 " (use -ftemplate-depth= to increase the maximum)",
20106 max_tinst_depth
, decl
);
20107 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20108 /* Pretend that we defined it. */
20109 DECL_INITIAL (decl
) = error_mark_node
;
20115 struct pending_template
**t
= &pending_templates
;
20116 struct pending_template
*last
= NULL
;
20120 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20121 bool complete
= false;
20123 if (TYPE_P (instantiation
))
20127 if (!COMPLETE_TYPE_P (instantiation
))
20129 instantiate_class_template (instantiation
);
20130 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20131 for (fn
= TYPE_METHODS (instantiation
);
20133 fn
= TREE_CHAIN (fn
))
20134 if (! DECL_ARTIFICIAL (fn
))
20135 instantiate_decl (fn
,
20137 /*expl_inst_class_mem_p=*/false);
20138 if (COMPLETE_TYPE_P (instantiation
))
20142 complete
= COMPLETE_TYPE_P (instantiation
);
20146 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20147 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20150 = instantiate_decl (instantiation
,
20152 /*expl_inst_class_mem_p=*/false);
20153 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20157 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20158 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20162 /* If INSTANTIATION has been instantiated, then we don't
20163 need to consider it again in the future. */
20171 current_tinst_level
= NULL
;
20173 last_pending_template
= last
;
20175 while (reconsider
);
20177 input_location
= saved_loc
;
20180 /* Substitute ARGVEC into T, which is a list of initializers for
20181 either base class or a non-static data member. The TREE_PURPOSEs
20182 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20183 instantiate_decl. */
20186 tsubst_initializer_list (tree t
, tree argvec
)
20188 tree inits
= NULL_TREE
;
20190 for (; t
; t
= TREE_CHAIN (t
))
20194 tree expanded_bases
= NULL_TREE
;
20195 tree expanded_arguments
= NULL_TREE
;
20198 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20203 /* Expand the base class expansion type into separate base
20205 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20206 tf_warning_or_error
,
20208 if (expanded_bases
== error_mark_node
)
20211 /* We'll be building separate TREE_LISTs of arguments for
20213 len
= TREE_VEC_LENGTH (expanded_bases
);
20214 expanded_arguments
= make_tree_vec (len
);
20215 for (i
= 0; i
< len
; i
++)
20216 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20218 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20219 expand each argument in the TREE_VALUE of t. */
20220 expr
= make_node (EXPR_PACK_EXPANSION
);
20221 PACK_EXPANSION_LOCAL_P (expr
) = true;
20222 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20223 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20225 if (TREE_VALUE (t
) == void_type_node
)
20226 /* VOID_TYPE_NODE is used to indicate
20227 value-initialization. */
20229 for (i
= 0; i
< len
; i
++)
20230 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20234 /* Substitute parameter packs into each argument in the
20236 in_base_initializer
= 1;
20237 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20239 tree expanded_exprs
;
20241 /* Expand the argument. */
20242 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20244 = tsubst_pack_expansion (expr
, argvec
,
20245 tf_warning_or_error
,
20247 if (expanded_exprs
== error_mark_node
)
20250 /* Prepend each of the expanded expressions to the
20251 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20252 for (i
= 0; i
< len
; i
++)
20254 TREE_VEC_ELT (expanded_arguments
, i
) =
20255 tree_cons (NULL_TREE
,
20256 TREE_VEC_ELT (expanded_exprs
, i
),
20257 TREE_VEC_ELT (expanded_arguments
, i
));
20260 in_base_initializer
= 0;
20262 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20263 since we built them backwards. */
20264 for (i
= 0; i
< len
; i
++)
20266 TREE_VEC_ELT (expanded_arguments
, i
) =
20267 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20272 for (i
= 0; i
< len
; ++i
)
20274 if (expanded_bases
)
20276 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20277 decl
= expand_member_init (decl
);
20278 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20283 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20284 tf_warning_or_error
, NULL_TREE
);
20286 decl
= expand_member_init (decl
);
20287 if (decl
&& !DECL_P (decl
))
20288 in_base_initializer
= 1;
20290 init
= TREE_VALUE (t
);
20292 if (init
!= void_type_node
)
20293 init
= tsubst_expr (init
, argvec
,
20294 tf_warning_or_error
, NULL_TREE
,
20295 /*integral_constant_expression_p=*/false);
20296 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20297 /* If we had an initializer but it instantiated to nothing,
20298 value-initialize the object. This will only occur when
20299 the initializer was a pack expansion where the parameter
20300 packs used in that expansion were of length zero. */
20301 init
= void_type_node
;
20302 in_base_initializer
= 0;
20307 init
= build_tree_list (decl
, init
);
20308 TREE_CHAIN (init
) = inits
;
20316 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20319 set_current_access_from_decl (tree decl
)
20321 if (TREE_PRIVATE (decl
))
20322 current_access_specifier
= access_private_node
;
20323 else if (TREE_PROTECTED (decl
))
20324 current_access_specifier
= access_protected_node
;
20326 current_access_specifier
= access_public_node
;
20329 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20330 is the instantiation (which should have been created with
20331 start_enum) and ARGS are the template arguments to use. */
20334 tsubst_enum (tree tag
, tree newtag
, tree args
)
20338 if (SCOPED_ENUM_P (newtag
))
20339 begin_scope (sk_scoped_enum
, newtag
);
20341 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20346 decl
= TREE_VALUE (e
);
20347 /* Note that in a template enum, the TREE_VALUE is the
20348 CONST_DECL, not the corresponding INTEGER_CST. */
20349 value
= tsubst_expr (DECL_INITIAL (decl
),
20350 args
, tf_warning_or_error
, NULL_TREE
,
20351 /*integral_constant_expression_p=*/true);
20353 /* Give this enumeration constant the correct access. */
20354 set_current_access_from_decl (decl
);
20356 /* Actually build the enumerator itself. */
20358 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
20361 if (SCOPED_ENUM_P (newtag
))
20364 finish_enum_value_list (newtag
);
20365 finish_enum (newtag
);
20367 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20368 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20371 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20372 its type -- but without substituting the innermost set of template
20373 arguments. So, innermost set of template parameters will appear in
20377 get_mostly_instantiated_function_type (tree decl
)
20385 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
20386 targs
= DECL_TI_ARGS (decl
);
20387 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
20388 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
20390 /* There should be as many levels of arguments as there are levels
20392 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
20394 fn_type
= TREE_TYPE (tmpl
);
20396 if (parm_depth
== 1)
20397 /* No substitution is necessary. */
20404 /* Replace the innermost level of the TARGS with NULL_TREEs to
20405 let tsubst know not to substitute for those parameters. */
20406 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20407 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
20408 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
20409 TMPL_ARGS_LEVEL (targs
, i
));
20410 SET_TMPL_ARGS_LEVEL (partial_args
,
20411 TMPL_ARGS_DEPTH (targs
),
20412 make_tree_vec (DECL_NTPARMS (tmpl
)));
20414 /* Make sure that we can see identifiers, and compute access
20416 push_access_scope (decl
);
20418 ++processing_template_decl
;
20419 /* Now, do the (partial) substitution to figure out the
20420 appropriate function type. */
20421 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
20422 --processing_template_decl
;
20424 /* Substitute into the template parameters to obtain the real
20425 innermost set of parameters. This step is important if the
20426 innermost set of template parameters contains value
20427 parameters whose types depend on outer template parameters. */
20428 TREE_VEC_LENGTH (partial_args
)--;
20429 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
20431 pop_access_scope (decl
);
20437 /* Return truthvalue if we're processing a template different from
20438 the last one involved in diagnostics. */
20440 problematic_instantiation_changed (void)
20442 return current_tinst_level
!= last_error_tinst_level
;
20445 /* Remember current template involved in diagnostics. */
20447 record_last_problematic_instantiation (void)
20449 last_error_tinst_level
= current_tinst_level
;
20452 struct tinst_level
*
20453 current_instantiation (void)
20455 return current_tinst_level
;
20458 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20459 type. Return zero for ok, nonzero for disallowed. Issue error and
20460 warning messages under control of COMPLAIN. */
20463 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20465 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20467 else if (POINTER_TYPE_P (type
))
20469 else if (TYPE_PTRMEM_P (type
))
20471 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20473 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20475 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20477 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20480 if (complain
& tf_error
)
20482 if (type
== error_mark_node
)
20483 inform (input_location
, "invalid template non-type parameter");
20485 error ("%q#T is not a valid type for a template non-type parameter",
20491 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20492 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20495 dependent_type_p_r (tree type
)
20501 A type is dependent if it is:
20503 -- a template parameter. Template template parameters are types
20504 for us (since TYPE_P holds true for them) so we handle
20506 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20507 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20509 /* -- a qualified-id with a nested-name-specifier which contains a
20510 class-name that names a dependent type or whose unqualified-id
20511 names a dependent type. */
20512 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20514 /* -- a cv-qualified type where the cv-unqualified type is
20516 type
= TYPE_MAIN_VARIANT (type
);
20517 /* -- a compound type constructed from any dependent type. */
20518 if (TYPE_PTRMEM_P (type
))
20519 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20520 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20522 else if (TYPE_PTR_P (type
)
20523 || TREE_CODE (type
) == REFERENCE_TYPE
)
20524 return dependent_type_p (TREE_TYPE (type
));
20525 else if (TREE_CODE (type
) == FUNCTION_TYPE
20526 || TREE_CODE (type
) == METHOD_TYPE
)
20530 if (dependent_type_p (TREE_TYPE (type
)))
20532 for (arg_type
= TYPE_ARG_TYPES (type
);
20534 arg_type
= TREE_CHAIN (arg_type
))
20535 if (dependent_type_p (TREE_VALUE (arg_type
)))
20539 /* -- an array type constructed from any dependent type or whose
20540 size is specified by a constant expression that is
20543 We checked for type- and value-dependence of the bounds in
20544 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20545 if (TREE_CODE (type
) == ARRAY_TYPE
)
20547 if (TYPE_DOMAIN (type
)
20548 && dependent_type_p (TYPE_DOMAIN (type
)))
20550 return dependent_type_p (TREE_TYPE (type
));
20553 /* -- a template-id in which either the template name is a template
20555 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20557 /* ... or any of the template arguments is a dependent type or
20558 an expression that is type-dependent or value-dependent. */
20559 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
20560 && (any_dependent_template_arguments_p
20561 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
20564 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20565 dependent; if the argument of the `typeof' expression is not
20566 type-dependent, then it should already been have resolved. */
20567 if (TREE_CODE (type
) == TYPEOF_TYPE
20568 || TREE_CODE (type
) == DECLTYPE_TYPE
20569 || TREE_CODE (type
) == UNDERLYING_TYPE
)
20572 /* A template argument pack is dependent if any of its packed
20574 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
20576 tree args
= ARGUMENT_PACK_ARGS (type
);
20577 int i
, len
= TREE_VEC_LENGTH (args
);
20578 for (i
= 0; i
< len
; ++i
)
20579 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20583 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20584 be template parameters. */
20585 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
20588 /* The standard does not specifically mention types that are local
20589 to template functions or local classes, but they should be
20590 considered dependent too. For example:
20592 template <int I> void f() {
20597 The size of `E' cannot be known until the value of `I' has been
20598 determined. Therefore, `E' must be considered dependent. */
20599 scope
= TYPE_CONTEXT (type
);
20600 if (scope
&& TYPE_P (scope
))
20601 return dependent_type_p (scope
);
20602 /* Don't use type_dependent_expression_p here, as it can lead
20603 to infinite recursion trying to determine whether a lambda
20604 nested in a lambda is dependent (c++/47687). */
20605 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
20606 && DECL_LANG_SPECIFIC (scope
)
20607 && DECL_TEMPLATE_INFO (scope
)
20608 && (any_dependent_template_arguments_p
20609 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
20612 /* Other types are non-dependent. */
20616 /* Returns TRUE if TYPE is dependent, in the sense of
20617 [temp.dep.type]. Note that a NULL type is considered dependent. */
20620 dependent_type_p (tree type
)
20622 /* If there are no template parameters in scope, then there can't be
20623 any dependent types. */
20624 if (!processing_template_decl
)
20626 /* If we are not processing a template, then nobody should be
20627 providing us with a dependent type. */
20629 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
20633 /* If the type is NULL, we have not computed a type for the entity
20634 in question; in that case, the type is dependent. */
20638 /* Erroneous types can be considered non-dependent. */
20639 if (type
== error_mark_node
)
20642 /* If we have not already computed the appropriate value for TYPE,
20644 if (!TYPE_DEPENDENT_P_VALID (type
))
20646 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
20647 TYPE_DEPENDENT_P_VALID (type
) = 1;
20650 return TYPE_DEPENDENT_P (type
);
20653 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20654 lookup. In other words, a dependent type that is not the current
20658 dependent_scope_p (tree scope
)
20660 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
20661 && !currently_open_class (scope
));
20664 /* T is a SCOPE_REF; return whether we need to consider it
20665 instantiation-dependent so that we can check access at instantiation
20666 time even though we know which member it resolves to. */
20669 instantiation_dependent_scope_ref_p (tree t
)
20671 if (DECL_P (TREE_OPERAND (t
, 1))
20672 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
20673 && accessible_in_template_p (TREE_OPERAND (t
, 0),
20674 TREE_OPERAND (t
, 1)))
20680 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20681 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20684 /* Note that this predicate is not appropriate for general expressions;
20685 only constant expressions (that satisfy potential_constant_expression)
20686 can be tested for value dependence. */
20689 value_dependent_expression_p (tree expression
)
20691 if (!processing_template_decl
)
20694 /* A name declared with a dependent type. */
20695 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
20698 switch (TREE_CODE (expression
))
20700 case IDENTIFIER_NODE
:
20701 /* A name that has not been looked up -- must be dependent. */
20704 case TEMPLATE_PARM_INDEX
:
20705 /* A non-type template parm. */
20709 /* A non-type template parm. */
20710 if (DECL_TEMPLATE_PARM_P (expression
))
20712 return value_dependent_expression_p (DECL_INITIAL (expression
));
20715 /* A constant with literal type and is initialized
20716 with an expression that is value-dependent.
20718 Note that a non-dependent parenthesized initializer will have
20719 already been replaced with its constant value, so if we see
20720 a TREE_LIST it must be dependent. */
20721 if (DECL_INITIAL (expression
)
20722 && decl_constant_var_p (expression
)
20723 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
20724 || value_dependent_expression_p (DECL_INITIAL (expression
))))
20728 case DYNAMIC_CAST_EXPR
:
20729 case STATIC_CAST_EXPR
:
20730 case CONST_CAST_EXPR
:
20731 case REINTERPRET_CAST_EXPR
:
20733 /* These expressions are value-dependent if the type to which
20734 the cast occurs is dependent or the expression being casted
20735 is value-dependent. */
20737 tree type
= TREE_TYPE (expression
);
20739 if (dependent_type_p (type
))
20742 /* A functional cast has a list of operands. */
20743 expression
= TREE_OPERAND (expression
, 0);
20746 /* If there are no operands, it must be an expression such
20747 as "int()". This should not happen for aggregate types
20748 because it would form non-constant expressions. */
20749 gcc_assert (cxx_dialect
>= cxx11
20750 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
20755 if (TREE_CODE (expression
) == TREE_LIST
)
20756 return any_value_dependent_elements_p (expression
);
20758 return value_dependent_expression_p (expression
);
20762 if (SIZEOF_EXPR_TYPE_P (expression
))
20763 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
20767 /* A `sizeof' expression is value-dependent if the operand is
20768 type-dependent or is a pack expansion. */
20769 expression
= TREE_OPERAND (expression
, 0);
20770 if (PACK_EXPANSION_P (expression
))
20772 else if (TYPE_P (expression
))
20773 return dependent_type_p (expression
);
20774 return instantiation_dependent_expression_p (expression
);
20776 case AT_ENCODE_EXPR
:
20777 /* An 'encode' expression is value-dependent if the operand is
20779 expression
= TREE_OPERAND (expression
, 0);
20780 return dependent_type_p (expression
);
20782 case NOEXCEPT_EXPR
:
20783 expression
= TREE_OPERAND (expression
, 0);
20784 return instantiation_dependent_expression_p (expression
);
20787 /* All instantiation-dependent expressions should also be considered
20788 value-dependent. */
20789 return instantiation_dependent_scope_ref_p (expression
);
20791 case COMPONENT_REF
:
20792 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
20793 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
20795 case NONTYPE_ARGUMENT_PACK
:
20796 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
20797 is value-dependent. */
20799 tree values
= ARGUMENT_PACK_ARGS (expression
);
20800 int i
, len
= TREE_VEC_LENGTH (values
);
20802 for (i
= 0; i
< len
; ++i
)
20803 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
20811 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
20812 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
20813 || (type2
? dependent_type_p (type2
) : false));
20817 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20818 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
20821 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20822 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
20826 tree op
= TREE_OPERAND (expression
, 0);
20827 return (value_dependent_expression_p (op
)
20828 || has_value_dependent_address (op
));
20833 tree fn
= get_callee_fndecl (expression
);
20835 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
20837 nargs
= call_expr_nargs (expression
);
20838 for (i
= 0; i
< nargs
; ++i
)
20840 tree op
= CALL_EXPR_ARG (expression
, i
);
20841 /* In a call to a constexpr member function, look through the
20842 implicit ADDR_EXPR on the object argument so that it doesn't
20843 cause the call to be considered value-dependent. We also
20844 look through it in potential_constant_expression. */
20845 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
20846 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
20847 && TREE_CODE (op
) == ADDR_EXPR
)
20848 op
= TREE_OPERAND (op
, 0);
20849 if (value_dependent_expression_p (op
))
20855 case TEMPLATE_ID_EXPR
:
20856 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
20858 return type_dependent_expression_p (expression
);
20864 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
20865 if (value_dependent_expression_p (val
))
20871 /* Treat a GNU statement expression as dependent to avoid crashing
20872 under fold_non_dependent_expr; it can't be constant. */
20876 /* A constant expression is value-dependent if any subexpression is
20877 value-dependent. */
20878 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
20880 case tcc_reference
:
20882 case tcc_comparison
:
20884 case tcc_expression
:
20887 int i
, len
= cp_tree_operand_length (expression
);
20889 for (i
= 0; i
< len
; i
++)
20891 tree t
= TREE_OPERAND (expression
, i
);
20893 /* In some cases, some of the operands may be missing.l
20894 (For example, in the case of PREDECREMENT_EXPR, the
20895 amount to increment by may be missing.) That doesn't
20896 make the expression dependent. */
20897 if (t
&& value_dependent_expression_p (t
))
20908 /* The expression is not value-dependent. */
20912 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
20913 [temp.dep.expr]. Note that an expression with no type is
20914 considered dependent. Other parts of the compiler arrange for an
20915 expression with type-dependent subexpressions to have no type, so
20916 this function doesn't have to be fully recursive. */
20919 type_dependent_expression_p (tree expression
)
20921 if (!processing_template_decl
)
20924 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
20927 /* An unresolved name is always dependent. */
20928 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
20931 /* Some expression forms are never type-dependent. */
20932 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
20933 || TREE_CODE (expression
) == SIZEOF_EXPR
20934 || TREE_CODE (expression
) == ALIGNOF_EXPR
20935 || TREE_CODE (expression
) == AT_ENCODE_EXPR
20936 || TREE_CODE (expression
) == NOEXCEPT_EXPR
20937 || TREE_CODE (expression
) == TRAIT_EXPR
20938 || TREE_CODE (expression
) == TYPEID_EXPR
20939 || TREE_CODE (expression
) == DELETE_EXPR
20940 || TREE_CODE (expression
) == VEC_DELETE_EXPR
20941 || TREE_CODE (expression
) == THROW_EXPR
)
20944 /* The types of these expressions depends only on the type to which
20945 the cast occurs. */
20946 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
20947 || TREE_CODE (expression
) == STATIC_CAST_EXPR
20948 || TREE_CODE (expression
) == CONST_CAST_EXPR
20949 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
20950 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
20951 || TREE_CODE (expression
) == CAST_EXPR
)
20952 return dependent_type_p (TREE_TYPE (expression
));
20954 /* The types of these expressions depends only on the type created
20955 by the expression. */
20956 if (TREE_CODE (expression
) == NEW_EXPR
20957 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
20959 /* For NEW_EXPR tree nodes created inside a template, either
20960 the object type itself or a TREE_LIST may appear as the
20962 tree type
= TREE_OPERAND (expression
, 1);
20963 if (TREE_CODE (type
) == TREE_LIST
)
20964 /* This is an array type. We need to check array dimensions
20966 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
20967 || value_dependent_expression_p
20968 (TREE_OPERAND (TREE_VALUE (type
), 1));
20970 return dependent_type_p (type
);
20973 if (TREE_CODE (expression
) == SCOPE_REF
)
20975 tree scope
= TREE_OPERAND (expression
, 0);
20976 tree name
= TREE_OPERAND (expression
, 1);
20978 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
20979 contains an identifier associated by name lookup with one or more
20980 declarations declared with a dependent type, or...a
20981 nested-name-specifier or qualified-id that names a member of an
20982 unknown specialization. */
20983 return (type_dependent_expression_p (name
)
20984 || dependent_scope_p (scope
));
20987 if (TREE_CODE (expression
) == FUNCTION_DECL
20988 && DECL_LANG_SPECIFIC (expression
)
20989 && DECL_TEMPLATE_INFO (expression
)
20990 && (any_dependent_template_arguments_p
20991 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
20994 if (TREE_CODE (expression
) == TEMPLATE_DECL
20995 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
20998 if (TREE_CODE (expression
) == STMT_EXPR
)
20999 expression
= stmt_expr_value_expr (expression
);
21001 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21006 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21008 if (type_dependent_expression_p (elt
))
21014 /* A static data member of the current instantiation with incomplete
21015 array type is type-dependent, as the definition and specializations
21016 can have different bounds. */
21017 if (VAR_P (expression
)
21018 && DECL_CLASS_SCOPE_P (expression
)
21019 && dependent_type_p (DECL_CONTEXT (expression
))
21020 && VAR_HAD_UNKNOWN_BOUND (expression
))
21023 /* An array of unknown bound depending on a variadic parameter, eg:
21025 template<typename... Args>
21026 void foo (Args... args)
21028 int arr[] = { args... };
21031 template<int... vals>
21034 int arr[] = { vals... };
21037 If the array has no length and has an initializer, it must be that
21038 we couldn't determine its length in cp_complete_array_type because
21039 it is dependent. */
21040 if (VAR_P (expression
)
21041 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21042 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21043 && DECL_INITIAL (expression
))
21046 if (TREE_TYPE (expression
) == unknown_type_node
)
21048 if (TREE_CODE (expression
) == ADDR_EXPR
)
21049 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21050 if (TREE_CODE (expression
) == COMPONENT_REF
21051 || TREE_CODE (expression
) == OFFSET_REF
)
21053 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21055 expression
= TREE_OPERAND (expression
, 1);
21056 if (identifier_p (expression
))
21059 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21060 if (TREE_CODE (expression
) == SCOPE_REF
)
21063 /* Always dependent, on the number of arguments if nothing else. */
21064 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21067 if (BASELINK_P (expression
))
21068 expression
= BASELINK_FUNCTIONS (expression
);
21070 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21072 if (any_dependent_template_arguments_p
21073 (TREE_OPERAND (expression
, 1)))
21075 expression
= TREE_OPERAND (expression
, 0);
21077 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21078 || TREE_CODE (expression
) == FUNCTION_DECL
);
21082 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21084 expression
= OVL_NEXT (expression
);
21089 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21091 return (dependent_type_p (TREE_TYPE (expression
)));
21094 /* walk_tree callback function for instantiation_dependent_expression_p,
21095 below. Returns non-zero if a dependent subexpression is found. */
21098 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21103 /* We don't have to worry about decltype currently because decltype
21104 of an instantiation-dependent expr is a dependent type. This
21105 might change depending on the resolution of DR 1172. */
21106 *walk_subtrees
= false;
21109 enum tree_code code
= TREE_CODE (*tp
);
21112 /* Don't treat an argument list as dependent just because it has no
21120 /* A constant with a dependent initializer is dependent. */
21121 if (value_dependent_expression_p (*tp
))
21125 case TEMPLATE_PARM_INDEX
:
21128 /* Handle expressions with type operands. */
21132 case AT_ENCODE_EXPR
:
21134 tree op
= TREE_OPERAND (*tp
, 0);
21135 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21136 op
= TREE_TYPE (op
);
21139 if (dependent_type_p (op
))
21143 *walk_subtrees
= false;
21151 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21152 || (TRAIT_EXPR_TYPE2 (*tp
)
21153 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21155 *walk_subtrees
= false;
21158 case COMPONENT_REF
:
21159 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21160 /* In a template, finish_class_member_access_expr creates a
21161 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21162 type-dependent, so that we can check access control at
21163 instantiation time (PR 42277). See also Core issue 1273. */
21168 if (instantiation_dependent_scope_ref_p (*tp
))
21173 /* Treat statement-expressions as dependent. */
21181 if (type_dependent_expression_p (*tp
))
21187 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21188 sense defined by the ABI:
21190 "An expression is instantiation-dependent if it is type-dependent
21191 or value-dependent, or it has a subexpression that is type-dependent
21192 or value-dependent." */
21195 instantiation_dependent_expression_p (tree expression
)
21199 if (!processing_template_decl
)
21202 if (expression
== error_mark_node
)
21205 result
= cp_walk_tree_without_duplicates (&expression
,
21206 instantiation_dependent_r
, NULL
);
21207 return result
!= NULL_TREE
;
21210 /* Like type_dependent_expression_p, but it also works while not processing
21211 a template definition, i.e. during substitution or mangling. */
21214 type_dependent_expression_p_push (tree expr
)
21217 ++processing_template_decl
;
21218 b
= type_dependent_expression_p (expr
);
21219 --processing_template_decl
;
21223 /* Returns TRUE if ARGS contains a type-dependent expression. */
21226 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21231 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21233 if (type_dependent_expression_p (arg
))
21239 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21240 expressions) contains any type-dependent expressions. */
21243 any_type_dependent_elements_p (const_tree list
)
21245 for (; list
; list
= TREE_CHAIN (list
))
21246 if (type_dependent_expression_p (TREE_VALUE (list
)))
21252 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21253 expressions) contains any value-dependent expressions. */
21256 any_value_dependent_elements_p (const_tree list
)
21258 for (; list
; list
= TREE_CHAIN (list
))
21259 if (value_dependent_expression_p (TREE_VALUE (list
)))
21265 /* Returns TRUE if the ARG (a template argument) is dependent. */
21268 dependent_template_arg_p (tree arg
)
21270 if (!processing_template_decl
)
21273 /* Assume a template argument that was wrongly written by the user
21274 is dependent. This is consistent with what
21275 any_dependent_template_arguments_p [that calls this function]
21277 if (!arg
|| arg
== error_mark_node
)
21280 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21281 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21283 if (TREE_CODE (arg
) == TEMPLATE_DECL
21284 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21285 return dependent_template_p (arg
);
21286 else if (ARGUMENT_PACK_P (arg
))
21288 tree args
= ARGUMENT_PACK_ARGS (arg
);
21289 int i
, len
= TREE_VEC_LENGTH (args
);
21290 for (i
= 0; i
< len
; ++i
)
21292 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21298 else if (TYPE_P (arg
))
21299 return dependent_type_p (arg
);
21301 return (type_dependent_expression_p (arg
)
21302 || value_dependent_expression_p (arg
));
21305 /* Returns true if ARGS (a collection of template arguments) contains
21306 any types that require structural equality testing. */
21309 any_template_arguments_need_structural_equality_p (tree args
)
21316 if (args
== error_mark_node
)
21319 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21321 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21322 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21324 tree arg
= TREE_VEC_ELT (level
, j
);
21325 tree packed_args
= NULL_TREE
;
21328 if (ARGUMENT_PACK_P (arg
))
21330 /* Look inside the argument pack. */
21331 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21332 len
= TREE_VEC_LENGTH (packed_args
);
21335 for (k
= 0; k
< len
; ++k
)
21338 arg
= TREE_VEC_ELT (packed_args
, k
);
21340 if (error_operand_p (arg
))
21342 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21344 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21346 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21347 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21356 /* Returns true if ARGS (a collection of template arguments) contains
21357 any dependent arguments. */
21360 any_dependent_template_arguments_p (const_tree args
)
21367 if (args
== error_mark_node
)
21370 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21372 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21373 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21374 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21381 /* Returns TRUE if the template TMPL is dependent. */
21384 dependent_template_p (tree tmpl
)
21386 if (TREE_CODE (tmpl
) == OVERLOAD
)
21390 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21392 tmpl
= OVL_NEXT (tmpl
);
21397 /* Template template parameters are dependent. */
21398 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21399 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21401 /* So are names that have not been looked up. */
21402 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21404 /* So are member templates of dependent classes. */
21405 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21406 return dependent_type_p (DECL_CONTEXT (tmpl
));
21410 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21413 dependent_template_id_p (tree tmpl
, tree args
)
21415 return (dependent_template_p (tmpl
)
21416 || any_dependent_template_arguments_p (args
));
21419 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21423 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21427 if (!processing_template_decl
)
21430 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21432 tree decl
= TREE_VEC_ELT (declv
, i
);
21433 tree init
= TREE_VEC_ELT (initv
, i
);
21434 tree cond
= TREE_VEC_ELT (condv
, i
);
21435 tree incr
= TREE_VEC_ELT (incrv
, i
);
21437 if (type_dependent_expression_p (decl
))
21440 if (init
&& type_dependent_expression_p (init
))
21443 if (type_dependent_expression_p (cond
))
21446 if (COMPARISON_CLASS_P (cond
)
21447 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21448 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21451 if (TREE_CODE (incr
) == MODOP_EXPR
)
21453 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21454 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21457 else if (type_dependent_expression_p (incr
))
21459 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21461 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21463 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21465 tree t
= TREE_OPERAND (incr
, 1);
21466 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21467 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21476 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21477 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21478 no such TYPE can be found. Note that this function peers inside
21479 uninstantiated templates and therefore should be used only in
21480 extremely limited situations. ONLY_CURRENT_P restricts this
21481 peering to the currently open classes hierarchy (which is required
21482 when comparing types). */
21485 resolve_typename_type (tree type
, bool only_current_p
)
21494 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21496 scope
= TYPE_CONTEXT (type
);
21497 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21498 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21499 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21500 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21501 identifier of the TYPENAME_TYPE anymore.
21502 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21503 TYPENAME_TYPE instead, we avoid messing up with a possible
21504 typedef variant case. */
21505 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21507 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21508 it first before we can figure out what NAME refers to. */
21509 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21511 if (TYPENAME_IS_RESOLVING_P (scope
))
21512 /* Given a class template A with a dependent base with nested type C,
21513 typedef typename A::C::C C will land us here, as trying to resolve
21514 the initial A::C leads to the local C typedef, which leads back to
21515 A::C::C. So we break the recursion now. */
21518 scope
= resolve_typename_type (scope
, only_current_p
);
21520 /* If we don't know what SCOPE refers to, then we cannot resolve the
21522 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21524 /* If the SCOPE is a template type parameter, we have no way of
21525 resolving the name. */
21526 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21528 /* If the SCOPE is not the current instantiation, there's no reason
21529 to look inside it. */
21530 if (only_current_p
&& !currently_open_class (scope
))
21532 /* If this is a typedef, we don't want to look inside (c++/11987). */
21533 if (typedef_variant_p (type
))
21535 /* If SCOPE isn't the template itself, it will not have a valid
21536 TYPE_FIELDS list. */
21537 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21538 /* scope is either the template itself or a compatible instantiation
21539 like X<T>, so look up the name in the original template. */
21540 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
21542 /* scope is a partial instantiation, so we can't do the lookup or we
21543 will lose the template arguments. */
21545 /* Enter the SCOPE so that name lookup will be resolved as if we
21546 were in the class definition. In particular, SCOPE will no
21547 longer be considered a dependent type. */
21548 pushed_scope
= push_scope (scope
);
21549 /* Look up the declaration. */
21550 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
21551 tf_warning_or_error
);
21553 result
= NULL_TREE
;
21555 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21556 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21559 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
21560 && TREE_CODE (decl
) == TYPE_DECL
)
21562 result
= TREE_TYPE (decl
);
21563 if (result
== error_mark_node
)
21564 result
= NULL_TREE
;
21566 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
21567 && DECL_CLASS_TEMPLATE_P (decl
))
21571 /* Obtain the template and the arguments. */
21572 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
21573 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
21574 /* Instantiate the template. */
21575 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
21576 /*entering_scope=*/0,
21577 tf_error
| tf_user
);
21578 if (result
== error_mark_node
)
21579 result
= NULL_TREE
;
21582 /* Leave the SCOPE. */
21584 pop_scope (pushed_scope
);
21586 /* If we failed to resolve it, return the original typename. */
21590 /* If lookup found a typename type, resolve that too. */
21591 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
21593 /* Ill-formed programs can cause infinite recursion here, so we
21594 must catch that. */
21595 TYPENAME_IS_RESOLVING_P (type
) = 1;
21596 result
= resolve_typename_type (result
, only_current_p
);
21597 TYPENAME_IS_RESOLVING_P (type
) = 0;
21600 /* Qualify the resulting type. */
21601 quals
= cp_type_quals (type
);
21603 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
21608 /* EXPR is an expression which is not type-dependent. Return a proxy
21609 for EXPR that can be used to compute the types of larger
21610 expressions containing EXPR. */
21613 build_non_dependent_expr (tree expr
)
21617 #ifdef ENABLE_CHECKING
21618 /* Try to get a constant value for all non-dependent expressions in
21619 order to expose bugs in *_dependent_expression_p and constexpr. */
21620 if (cxx_dialect
>= cxx11
)
21621 maybe_constant_value (fold_non_dependent_expr_sfinae (expr
, tf_none
));
21624 /* Preserve OVERLOADs; the functions must be available to resolve
21627 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
21628 inner_expr
= stmt_expr_value_expr (inner_expr
);
21629 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
21630 inner_expr
= TREE_OPERAND (inner_expr
, 0);
21631 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
21632 inner_expr
= TREE_OPERAND (inner_expr
, 1);
21633 if (is_overloaded_fn (inner_expr
)
21634 || TREE_CODE (inner_expr
) == OFFSET_REF
)
21636 /* There is no need to return a proxy for a variable. */
21639 /* Preserve string constants; conversions from string constants to
21640 "char *" are allowed, even though normally a "const char *"
21641 cannot be used to initialize a "char *". */
21642 if (TREE_CODE (expr
) == STRING_CST
)
21644 /* Preserve void and arithmetic constants, as an optimization -- there is no
21645 reason to create a new node. */
21646 if (TREE_CODE (expr
) == VOID_CST
21647 || TREE_CODE (expr
) == INTEGER_CST
21648 || TREE_CODE (expr
) == REAL_CST
)
21650 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21651 There is at least one place where we want to know that a
21652 particular expression is a throw-expression: when checking a ?:
21653 expression, there are special rules if the second or third
21654 argument is a throw-expression. */
21655 if (TREE_CODE (expr
) == THROW_EXPR
)
21658 /* Don't wrap an initializer list, we need to be able to look inside. */
21659 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
21662 /* Don't wrap a dummy object, we need to be able to test for it. */
21663 if (is_dummy_object (expr
))
21666 if (TREE_CODE (expr
) == COND_EXPR
)
21667 return build3 (COND_EXPR
,
21669 TREE_OPERAND (expr
, 0),
21670 (TREE_OPERAND (expr
, 1)
21671 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
21672 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
21673 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
21674 if (TREE_CODE (expr
) == COMPOUND_EXPR
21675 && !COMPOUND_EXPR_OVERLOADED (expr
))
21676 return build2 (COMPOUND_EXPR
,
21678 TREE_OPERAND (expr
, 0),
21679 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
21681 /* If the type is unknown, it can't really be non-dependent */
21682 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
21684 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21685 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
21688 /* ARGS is a vector of expressions as arguments to a function call.
21689 Replace the arguments with equivalent non-dependent expressions.
21690 This modifies ARGS in place. */
21693 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
21698 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
21700 tree newarg
= build_non_dependent_expr (arg
);
21702 (*args
)[ix
] = newarg
;
21706 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21707 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21711 make_auto_1 (tree name
)
21713 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
21714 TYPE_NAME (au
) = build_decl (input_location
,
21715 TYPE_DECL
, name
, au
);
21716 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
21717 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
21718 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
21719 TYPE_NAME (au
), NULL_TREE
);
21720 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
21721 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
21722 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
21728 make_decltype_auto (void)
21730 return make_auto_1 (get_identifier ("decltype(auto)"));
21736 return make_auto_1 (get_identifier ("auto"));
21739 /* Given type ARG, return std::initializer_list<ARG>. */
21744 tree std_init_list
= namespace_binding
21745 (get_identifier ("initializer_list"), std_node
);
21747 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
21749 error ("deducing from brace-enclosed initializer list requires "
21750 "#include <initializer_list>");
21751 return error_mark_node
;
21753 argvec
= make_tree_vec (1);
21754 TREE_VEC_ELT (argvec
, 0) = arg
;
21755 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
21756 NULL_TREE
, 0, tf_warning_or_error
);
21759 /* Replace auto in TYPE with std::initializer_list<auto>. */
21762 listify_autos (tree type
, tree auto_node
)
21764 tree init_auto
= listify (auto_node
);
21765 tree argvec
= make_tree_vec (1);
21766 TREE_VEC_ELT (argvec
, 0) = init_auto
;
21767 if (processing_template_decl
)
21768 argvec
= add_to_template_args (current_template_args (), argvec
);
21769 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21772 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
21773 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
21776 do_auto_deduction (tree type
, tree init
, tree auto_node
)
21780 if (init
== error_mark_node
)
21781 return error_mark_node
;
21783 if (type_dependent_expression_p (init
))
21784 /* Defining a subset of type-dependent expressions that we can deduce
21785 from ahead of time isn't worth the trouble. */
21788 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
21789 with either a new invented type template parameter U or, if the
21790 initializer is a braced-init-list (8.5.4), with
21791 std::initializer_list<U>. */
21792 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
21793 type
= listify_autos (type
, auto_node
);
21795 init
= resolve_nondeduced_context (init
);
21797 targs
= make_tree_vec (1);
21798 if (AUTO_IS_DECLTYPE (auto_node
))
21800 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
21801 && !REF_PARENTHESIZED_P (init
)));
21802 TREE_VEC_ELT (targs
, 0)
21803 = finish_decltype_type (init
, id
, tf_warning_or_error
);
21804 if (type
!= auto_node
)
21806 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
21807 return error_mark_node
;
21812 tree parms
= build_tree_list (NULL_TREE
, type
);
21813 tree tparms
= make_tree_vec (1);
21816 TREE_VEC_ELT (tparms
, 0)
21817 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
21818 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
21819 DEDUCE_CALL
, LOOKUP_NORMAL
,
21820 NULL
, /*explain_p=*/false);
21823 if (processing_template_decl
)
21824 /* Try again at instantiation time. */
21826 if (type
&& type
!= error_mark_node
)
21827 /* If type is error_mark_node a diagnostic must have been
21828 emitted by now. Also, having a mention to '<type error>'
21829 in the diagnostic is not really useful to the user. */
21831 if (cfun
&& auto_node
== current_function_auto_return_pattern
21832 && LAMBDA_FUNCTION_P (current_function_decl
))
21833 error ("unable to deduce lambda return type from %qE", init
);
21835 error ("unable to deduce %qT from %qE", type
, init
);
21837 return error_mark_node
;
21841 /* If the list of declarators contains more than one declarator, the type
21842 of each declared variable is determined as described above. If the
21843 type deduced for the template parameter U is not the same in each
21844 deduction, the program is ill-formed. */
21845 if (TREE_TYPE (auto_node
)
21846 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
21848 if (cfun
&& auto_node
== current_function_auto_return_pattern
21849 && LAMBDA_FUNCTION_P (current_function_decl
))
21850 error ("inconsistent types %qT and %qT deduced for "
21851 "lambda return type", TREE_TYPE (auto_node
),
21852 TREE_VEC_ELT (targs
, 0));
21854 error ("inconsistent deduction for %qT: %qT and then %qT",
21855 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
21856 return error_mark_node
;
21858 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
21860 if (processing_template_decl
)
21861 targs
= add_to_template_args (current_template_args (), targs
);
21862 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
21865 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
21869 splice_late_return_type (tree type
, tree late_return_type
)
21873 if (late_return_type
== NULL_TREE
)
21875 argvec
= make_tree_vec (1);
21876 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
21877 if (processing_template_parmlist
)
21878 /* For a late-specified return type in a template type-parameter, we
21879 need to add a dummy argument level for its parmlist. */
21880 argvec
= add_to_template_args
21881 (make_tree_vec (processing_template_parmlist
), argvec
);
21882 if (current_template_parms
)
21883 argvec
= add_to_template_args (current_template_args (), argvec
);
21884 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21887 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
21888 'decltype(auto)'. */
21891 is_auto (const_tree type
)
21893 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
21894 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
21895 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
21901 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
21902 a use of `auto'. Returns NULL_TREE otherwise. */
21905 type_uses_auto (tree type
)
21907 return find_type_usage (type
, is_auto
);
21910 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
21911 'decltype(auto)' or a concept. */
21914 is_auto_or_concept (const_tree type
)
21916 return is_auto (type
); // or concept
21919 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
21920 a concept identifier) iff TYPE contains a use of a generic type. Returns
21921 NULL_TREE otherwise. */
21924 type_uses_auto_or_concept (tree type
)
21926 return find_type_usage (type
, is_auto_or_concept
);
21930 /* For a given template T, return the vector of typedefs referenced
21931 in T for which access check is needed at T instantiation time.
21932 T is either a FUNCTION_DECL or a RECORD_TYPE.
21933 Those typedefs were added to T by the function
21934 append_type_to_template_for_access_check. */
21936 vec
<qualified_typedef_usage_t
, va_gc
> *
21937 get_types_needing_access_check (tree t
)
21940 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
21942 if (!t
|| t
== error_mark_node
)
21945 if (!(ti
= get_template_info (t
)))
21948 if (CLASS_TYPE_P (t
)
21949 || TREE_CODE (t
) == FUNCTION_DECL
)
21951 if (!TI_TEMPLATE (ti
))
21954 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
21960 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
21961 tied to T. That list of typedefs will be access checked at
21962 T instantiation time.
21963 T is either a FUNCTION_DECL or a RECORD_TYPE.
21964 TYPE_DECL is a TYPE_DECL node representing a typedef.
21965 SCOPE is the scope through which TYPE_DECL is accessed.
21966 LOCATION is the location of the usage point of TYPE_DECL.
21968 This function is a subroutine of
21969 append_type_to_template_for_access_check. */
21972 append_type_to_template_for_access_check_1 (tree t
,
21975 location_t location
)
21977 qualified_typedef_usage_t typedef_usage
;
21980 if (!t
|| t
== error_mark_node
)
21983 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
21984 || CLASS_TYPE_P (t
))
21986 && TREE_CODE (type_decl
) == TYPE_DECL
21989 if (!(ti
= get_template_info (t
)))
21992 gcc_assert (TI_TEMPLATE (ti
));
21994 typedef_usage
.typedef_decl
= type_decl
;
21995 typedef_usage
.context
= scope
;
21996 typedef_usage
.locus
= location
;
21998 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22001 /* Append TYPE_DECL to the template TEMPL.
22002 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22003 At TEMPL instanciation time, TYPE_DECL will be checked to see
22004 if it can be accessed through SCOPE.
22005 LOCATION is the location of the usage point of TYPE_DECL.
22007 e.g. consider the following code snippet:
22014 template<class U> struct S
22016 C::myint mi; // <-- usage point of the typedef C::myint
22021 At S<char> instantiation time, we need to check the access of C::myint
22022 In other words, we need to check the access of the myint typedef through
22023 the C scope. For that purpose, this function will add the myint typedef
22024 and the scope C through which its being accessed to a list of typedefs
22025 tied to the template S. That list will be walked at template instantiation
22026 time and access check performed on each typedefs it contains.
22027 Note that this particular code snippet should yield an error because
22028 myint is private to C. */
22031 append_type_to_template_for_access_check (tree templ
,
22034 location_t location
)
22036 qualified_typedef_usage_t
*iter
;
22039 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22041 /* Make sure we don't append the type to the template twice. */
22042 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22043 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22046 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22050 /* Convert the generic type parameters in PARM that match the types given in the
22051 range [START_IDX, END_IDX) from the current_template_parms into generic type
22055 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22057 tree current
= current_template_parms
;
22058 int depth
= TMPL_PARMS_DEPTH (current
);
22059 current
= INNERMOST_TEMPLATE_PARMS (current
);
22060 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22062 for (int i
= 0; i
< start_idx
; ++i
)
22063 TREE_VEC_ELT (replacement
, i
)
22064 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22066 for (int i
= start_idx
; i
< end_idx
; ++i
)
22068 /* Create a distinct parameter pack type from the current parm and add it
22069 to the replacement args to tsubst below into the generic function
22072 tree o
= TREE_TYPE (TREE_VALUE
22073 (TREE_VEC_ELT (current
, i
)));
22074 tree t
= copy_type (o
);
22075 TEMPLATE_TYPE_PARM_INDEX (t
)
22076 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22078 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22079 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22080 TYPE_MAIN_VARIANT (t
) = t
;
22081 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22082 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22083 TREE_VEC_ELT (replacement
, i
) = t
;
22084 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22087 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22088 TREE_VEC_ELT (replacement
, i
)
22089 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22091 /* If there are more levels then build up the replacement with the outer
22094 replacement
= add_to_template_args (template_parms_to_args
22095 (TREE_CHAIN (current_template_parms
)),
22098 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22102 /* Set up the hash tables for template instantiations. */
22105 init_template_processing (void)
22107 decl_specializations
= htab_create_ggc (37,
22108 hash_specialization
,
22109 eq_specializations
,
22111 type_specializations
= htab_create_ggc (37,
22112 hash_specialization
,
22113 eq_specializations
,
22117 /* Print stats about the template hash tables for -fstats. */
22120 print_template_statistics (void)
22122 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22123 "%f collisions\n", (long) htab_size (decl_specializations
),
22124 (long) htab_elements (decl_specializations
),
22125 htab_collisions (decl_specializations
));
22126 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22127 "%f collisions\n", (long) htab_size (type_specializations
),
22128 (long) htab_elements (type_specializations
),
22129 htab_collisions (type_specializations
));
22132 #include "gt-cp-pt.h"