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 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
4423 /* You can't have a function template declaration in a local
4424 scope, nor you can you define a member of a class template in a
4428 if (TREE_CODE (decl
) == TYPE_DECL
4430 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4431 /* A lambda doesn't have an explicit declaration; don't complain
4432 about the parms of the enclosing class. */
4435 if (current_class_type
4436 && !TYPE_BEING_DEFINED (current_class_type
)
4437 && DECL_LANG_SPECIFIC (decl
)
4438 && DECL_DECLARES_FUNCTION_P (decl
)
4439 /* If this is either a friend defined in the scope of the class
4440 or a member function. */
4441 && (DECL_FUNCTION_MEMBER_P (decl
)
4442 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4443 : DECL_FRIEND_CONTEXT (decl
)
4444 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4446 /* And, if it was a member function, it really was defined in
4447 the scope of the class. */
4448 && (!DECL_FUNCTION_MEMBER_P (decl
)
4449 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4450 /* We already checked these parameters when the template was
4451 declared, so there's no need to do it again now. This function
4452 was defined in class scope, but we're processing its body now
4453 that the class is complete. */
4456 /* Core issue 226 (C++0x only): the following only applies to class
4459 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4463 If a template-parameter has a default template-argument, all
4464 subsequent template-parameters shall have a default
4465 template-argument supplied. */
4466 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4468 tree inner_parms
= TREE_VALUE (parm_level
);
4469 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4470 int seen_def_arg_p
= 0;
4473 for (i
= 0; i
< ntparms
; ++i
)
4475 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4477 if (parm
== error_mark_node
)
4480 if (TREE_PURPOSE (parm
))
4482 else if (seen_def_arg_p
4483 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4485 error ("no default argument for %qD", TREE_VALUE (parm
));
4486 /* For better subsequent error-recovery, we indicate that
4487 there should have been a default argument. */
4488 TREE_PURPOSE (parm
) = error_mark_node
;
4491 else if (!is_partial
4493 /* Don't complain about an enclosing partial
4495 && parm_level
== parms
4496 && TREE_CODE (decl
) == TYPE_DECL
4498 && template_parameter_pack_p (TREE_VALUE (parm
))
4499 /* A fixed parameter pack will be partially
4500 instantiated into a fixed length list. */
4501 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4503 /* A primary class template can only have one
4504 parameter pack, at the end of the template
4507 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
4508 error ("parameter pack %qE must be at the end of the"
4509 " template parameter list", TREE_VALUE (parm
));
4511 error ("parameter pack %qT must be at the end of the"
4512 " template parameter list",
4513 TREE_TYPE (TREE_VALUE (parm
)));
4515 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4523 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4527 /* For an ordinary class template, default template arguments are
4528 allowed at the innermost level, e.g.:
4529 template <class T = int>
4531 but, in a partial specialization, they're not allowed even
4532 there, as we have in [temp.class.spec]:
4534 The template parameter list of a specialization shall not
4535 contain default template argument values.
4537 So, for a partial specialization, or for a function template
4538 (in C++98/C++03), we look at all of them. */
4541 /* But, for a primary class template that is not a partial
4542 specialization we look at all template parameters except the
4544 parms
= TREE_CHAIN (parms
);
4546 /* Figure out what error message to issue. */
4547 if (is_friend_decl
== 2)
4548 msg
= G_("default template arguments may not be used in function template "
4549 "friend re-declaration");
4550 else if (is_friend_decl
)
4551 msg
= G_("default template arguments may not be used in function template "
4552 "friend declarations");
4553 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4554 msg
= G_("default template arguments may not be used in function templates "
4555 "without -std=c++11 or -std=gnu++11");
4556 else if (is_partial
)
4557 msg
= G_("default template arguments may not be used in "
4558 "partial specializations");
4560 msg
= G_("default argument for template parameter for class enclosing %qD");
4562 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4563 /* If we're inside a class definition, there's no need to
4564 examine the parameters to the class itself. On the one
4565 hand, they will be checked when the class is defined, and,
4566 on the other, default arguments are valid in things like:
4567 template <class T = double>
4568 struct S { template <class U> void f(U); };
4569 Here the default argument for `S' has no bearing on the
4570 declaration of `f'. */
4571 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4573 /* Check everything. */
4574 last_level_to_check
= 0;
4576 for (parm_level
= parms
;
4577 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4578 parm_level
= TREE_CHAIN (parm_level
))
4580 tree inner_parms
= TREE_VALUE (parm_level
);
4584 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4585 for (i
= 0; i
< ntparms
; ++i
)
4587 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4590 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4595 if (is_friend_decl
== 2)
4602 /* Clear out the default argument so that we are not
4604 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
4608 /* At this point, if we're still interested in issuing messages,
4609 they must apply to classes surrounding the object declared. */
4611 msg
= G_("default argument for template parameter for class "
4618 /* Worker for push_template_decl_real, called via
4619 for_each_template_parm. DATA is really an int, indicating the
4620 level of the parameters we are interested in. If T is a template
4621 parameter of that level, return nonzero. */
4624 template_parm_this_level_p (tree t
, void* data
)
4626 int this_level
= *(int *)data
;
4629 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4630 level
= TEMPLATE_PARM_LEVEL (t
);
4632 level
= TEMPLATE_TYPE_LEVEL (t
);
4633 return level
== this_level
;
4636 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4637 parameters given by current_template_args, or reuses a
4638 previously existing one, if appropriate. Returns the DECL, or an
4639 equivalent one, if it is replaced via a call to duplicate_decls.
4641 If IS_FRIEND is true, DECL is a friend declaration. */
4644 push_template_decl_real (tree decl
, bool is_friend
)
4652 int new_template_p
= 0;
4653 /* True if the template is a member template, in the sense of
4655 bool member_template_p
= false;
4657 if (decl
== error_mark_node
|| !current_template_parms
)
4658 return error_mark_node
;
4660 /* See if this is a partial specialization. */
4661 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
4662 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
4663 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
4665 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
4669 /* For a friend, we want the context of the friend function, not
4670 the type of which it is a friend. */
4671 ctx
= CP_DECL_CONTEXT (decl
);
4672 else if (CP_DECL_CONTEXT (decl
)
4673 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4674 /* In the case of a virtual function, we want the class in which
4676 ctx
= CP_DECL_CONTEXT (decl
);
4678 /* Otherwise, if we're currently defining some class, the DECL
4679 is assumed to be a member of the class. */
4680 ctx
= current_scope ();
4682 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
4685 if (!DECL_CONTEXT (decl
))
4686 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
4688 /* See if this is a primary template. */
4689 if (is_friend
&& ctx
4690 && uses_template_parms_level (ctx
, processing_template_decl
))
4691 /* A friend template that specifies a class context, i.e.
4692 template <typename T> friend void A<T>::f();
4696 is_primary
= template_parm_scope_p ();
4700 if (DECL_CLASS_SCOPE_P (decl
))
4701 member_template_p
= true;
4702 if (TREE_CODE (decl
) == TYPE_DECL
4703 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
4705 error ("template class without a name");
4706 return error_mark_node
;
4708 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
4710 if (DECL_DESTRUCTOR_P (decl
))
4714 A destructor shall not be a member template. */
4715 error ("destructor %qD declared as member template", decl
);
4716 return error_mark_node
;
4718 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
4719 && (!prototype_p (TREE_TYPE (decl
))
4720 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
4721 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
4722 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
4723 == void_list_node
)))
4725 /* [basic.stc.dynamic.allocation]
4727 An allocation function can be a function
4728 template. ... Template allocation functions shall
4729 have two or more parameters. */
4730 error ("invalid template declaration of %qD", decl
);
4731 return error_mark_node
;
4734 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4735 && CLASS_TYPE_P (TREE_TYPE (decl
)))
4737 else if (TREE_CODE (decl
) == TYPE_DECL
4738 && TYPE_DECL_ALIAS_P (decl
))
4739 /* alias-declaration */
4740 gcc_assert (!DECL_ARTIFICIAL (decl
));
4743 error ("template declaration of %q#D", decl
);
4744 return error_mark_node
;
4748 /* Check to see that the rules regarding the use of default
4749 arguments are not being violated. */
4750 check_default_tmpl_args (decl
, current_template_parms
,
4751 is_primary
, is_partial
, /*is_friend_decl=*/0);
4753 /* Ensure that there are no parameter packs in the type of this
4754 declaration that have not been expanded. */
4755 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4757 /* Check each of the arguments individually to see if there are
4758 any bare parameter packs. */
4759 tree type
= TREE_TYPE (decl
);
4760 tree arg
= DECL_ARGUMENTS (decl
);
4761 tree argtype
= TYPE_ARG_TYPES (type
);
4763 while (arg
&& argtype
)
4765 if (!DECL_PACK_P (arg
)
4766 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
4768 /* This is a PARM_DECL that contains unexpanded parameter
4769 packs. We have already complained about this in the
4770 check_for_bare_parameter_packs call, so just replace
4771 these types with ERROR_MARK_NODE. */
4772 TREE_TYPE (arg
) = error_mark_node
;
4773 TREE_VALUE (argtype
) = error_mark_node
;
4776 arg
= DECL_CHAIN (arg
);
4777 argtype
= TREE_CHAIN (argtype
);
4780 /* Check for bare parameter packs in the return type and the
4781 exception specifiers. */
4782 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
4783 /* Errors were already issued, set return type to int
4784 as the frontend doesn't expect error_mark_node as
4786 TREE_TYPE (type
) = integer_type_node
;
4787 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
4788 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
4790 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
4791 && TYPE_DECL_ALIAS_P (decl
))
4792 ? DECL_ORIGINAL_TYPE (decl
)
4793 : TREE_TYPE (decl
)))
4795 TREE_TYPE (decl
) = error_mark_node
;
4796 return error_mark_node
;
4800 return process_partial_specialization (decl
);
4802 args
= current_template_args ();
4805 || TREE_CODE (ctx
) == FUNCTION_DECL
4806 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
4807 || (TREE_CODE (decl
) == TYPE_DECL
4808 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4809 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
4811 if (DECL_LANG_SPECIFIC (decl
)
4812 && DECL_TEMPLATE_INFO (decl
)
4813 && DECL_TI_TEMPLATE (decl
))
4814 tmpl
= DECL_TI_TEMPLATE (decl
);
4815 /* If DECL is a TYPE_DECL for a class-template, then there won't
4816 be DECL_LANG_SPECIFIC. The information equivalent to
4817 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4818 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4819 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
4820 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
4822 /* Since a template declaration already existed for this
4823 class-type, we must be redeclaring it here. Make sure
4824 that the redeclaration is valid. */
4825 redeclare_class_template (TREE_TYPE (decl
),
4826 current_template_parms
);
4827 /* We don't need to create a new TEMPLATE_DECL; just use the
4828 one we already had. */
4829 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
4833 tmpl
= build_template_decl (decl
, current_template_parms
,
4837 if (DECL_LANG_SPECIFIC (decl
)
4838 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4840 /* A specialization of a member template of a template
4842 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4843 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
4844 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
4850 tree a
, t
, current
, parms
;
4852 tree tinfo
= get_template_info (decl
);
4856 error ("template definition of non-template %q#D", decl
);
4857 return error_mark_node
;
4860 tmpl
= TI_TEMPLATE (tinfo
);
4862 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
4863 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
4864 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4865 && DECL_MEMBER_TEMPLATE_P (tmpl
))
4869 /* The declaration is a specialization of a member
4870 template, declared outside the class. Therefore, the
4871 innermost template arguments will be NULL, so we
4872 replace them with the arguments determined by the
4873 earlier call to check_explicit_specialization. */
4874 args
= DECL_TI_ARGS (decl
);
4877 = build_template_decl (decl
, current_template_parms
,
4879 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
4880 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
4881 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
4882 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
4883 DECL_TEMPLATE_INFO (new_tmpl
)
4884 = build_template_info (tmpl
, args
);
4886 register_specialization (new_tmpl
,
4887 most_general_template (tmpl
),
4893 /* Make sure the template headers we got make sense. */
4895 parms
= DECL_TEMPLATE_PARMS (tmpl
);
4896 i
= TMPL_PARMS_DEPTH (parms
);
4897 if (TMPL_ARGS_DEPTH (args
) != i
)
4899 error ("expected %d levels of template parms for %q#D, got %d",
4900 i
, decl
, TMPL_ARGS_DEPTH (args
));
4901 DECL_INTERFACE_KNOWN (decl
) = 1;
4902 return error_mark_node
;
4905 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
4907 a
= TMPL_ARGS_LEVEL (args
, i
);
4908 t
= INNERMOST_TEMPLATE_PARMS (parms
);
4910 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
4912 if (current
== decl
)
4913 error ("got %d template parameters for %q#D",
4914 TREE_VEC_LENGTH (a
), decl
);
4916 error ("got %d template parameters for %q#T",
4917 TREE_VEC_LENGTH (a
), current
);
4918 error (" but %d required", TREE_VEC_LENGTH (t
));
4919 /* Avoid crash in import_export_decl. */
4920 DECL_INTERFACE_KNOWN (decl
) = 1;
4921 return error_mark_node
;
4924 if (current
== decl
)
4926 else if (current
== NULL_TREE
)
4927 /* Can happen in erroneous input. */
4930 current
= get_containing_scope (current
);
4933 /* Check that the parms are used in the appropriate qualifying scopes
4934 in the declarator. */
4935 if (!comp_template_args
4937 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
4940 template arguments to %qD do not match original template %qD",
4941 decl
, DECL_TEMPLATE_RESULT (tmpl
));
4942 if (!uses_template_parms (TI_ARGS (tinfo
)))
4943 inform (input_location
, "use template<> for an explicit specialization");
4944 /* Avoid crash in import_export_decl. */
4945 DECL_INTERFACE_KNOWN (decl
) = 1;
4946 return error_mark_node
;
4950 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4951 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
4953 /* Push template declarations for global functions and types. Note
4954 that we do not try to push a global template friend declared in a
4955 template class; such a thing may well depend on the template
4956 parameters of the class. */
4957 if (new_template_p
&& !ctx
4958 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
4960 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
4961 if (tmpl
== error_mark_node
)
4962 return error_mark_node
;
4964 /* Hide template friend classes that haven't been declared yet. */
4965 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
4967 DECL_ANTICIPATED (tmpl
) = 1;
4968 DECL_FRIEND_P (tmpl
) = 1;
4974 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
4977 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
4978 if (DECL_CONV_FN_P (tmpl
))
4980 int depth
= TMPL_PARMS_DEPTH (parms
);
4982 /* It is a conversion operator. See if the type converted to
4983 depends on innermost template operands. */
4985 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
4987 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
4990 /* Give template template parms a DECL_CONTEXT of the template
4991 for which they are a parameter. */
4992 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
4993 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
4995 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
4996 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
4997 DECL_CONTEXT (parm
) = tmpl
;
5001 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5002 back to its most general template. If TMPL is a specialization,
5003 ARGS may only have the innermost set of arguments. Add the missing
5004 argument levels if necessary. */
5005 if (DECL_TEMPLATE_INFO (tmpl
))
5006 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5008 info
= build_template_info (tmpl
, args
);
5010 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5011 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5014 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5015 retrofit_lang_decl (decl
);
5016 if (DECL_LANG_SPECIFIC (decl
))
5017 DECL_TEMPLATE_INFO (decl
) = info
;
5020 return DECL_TEMPLATE_RESULT (tmpl
);
5024 push_template_decl (tree decl
)
5026 return push_template_decl_real (decl
, false);
5029 /* FN is an inheriting constructor that inherits from the constructor
5030 template INHERITED; turn FN into a constructor template with a matching
5034 add_inherited_template_parms (tree fn
, tree inherited
)
5037 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5038 inner_parms
= copy_node (inner_parms
);
5040 = tree_cons (size_int (processing_template_decl
+ 1),
5041 inner_parms
, current_template_parms
);
5042 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5043 tree args
= template_parms_to_args (parms
);
5044 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5045 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5046 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5047 DECL_ARTIFICIAL (tmpl
) = true;
5048 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5052 /* Called when a class template TYPE is redeclared with the indicated
5053 template PARMS, e.g.:
5055 template <class T> struct S;
5056 template <class T> struct S {}; */
5059 redeclare_class_template (tree type
, tree parms
)
5065 if (!TYPE_TEMPLATE_INFO (type
))
5067 error ("%qT is not a template type", type
);
5071 tmpl
= TYPE_TI_TEMPLATE (type
);
5072 if (!PRIMARY_TEMPLATE_P (tmpl
))
5073 /* The type is nested in some template class. Nothing to worry
5074 about here; there are no new template parameters for the nested
5080 error ("template specifiers not specified in declaration of %qD",
5085 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5086 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5088 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5090 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5091 "redeclared with %d template parameter",
5092 "redeclared with %d template parameters",
5093 TREE_VEC_LENGTH (parms
));
5094 inform_n (input_location
, TREE_VEC_LENGTH (tmpl_parms
),
5095 "previous declaration %q+D used %d template parameter",
5096 "previous declaration %q+D used %d template parameters",
5097 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5101 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5108 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5109 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5112 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5113 if (error_operand_p (tmpl_parm
))
5116 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5117 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5118 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5120 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5122 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5123 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5124 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5125 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5126 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5127 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5128 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5129 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5130 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5132 error ("template parameter %q+#D", tmpl_parm
);
5133 error ("redeclared here as %q#D", parm
);
5137 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5139 /* We have in [temp.param]:
5141 A template-parameter may not be given default arguments
5142 by two different declarations in the same scope. */
5143 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5144 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5145 "original definition appeared here");
5149 if (parm_default
!= NULL_TREE
)
5150 /* Update the previous template parameters (which are the ones
5151 that will really count) with the new default value. */
5152 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5153 else if (tmpl_default
!= NULL_TREE
)
5154 /* Update the new parameters, too; they'll be used as the
5155 parameters for any members. */
5156 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5162 /* Simplify EXPR if it is a non-dependent expression. Returns the
5163 (possibly simplified) expression. */
5166 fold_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5168 if (expr
== NULL_TREE
)
5171 /* If we're in a template, but EXPR isn't value dependent, simplify
5172 it. We're supposed to treat:
5174 template <typename T> void f(T[1 + 1]);
5175 template <typename T> void f(T[2]);
5177 as two declarations of the same function, for example. */
5178 if (processing_template_decl
5179 && !instantiation_dependent_expression_p (expr
)
5180 && potential_constant_expression (expr
))
5182 HOST_WIDE_INT saved_processing_template_decl
;
5184 saved_processing_template_decl
= processing_template_decl
;
5185 processing_template_decl
= 0;
5186 expr
= tsubst_copy_and_build (expr
,
5189 /*in_decl=*/NULL_TREE
,
5190 /*function_p=*/false,
5191 /*integral_constant_expression_p=*/true);
5192 processing_template_decl
= saved_processing_template_decl
;
5198 fold_non_dependent_expr (tree expr
)
5200 return fold_non_dependent_expr_sfinae (expr
, tf_error
);
5203 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5204 template declaration, or a TYPE_DECL for an alias declaration. */
5207 alias_type_or_template_p (tree t
)
5211 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5214 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5215 || DECL_ALIAS_TEMPLATE_P (t
));
5218 /* Return TRUE iff is a specialization of an alias template. */
5221 alias_template_specialization_p (const_tree t
)
5227 && TYPE_TEMPLATE_INFO (t
)
5228 && PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (t
))
5229 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (t
)));
5232 /* Return the number of innermost template parameters in TMPL. */
5235 num_innermost_template_parms (tree tmpl
)
5237 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5238 return TREE_VEC_LENGTH (parms
);
5241 /* Return either TMPL or another template that it is equivalent to under DR
5242 1286: An alias that just changes the name of a template is equivalent to
5243 the other template. */
5246 get_underlying_template (tree tmpl
)
5248 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5249 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5251 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5252 if (TYPE_TEMPLATE_INFO (result
))
5254 tree sub
= TYPE_TI_TEMPLATE (result
);
5255 if (PRIMARY_TEMPLATE_P (sub
)
5256 && (num_innermost_template_parms (tmpl
)
5257 == num_innermost_template_parms (sub
)))
5259 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5260 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5261 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5263 /* The alias type is equivalent to the pattern of the
5264 underlying template, so strip the alias. */
5274 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5275 must be a function or a pointer-to-function type, as specified
5276 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5277 and check that the resulting function has external linkage. */
5280 convert_nontype_argument_function (tree type
, tree expr
,
5281 tsubst_flags_t complain
)
5285 linkage_kind linkage
;
5287 fn
= instantiate_type (type
, fns
, tf_none
);
5288 if (fn
== error_mark_node
)
5289 return error_mark_node
;
5292 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5293 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5294 if (BASELINK_P (fn_no_ptr
))
5295 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5297 /* [temp.arg.nontype]/1
5299 A template-argument for a non-type, non-template template-parameter
5302 -- the address of an object or function with external [C++11: or
5303 internal] linkage. */
5305 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5307 if (complain
& tf_error
)
5309 error ("%qE is not a valid template argument for type %qT",
5311 if (TYPE_PTR_P (type
))
5312 error ("it must be the address of a function with "
5313 "external linkage");
5315 error ("it must be the name of a function with "
5316 "external linkage");
5321 linkage
= decl_linkage (fn_no_ptr
);
5322 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5324 if (complain
& tf_error
)
5326 if (cxx_dialect
>= cxx11
)
5327 error ("%qE is not a valid template argument for type %qT "
5328 "because %qD has no linkage",
5329 expr
, type
, fn_no_ptr
);
5331 error ("%qE is not a valid template argument for type %qT "
5332 "because %qD does not have external linkage",
5333 expr
, type
, fn_no_ptr
);
5341 /* Subroutine of convert_nontype_argument.
5342 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5343 Emit an error otherwise. */
5346 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5347 tsubst_flags_t complain
)
5350 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5352 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5354 if (processing_template_decl
5355 && TREE_CODE (expr
) == ADDR_EXPR
5356 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
5358 if (complain
& tf_error
)
5360 error ("%qE is not a valid template argument for type %qT",
5362 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5367 /* Returns TRUE iff the address of OP is value-dependent.
5369 14.6.2.4 [temp.dep.temp]:
5370 A non-integral non-type template-argument is dependent if its type is
5371 dependent or it has either of the following forms
5374 and contains a nested-name-specifier which specifies a class-name that
5375 names a dependent type.
5377 We generalize this to just say that the address of a member of a
5378 dependent class is value-dependent; the above doesn't cover the
5379 address of a static data member named with an unqualified-id. */
5382 has_value_dependent_address (tree op
)
5384 /* We could use get_inner_reference here, but there's no need;
5385 this is only relevant for template non-type arguments, which
5386 can only be expressed as &id-expression. */
5389 tree ctx
= CP_DECL_CONTEXT (op
);
5390 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5397 /* The next set of functions are used for providing helpful explanatory
5398 diagnostics for failed overload resolution. Their messages should be
5399 indented by two spaces for consistency with the messages in
5403 unify_success (bool /*explain_p*/)
5409 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5412 inform (input_location
,
5413 " couldn't deduce template parameter %qD", parm
);
5418 unify_invalid (bool /*explain_p*/)
5424 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5427 inform (input_location
,
5428 " types %qT and %qT have incompatible cv-qualifiers",
5434 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5437 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5442 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5445 inform (input_location
,
5446 " template parameter %qD is not a parameter pack, but "
5453 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5456 inform (input_location
,
5457 " template argument %qE does not match "
5458 "pointer-to-member constant %qE",
5464 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5467 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5472 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5475 inform (input_location
,
5476 " inconsistent parameter pack deduction with %qT and %qT",
5482 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5487 inform (input_location
,
5488 " deduced conflicting types for parameter %qT (%qT and %qT)",
5489 parm
, first
, second
);
5491 inform (input_location
,
5492 " deduced conflicting values for non-type parameter "
5493 "%qE (%qE and %qE)", parm
, first
, second
);
5499 unify_vla_arg (bool explain_p
, tree arg
)
5502 inform (input_location
,
5503 " variable-sized array type %qT is not "
5504 "a valid template argument",
5510 unify_method_type_error (bool explain_p
, tree arg
)
5513 inform (input_location
,
5514 " member function type %qT is not a valid template argument",
5520 unify_arity (bool explain_p
, int have
, int wanted
)
5523 inform_n (input_location
, wanted
,
5524 " candidate expects %d argument, %d provided",
5525 " candidate expects %d arguments, %d provided",
5531 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5533 return unify_arity (explain_p
, have
, wanted
);
5537 unify_too_few_arguments (bool explain_p
, int have
, int wanted
)
5539 return unify_arity (explain_p
, have
, wanted
);
5543 unify_arg_conversion (bool explain_p
, tree to_type
,
5544 tree from_type
, tree arg
)
5547 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5548 " cannot convert %qE (type %qT) to type %qT",
5549 arg
, from_type
, to_type
);
5554 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5555 tree parm
, tree arg
)
5560 case tbr_ambiguous_baseclass
:
5561 inform (input_location
, " %qT is an ambiguous base class of %qT",
5565 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5572 unify_inconsistent_template_template_parameters (bool explain_p
)
5575 inform (input_location
,
5576 " template parameters of a template template argument are "
5577 "inconsistent with other deduced template arguments");
5582 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5585 inform (input_location
,
5586 " can't deduce a template for %qT from non-template type %qT",
5592 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5595 inform (input_location
,
5596 " template argument %qE does not match %qD", arg
, parm
);
5601 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5604 inform (input_location
,
5605 " could not resolve address from overloaded function %qE",
5610 /* Attempt to convert the non-type template parameter EXPR to the
5611 indicated TYPE. If the conversion is successful, return the
5612 converted value. If the conversion is unsuccessful, return
5613 NULL_TREE if we issued an error message, or error_mark_node if we
5614 did not. We issue error messages for out-and-out bad template
5615 parameters, but not simply because the conversion failed, since we
5616 might be just trying to do argument deduction. Both TYPE and EXPR
5617 must be non-dependent.
5619 The conversion follows the special rules described in
5620 [temp.arg.nontype], and it is much more strict than an implicit
5623 This function is called twice for each template argument (see
5624 lookup_template_class for a more accurate description of this
5625 problem). This means that we need to handle expressions which
5626 are not valid in a C++ source, but can be created from the
5627 first call (for instance, casts to perform conversions). These
5628 hacks can go away after we fix the double coercion problem. */
5631 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5635 /* Detect immediately string literals as invalid non-type argument.
5636 This special-case is not needed for correctness (we would easily
5637 catch this later), but only to provide better diagnostic for this
5638 common user mistake. As suggested by DR 100, we do not mention
5639 linkage issues in the diagnostic as this is not the point. */
5640 /* FIXME we're making this OK. */
5641 if (TREE_CODE (expr
) == STRING_CST
)
5643 if (complain
& tf_error
)
5644 error ("%qE is not a valid template argument for type %qT "
5645 "because string literals can never be used in this context",
5650 /* Add the ADDR_EXPR now for the benefit of
5651 value_dependent_expression_p. */
5652 if (TYPE_PTROBV_P (type
)
5653 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5655 expr
= decay_conversion (expr
, complain
);
5656 if (expr
== error_mark_node
)
5657 return error_mark_node
;
5660 /* If we are in a template, EXPR may be non-dependent, but still
5661 have a syntactic, rather than semantic, form. For example, EXPR
5662 might be a SCOPE_REF, rather than the VAR_DECL to which the
5663 SCOPE_REF refers. Preserving the qualifying scope is necessary
5664 so that access checking can be performed when the template is
5665 instantiated -- but here we need the resolved form so that we can
5666 convert the argument. */
5667 if (TYPE_REF_OBJ_P (type
)
5668 && has_value_dependent_address (expr
))
5669 /* If we want the address and it's value-dependent, don't fold. */;
5670 else if (!type_unknown_p (expr
))
5671 expr
= fold_non_dependent_expr_sfinae (expr
, complain
);
5672 if (error_operand_p (expr
))
5673 return error_mark_node
;
5674 expr_type
= TREE_TYPE (expr
);
5675 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5676 expr
= mark_lvalue_use (expr
);
5678 expr
= mark_rvalue_use (expr
);
5680 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5681 to a non-type argument of "nullptr". */
5682 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5683 expr
= convert (type
, expr
);
5685 /* In C++11, integral or enumeration non-type template arguments can be
5686 arbitrary constant expressions. Pointer and pointer to
5687 member arguments can be general constant expressions that evaluate
5688 to a null value, but otherwise still need to be of a specific form. */
5689 if (cxx_dialect
>= cxx11
)
5691 if (TREE_CODE (expr
) == PTRMEM_CST
)
5692 /* A PTRMEM_CST is already constant, and a valid template
5693 argument for a parameter of pointer to member type, we just want
5694 to leave it in that form rather than lower it to a
5696 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5697 expr
= maybe_constant_value (expr
);
5698 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5700 tree folded
= maybe_constant_value (expr
);
5701 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5702 : null_member_pointer_value_p (folded
))
5707 /* HACK: Due to double coercion, we can get a
5708 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5709 which is the tree that we built on the first call (see
5710 below when coercing to reference to object or to reference to
5711 function). We just strip everything and get to the arg.
5712 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5714 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5716 tree probe_type
, probe
= expr
;
5717 if (REFERENCE_REF_P (probe
))
5718 probe
= TREE_OPERAND (probe
, 0);
5719 probe_type
= TREE_TYPE (probe
);
5720 if (TREE_CODE (probe
) == NOP_EXPR
)
5722 /* ??? Maybe we could use convert_from_reference here, but we
5723 would need to relax its constraints because the NOP_EXPR
5724 could actually change the type to something more cv-qualified,
5725 and this is not folded by convert_from_reference. */
5726 tree addr
= TREE_OPERAND (probe
, 0);
5727 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5728 && TREE_CODE (addr
) == ADDR_EXPR
5729 && TYPE_PTR_P (TREE_TYPE (addr
))
5730 && (same_type_ignoring_top_level_qualifiers_p
5731 (TREE_TYPE (probe_type
),
5732 TREE_TYPE (TREE_TYPE (addr
)))))
5734 expr
= TREE_OPERAND (addr
, 0);
5735 expr_type
= TREE_TYPE (probe_type
);
5740 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5741 parameter is a pointer to object, through decay and
5742 qualification conversion. Let's strip everything. */
5743 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5747 if (TREE_CODE (probe
) == ADDR_EXPR
5748 && TYPE_PTR_P (TREE_TYPE (probe
)))
5750 /* Skip the ADDR_EXPR only if it is part of the decay for
5751 an array. Otherwise, it is part of the original argument
5752 in the source code. */
5753 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5754 probe
= TREE_OPERAND (probe
, 0);
5756 expr_type
= TREE_TYPE (expr
);
5760 /* [temp.arg.nontype]/5, bullet 1
5762 For a non-type template-parameter of integral or enumeration type,
5763 integral promotions (_conv.prom_) and integral conversions
5764 (_conv.integral_) are applied. */
5765 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5767 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5768 t
= maybe_constant_value (t
);
5769 if (t
!= error_mark_node
)
5772 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5773 return error_mark_node
;
5775 /* Notice that there are constant expressions like '4 % 0' which
5776 do not fold into integer constants. */
5777 if (TREE_CODE (expr
) != INTEGER_CST
)
5779 if (complain
& tf_error
)
5781 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
5782 if (processing_template_decl
5783 && !require_potential_constant_expression (expr
))
5785 expr
= cxx_constant_value (expr
);
5786 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
5787 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
5788 "in template argument for type %qT ", type
);
5789 if (expr
== error_mark_node
)
5791 /* else cxx_constant_value complained but gave us
5792 a real constant, so go ahead. */
5793 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
5799 /* Avoid typedef problems. */
5800 if (TREE_TYPE (expr
) != type
)
5801 expr
= fold_convert (type
, expr
);
5803 /* [temp.arg.nontype]/5, bullet 2
5805 For a non-type template-parameter of type pointer to object,
5806 qualification conversions (_conv.qual_) and the array-to-pointer
5807 conversion (_conv.array_) are applied. */
5808 else if (TYPE_PTROBV_P (type
))
5810 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5812 A template-argument for a non-type, non-template template-parameter
5813 shall be one of: [...]
5815 -- the name of a non-type template-parameter;
5816 -- the address of an object or function with external linkage, [...]
5817 expressed as "& id-expression" where the & is optional if the name
5818 refers to a function or array, or if the corresponding
5819 template-parameter is a reference.
5821 Here, we do not care about functions, as they are invalid anyway
5822 for a parameter of type pointer-to-object. */
5824 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
5825 /* Non-type template parameters are OK. */
5827 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5828 /* Null pointer values are OK in C++11. */;
5829 else if (TREE_CODE (expr
) != ADDR_EXPR
5830 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
5834 if (complain
& tf_error
)
5835 error ("%qD is not a valid template argument "
5836 "because %qD is a variable, not the address of "
5837 "a variable", expr
, expr
);
5840 if (POINTER_TYPE_P (expr_type
))
5842 if (complain
& tf_error
)
5843 error ("%qE is not a valid template argument for %qT "
5844 "because it is not the address of a variable",
5848 /* Other values, like integer constants, might be valid
5849 non-type arguments of some other type. */
5850 return error_mark_node
;
5856 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
5857 ? TREE_OPERAND (expr
, 0) : expr
);
5860 if (complain
& tf_error
)
5861 error ("%qE is not a valid template argument of type %qT "
5862 "because %qE is not a variable", expr
, type
, decl
);
5865 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
5867 if (complain
& tf_error
)
5868 error ("%qE is not a valid template argument of type %qT "
5869 "because %qD does not have external linkage",
5873 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
5875 if (complain
& tf_error
)
5876 error ("%qE is not a valid template argument of type %qT "
5877 "because %qD has no linkage", expr
, type
, decl
);
5882 expr
= decay_conversion (expr
, complain
);
5883 if (expr
== error_mark_node
)
5884 return error_mark_node
;
5886 expr
= perform_qualification_conversions (type
, expr
);
5887 if (expr
== error_mark_node
)
5888 return error_mark_node
;
5890 /* [temp.arg.nontype]/5, bullet 3
5892 For a non-type template-parameter of type reference to object, no
5893 conversions apply. The type referred to by the reference may be more
5894 cv-qualified than the (otherwise identical) type of the
5895 template-argument. The template-parameter is bound directly to the
5896 template-argument, which must be an lvalue. */
5897 else if (TYPE_REF_OBJ_P (type
))
5899 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
5901 return error_mark_node
;
5903 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
5905 if (complain
& tf_error
)
5906 error ("%qE is not a valid template argument for type %qT "
5907 "because of conflicts in cv-qualification", expr
, type
);
5911 if (!real_lvalue_p (expr
))
5913 if (complain
& tf_error
)
5914 error ("%qE is not a valid template argument for type %qT "
5915 "because it is not an lvalue", expr
, type
);
5919 /* [temp.arg.nontype]/1
5921 A template-argument for a non-type, non-template template-parameter
5922 shall be one of: [...]
5924 -- the address of an object or function with external linkage. */
5925 if (INDIRECT_REF_P (expr
)
5926 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
5928 expr
= TREE_OPERAND (expr
, 0);
5931 if (complain
& tf_error
)
5932 error ("%q#D is not a valid template argument for type %qT "
5933 "because a reference variable does not have a constant "
5934 "address", expr
, type
);
5941 if (complain
& tf_error
)
5942 error ("%qE is not a valid template argument for type %qT "
5943 "because it is not an object with external linkage",
5948 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
5950 if (complain
& tf_error
)
5951 error ("%qE is not a valid template argument for type %qT "
5952 "because object %qD has not external linkage",
5957 expr
= build_nop (type
, build_address (expr
));
5959 /* [temp.arg.nontype]/5, bullet 4
5961 For a non-type template-parameter of type pointer to function, only
5962 the function-to-pointer conversion (_conv.func_) is applied. If the
5963 template-argument represents a set of overloaded functions (or a
5964 pointer to such), the matching function is selected from the set
5966 else if (TYPE_PTRFN_P (type
))
5968 /* If the argument is a template-id, we might not have enough
5969 context information to decay the pointer. */
5970 if (!type_unknown_p (expr_type
))
5972 expr
= decay_conversion (expr
, complain
);
5973 if (expr
== error_mark_node
)
5974 return error_mark_node
;
5977 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5978 /* Null pointer values are OK in C++11. */
5979 return perform_qualification_conversions (type
, expr
);
5981 expr
= convert_nontype_argument_function (type
, expr
, complain
);
5982 if (!expr
|| expr
== error_mark_node
)
5985 /* [temp.arg.nontype]/5, bullet 5
5987 For a non-type template-parameter of type reference to function, no
5988 conversions apply. If the template-argument represents a set of
5989 overloaded functions, the matching function is selected from the set
5991 else if (TYPE_REFFN_P (type
))
5993 if (TREE_CODE (expr
) == ADDR_EXPR
)
5995 if (complain
& tf_error
)
5997 error ("%qE is not a valid template argument for type %qT "
5998 "because it is a pointer", expr
, type
);
5999 inform (input_location
, "try using %qE instead",
6000 TREE_OPERAND (expr
, 0));
6005 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6006 if (!expr
|| expr
== error_mark_node
)
6009 expr
= build_nop (type
, build_address (expr
));
6011 /* [temp.arg.nontype]/5, bullet 6
6013 For a non-type template-parameter of type pointer to member function,
6014 no conversions apply. If the template-argument represents a set of
6015 overloaded member functions, the matching member function is selected
6016 from the set (_over.over_). */
6017 else if (TYPE_PTRMEMFUNC_P (type
))
6019 expr
= instantiate_type (type
, expr
, tf_none
);
6020 if (expr
== error_mark_node
)
6021 return error_mark_node
;
6023 /* [temp.arg.nontype] bullet 1 says the pointer to member
6024 expression must be a pointer-to-member constant. */
6025 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6026 return error_mark_node
;
6028 /* There is no way to disable standard conversions in
6029 resolve_address_of_overloaded_function (called by
6030 instantiate_type). It is possible that the call succeeded by
6031 converting &B::I to &D::I (where B is a base of D), so we need
6032 to reject this conversion here.
6034 Actually, even if there was a way to disable standard conversions,
6035 it would still be better to reject them here so that we can
6036 provide a superior diagnostic. */
6037 if (!same_type_p (TREE_TYPE (expr
), type
))
6039 if (complain
& tf_error
)
6041 error ("%qE is not a valid template argument for type %qT "
6042 "because it is of type %qT", expr
, type
,
6044 /* If we are just one standard conversion off, explain. */
6045 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6046 inform (input_location
,
6047 "standard conversions are not allowed in this context");
6052 /* [temp.arg.nontype]/5, bullet 7
6054 For a non-type template-parameter of type pointer to data member,
6055 qualification conversions (_conv.qual_) are applied. */
6056 else if (TYPE_PTRDATAMEM_P (type
))
6058 /* [temp.arg.nontype] bullet 1 says the pointer to member
6059 expression must be a pointer-to-member constant. */
6060 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6061 return error_mark_node
;
6063 expr
= perform_qualification_conversions (type
, expr
);
6064 if (expr
== error_mark_node
)
6067 else if (NULLPTR_TYPE_P (type
))
6069 if (expr
!= nullptr_node
)
6071 if (complain
& tf_error
)
6072 error ("%qE is not a valid template argument for type %qT "
6073 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6078 /* A template non-type parameter must be one of the above. */
6082 /* Sanity check: did we actually convert the argument to the
6084 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6085 (type
, TREE_TYPE (expr
)));
6089 /* Subroutine of coerce_template_template_parms, which returns 1 if
6090 PARM_PARM and ARG_PARM match using the rule for the template
6091 parameters of template template parameters. Both PARM and ARG are
6092 template parameters; the rest of the arguments are the same as for
6093 coerce_template_template_parms.
6096 coerce_template_template_parm (tree parm
,
6098 tsubst_flags_t complain
,
6102 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6103 || parm
== NULL_TREE
|| error_operand_p (parm
))
6106 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6109 switch (TREE_CODE (parm
))
6112 /* We encounter instantiations of templates like
6113 template <template <template <class> class> class TT>
6116 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6117 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6119 if (!coerce_template_template_parms
6120 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6126 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6127 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6128 /* Argument is a parameter pack but parameter is not. */
6133 /* The tsubst call is used to handle cases such as
6135 template <int> class C {};
6136 template <class T, template <T> class TT> class D {};
6139 i.e. the parameter list of TT depends on earlier parameters. */
6140 if (!uses_template_parms (TREE_TYPE (arg
))
6142 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6146 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6147 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6148 /* Argument is a parameter pack but parameter is not. */
6161 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6162 template template parameters. Both PARM_PARMS and ARG_PARMS are
6163 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6166 Consider the example:
6167 template <class T> class A;
6168 template<template <class U> class TT> class B;
6170 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6171 the parameters to A, and OUTER_ARGS contains A. */
6174 coerce_template_template_parms (tree parm_parms
,
6176 tsubst_flags_t complain
,
6180 int nparms
, nargs
, i
;
6184 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6185 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6187 nparms
= TREE_VEC_LENGTH (parm_parms
);
6188 nargs
= TREE_VEC_LENGTH (arg_parms
);
6190 /* Determine whether we have a parameter pack at the end of the
6191 template template parameter's template parameter list. */
6192 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6194 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6196 if (error_operand_p (parm
))
6199 switch (TREE_CODE (parm
))
6203 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6208 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6218 && !(variadic_p
&& nargs
>= nparms
- 1))
6221 /* Check all of the template parameters except the parameter pack at
6222 the end (if any). */
6223 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6225 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6226 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6229 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6230 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6232 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6240 /* Check each of the template parameters in the template
6241 argument against the template parameter pack at the end of
6242 the template template parameter. */
6243 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6246 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6248 for (; i
< nargs
; ++i
)
6250 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6253 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6255 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6264 /* Verifies that the deduced template arguments (in TARGS) for the
6265 template template parameters (in TPARMS) represent valid bindings,
6266 by comparing the template parameter list of each template argument
6267 to the template parameter list of its corresponding template
6268 template parameter, in accordance with DR150. This
6269 routine can only be called after all template arguments have been
6270 deduced. It will return TRUE if all of the template template
6271 parameter bindings are okay, FALSE otherwise. */
6273 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6275 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6278 /* We're dealing with template parms in this process. */
6279 ++processing_template_decl
;
6281 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6283 for (i
= 0; i
< ntparms
; ++i
)
6285 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6286 tree targ
= TREE_VEC_ELT (targs
, i
);
6288 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6290 tree packed_args
= NULL_TREE
;
6293 if (ARGUMENT_PACK_P (targ
))
6295 /* Look inside the argument pack. */
6296 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6297 len
= TREE_VEC_LENGTH (packed_args
);
6300 for (idx
= 0; idx
< len
; ++idx
)
6302 tree targ_parms
= NULL_TREE
;
6305 /* Extract the next argument from the argument
6307 targ
= TREE_VEC_ELT (packed_args
, idx
);
6309 if (PACK_EXPANSION_P (targ
))
6310 /* Look at the pattern of the pack expansion. */
6311 targ
= PACK_EXPANSION_PATTERN (targ
);
6313 /* Extract the template parameters from the template
6315 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6316 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6317 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6318 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6320 /* Verify that we can coerce the template template
6321 parameters from the template argument to the template
6322 parameter. This requires an exact match. */
6324 && !coerce_template_template_parms
6325 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6340 --processing_template_decl
;
6344 /* Since type attributes aren't mangled, we need to strip them from
6345 template type arguments. */
6348 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6351 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6353 mv
= TYPE_MAIN_VARIANT (arg
);
6354 arg
= strip_typedefs (arg
);
6355 if (TYPE_ALIGN (arg
) != TYPE_ALIGN (mv
)
6356 || TYPE_ATTRIBUTES (arg
) != TYPE_ATTRIBUTES (mv
))
6358 if (complain
& tf_warning
)
6359 warning (0, "ignoring attributes on template argument %qT", arg
);
6360 arg
= build_aligned_type (arg
, TYPE_ALIGN (mv
));
6361 arg
= cp_build_type_attribute_variant (arg
, TYPE_ATTRIBUTES (mv
));
6366 /* Convert the indicated template ARG as necessary to match the
6367 indicated template PARM. Returns the converted ARG, or
6368 error_mark_node if the conversion was unsuccessful. Error and
6369 warning messages are issued under control of COMPLAIN. This
6370 conversion is for the Ith parameter in the parameter list. ARGS is
6371 the full set of template arguments deduced so far. */
6374 convert_template_argument (tree parm
,
6377 tsubst_flags_t complain
,
6383 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6385 if (TREE_CODE (arg
) == TREE_LIST
6386 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6388 /* The template argument was the name of some
6389 member function. That's usually
6390 invalid, but static members are OK. In any
6391 case, grab the underlying fields/functions
6392 and issue an error later if required. */
6393 orig_arg
= TREE_VALUE (arg
);
6394 TREE_TYPE (arg
) = unknown_type_node
;
6399 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6400 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6401 || requires_tmpl_type
);
6403 /* When determining whether an argument pack expansion is a template,
6404 look at the pattern. */
6405 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6406 arg
= PACK_EXPANSION_PATTERN (arg
);
6408 /* Deal with an injected-class-name used as a template template arg. */
6409 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6411 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6412 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6414 if (cxx_dialect
>= cxx11
)
6415 /* OK under DR 1004. */;
6416 else if (complain
& tf_warning_or_error
)
6417 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6418 " used as template template argument", TYPE_NAME (arg
));
6419 else if (flag_pedantic_errors
)
6427 ((TREE_CODE (arg
) == TEMPLATE_DECL
6428 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6429 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6430 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6431 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6434 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6435 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6436 arg
= TYPE_STUB_DECL (arg
);
6438 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6440 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6441 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6443 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6445 if (complain
& tf_error
)
6446 error ("invalid use of destructor %qE as a type", orig_arg
);
6447 return error_mark_node
;
6450 permerror (input_location
,
6451 "to refer to a type member of a template parameter, "
6452 "use %<typename %E%>", orig_arg
);
6454 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6455 TREE_OPERAND (arg
, 1),
6461 if (is_type
!= requires_type
)
6465 if (complain
& tf_error
)
6467 error ("type/value mismatch at argument %d in template "
6468 "parameter list for %qD",
6471 inform (input_location
,
6472 " expected a constant of type %qT, got %qT",
6474 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6475 else if (requires_tmpl_type
)
6476 inform (input_location
,
6477 " expected a class template, got %qE", orig_arg
);
6479 inform (input_location
,
6480 " expected a type, got %qE", orig_arg
);
6483 return error_mark_node
;
6485 if (is_tmpl_type
^ requires_tmpl_type
)
6487 if (in_decl
&& (complain
& tf_error
))
6489 error ("type/value mismatch at argument %d in template "
6490 "parameter list for %qD",
6493 inform (input_location
,
6494 " expected a type, got %qT", DECL_NAME (arg
));
6496 inform (input_location
,
6497 " expected a class template, got %qT", orig_arg
);
6499 return error_mark_node
;
6504 if (requires_tmpl_type
)
6506 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6508 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6509 /* The number of argument required is not known yet.
6510 Just accept it for now. */
6511 val
= TREE_TYPE (arg
);
6514 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6517 /* Strip alias templates that are equivalent to another
6519 arg
= get_underlying_template (arg
);
6520 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6522 if (coerce_template_template_parms (parmparm
, argparm
,
6528 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6530 if (val
!= error_mark_node
)
6532 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6533 val
= TREE_TYPE (val
);
6534 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6535 val
= make_pack_expansion (val
);
6540 if (in_decl
&& (complain
& tf_error
))
6542 error ("type/value mismatch at argument %d in "
6543 "template parameter list for %qD",
6545 inform (input_location
,
6546 " expected a template of type %qD, got %qT",
6550 val
= error_mark_node
;
6556 /* We only form one instance of each template specialization.
6557 Therefore, if we use a non-canonical variant (i.e., a
6558 typedef), any future messages referring to the type will use
6559 the typedef, which is confusing if those future uses do not
6560 themselves also use the typedef. */
6562 val
= canonicalize_type_argument (val
, complain
);
6566 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6568 if (invalid_nontype_parm_type_p (t
, complain
))
6569 return error_mark_node
;
6571 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6573 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6577 /* Not sure if this is reachable, but it doesn't hurt
6579 error ("type mismatch in nontype parameter pack");
6580 val
= error_mark_node
;
6583 else if (!dependent_template_arg_p (orig_arg
)
6584 && !uses_template_parms (t
))
6585 /* We used to call digest_init here. However, digest_init
6586 will report errors, which we don't want when complain
6587 is zero. More importantly, digest_init will try too
6588 hard to convert things: for example, `0' should not be
6589 converted to pointer type at this point according to
6590 the standard. Accepting this is not merely an
6591 extension, since deciding whether or not these
6592 conversions can occur is part of determining which
6593 function template to call, or whether a given explicit
6594 argument specification is valid. */
6595 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6597 val
= strip_typedefs_expr (orig_arg
);
6599 if (val
== NULL_TREE
)
6600 val
= error_mark_node
;
6601 else if (val
== error_mark_node
&& (complain
& tf_error
))
6602 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6604 if (TREE_CODE (val
) == SCOPE_REF
)
6606 /* Strip typedefs from the SCOPE_REF. */
6607 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6608 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6610 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6611 QUALIFIED_NAME_IS_TEMPLATE (val
));
6618 /* Coerces the remaining template arguments in INNER_ARGS (from
6619 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6620 Returns the coerced argument pack. PARM_IDX is the position of this
6621 parameter in the template parameter list. ARGS is the original
6622 template argument list. */
6624 coerce_template_parameter_pack (tree parms
,
6632 tsubst_flags_t complain
)
6634 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6635 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6638 tree packed_parms
= NULL_TREE
;
6640 if (arg_idx
> nargs
)
6643 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6645 /* When the template parameter is a non-type template parameter pack
6646 or template template parameter pack whose type or template
6647 parameters use parameter packs, we know exactly how many arguments
6648 we are looking for. Build a vector of the instantiated decls for
6649 these template parameters in PACKED_PARMS. */
6650 /* We can't use make_pack_expansion here because it would interpret a
6651 _DECL as a use rather than a declaration. */
6652 tree decl
= TREE_VALUE (parm
);
6653 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6654 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6655 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6656 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6658 TREE_VEC_LENGTH (args
)--;
6659 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6660 TREE_VEC_LENGTH (args
)++;
6662 if (packed_parms
== error_mark_node
)
6663 return error_mark_node
;
6665 /* If we're doing a partial instantiation of a member template,
6666 verify that all of the types used for the non-type
6667 template parameter pack are, in fact, valid for non-type
6668 template parameters. */
6670 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6672 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6673 for (j
= 0; j
< len
; ++j
)
6675 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6676 if (invalid_nontype_parm_type_p (t
, complain
))
6677 return error_mark_node
;
6681 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6684 packed_args
= make_tree_vec (nargs
- arg_idx
);
6686 /* Convert the remaining arguments, which will be a part of the
6687 parameter pack "parm". */
6688 for (; arg_idx
< nargs
; ++arg_idx
)
6690 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6691 tree actual_parm
= TREE_VALUE (parm
);
6692 int pack_idx
= arg_idx
- parm_idx
;
6696 /* Once we've packed as many args as we have types, stop. */
6697 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6699 else if (PACK_EXPANSION_P (arg
))
6700 /* We don't know how many args we have yet, just
6701 use the unconverted ones for now. */
6704 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6707 if (arg
== error_mark_node
)
6709 if (complain
& tf_error
)
6710 error ("template argument %d is invalid", arg_idx
+ 1);
6713 arg
= convert_template_argument (actual_parm
,
6714 arg
, new_args
, complain
, parm_idx
,
6716 if (arg
== error_mark_node
)
6718 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6721 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6722 && TREE_VEC_LENGTH (packed_args
) > 0)
6724 if (complain
& tf_error
)
6725 error ("wrong number of template arguments (%d, should be %d)",
6726 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6727 return error_mark_node
;
6730 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6731 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6732 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6735 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6736 TREE_TYPE (argument_pack
)
6737 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6738 TREE_CONSTANT (argument_pack
) = 1;
6741 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6742 #ifdef ENABLE_CHECKING
6743 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6744 TREE_VEC_LENGTH (packed_args
));
6746 return argument_pack
;
6749 /* Returns the number of pack expansions in the template argument vector
6753 pack_expansion_args_count (tree args
)
6758 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6760 tree elt
= TREE_VEC_ELT (args
, i
);
6761 if (elt
&& PACK_EXPANSION_P (elt
))
6767 /* Convert all template arguments to their appropriate types, and
6768 return a vector containing the innermost resulting template
6769 arguments. If any error occurs, return error_mark_node. Error and
6770 warning messages are issued under control of COMPLAIN.
6772 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6773 for arguments not specified in ARGS. Otherwise, if
6774 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6775 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6776 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6780 coerce_template_parms (tree parms
,
6783 tsubst_flags_t complain
,
6784 bool require_all_args
,
6785 bool use_default_args
)
6787 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6788 tree orig_inner_args
;
6791 tree new_inner_args
;
6792 int saved_unevaluated_operand
;
6793 int saved_inhibit_evaluation_warnings
;
6795 /* When used as a boolean value, indicates whether this is a
6796 variadic template parameter list. Since it's an int, we can also
6797 subtract it from nparms to get the number of non-variadic
6800 int variadic_args_p
= 0;
6801 int post_variadic_parms
= 0;
6803 if (args
== error_mark_node
)
6804 return error_mark_node
;
6806 nparms
= TREE_VEC_LENGTH (parms
);
6808 /* Determine if there are any parameter packs. */
6809 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
6811 tree tparm
= TREE_VALUE (TREE_VEC_ELT (parms
, parm_idx
));
6813 ++post_variadic_parms
;
6814 if (template_parameter_pack_p (tparm
))
6818 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
6819 /* If there are no parameters that follow a parameter pack, we need to
6820 expand any argument packs so that we can deduce a parameter pack from
6821 some non-packed args followed by an argument pack, as in variadic85.C.
6822 If there are such parameters, we need to leave argument packs intact
6823 so the arguments are assigned properly. This can happen when dealing
6824 with a nested class inside a partial specialization of a class
6825 template, as in variadic92.C, or when deducing a template parameter pack
6826 from a sub-declarator, as in variadic114.C. */
6827 if (!post_variadic_parms
)
6828 inner_args
= expand_template_argument_pack (inner_args
);
6830 /* Count any pack expansion args. */
6831 variadic_args_p
= pack_expansion_args_count (inner_args
);
6833 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6834 if ((nargs
> nparms
&& !variadic_p
)
6835 || (nargs
< nparms
- variadic_p
6838 && (!use_default_args
6839 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
6840 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
6842 if (complain
& tf_error
)
6846 nparms
-= variadic_p
;
6847 error ("wrong number of template arguments "
6848 "(%d, should be %d or more)", nargs
, nparms
);
6851 error ("wrong number of template arguments "
6852 "(%d, should be %d)", nargs
, nparms
);
6855 error ("provided for %q+D", in_decl
);
6858 return error_mark_node
;
6860 /* We can't pass a pack expansion to a non-pack parameter of an alias
6861 template (DR 1430). */
6862 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
6864 && nargs
- variadic_args_p
< nparms
- variadic_p
)
6866 if (complain
& tf_error
)
6868 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
6870 tree arg
= TREE_VEC_ELT (inner_args
, i
);
6871 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
6873 if (PACK_EXPANSION_P (arg
)
6874 && !template_parameter_pack_p (parm
))
6876 error ("pack expansion argument for non-pack parameter "
6877 "%qD of alias template %qD", parm
, in_decl
);
6878 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
6885 return error_mark_node
;
6888 /* We need to evaluate the template arguments, even though this
6889 template-id may be nested within a "sizeof". */
6890 saved_unevaluated_operand
= cp_unevaluated_operand
;
6891 cp_unevaluated_operand
= 0;
6892 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6893 c_inhibit_evaluation_warnings
= 0;
6894 new_inner_args
= make_tree_vec (nparms
);
6895 new_args
= add_outermost_template_args (args
, new_inner_args
);
6896 int pack_adjust
= 0;
6897 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
6902 /* Get the Ith template parameter. */
6903 parm
= TREE_VEC_ELT (parms
, parm_idx
);
6905 if (parm
== error_mark_node
)
6907 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
6911 /* Calculate the next argument. */
6912 if (arg_idx
< nargs
)
6913 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6917 if (template_parameter_pack_p (TREE_VALUE (parm
))
6918 && !(arg
&& ARGUMENT_PACK_P (arg
)))
6920 /* Some arguments will be placed in the
6921 template parameter pack PARM. */
6922 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
6923 inner_args
, arg_idx
,
6927 if (arg
== NULL_TREE
)
6929 /* We don't know how many args we have yet, just use the
6930 unconverted (and still packed) ones for now. */
6931 new_inner_args
= orig_inner_args
;
6936 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
6938 /* Store this argument. */
6939 if (arg
== error_mark_node
)
6942 /* We are done with all of the arguments. */
6947 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
6948 arg_idx
+= pack_adjust
;
6955 if (PACK_EXPANSION_P (arg
))
6957 /* "If every valid specialization of a variadic template
6958 requires an empty template parameter pack, the template is
6959 ill-formed, no diagnostic required." So check that the
6960 pattern works with this parameter. */
6961 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
6962 tree conv
= convert_template_argument (TREE_VALUE (parm
),
6966 if (conv
== error_mark_node
)
6968 inform (input_location
, "so any instantiation with a "
6969 "non-empty parameter pack would be ill-formed");
6972 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
6973 /* Recover from missing typename. */
6974 TREE_VEC_ELT (inner_args
, arg_idx
)
6975 = make_pack_expansion (conv
);
6977 /* We don't know how many args we have yet, just
6978 use the unconverted ones for now. */
6979 new_inner_args
= inner_args
;
6984 else if (require_all_args
)
6986 /* There must be a default arg in this case. */
6987 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
6989 /* The position of the first default template argument,
6990 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6992 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
6993 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
6994 arg_idx
- pack_adjust
);
6999 if (arg
== error_mark_node
)
7001 if (complain
& tf_error
)
7002 error ("template argument %d is invalid", arg_idx
+ 1);
7005 /* This only occurs if there was an error in the template
7006 parameter list itself (which we would already have
7007 reported) that we are trying to recover from, e.g., a class
7008 template with a parameter list such as
7009 template<typename..., typename>. */
7012 arg
= convert_template_argument (TREE_VALUE (parm
),
7013 arg
, new_args
, complain
,
7016 if (arg
== error_mark_node
)
7018 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7020 cp_unevaluated_operand
= saved_unevaluated_operand
;
7021 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7023 if (variadic_p
&& arg_idx
< nargs
)
7025 if (complain
& tf_error
)
7027 error ("wrong number of template arguments "
7028 "(%d, should be %d)", nargs
, arg_idx
);
7030 error ("provided for %q+D", in_decl
);
7032 return error_mark_node
;
7036 return error_mark_node
;
7038 #ifdef ENABLE_CHECKING
7039 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7040 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7041 TREE_VEC_LENGTH (new_inner_args
));
7044 return new_inner_args
;
7047 /* Like coerce_template_parms. If PARMS represents all template
7048 parameters levels, this function returns a vector of vectors
7049 representing all the resulting argument levels. Note that in this
7050 case, only the innermost arguments are coerced because the
7051 outermost ones are supposed to have been coerced already.
7053 Otherwise, if PARMS represents only (the innermost) vector of
7054 parameters, this function returns a vector containing just the
7055 innermost resulting arguments. */
7058 coerce_innermost_template_parms (tree parms
,
7061 tsubst_flags_t complain
,
7062 bool require_all_args
,
7063 bool use_default_args
)
7065 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7066 int args_depth
= TMPL_ARGS_DEPTH (args
);
7069 if (parms_depth
> 1)
7071 coerced_args
= make_tree_vec (parms_depth
);
7075 for (level
= parms
, cur_depth
= parms_depth
;
7076 parms_depth
> 0 && level
!= NULL_TREE
;
7077 level
= TREE_CHAIN (level
), --cur_depth
)
7080 if (cur_depth
== args_depth
)
7081 l
= coerce_template_parms (TREE_VALUE (level
),
7082 args
, in_decl
, complain
,
7086 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7088 if (l
== error_mark_node
)
7089 return error_mark_node
;
7091 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7095 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7096 args
, in_decl
, complain
,
7099 return coerced_args
;
7102 /* Returns 1 if template args OT and NT are equivalent. */
7105 template_args_equal (tree ot
, tree nt
)
7109 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7112 if (TREE_CODE (nt
) == TREE_VEC
)
7113 /* For member templates */
7114 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7115 else if (PACK_EXPANSION_P (ot
))
7116 return (PACK_EXPANSION_P (nt
)
7117 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7118 PACK_EXPANSION_PATTERN (nt
))
7119 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7120 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7121 else if (ARGUMENT_PACK_P (ot
))
7126 if (!ARGUMENT_PACK_P (nt
))
7129 opack
= ARGUMENT_PACK_ARGS (ot
);
7130 npack
= ARGUMENT_PACK_ARGS (nt
);
7131 len
= TREE_VEC_LENGTH (opack
);
7132 if (TREE_VEC_LENGTH (npack
) != len
)
7134 for (i
= 0; i
< len
; ++i
)
7135 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7136 TREE_VEC_ELT (npack
, i
)))
7140 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7142 /* We get here probably because we are in the middle of substituting
7143 into the pattern of a pack expansion. In that case the
7144 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7145 interested in. So we want to use the initial pack argument for
7147 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7148 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7149 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7150 return template_args_equal (ot
, nt
);
7152 else if (TYPE_P (nt
))
7153 return TYPE_P (ot
) && same_type_p (ot
, nt
);
7154 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7157 return cp_tree_equal (ot
, nt
);
7160 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7161 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7162 NEWARG_PTR with the offending arguments if they are non-NULL. */
7165 comp_template_args_with_info (tree oldargs
, tree newargs
,
7166 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7170 if (oldargs
== newargs
)
7173 if (!oldargs
|| !newargs
)
7176 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7179 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7181 tree nt
= TREE_VEC_ELT (newargs
, i
);
7182 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7184 if (! template_args_equal (ot
, nt
))
7186 if (oldarg_ptr
!= NULL
)
7188 if (newarg_ptr
!= NULL
)
7196 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7197 of template arguments. Returns 0 otherwise. */
7200 comp_template_args (tree oldargs
, tree newargs
)
7202 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7206 add_pending_template (tree d
)
7208 tree ti
= (TYPE_P (d
)
7209 ? CLASSTYPE_TEMPLATE_INFO (d
)
7210 : DECL_TEMPLATE_INFO (d
));
7211 struct pending_template
*pt
;
7214 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7217 /* We are called both from instantiate_decl, where we've already had a
7218 tinst_level pushed, and instantiate_template, where we haven't.
7220 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7223 push_tinst_level (d
);
7225 pt
= ggc_alloc
<pending_template
> ();
7227 pt
->tinst
= current_tinst_level
;
7228 if (last_pending_template
)
7229 last_pending_template
->next
= pt
;
7231 pending_templates
= pt
;
7233 last_pending_template
= pt
;
7235 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7242 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7243 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7244 documentation for TEMPLATE_ID_EXPR. */
7247 lookup_template_function (tree fns
, tree arglist
)
7251 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7252 return error_mark_node
;
7254 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7256 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7258 error ("%q#D is not a function template", fns
);
7259 return error_mark_node
;
7262 if (BASELINK_P (fns
))
7264 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7266 BASELINK_FUNCTIONS (fns
),
7271 type
= TREE_TYPE (fns
);
7272 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7273 type
= unknown_type_node
;
7275 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7278 /* Within the scope of a template class S<T>, the name S gets bound
7279 (in build_self_reference) to a TYPE_DECL for the class, not a
7280 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7281 or one of its enclosing classes, and that type is a template,
7282 return the associated TEMPLATE_DECL. Otherwise, the original
7285 Also handle the case when DECL is a TREE_LIST of ambiguous
7286 injected-class-names from different bases. */
7289 maybe_get_template_decl_from_type_decl (tree decl
)
7291 if (decl
== NULL_TREE
)
7294 /* DR 176: A lookup that finds an injected-class-name (10.2
7295 [class.member.lookup]) can result in an ambiguity in certain cases
7296 (for example, if it is found in more than one base class). If all of
7297 the injected-class-names that are found refer to specializations of
7298 the same class template, and if the name is followed by a
7299 template-argument-list, the reference refers to the class template
7300 itself and not a specialization thereof, and is not ambiguous. */
7301 if (TREE_CODE (decl
) == TREE_LIST
)
7303 tree t
, tmpl
= NULL_TREE
;
7304 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7306 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7309 else if (tmpl
!= elt
)
7312 if (tmpl
&& t
== NULL_TREE
)
7318 return (decl
!= NULL_TREE
7319 && DECL_SELF_REFERENCE_P (decl
)
7320 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7321 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7324 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7325 parameters, find the desired type.
7327 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7329 IN_DECL, if non-NULL, is the template declaration we are trying to
7332 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7333 the class we are looking up.
7335 Issue error and warning messages under control of COMPLAIN.
7337 If the template class is really a local class in a template
7338 function, then the FUNCTION_CONTEXT is the function in which it is
7341 ??? Note that this function is currently called *twice* for each
7342 template-id: the first time from the parser, while creating the
7343 incomplete type (finish_template_type), and the second type during the
7344 real instantiation (instantiate_template_class). This is surely something
7345 that we want to avoid. It also causes some problems with argument
7346 coercion (see convert_nontype_argument for more information on this). */
7349 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7350 int entering_scope
, tsubst_flags_t complain
)
7352 tree templ
= NULL_TREE
, parmlist
;
7359 if (identifier_p (d1
))
7361 tree value
= innermost_non_namespace_value (d1
);
7362 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7367 push_decl_namespace (context
);
7368 templ
= lookup_name (d1
);
7369 templ
= maybe_get_template_decl_from_type_decl (templ
);
7371 pop_decl_namespace ();
7374 context
= DECL_CONTEXT (templ
);
7376 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7378 tree type
= TREE_TYPE (d1
);
7380 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7381 an implicit typename for the second A. Deal with it. */
7382 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7383 type
= TREE_TYPE (type
);
7385 if (CLASSTYPE_TEMPLATE_INFO (type
))
7387 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7388 d1
= DECL_NAME (templ
);
7391 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7392 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7394 templ
= TYPE_TI_TEMPLATE (d1
);
7395 d1
= DECL_NAME (templ
);
7397 else if (TREE_CODE (d1
) == TEMPLATE_DECL
7398 && DECL_TEMPLATE_RESULT (d1
)
7399 && TREE_CODE (DECL_TEMPLATE_RESULT (d1
)) == TYPE_DECL
)
7402 d1
= DECL_NAME (templ
);
7403 context
= DECL_CONTEXT (templ
);
7405 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7408 d1
= DECL_NAME (templ
);
7411 /* Issue an error message if we didn't find a template. */
7414 if (complain
& tf_error
)
7415 error ("%qT is not a template", d1
);
7416 return error_mark_node
;
7419 if (TREE_CODE (templ
) != TEMPLATE_DECL
7420 /* Make sure it's a user visible template, if it was named by
7422 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7423 && !PRIMARY_TEMPLATE_P (templ
)))
7425 if (complain
& tf_error
)
7427 error ("non-template type %qT used as a template", d1
);
7429 error ("for template declaration %q+D", in_decl
);
7431 return error_mark_node
;
7434 complain
&= ~tf_user
;
7436 /* An alias that just changes the name of a template is equivalent to the
7437 other template, so if any of the arguments are pack expansions, strip
7438 the alias to avoid problems with a pack expansion passed to a non-pack
7439 alias template parameter (DR 1430). */
7440 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7441 templ
= get_underlying_template (templ
);
7443 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7445 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7446 template arguments */
7452 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7454 /* Consider an example where a template template parameter declared as
7456 template <class T, class U = std::allocator<T> > class TT
7458 The template parameter level of T and U are one level larger than
7459 of TT. To proper process the default argument of U, say when an
7460 instantiation `TT<int>' is seen, we need to build the full
7461 arguments containing {int} as the innermost level. Outer levels,
7462 available when not appearing as default template argument, can be
7463 obtained from the arguments of the enclosing template.
7465 Suppose that TT is later substituted with std::vector. The above
7466 instantiation is `TT<int, std::allocator<T> >' with TT at
7467 level 1, and T at level 2, while the template arguments at level 1
7468 becomes {std::vector} and the inner level 2 is {int}. */
7470 outer
= DECL_CONTEXT (templ
);
7472 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7473 else if (current_template_parms
)
7474 /* This is an argument of the current template, so we haven't set
7475 DECL_CONTEXT yet. */
7476 outer
= current_template_args ();
7479 arglist
= add_to_template_args (outer
, arglist
);
7481 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7483 /*require_all_args=*/true,
7484 /*use_default_args=*/true);
7485 if (arglist2
== error_mark_node
7486 || (!uses_template_parms (arglist2
)
7487 && check_instantiated_args (templ
, arglist2
, complain
)))
7488 return error_mark_node
;
7490 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7495 tree template_type
= TREE_TYPE (templ
);
7498 tree found
= NULL_TREE
;
7501 int is_dependent_type
;
7502 int use_partial_inst_tmpl
= false;
7504 if (template_type
== error_mark_node
)
7505 /* An error occurred while building the template TEMPL, and a
7506 diagnostic has most certainly been emitted for that
7507 already. Let's propagate that error. */
7508 return error_mark_node
;
7510 gen_tmpl
= most_general_template (templ
);
7511 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7512 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7513 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7515 if (arg_depth
== 1 && parm_depth
> 1)
7517 /* We've been given an incomplete set of template arguments.
7520 template <class T> struct S1 {
7521 template <class U> struct S2 {};
7522 template <class U> struct S2<U*> {};
7525 we will be called with an ARGLIST of `U*', but the
7526 TEMPLATE will be `template <class T> template
7527 <class U> struct S1<T>::S2'. We must fill in the missing
7530 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7532 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7535 /* Now we should have enough arguments. */
7536 gcc_assert (parm_depth
== arg_depth
);
7538 /* From here on, we're only interested in the most general
7541 /* Calculate the BOUND_ARGS. These will be the args that are
7542 actually tsubst'd into the definition to create the
7546 /* We have multiple levels of arguments to coerce, at once. */
7548 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
7550 tree bound_args
= make_tree_vec (parm_depth
);
7552 for (i
= saved_depth
,
7553 t
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7554 i
> 0 && t
!= NULL_TREE
;
7555 --i
, t
= TREE_CHAIN (t
))
7558 if (i
== saved_depth
)
7559 a
= coerce_template_parms (TREE_VALUE (t
),
7562 /*require_all_args=*/true,
7563 /*use_default_args=*/true);
7565 /* Outer levels should have already been coerced. */
7566 a
= TMPL_ARGS_LEVEL (arglist
, i
);
7568 /* Don't process further if one of the levels fails. */
7569 if (a
== error_mark_node
)
7571 /* Restore the ARGLIST to its full size. */
7572 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7573 return error_mark_node
;
7576 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
7578 /* We temporarily reduce the length of the ARGLIST so
7579 that coerce_template_parms will see only the arguments
7580 corresponding to the template parameters it is
7582 TREE_VEC_LENGTH (arglist
)--;
7585 /* Restore the ARGLIST to its full size. */
7586 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7588 arglist
= bound_args
;
7592 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
7593 INNERMOST_TEMPLATE_ARGS (arglist
),
7596 /*require_all_args=*/true,
7597 /*use_default_args=*/true);
7599 if (arglist
== error_mark_node
)
7600 /* We were unable to bind the arguments. */
7601 return error_mark_node
;
7603 /* In the scope of a template class, explicit references to the
7604 template class refer to the type of the template, not any
7605 instantiation of it. For example, in:
7607 template <class T> class C { void f(C<T>); }
7609 the `C<T>' is just the same as `C'. Outside of the
7610 class, however, such a reference is an instantiation. */
7612 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7613 || currently_open_class (template_type
))
7614 /* comp_template_args is expensive, check it last. */
7615 && comp_template_args (TYPE_TI_ARGS (template_type
),
7617 return template_type
;
7619 /* If we already have this specialization, return it. */
7620 elt
.tmpl
= gen_tmpl
;
7622 hash
= hash_specialization (&elt
);
7623 entry
= (spec_entry
*) htab_find_with_hash (type_specializations
,
7629 is_dependent_type
= uses_template_parms (arglist
);
7631 /* If the deduced arguments are invalid, then the binding
7633 if (!is_dependent_type
7634 && check_instantiated_args (gen_tmpl
,
7635 INNERMOST_TEMPLATE_ARGS (arglist
),
7637 return error_mark_node
;
7639 if (!is_dependent_type
7640 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7641 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7642 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7644 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7645 DECL_NAME (gen_tmpl
),
7646 /*tag_scope=*/ts_global
);
7650 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7652 if (context
== error_mark_node
)
7653 return error_mark_node
;
7656 context
= global_namespace
;
7658 /* Create the type. */
7659 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7661 /* The user referred to a specialization of an alias
7662 template represented by GEN_TMPL.
7664 [temp.alias]/2 says:
7666 When a template-id refers to the specialization of an
7667 alias template, it is equivalent to the associated
7668 type obtained by substitution of its
7669 template-arguments for the template-parameters in the
7670 type-id of the alias template. */
7672 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7673 /* Note that the call above (by indirectly calling
7674 register_specialization in tsubst_decl) registers the
7675 TYPE_DECL representing the specialization of the alias
7676 template. So next time someone substitutes ARGLIST for
7677 the template parms into the alias template (GEN_TMPL),
7678 she'll get that TYPE_DECL back. */
7680 if (t
== error_mark_node
)
7683 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7685 if (!is_dependent_type
)
7687 set_current_access_from_decl (TYPE_NAME (template_type
));
7688 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7689 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7690 arglist
, complain
, in_decl
),
7691 SCOPED_ENUM_P (template_type
), NULL
);
7693 if (t
== error_mark_node
)
7698 /* We don't want to call start_enum for this type, since
7699 the values for the enumeration constants may involve
7700 template parameters. And, no one should be interested
7701 in the enumeration constants for such a type. */
7702 t
= cxx_make_type (ENUMERAL_TYPE
);
7703 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7705 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7706 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7707 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7709 else if (CLASS_TYPE_P (template_type
))
7711 t
= make_class_type (TREE_CODE (template_type
));
7712 CLASSTYPE_DECLARED_CLASS (t
)
7713 = CLASSTYPE_DECLARED_CLASS (template_type
);
7714 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7715 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7717 /* A local class. Make sure the decl gets registered properly. */
7718 if (context
== current_function_decl
)
7719 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7721 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7722 /* This instantiation is another name for the primary
7723 template type. Set the TYPE_CANONICAL field
7725 TYPE_CANONICAL (t
) = template_type
;
7726 else if (any_template_arguments_need_structural_equality_p (arglist
))
7727 /* Some of the template arguments require structural
7728 equality testing, so this template class requires
7729 structural equality testing. */
7730 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7735 /* If we called start_enum or pushtag above, this information
7736 will already be set up. */
7739 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7741 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7742 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7743 DECL_SOURCE_LOCATION (type_decl
)
7744 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7747 type_decl
= TYPE_NAME (t
);
7749 if (CLASS_TYPE_P (template_type
))
7751 TREE_PRIVATE (type_decl
)
7752 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7753 TREE_PROTECTED (type_decl
)
7754 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7755 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7757 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7758 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7762 /* Let's consider the explicit specialization of a member
7763 of a class template specialization that is implicitly instantiated,
7768 template<class U> struct M {}; //#0
7773 struct S<int>::M<char> //#1
7777 [temp.expl.spec]/4 says this is valid.
7779 In this case, when we write:
7782 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7785 When we encounter #1, we want to store the partial instantiation
7786 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7788 For all cases other than this "explicit specialization of member of a
7789 class template", we just want to store the most general template into
7790 the CLASSTYPE_TI_TEMPLATE of M.
7792 This case of "explicit specialization of member of a class template"
7794 1/ the enclosing class is an instantiation of, and therefore not
7795 the same as, the context of the most general template, and
7796 2/ we aren't looking at the partial instantiation itself, i.e.
7797 the innermost arguments are not the same as the innermost parms of
7798 the most general template.
7800 So it's only when 1/ and 2/ happens that we want to use the partial
7801 instantiation of the member template in lieu of its most general
7804 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
7805 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
7806 /* the enclosing class must be an instantiation... */
7807 && CLASS_TYPE_P (context
)
7808 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
7810 tree partial_inst_args
;
7811 TREE_VEC_LENGTH (arglist
)--;
7812 ++processing_template_decl
;
7814 tsubst (INNERMOST_TEMPLATE_ARGS
7815 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
7816 arglist
, complain
, NULL_TREE
);
7817 --processing_template_decl
;
7818 TREE_VEC_LENGTH (arglist
)++;
7819 use_partial_inst_tmpl
=
7820 /*...and we must not be looking at the partial instantiation
7822 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
7826 if (!use_partial_inst_tmpl
)
7827 /* This case is easy; there are no member templates involved. */
7831 /* This is a full instantiation of a member template. Find
7832 the partial instantiation of which this is an instance. */
7834 /* Temporarily reduce by one the number of levels in the ARGLIST
7835 so as to avoid comparing the last set of arguments. */
7836 TREE_VEC_LENGTH (arglist
)--;
7837 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
7838 TREE_VEC_LENGTH (arglist
)++;
7839 /* FOUND is either a proper class type, or an alias
7840 template specialization. In the later case, it's a
7841 TYPE_DECL, resulting from the substituting of arguments
7842 for parameters in the TYPE_DECL of the alias template
7843 done earlier. So be careful while getting the template
7845 found
= TREE_CODE (found
) == TYPE_DECL
7846 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
7847 : CLASSTYPE_TI_TEMPLATE (found
);
7850 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
7853 slot
= htab_find_slot_with_hash (type_specializations
,
7854 &elt
, hash
, INSERT
);
7855 entry
= ggc_alloc
<spec_entry
> ();
7859 /* Note this use of the partial instantiation so we can check it
7860 later in maybe_process_partial_specialization. */
7861 DECL_TEMPLATE_INSTANTIATIONS (found
)
7862 = tree_cons (arglist
, t
,
7863 DECL_TEMPLATE_INSTANTIATIONS (found
));
7865 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
7866 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7867 /* Now that the type has been registered on the instantiations
7868 list, we set up the enumerators. Because the enumeration
7869 constants may involve the enumeration type itself, we make
7870 sure to register the type first, and then create the
7871 constants. That way, doing tsubst_expr for the enumeration
7872 constants won't result in recursive calls here; we'll find
7873 the instantiation and exit above. */
7874 tsubst_enum (template_type
, t
, arglist
);
7876 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
7877 /* If the type makes use of template parameters, the
7878 code that generates debugging information will crash. */
7879 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
7881 /* Possibly limit visibility based on template args. */
7882 TREE_PUBLIC (type_decl
) = 1;
7883 determine_visibility (type_decl
);
7889 /* Wrapper for lookup_template_class_1. */
7892 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
7893 int entering_scope
, tsubst_flags_t complain
)
7896 timevar_push (TV_TEMPLATE_INST
);
7897 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
7898 entering_scope
, complain
);
7899 timevar_pop (TV_TEMPLATE_INST
);
7907 /* True when we should also visit template parameters that occur in
7908 non-deduced contexts. */
7909 bool include_nondeduced_p
;
7910 struct pointer_set_t
*visited
;
7913 /* Called from for_each_template_parm via walk_tree. */
7916 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
7919 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
7920 tree_fn_t fn
= pfd
->fn
;
7921 void *data
= pfd
->data
;
7924 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
7925 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
7926 pfd
->include_nondeduced_p
))
7927 return error_mark_node
;
7929 switch (TREE_CODE (t
))
7932 if (TYPE_PTRMEMFUNC_P (t
))
7938 if (!TYPE_TEMPLATE_INFO (t
))
7940 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
7941 fn
, data
, pfd
->visited
,
7942 pfd
->include_nondeduced_p
))
7943 return error_mark_node
;
7947 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
7948 fn
, data
, pfd
->visited
,
7949 pfd
->include_nondeduced_p
)
7950 || for_each_template_parm (TYPE_MAX_VALUE (t
),
7951 fn
, data
, pfd
->visited
,
7952 pfd
->include_nondeduced_p
))
7953 return error_mark_node
;
7957 /* Since we're not going to walk subtrees, we have to do this
7959 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
7960 pfd
->visited
, pfd
->include_nondeduced_p
))
7961 return error_mark_node
;
7965 /* Check the return type. */
7966 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
7967 pfd
->include_nondeduced_p
))
7968 return error_mark_node
;
7970 /* Check the parameter types. Since default arguments are not
7971 instantiated until they are needed, the TYPE_ARG_TYPES may
7972 contain expressions that involve template parameters. But,
7973 no-one should be looking at them yet. And, once they're
7974 instantiated, they don't contain template parameters, so
7975 there's no point in looking at them then, either. */
7979 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
7980 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
7981 pfd
->visited
, pfd
->include_nondeduced_p
))
7982 return error_mark_node
;
7984 /* Since we've already handled the TYPE_ARG_TYPES, we don't
7985 want walk_tree walking into them itself. */
7991 case UNDERLYING_TYPE
:
7992 if (pfd
->include_nondeduced_p
7993 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
7995 pfd
->include_nondeduced_p
))
7996 return error_mark_node
;
8001 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
8002 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
8003 pfd
->visited
, pfd
->include_nondeduced_p
))
8004 return error_mark_node
;
8009 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
8010 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
8011 pfd
->visited
, pfd
->include_nondeduced_p
))
8012 return error_mark_node
;
8013 if (DECL_CONTEXT (t
)
8014 && pfd
->include_nondeduced_p
8015 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
8016 pfd
->visited
, pfd
->include_nondeduced_p
))
8017 return error_mark_node
;
8020 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8021 /* Record template parameters such as `T' inside `TT<T>'. */
8022 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
8023 pfd
->include_nondeduced_p
))
8024 return error_mark_node
;
8027 case TEMPLATE_TEMPLATE_PARM
:
8028 case TEMPLATE_TYPE_PARM
:
8029 case TEMPLATE_PARM_INDEX
:
8030 if (fn
&& (*fn
)(t
, data
))
8031 return error_mark_node
;
8033 return error_mark_node
;
8037 /* A template template parameter is encountered. */
8038 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
8039 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8040 pfd
->include_nondeduced_p
))
8041 return error_mark_node
;
8043 /* Already substituted template template parameter */
8049 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8051 pfd
->include_nondeduced_p
))
8052 return error_mark_node
;
8056 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8057 && pfd
->include_nondeduced_p
8058 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8059 (TREE_TYPE (t
)), fn
, data
,
8060 pfd
->visited
, pfd
->include_nondeduced_p
))
8061 return error_mark_node
;
8066 /* If there's no type, then this thing must be some expression
8067 involving template parameters. */
8068 if (!fn
&& !TREE_TYPE (t
))
8069 return error_mark_node
;
8074 case IMPLICIT_CONV_EXPR
:
8075 case REINTERPRET_CAST_EXPR
:
8076 case CONST_CAST_EXPR
:
8077 case STATIC_CAST_EXPR
:
8078 case DYNAMIC_CAST_EXPR
:
8082 case PSEUDO_DTOR_EXPR
:
8084 return error_mark_node
;
8091 /* We didn't find any template parameters we liked. */
8095 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8096 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8097 call FN with the parameter and the DATA.
8098 If FN returns nonzero, the iteration is terminated, and
8099 for_each_template_parm returns 1. Otherwise, the iteration
8100 continues. If FN never returns a nonzero value, the value
8101 returned by for_each_template_parm is 0. If FN is NULL, it is
8102 considered to be the function which always returns 1.
8104 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8105 parameters that occur in non-deduced contexts. When false, only
8106 visits those template parameters that can be deduced. */
8109 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8110 struct pointer_set_t
*visited
,
8111 bool include_nondeduced_p
)
8113 struct pair_fn_data pfd
;
8119 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8121 /* Walk the tree. (Conceptually, we would like to walk without
8122 duplicates, but for_each_template_parm_r recursively calls
8123 for_each_template_parm, so we would need to reorganize a fair
8124 bit to use walk_tree_without_duplicates, so we keep our own
8127 pfd
.visited
= visited
;
8129 pfd
.visited
= pointer_set_create ();
8130 result
= cp_walk_tree (&t
,
8131 for_each_template_parm_r
,
8133 pfd
.visited
) != NULL_TREE
;
8138 pointer_set_destroy (pfd
.visited
);
8145 /* Returns true if T depends on any template parameter. */
8148 uses_template_parms (tree t
)
8151 int saved_processing_template_decl
;
8153 saved_processing_template_decl
= processing_template_decl
;
8154 if (!saved_processing_template_decl
)
8155 processing_template_decl
= 1;
8157 dependent_p
= dependent_type_p (t
);
8158 else if (TREE_CODE (t
) == TREE_VEC
)
8159 dependent_p
= any_dependent_template_arguments_p (t
);
8160 else if (TREE_CODE (t
) == TREE_LIST
)
8161 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8162 || uses_template_parms (TREE_CHAIN (t
)));
8163 else if (TREE_CODE (t
) == TYPE_DECL
)
8164 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8167 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8168 || TREE_CODE (t
) == OVERLOAD
8171 || TREE_CODE (t
) == TRAIT_EXPR
8172 || TREE_CODE (t
) == CONSTRUCTOR
8173 || CONSTANT_CLASS_P (t
))
8174 dependent_p
= (type_dependent_expression_p (t
)
8175 || value_dependent_expression_p (t
));
8178 gcc_assert (t
== error_mark_node
);
8179 dependent_p
= false;
8182 processing_template_decl
= saved_processing_template_decl
;
8187 /* Returns true iff current_function_decl is an incompletely instantiated
8188 template. Useful instead of processing_template_decl because the latter
8189 is set to 0 during fold_non_dependent_expr. */
8192 in_template_function (void)
8194 tree fn
= current_function_decl
;
8196 ++processing_template_decl
;
8197 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8198 && DECL_TEMPLATE_INFO (fn
)
8199 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8200 --processing_template_decl
;
8204 /* Returns true if T depends on any template parameter with level LEVEL. */
8207 uses_template_parms_level (tree t
, int level
)
8209 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8210 /*include_nondeduced_p=*/true);
8213 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8214 ill-formed translation unit, i.e. a variable or function that isn't
8215 usable in a constant expression. */
8218 neglectable_inst_p (tree d
)
8221 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8222 : decl_maybe_constant_var_p (d
)));
8225 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8226 neglectable and instantiated from within an erroneous instantiation. */
8229 limit_bad_template_recursion (tree decl
)
8231 struct tinst_level
*lev
= current_tinst_level
;
8232 int errs
= errorcount
+ sorrycount
;
8233 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8236 for (; lev
; lev
= lev
->next
)
8237 if (neglectable_inst_p (lev
->decl
))
8240 return (lev
&& errs
> lev
->errors
);
8243 static int tinst_depth
;
8244 extern int max_tinst_depth
;
8247 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8249 /* We're starting to instantiate D; record the template instantiation context
8250 for diagnostics and to restore it later. */
8253 push_tinst_level (tree d
)
8255 struct tinst_level
*new_level
;
8257 if (tinst_depth
>= max_tinst_depth
)
8259 last_error_tinst_level
= current_tinst_level
;
8260 if (TREE_CODE (d
) == TREE_LIST
)
8261 error ("template instantiation depth exceeds maximum of %d (use "
8262 "-ftemplate-depth= to increase the maximum) substituting %qS",
8263 max_tinst_depth
, d
);
8265 error ("template instantiation depth exceeds maximum of %d (use "
8266 "-ftemplate-depth= to increase the maximum) instantiating %qD",
8267 max_tinst_depth
, d
);
8269 print_instantiation_context ();
8274 /* If the current instantiation caused problems, don't let it instantiate
8275 anything else. Do allow deduction substitution and decls usable in
8276 constant expressions. */
8277 if (limit_bad_template_recursion (d
))
8280 new_level
= ggc_alloc
<tinst_level
> ();
8281 new_level
->decl
= d
;
8282 new_level
->locus
= input_location
;
8283 new_level
->errors
= errorcount
+sorrycount
;
8284 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8285 new_level
->next
= current_tinst_level
;
8286 current_tinst_level
= new_level
;
8289 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8290 depth_reached
= tinst_depth
;
8295 /* We're done instantiating this template; return to the instantiation
8299 pop_tinst_level (void)
8301 /* Restore the filename and line number stashed away when we started
8302 this instantiation. */
8303 input_location
= current_tinst_level
->locus
;
8304 current_tinst_level
= current_tinst_level
->next
;
8308 /* We're instantiating a deferred template; restore the template
8309 instantiation context in which the instantiation was requested, which
8310 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8313 reopen_tinst_level (struct tinst_level
*level
)
8315 struct tinst_level
*t
;
8318 for (t
= level
; t
; t
= t
->next
)
8321 current_tinst_level
= level
;
8323 if (current_tinst_level
)
8324 current_tinst_level
->errors
= errorcount
+sorrycount
;
8328 /* Returns the TINST_LEVEL which gives the original instantiation
8331 struct tinst_level
*
8332 outermost_tinst_level (void)
8334 struct tinst_level
*level
= current_tinst_level
;
8337 level
= level
->next
;
8341 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8342 vector of template arguments, as for tsubst.
8344 Returns an appropriate tsubst'd friend declaration. */
8347 tsubst_friend_function (tree decl
, tree args
)
8351 if (TREE_CODE (decl
) == FUNCTION_DECL
8352 && DECL_TEMPLATE_INSTANTIATION (decl
)
8353 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8354 /* This was a friend declared with an explicit template
8355 argument list, e.g.:
8359 to indicate that f was a template instantiation, not a new
8360 function declaration. Now, we have to figure out what
8361 instantiation of what template. */
8363 tree template_id
, arglist
, fns
;
8366 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8368 /* Friend functions are looked up in the containing namespace scope.
8369 We must enter that scope, to avoid finding member functions of the
8370 current class with same name. */
8371 push_nested_namespace (ns
);
8372 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8373 tf_warning_or_error
, NULL_TREE
,
8374 /*integral_constant_expression_p=*/false);
8375 pop_nested_namespace (ns
);
8376 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8377 tf_warning_or_error
, NULL_TREE
);
8378 template_id
= lookup_template_function (fns
, arglist
);
8380 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8381 tmpl
= determine_specialization (template_id
, new_friend
,
8383 /*need_member_template=*/0,
8384 TREE_VEC_LENGTH (args
),
8386 return instantiate_template (tmpl
, new_args
, tf_error
);
8389 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8391 /* The NEW_FRIEND will look like an instantiation, to the
8392 compiler, but is not an instantiation from the point of view of
8393 the language. For example, we might have had:
8395 template <class T> struct S {
8396 template <class U> friend void f(T, U);
8399 Then, in S<int>, template <class U> void f(int, U) is not an
8400 instantiation of anything. */
8401 if (new_friend
== error_mark_node
)
8402 return error_mark_node
;
8404 DECL_USE_TEMPLATE (new_friend
) = 0;
8405 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8407 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8408 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8409 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8412 /* The mangled name for the NEW_FRIEND is incorrect. The function
8413 is not a template instantiation and should not be mangled like
8414 one. Therefore, we forget the mangling here; we'll recompute it
8415 later if we need it. */
8416 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8418 SET_DECL_RTL (new_friend
, NULL
);
8419 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8422 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8425 tree new_friend_template_info
;
8426 tree new_friend_result_template_info
;
8428 int new_friend_is_defn
;
8430 /* We must save some information from NEW_FRIEND before calling
8431 duplicate decls since that function will free NEW_FRIEND if
8433 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8434 new_friend_is_defn
=
8435 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8436 (template_for_substitution (new_friend
)))
8438 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8440 /* This declaration is a `primary' template. */
8441 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8443 new_friend_result_template_info
8444 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8447 new_friend_result_template_info
= NULL_TREE
;
8449 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8450 if (new_friend_is_defn
)
8451 DECL_INITIAL (new_friend
) = error_mark_node
;
8453 /* Inside pushdecl_namespace_level, we will push into the
8454 current namespace. However, the friend function should go
8455 into the namespace of the template. */
8456 ns
= decl_namespace_context (new_friend
);
8457 push_nested_namespace (ns
);
8458 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8459 pop_nested_namespace (ns
);
8461 if (old_decl
== error_mark_node
)
8462 return error_mark_node
;
8464 if (old_decl
!= new_friend
)
8466 /* This new friend declaration matched an existing
8467 declaration. For example, given:
8469 template <class T> void f(T);
8470 template <class U> class C {
8471 template <class T> friend void f(T) {}
8474 the friend declaration actually provides the definition
8475 of `f', once C has been instantiated for some type. So,
8476 old_decl will be the out-of-class template declaration,
8477 while new_friend is the in-class definition.
8479 But, if `f' was called before this point, the
8480 instantiation of `f' will have DECL_TI_ARGS corresponding
8481 to `T' but not to `U', references to which might appear
8482 in the definition of `f'. Previously, the most general
8483 template for an instantiation of `f' was the out-of-class
8484 version; now it is the in-class version. Therefore, we
8485 run through all specialization of `f', adding to their
8486 DECL_TI_ARGS appropriately. In particular, they need a
8487 new set of outer arguments, corresponding to the
8488 arguments for this class instantiation.
8490 The same situation can arise with something like this:
8493 template <class T> class C {
8497 when `C<int>' is instantiated. Now, `f(int)' is defined
8500 if (!new_friend_is_defn
)
8501 /* On the other hand, if the in-class declaration does
8502 *not* provide a definition, then we don't want to alter
8503 existing definitions. We can just leave everything
8508 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8509 tree new_args
= TI_ARGS (new_friend_template_info
);
8511 /* Overwrite whatever template info was there before, if
8512 any, with the new template information pertaining to
8514 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8516 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8518 /* We should have called reregister_specialization in
8520 gcc_assert (retrieve_specialization (new_template
,
8524 /* Instantiate it if the global has already been used. */
8525 if (DECL_ODR_USED (old_decl
))
8526 instantiate_decl (old_decl
, /*defer_ok=*/true,
8527 /*expl_inst_class_mem_p=*/false);
8533 /* Indicate that the old function template is a partial
8535 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8536 = new_friend_result_template_info
;
8538 gcc_assert (new_template
8539 == most_general_template (new_template
));
8540 gcc_assert (new_template
!= old_decl
);
8542 /* Reassign any specializations already in the hash table
8543 to the new more general template, and add the
8544 additional template args. */
8545 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8549 tree spec
= TREE_VALUE (t
);
8552 elt
.tmpl
= old_decl
;
8553 elt
.args
= DECL_TI_ARGS (spec
);
8554 elt
.spec
= NULL_TREE
;
8556 htab_remove_elt (decl_specializations
, &elt
);
8559 = add_outermost_template_args (new_args
,
8560 DECL_TI_ARGS (spec
));
8562 register_specialization
8563 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8566 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8570 /* The information from NEW_FRIEND has been merged into OLD_DECL
8571 by duplicate_decls. */
8572 new_friend
= old_decl
;
8577 tree context
= DECL_CONTEXT (new_friend
);
8581 template <class T> class C {
8582 template <class U> friend void C1<U>::f (); // case 1
8583 friend void C2<T>::f (); // case 2
8585 we only need to make sure CONTEXT is a complete type for
8586 case 2. To distinguish between the two cases, we note that
8587 CONTEXT of case 1 remains dependent type after tsubst while
8588 this isn't true for case 2. */
8589 ++processing_template_decl
;
8590 dependent_p
= dependent_type_p (context
);
8591 --processing_template_decl
;
8594 && !complete_type_or_else (context
, NULL_TREE
))
8595 return error_mark_node
;
8597 if (COMPLETE_TYPE_P (context
))
8599 tree fn
= new_friend
;
8600 /* do_friend adds the TEMPLATE_DECL for any member friend
8601 template even if it isn't a member template, i.e.
8602 template <class T> friend A<T>::f();
8603 Look through it in that case. */
8604 if (TREE_CODE (fn
) == TEMPLATE_DECL
8605 && !PRIMARY_TEMPLATE_P (fn
))
8606 fn
= DECL_TEMPLATE_RESULT (fn
);
8607 /* Check to see that the declaration is really present, and,
8608 possibly obtain an improved declaration. */
8609 fn
= check_classfn (context
, fn
, NULL_TREE
);
8619 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8620 template arguments, as for tsubst.
8622 Returns an appropriate tsubst'd friend type or error_mark_node on
8626 tsubst_friend_class (tree friend_tmpl
, tree args
)
8632 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8634 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8635 return TREE_TYPE (t
);
8638 context
= CP_DECL_CONTEXT (friend_tmpl
);
8640 if (context
!= global_namespace
)
8642 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8643 push_nested_namespace (context
);
8645 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8648 /* Look for a class template declaration. We look for hidden names
8649 because two friend declarations of the same template are the
8650 same. For example, in:
8653 template <typename> friend class F;
8655 template <typename> struct B {
8656 template <typename> friend class F;
8659 both F templates are the same. */
8660 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8661 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8663 /* But, if we don't find one, it might be because we're in a
8664 situation like this:
8672 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8673 for `S<int>', not the TEMPLATE_DECL. */
8674 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8676 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8677 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8680 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8682 /* The friend template has already been declared. Just
8683 check to see that the declarations match, and install any new
8684 default parameters. We must tsubst the default parameters,
8685 of course. We only need the innermost template parameters
8686 because that is all that redeclare_class_template will look
8688 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8689 > TMPL_ARGS_DEPTH (args
))
8692 location_t saved_input_location
;
8693 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8694 args
, tf_warning_or_error
);
8696 saved_input_location
= input_location
;
8697 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8698 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8699 input_location
= saved_input_location
;
8703 friend_type
= TREE_TYPE (tmpl
);
8707 /* The friend template has not already been declared. In this
8708 case, the instantiation of the template class will cause the
8709 injection of this template into the global scope. */
8710 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8711 if (tmpl
== error_mark_node
)
8712 return error_mark_node
;
8714 /* The new TMPL is not an instantiation of anything, so we
8715 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8716 the new type because that is supposed to be the corresponding
8717 template decl, i.e., TMPL. */
8718 DECL_USE_TEMPLATE (tmpl
) = 0;
8719 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8720 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8721 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8722 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8724 /* Inject this template into the global scope. */
8725 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8728 if (context
!= global_namespace
)
8730 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8731 pop_nested_namespace (context
);
8733 pop_nested_class ();
8739 /* Returns zero if TYPE cannot be completed later due to circularity.
8740 Otherwise returns one. */
8743 can_complete_type_without_circularity (tree type
)
8745 if (type
== NULL_TREE
|| type
== error_mark_node
)
8747 else if (COMPLETE_TYPE_P (type
))
8749 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8750 return can_complete_type_without_circularity (TREE_TYPE (type
));
8751 else if (CLASS_TYPE_P (type
)
8752 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
8758 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
8760 /* Apply any attributes which had to be deferred until instantiation
8761 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8762 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8765 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
8766 tree args
, tsubst_flags_t complain
, tree in_decl
)
8768 tree last_dep
= NULL_TREE
;
8772 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
8773 if (ATTR_IS_DEPENDENT (t
))
8776 attributes
= copy_list (attributes
);
8780 if (DECL_P (*decl_p
))
8782 if (TREE_TYPE (*decl_p
) == error_mark_node
)
8784 p
= &DECL_ATTRIBUTES (*decl_p
);
8787 p
= &TYPE_ATTRIBUTES (*decl_p
);
8791 tree late_attrs
= NULL_TREE
;
8792 tree
*q
= &late_attrs
;
8794 for (*p
= attributes
; *p
; )
8797 if (ATTR_IS_DEPENDENT (t
))
8799 *p
= TREE_CHAIN (t
);
8800 TREE_CHAIN (t
) = NULL_TREE
;
8801 if ((flag_openmp
|| flag_cilkplus
)
8802 && is_attribute_p ("omp declare simd",
8803 get_attribute_name (t
))
8806 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
8807 clauses
= tsubst_omp_clauses (clauses
, true, args
,
8809 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
8810 clauses
= finish_omp_clauses (clauses
);
8811 tree parms
= DECL_ARGUMENTS (*decl_p
);
8813 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
8815 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
8817 TREE_VALUE (t
) = NULL_TREE
;
8819 /* If the first attribute argument is an identifier, don't
8820 pass it through tsubst. Attributes like mode, format,
8821 cleanup and several target specific attributes expect it
8823 else if (attribute_takes_identifier_p (get_attribute_name (t
))
8827 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
8829 /*integral_constant_expression_p=*/false);
8830 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
8832 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
8837 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
8838 /*integral_constant_expression_p=*/false);
8840 q
= &TREE_CHAIN (t
);
8843 p
= &TREE_CHAIN (t
);
8846 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
8850 /* Perform (or defer) access check for typedefs that were referenced
8851 from within the template TMPL code.
8852 This is a subroutine of instantiate_decl and instantiate_class_template.
8853 TMPL is the template to consider and TARGS is the list of arguments of
8857 perform_typedefs_access_check (tree tmpl
, tree targs
)
8859 location_t saved_location
;
8861 qualified_typedef_usage_t
*iter
;
8864 || (!CLASS_TYPE_P (tmpl
)
8865 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
8868 saved_location
= input_location
;
8869 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
8871 tree type_decl
= iter
->typedef_decl
;
8872 tree type_scope
= iter
->context
;
8874 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
8877 if (uses_template_parms (type_decl
))
8878 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
8879 if (uses_template_parms (type_scope
))
8880 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
8882 /* Make access check error messages point to the location
8883 of the use of the typedef. */
8884 input_location
= iter
->locus
;
8885 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
8886 type_decl
, type_decl
,
8887 tf_warning_or_error
);
8889 input_location
= saved_location
;
8893 instantiate_class_template_1 (tree type
)
8895 tree templ
, args
, pattern
, t
, member
;
8899 unsigned int saved_maximum_field_alignment
;
8902 if (type
== error_mark_node
)
8903 return error_mark_node
;
8905 if (COMPLETE_OR_OPEN_TYPE_P (type
)
8906 || uses_template_parms (type
))
8909 /* Figure out which template is being instantiated. */
8910 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
8911 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
8913 /* Determine what specialization of the original template to
8915 t
= most_specialized_class (type
, tf_warning_or_error
);
8916 if (t
== error_mark_node
)
8918 TYPE_BEING_DEFINED (type
) = 1;
8919 return error_mark_node
;
8923 /* This TYPE is actually an instantiation of a partial
8924 specialization. We replace the innermost set of ARGS with
8925 the arguments appropriate for substitution. For example,
8928 template <class T> struct S {};
8929 template <class T> struct S<T*> {};
8931 and supposing that we are instantiating S<int*>, ARGS will
8932 presently be {int*} -- but we need {int}. */
8933 pattern
= TREE_TYPE (t
);
8934 args
= TREE_PURPOSE (t
);
8938 pattern
= TREE_TYPE (templ
);
8939 args
= CLASSTYPE_TI_ARGS (type
);
8942 /* If the template we're instantiating is incomplete, then clearly
8943 there's nothing we can do. */
8944 if (!COMPLETE_TYPE_P (pattern
))
8947 /* If we've recursively instantiated too many templates, stop. */
8948 if (! push_tinst_level (type
))
8951 /* Now we're really doing the instantiation. Mark the type as in
8952 the process of being defined. */
8953 TYPE_BEING_DEFINED (type
) = 1;
8955 /* We may be in the middle of deferred access check. Disable
8957 push_deferring_access_checks (dk_no_deferred
);
8959 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
8960 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
8961 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
8962 fn_context
= error_mark_node
;
8964 push_to_top_level ();
8965 /* Use #pragma pack from the template context. */
8966 saved_maximum_field_alignment
= maximum_field_alignment
;
8967 maximum_field_alignment
= TYPE_PRECISION (pattern
);
8969 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
8971 /* Set the input location to the most specialized template definition.
8972 This is needed if tsubsting causes an error. */
8973 typedecl
= TYPE_MAIN_DECL (pattern
);
8974 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
8975 DECL_SOURCE_LOCATION (typedecl
);
8977 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
8978 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
8979 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
8980 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
8981 if (ANON_AGGR_TYPE_P (pattern
))
8982 SET_ANON_AGGR_TYPE_P (type
);
8983 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
8985 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
8986 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
8987 /* Adjust visibility for template arguments. */
8988 determine_visibility (TYPE_MAIN_DECL (type
));
8990 if (CLASS_TYPE_P (type
))
8991 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
8993 pbinfo
= TYPE_BINFO (pattern
);
8995 /* We should never instantiate a nested class before its enclosing
8996 class; we need to look up the nested class by name before we can
8997 instantiate it, and that lookup should instantiate the enclosing
8999 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
9000 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
9002 base_list
= NULL_TREE
;
9003 if (BINFO_N_BASE_BINFOS (pbinfo
))
9009 /* We must enter the scope containing the type, as that is where
9010 the accessibility of types named in dependent bases are
9012 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9014 /* Substitute into each of the bases to determine the actual
9016 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9019 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9020 tree expanded_bases
= NULL_TREE
;
9023 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9026 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9027 args
, tf_error
, NULL_TREE
);
9028 if (expanded_bases
== error_mark_node
)
9031 len
= TREE_VEC_LENGTH (expanded_bases
);
9034 for (idx
= 0; idx
< len
; idx
++)
9037 /* Extract the already-expanded base class. */
9038 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9040 /* Substitute to figure out the base class. */
9041 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9044 if (base
== error_mark_node
)
9047 base_list
= tree_cons (access
, base
, base_list
);
9048 if (BINFO_VIRTUAL_P (pbase_binfo
))
9049 TREE_TYPE (base_list
) = integer_type_node
;
9053 /* The list is now in reverse order; correct that. */
9054 base_list
= nreverse (base_list
);
9057 pop_scope (pushed_scope
);
9059 /* Now call xref_basetypes to set up all the base-class
9061 xref_basetypes (type
, base_list
);
9063 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9064 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9065 args
, tf_error
, NULL_TREE
);
9066 fixup_attribute_variants (type
);
9068 /* Now that our base classes are set up, enter the scope of the
9069 class, so that name lookups into base classes, etc. will work
9070 correctly. This is precisely analogous to what we do in
9071 begin_class_definition when defining an ordinary non-template
9072 class, except we also need to push the enclosing classes. */
9073 push_nested_class (type
);
9075 /* Now members are processed in the order of declaration. */
9076 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9077 member
; member
= TREE_CHAIN (member
))
9079 tree t
= TREE_VALUE (member
);
9081 if (TREE_PURPOSE (member
))
9085 /* Build new CLASSTYPE_NESTED_UTDS. */
9088 bool class_template_p
;
9090 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9091 && TYPE_LANG_SPECIFIC (t
)
9092 && CLASSTYPE_IS_TEMPLATE (t
));
9093 /* If the member is a class template, then -- even after
9094 substitution -- there may be dependent types in the
9095 template argument list for the class. We increment
9096 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9097 that function will assume that no types are dependent
9098 when outside of a template. */
9099 if (class_template_p
)
9100 ++processing_template_decl
;
9101 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9102 if (class_template_p
)
9103 --processing_template_decl
;
9104 if (newtag
== error_mark_node
)
9107 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9109 tree name
= TYPE_IDENTIFIER (t
);
9111 if (class_template_p
)
9112 /* Unfortunately, lookup_template_class sets
9113 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9114 instantiation (i.e., for the type of a member
9115 template class nested within a template class.)
9116 This behavior is required for
9117 maybe_process_partial_specialization to work
9118 correctly, but is not accurate in this case;
9119 the TAG is not an instantiation of anything.
9120 (The corresponding TEMPLATE_DECL is an
9121 instantiation, but the TYPE is not.) */
9122 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9124 /* Now, we call pushtag to put this NEWTAG into the scope of
9125 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9126 pushtag calling push_template_decl. We don't have to do
9127 this for enums because it will already have been done in
9130 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9131 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9134 else if (DECL_DECLARES_FUNCTION_P (t
))
9136 /* Build new TYPE_METHODS. */
9139 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9140 ++processing_template_decl
;
9141 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9142 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9143 --processing_template_decl
;
9144 set_current_access_from_decl (r
);
9145 finish_member_declaration (r
);
9146 /* Instantiate members marked with attribute used. */
9147 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9149 if (TREE_CODE (r
) == FUNCTION_DECL
9150 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9151 cp_check_omp_declare_reduction (r
);
9155 /* Build new TYPE_FIELDS. */
9156 if (TREE_CODE (t
) == STATIC_ASSERT
)
9160 ++c_inhibit_evaluation_warnings
;
9162 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9163 tf_warning_or_error
, NULL_TREE
,
9164 /*integral_constant_expression_p=*/true);
9165 --c_inhibit_evaluation_warnings
;
9167 finish_static_assert (condition
,
9168 STATIC_ASSERT_MESSAGE (t
),
9169 STATIC_ASSERT_SOURCE_LOCATION (t
),
9172 else if (TREE_CODE (t
) != CONST_DECL
)
9175 tree vec
= NULL_TREE
;
9178 /* The file and line for this declaration, to
9179 assist in error message reporting. Since we
9180 called push_tinst_level above, we don't need to
9182 input_location
= DECL_SOURCE_LOCATION (t
);
9184 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9185 ++processing_template_decl
;
9186 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9187 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9188 --processing_template_decl
;
9190 if (TREE_CODE (r
) == TREE_VEC
)
9192 /* A capture pack became multiple fields. */
9194 len
= TREE_VEC_LENGTH (vec
);
9197 for (int i
= 0; i
< len
; ++i
)
9200 r
= TREE_VEC_ELT (vec
, i
);
9205 [t]he initialization (and any associated
9206 side-effects) of a static data member does
9207 not occur unless the static data member is
9208 itself used in a way that requires the
9209 definition of the static data member to
9212 Therefore, we do not substitute into the
9213 initialized for the static data member here. */
9214 finish_static_data_member_decl
9217 /*init_const_expr_p=*/false,
9218 /*asmspec_tree=*/NULL_TREE
,
9220 /* Instantiate members marked with attribute used. */
9221 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9224 else if (TREE_CODE (r
) == FIELD_DECL
)
9226 /* Determine whether R has a valid type and can be
9227 completed later. If R is invalid, then its type
9228 is replaced by error_mark_node. */
9229 tree rtype
= TREE_TYPE (r
);
9230 if (can_complete_type_without_circularity (rtype
))
9231 complete_type (rtype
);
9233 if (!COMPLETE_TYPE_P (rtype
))
9235 cxx_incomplete_type_error (r
, rtype
);
9236 TREE_TYPE (r
) = error_mark_node
;
9240 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9241 such a thing will already have been added to the field
9242 list by tsubst_enum in finish_member_declaration in the
9243 CLASSTYPE_NESTED_UTDS case above. */
9244 if (!(TREE_CODE (r
) == TYPE_DECL
9245 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9246 && DECL_ARTIFICIAL (r
)))
9248 set_current_access_from_decl (r
);
9249 finish_member_declaration (r
);
9257 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9258 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9260 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9262 tree friend_type
= t
;
9263 bool adjust_processing_template_decl
= false;
9265 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9267 /* template <class T> friend class C; */
9268 friend_type
= tsubst_friend_class (friend_type
, args
);
9269 adjust_processing_template_decl
= true;
9271 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9273 /* template <class T> friend class C::D; */
9274 friend_type
= tsubst (friend_type
, args
,
9275 tf_warning_or_error
, NULL_TREE
);
9276 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9277 friend_type
= TREE_TYPE (friend_type
);
9278 adjust_processing_template_decl
= true;
9280 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9281 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9283 /* This could be either
9287 when dependent_type_p is false or
9289 template <class U> friend class T::C;
9292 friend_type
= tsubst (friend_type
, args
,
9293 tf_warning_or_error
, NULL_TREE
);
9294 /* Bump processing_template_decl for correct
9295 dependent_type_p calculation. */
9296 ++processing_template_decl
;
9297 if (dependent_type_p (friend_type
))
9298 adjust_processing_template_decl
= true;
9299 --processing_template_decl
;
9301 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9302 && hidden_name_p (TYPE_NAME (friend_type
)))
9306 where C hasn't been declared yet. Let's lookup name
9307 from namespace scope directly, bypassing any name that
9308 come from dependent base class. */
9309 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9311 /* The call to xref_tag_from_type does injection for friend
9313 push_nested_namespace (ns
);
9315 xref_tag_from_type (friend_type
, NULL_TREE
,
9316 /*tag_scope=*/ts_current
);
9317 pop_nested_namespace (ns
);
9319 else if (uses_template_parms (friend_type
))
9320 /* friend class C<T>; */
9321 friend_type
= tsubst (friend_type
, args
,
9322 tf_warning_or_error
, NULL_TREE
);
9327 where C is already declared or
9329 friend class C<int>;
9331 We don't have to do anything in these cases. */
9333 if (adjust_processing_template_decl
)
9334 /* Trick make_friend_class into realizing that the friend
9335 we're adding is a template, not an ordinary class. It's
9336 important that we use make_friend_class since it will
9337 perform some error-checking and output cross-reference
9339 ++processing_template_decl
;
9341 if (friend_type
!= error_mark_node
)
9342 make_friend_class (type
, friend_type
, /*complain=*/false);
9344 if (adjust_processing_template_decl
)
9345 --processing_template_decl
;
9349 /* Build new DECL_FRIENDLIST. */
9352 /* The file and line for this declaration, to
9353 assist in error message reporting. Since we
9354 called push_tinst_level above, we don't need to
9356 input_location
= DECL_SOURCE_LOCATION (t
);
9358 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9360 ++processing_template_decl
;
9361 push_deferring_access_checks (dk_no_check
);
9364 r
= tsubst_friend_function (t
, args
);
9365 add_friend (type
, r
, /*complain=*/false);
9366 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9368 pop_deferring_access_checks ();
9369 --processing_template_decl
;
9375 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9377 tree decl
= lambda_function (type
);
9380 if (!DECL_TEMPLATE_INFO (decl
)
9381 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9382 instantiate_decl (decl
, false, false);
9384 /* We need to instantiate the capture list from the template
9385 after we've instantiated the closure members, but before we
9386 consider adding the conversion op. Also keep any captures
9387 that may have been added during instantiation of the op(). */
9388 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9390 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9391 args
, tf_warning_or_error
, NULL_TREE
,
9394 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9395 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9397 maybe_add_lambda_conv_op (type
);
9400 gcc_assert (errorcount
);
9403 /* Set the file and line number information to whatever is given for
9404 the class itself. This puts error messages involving generated
9405 implicit functions at a predictable point, and the same point
9406 that would be used for non-template classes. */
9407 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9409 unreverse_member_declarations (type
);
9410 finish_struct_1 (type
);
9411 TYPE_BEING_DEFINED (type
) = 0;
9413 /* We don't instantiate default arguments for member functions. 14.7.1:
9415 The implicit instantiation of a class template specialization causes
9416 the implicit instantiation of the declarations, but not of the
9417 definitions or default arguments, of the class member functions,
9418 member classes, static data members and member templates.... */
9420 /* Some typedefs referenced from within the template code need to be access
9421 checked at template instantiation time, i.e now. These types were
9422 added to the template at parsing time. Let's get those and perform
9423 the access checks then. */
9424 perform_typedefs_access_check (pattern
, args
);
9425 perform_deferred_access_checks (tf_warning_or_error
);
9426 pop_nested_class ();
9427 maximum_field_alignment
= saved_maximum_field_alignment
;
9429 pop_from_top_level ();
9430 pop_deferring_access_checks ();
9433 /* The vtable for a template class can be emitted in any translation
9434 unit in which the class is instantiated. When there is no key
9435 method, however, finish_struct_1 will already have added TYPE to
9436 the keyed_classes list. */
9437 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9438 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9443 /* Wrapper for instantiate_class_template_1. */
9446 instantiate_class_template (tree type
)
9449 timevar_push (TV_TEMPLATE_INST
);
9450 ret
= instantiate_class_template_1 (type
);
9451 timevar_pop (TV_TEMPLATE_INST
);
9456 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9462 else if (TYPE_P (t
))
9463 r
= tsubst (t
, args
, complain
, in_decl
);
9466 if (!(complain
& tf_warning
))
9467 ++c_inhibit_evaluation_warnings
;
9468 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9469 /*integral_constant_expression_p=*/true);
9470 if (!(complain
& tf_warning
))
9471 --c_inhibit_evaluation_warnings
;
9476 /* Given a function parameter pack TMPL_PARM and some function parameters
9477 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9478 and set *SPEC_P to point at the next point in the list. */
9481 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9483 /* Collect all of the extra "packed" parameters into an
9487 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9488 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9489 tree spec_parm
= *spec_p
;
9492 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9494 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9497 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9498 parmvec
= make_tree_vec (len
);
9499 parmtypevec
= make_tree_vec (len
);
9500 spec_parm
= *spec_p
;
9501 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9503 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9504 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9507 /* Build the argument packs. */
9508 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9509 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9510 TREE_TYPE (argpack
) = argtypepack
;
9511 *spec_p
= spec_parm
;
9516 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9517 NONTYPE_ARGUMENT_PACK. */
9520 make_fnparm_pack (tree spec_parm
)
9522 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9525 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9529 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9531 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9532 if (i
>= TREE_VEC_LENGTH (vec
))
9534 return PACK_EXPANSION_P (TREE_VEC_ELT (vec
, i
));
9538 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9541 make_argument_pack_select (tree arg_pack
, unsigned index
)
9543 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9545 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9546 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9551 /* This is a subroutine of tsubst_pack_expansion.
9553 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9554 mechanism to store the (non complete list of) arguments of the
9555 substitution and return a non substituted pack expansion, in order
9556 to wait for when we have enough arguments to really perform the
9560 use_pack_expansion_extra_args_p (tree parm_packs
,
9564 /* If one pack has an expansion and another pack has a normal
9565 argument or if one pack has an empty argument and an another
9566 one hasn't then tsubst_pack_expansion cannot perform the
9567 substitution and need to fall back on the
9568 PACK_EXPANSION_EXTRA mechanism. */
9569 if (parm_packs
== NULL_TREE
)
9571 else if (has_empty_arg
)
9574 bool has_expansion_arg
= false;
9575 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9577 bool has_non_expansion_arg
= false;
9578 for (tree parm_pack
= parm_packs
;
9580 parm_pack
= TREE_CHAIN (parm_pack
))
9582 tree arg
= TREE_VALUE (parm_pack
);
9584 if (argument_pack_element_is_expansion_p (arg
, i
))
9585 has_expansion_arg
= true;
9587 has_non_expansion_arg
= true;
9590 if (has_expansion_arg
&& has_non_expansion_arg
)
9596 /* [temp.variadic]/6 says that:
9598 The instantiation of a pack expansion [...]
9599 produces a list E1,E2, ..., En, where N is the number of elements
9600 in the pack expansion parameters.
9602 This subroutine of tsubst_pack_expansion produces one of these Ei.
9604 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9605 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9606 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9607 INDEX is the index 'i' of the element Ei to produce. ARGS,
9608 COMPLAIN, and IN_DECL are the same parameters as for the
9609 tsubst_pack_expansion function.
9611 The function returns the resulting Ei upon successful completion,
9614 Note that this function possibly modifies the ARGS parameter, so
9615 it's the responsibility of the caller to restore it. */
9618 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9621 tree args
/* This parm gets
9623 tsubst_flags_t complain
,
9627 bool ith_elem_is_expansion
= false;
9629 /* For each parameter pack, change the substitution of the parameter
9630 pack to the ith argument in its argument pack, then expand the
9632 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9634 tree parm
= TREE_PURPOSE (pack
);
9635 tree arg_pack
= TREE_VALUE (pack
);
9636 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9638 ith_elem_is_expansion
|=
9639 argument_pack_element_is_expansion_p (arg_pack
, index
);
9641 /* Select the Ith argument from the pack. */
9642 if (TREE_CODE (parm
) == PARM_DECL
9643 || TREE_CODE (parm
) == FIELD_DECL
)
9647 aps
= make_argument_pack_select (arg_pack
, index
);
9649 register_local_specialization (aps
, parm
);
9652 aps
= retrieve_local_specialization (parm
);
9657 template_parm_level_and_index (parm
, &level
, &idx
);
9661 aps
= make_argument_pack_select (arg_pack
, index
);
9662 /* Update the corresponding argument. */
9663 TMPL_ARG (args
, level
, idx
) = aps
;
9666 /* Re-use the ARGUMENT_PACK_SELECT. */
9667 aps
= TMPL_ARG (args
, level
, idx
);
9669 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9672 /* Substitute into the PATTERN with the (possibly altered)
9674 if (pattern
== in_decl
)
9675 /* Expanding a fixed parameter pack from
9676 coerce_template_parameter_pack. */
9677 t
= tsubst_decl (pattern
, args
, complain
);
9678 else if (!TYPE_P (pattern
))
9679 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9680 /*integral_constant_expression_p=*/false);
9682 t
= tsubst (pattern
, args
, complain
, in_decl
);
9684 /* If the Ith argument pack element is a pack expansion, then
9685 the Ith element resulting from the substituting is going to
9686 be a pack expansion as well. */
9687 if (ith_elem_is_expansion
)
9688 t
= make_pack_expansion (t
);
9693 /* Substitute ARGS into T, which is an pack expansion
9694 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9695 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9696 (if only a partial substitution could be performed) or
9697 ERROR_MARK_NODE if there was an error. */
9699 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9703 tree pack
, packs
= NULL_TREE
;
9704 bool unsubstituted_packs
= false;
9707 struct pointer_map_t
*saved_local_specializations
= NULL
;
9708 bool need_local_specializations
= false;
9711 gcc_assert (PACK_EXPANSION_P (t
));
9712 pattern
= PACK_EXPANSION_PATTERN (t
);
9714 /* Add in any args remembered from an earlier partial instantiation. */
9715 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9717 levels
= TMPL_ARGS_DEPTH (args
);
9719 /* Determine the argument packs that will instantiate the parameter
9720 packs used in the expansion expression. While we're at it,
9721 compute the number of arguments to be expanded and make sure it
9723 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
9724 pack
= TREE_CHAIN (pack
))
9726 tree parm_pack
= TREE_VALUE (pack
);
9727 tree arg_pack
= NULL_TREE
;
9728 tree orig_arg
= NULL_TREE
;
9731 if (TREE_CODE (parm_pack
) == BASES
)
9733 if (BASES_DIRECT (parm_pack
))
9734 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9735 args
, complain
, in_decl
, false));
9737 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9738 args
, complain
, in_decl
, false));
9740 if (TREE_CODE (parm_pack
) == PARM_DECL
)
9742 if (PACK_EXPANSION_LOCAL_P (t
))
9743 arg_pack
= retrieve_local_specialization (parm_pack
);
9746 /* We can't rely on local_specializations for a parameter
9747 name used later in a function declaration (such as in a
9748 late-specified return type). Even if it exists, it might
9749 have the wrong value for a recursive call. Just make a
9750 dummy decl, since it's only used for its type. */
9751 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
9752 if (arg_pack
&& DECL_PACK_P (arg_pack
))
9753 /* Partial instantiation of the parm_pack, we can't build
9754 up an argument pack yet. */
9755 arg_pack
= NULL_TREE
;
9757 arg_pack
= make_fnparm_pack (arg_pack
);
9758 need_local_specializations
= true;
9761 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
9762 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
9766 template_parm_level_and_index (parm_pack
, &level
, &idx
);
9768 if (level
<= levels
)
9769 arg_pack
= TMPL_ARG (args
, level
, idx
);
9772 orig_arg
= arg_pack
;
9773 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
9774 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
9776 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
9777 /* This can only happen if we forget to expand an argument
9778 pack somewhere else. Just return an error, silently. */
9780 result
= make_tree_vec (1);
9781 TREE_VEC_ELT (result
, 0) = error_mark_node
;
9788 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
9790 /* Don't bother trying to do a partial substitution with
9791 incomplete packs; we'll try again after deduction. */
9792 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
9797 else if (len
!= my_len
)
9799 if (!(complain
& tf_error
))
9800 /* Fail quietly. */;
9801 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
9802 error ("mismatched argument pack lengths while expanding "
9806 error ("mismatched argument pack lengths while expanding "
9809 return error_mark_node
;
9812 /* Keep track of the parameter packs and their corresponding
9814 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
9815 TREE_TYPE (packs
) = orig_arg
;
9819 /* We can't substitute for this parameter pack. We use a flag as
9820 well as the missing_level counter because function parameter
9821 packs don't have a level. */
9822 unsubstituted_packs
= true;
9826 /* We cannot expand this expansion expression, because we don't have
9827 all of the argument packs we need. */
9828 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
9830 /* We got some full packs, but we can't substitute them in until we
9831 have values for all the packs. So remember these until then. */
9833 t
= make_pack_expansion (pattern
);
9834 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
9837 else if (unsubstituted_packs
)
9839 /* There were no real arguments, we're just replacing a parameter
9840 pack with another version of itself. Substitute into the
9841 pattern and return a PACK_EXPANSION_*. The caller will need to
9843 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
9844 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9845 /*integral_constant_expression_p=*/false);
9847 t
= tsubst (pattern
, args
, complain
, in_decl
);
9848 t
= make_pack_expansion (t
);
9852 gcc_assert (len
>= 0);
9854 if (need_local_specializations
)
9856 /* We're in a late-specified return type, so create our own local
9857 specializations map; the current map is either NULL or (in the
9858 case of recursive unification) might have bindings that we don't
9859 want to use or alter. */
9860 saved_local_specializations
= local_specializations
;
9861 local_specializations
= pointer_map_create ();
9864 /* For each argument in each argument pack, substitute into the
9866 result
= make_tree_vec (len
);
9867 for (i
= 0; i
< len
; ++i
)
9869 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
9873 TREE_VEC_ELT (result
, i
) = t
;
9874 if (t
== error_mark_node
)
9876 result
= error_mark_node
;
9881 /* Update ARGS to restore the substitution from parameter packs to
9882 their argument packs. */
9883 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
9885 tree parm
= TREE_PURPOSE (pack
);
9887 if (TREE_CODE (parm
) == PARM_DECL
9888 || TREE_CODE (parm
) == FIELD_DECL
)
9889 register_local_specialization (TREE_TYPE (pack
), parm
);
9894 if (TREE_VALUE (pack
) == NULL_TREE
)
9897 template_parm_level_and_index (parm
, &level
, &idx
);
9899 /* Update the corresponding argument. */
9900 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
9901 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
9904 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
9908 if (need_local_specializations
)
9910 pointer_map_destroy (local_specializations
);
9911 local_specializations
= saved_local_specializations
;
9917 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
9918 TMPL. We do this using DECL_PARM_INDEX, which should work even with
9919 parameter packs; all parms generated from a function parameter pack will
9920 have the same DECL_PARM_INDEX. */
9923 get_pattern_parm (tree parm
, tree tmpl
)
9925 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
9928 if (DECL_ARTIFICIAL (parm
))
9930 for (patparm
= DECL_ARGUMENTS (pattern
);
9931 patparm
; patparm
= DECL_CHAIN (patparm
))
9932 if (DECL_ARTIFICIAL (patparm
)
9933 && DECL_NAME (parm
) == DECL_NAME (patparm
))
9938 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
9939 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
9940 gcc_assert (DECL_PARM_INDEX (patparm
)
9941 == DECL_PARM_INDEX (parm
));
9947 /* Substitute ARGS into the vector or list of template arguments T. */
9950 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9953 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
9956 if (t
== error_mark_node
)
9957 return error_mark_node
;
9959 len
= TREE_VEC_LENGTH (t
);
9960 elts
= XALLOCAVEC (tree
, len
);
9962 for (i
= 0; i
< len
; i
++)
9964 tree orig_arg
= TREE_VEC_ELT (t
, i
);
9967 if (TREE_CODE (orig_arg
) == TREE_VEC
)
9968 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
9969 else if (PACK_EXPANSION_P (orig_arg
))
9971 /* Substitute into an expansion expression. */
9972 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
9974 if (TREE_CODE (new_arg
) == TREE_VEC
)
9975 /* Add to the expanded length adjustment the number of
9976 expanded arguments. We subtract one from this
9977 measurement, because the argument pack expression
9978 itself is already counted as 1 in
9979 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
9980 the argument pack is empty. */
9981 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
9983 else if (ARGUMENT_PACK_P (orig_arg
))
9985 /* Substitute into each of the arguments. */
9986 new_arg
= TYPE_P (orig_arg
)
9987 ? cxx_make_type (TREE_CODE (orig_arg
))
9988 : make_node (TREE_CODE (orig_arg
));
9990 SET_ARGUMENT_PACK_ARGS (
9992 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
9993 args
, complain
, in_decl
));
9995 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
9996 new_arg
= error_mark_node
;
9998 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
9999 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
10000 complain
, in_decl
);
10001 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
10003 if (TREE_TYPE (new_arg
) == error_mark_node
)
10004 new_arg
= error_mark_node
;
10008 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
10010 if (new_arg
== error_mark_node
)
10011 return error_mark_node
;
10014 if (new_arg
!= orig_arg
)
10021 /* Make space for the expanded arguments coming from template
10023 t
= make_tree_vec (len
+ expanded_len_adjust
);
10024 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10025 arguments for a member template.
10026 In that case each TREE_VEC in ORIG_T represents a level of template
10027 arguments, and ORIG_T won't carry any non defaulted argument count.
10028 It will rather be the nested TREE_VECs that will carry one.
10029 In other words, ORIG_T carries a non defaulted argument count only
10030 if it doesn't contain any nested TREE_VEC. */
10031 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
10033 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
10034 count
+= expanded_len_adjust
;
10035 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
10037 for (i
= 0, out
= 0; i
< len
; i
++)
10039 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
10040 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
10041 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10045 /* Now expand the template argument pack "in place". */
10046 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10047 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10051 TREE_VEC_ELT (t
, out
) = elts
[i
];
10059 /* Return the result of substituting ARGS into the template parameters
10060 given by PARMS. If there are m levels of ARGS and m + n levels of
10061 PARMS, then the result will contain n levels of PARMS. For
10062 example, if PARMS is `template <class T> template <class U>
10063 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10064 result will be `template <int*, double, class V>'. */
10067 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10069 tree r
= NULL_TREE
;
10072 /* When substituting into a template, we must set
10073 PROCESSING_TEMPLATE_DECL as the template parameters may be
10074 dependent if they are based on one-another, and the dependency
10075 predicates are short-circuit outside of templates. */
10076 ++processing_template_decl
;
10078 for (new_parms
= &r
;
10079 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10080 new_parms
= &(TREE_CHAIN (*new_parms
)),
10081 parms
= TREE_CHAIN (parms
))
10084 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10087 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10091 if (parms
== error_mark_node
)
10094 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10096 if (tuple
== error_mark_node
)
10099 TREE_VEC_ELT (new_vec
, i
) =
10100 tsubst_template_parm (tuple
, args
, complain
);
10104 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10105 - TMPL_ARGS_DEPTH (args
)),
10106 new_vec
, NULL_TREE
);
10109 --processing_template_decl
;
10114 /* Return the result of substituting ARGS into one template parameter
10115 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10116 parameter and which TREE_PURPOSE is the default argument of the
10117 template parameter. */
10120 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10122 tree default_value
, parm_decl
;
10124 if (args
== NULL_TREE
10126 || t
== error_mark_node
)
10129 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10131 default_value
= TREE_PURPOSE (t
);
10132 parm_decl
= TREE_VALUE (t
);
10134 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10135 if (TREE_CODE (parm_decl
) == PARM_DECL
10136 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10137 parm_decl
= error_mark_node
;
10138 default_value
= tsubst_template_arg (default_value
, args
,
10139 complain
, NULL_TREE
);
10141 return build_tree_list (default_value
, parm_decl
);
10144 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10145 type T. If T is not an aggregate or enumeration type, it is
10146 handled as if by tsubst. IN_DECL is as for tsubst. If
10147 ENTERING_SCOPE is nonzero, T is the context for a template which
10148 we are presently tsubst'ing. Return the substituted value. */
10151 tsubst_aggr_type (tree t
,
10153 tsubst_flags_t complain
,
10155 int entering_scope
)
10157 if (t
== NULL_TREE
)
10160 switch (TREE_CODE (t
))
10163 if (TYPE_PTRMEMFUNC_P (t
))
10164 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10166 /* Else fall through. */
10167 case ENUMERAL_TYPE
:
10169 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10174 int saved_unevaluated_operand
;
10175 int saved_inhibit_evaluation_warnings
;
10177 /* In "sizeof(X<I>)" we need to evaluate "I". */
10178 saved_unevaluated_operand
= cp_unevaluated_operand
;
10179 cp_unevaluated_operand
= 0;
10180 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10181 c_inhibit_evaluation_warnings
= 0;
10183 /* First, determine the context for the type we are looking
10185 context
= TYPE_CONTEXT (t
);
10186 if (context
&& TYPE_P (context
))
10188 context
= tsubst_aggr_type (context
, args
, complain
,
10189 in_decl
, /*entering_scope=*/1);
10190 /* If context is a nested class inside a class template,
10191 it may still need to be instantiated (c++/33959). */
10192 context
= complete_type (context
);
10195 /* Then, figure out what arguments are appropriate for the
10196 type we are trying to find. For example, given:
10198 template <class T> struct S;
10199 template <class T, class U> void f(T, U) { S<U> su; }
10201 and supposing that we are instantiating f<int, double>,
10202 then our ARGS will be {int, double}, but, when looking up
10203 S we only want {double}. */
10204 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10205 complain
, in_decl
);
10206 if (argvec
== error_mark_node
)
10207 r
= error_mark_node
;
10210 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10211 entering_scope
, complain
);
10212 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10215 cp_unevaluated_operand
= saved_unevaluated_operand
;
10216 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10221 /* This is not a template type, so there's nothing to do. */
10225 return tsubst (t
, args
, complain
, in_decl
);
10229 /* Substitute into the default argument ARG (a default argument for
10230 FN), which has the indicated TYPE. */
10233 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10235 tree saved_class_ptr
= NULL_TREE
;
10236 tree saved_class_ref
= NULL_TREE
;
10237 int errs
= errorcount
+ sorrycount
;
10239 /* This can happen in invalid code. */
10240 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10243 /* This default argument came from a template. Instantiate the
10244 default argument here, not in tsubst. In the case of
10253 we must be careful to do name lookup in the scope of S<T>,
10254 rather than in the current class. */
10255 push_access_scope (fn
);
10256 /* The "this" pointer is not valid in a default argument. */
10259 saved_class_ptr
= current_class_ptr
;
10260 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10261 saved_class_ref
= current_class_ref
;
10262 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10265 push_deferring_access_checks(dk_no_deferred
);
10266 /* The default argument expression may cause implicitly defined
10267 member functions to be synthesized, which will result in garbage
10268 collection. We must treat this situation as if we were within
10269 the body of function so as to avoid collecting live data on the
10272 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10273 complain
, NULL_TREE
,
10274 /*integral_constant_expression_p=*/false);
10276 pop_deferring_access_checks();
10278 /* Restore the "this" pointer. */
10281 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10282 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10285 if (errorcount
+sorrycount
> errs
10286 && (complain
& tf_warning_or_error
))
10287 inform (input_location
,
10288 " when instantiating default argument for call to %D", fn
);
10290 /* Make sure the default argument is reasonable. */
10291 arg
= check_default_argument (type
, arg
, complain
);
10293 pop_access_scope (fn
);
10298 /* Substitute into all the default arguments for FN. */
10301 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10306 tmpl_args
= DECL_TI_ARGS (fn
);
10308 /* If this function is not yet instantiated, we certainly don't need
10309 its default arguments. */
10310 if (uses_template_parms (tmpl_args
))
10312 /* Don't do this again for clones. */
10313 if (DECL_CLONED_FUNCTION_P (fn
))
10316 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10318 arg
= TREE_CHAIN (arg
))
10319 if (TREE_PURPOSE (arg
))
10320 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10322 TREE_PURPOSE (arg
),
10326 /* Substitute the ARGS into the T, which is a _DECL. Return the
10327 result of the substitution. Issue error and warning messages under
10328 control of COMPLAIN. */
10331 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10333 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10334 location_t saved_loc
;
10335 tree r
= NULL_TREE
;
10337 hashval_t hash
= 0;
10339 /* Set the filename and linenumber to improve error-reporting. */
10340 saved_loc
= input_location
;
10341 input_location
= DECL_SOURCE_LOCATION (t
);
10343 switch (TREE_CODE (t
))
10345 case TEMPLATE_DECL
:
10347 /* We can get here when processing a member function template,
10348 member class template, or template template parameter. */
10349 tree decl
= DECL_TEMPLATE_RESULT (t
);
10354 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10356 /* Template template parameter is treated here. */
10357 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10358 if (new_type
== error_mark_node
)
10359 RETURN (error_mark_node
);
10360 /* If we get a real template back, return it. This can happen in
10361 the context of most_specialized_class. */
10362 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10366 DECL_CHAIN (r
) = NULL_TREE
;
10367 TREE_TYPE (r
) = new_type
;
10368 DECL_TEMPLATE_RESULT (r
)
10369 = build_decl (DECL_SOURCE_LOCATION (decl
),
10370 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10371 DECL_TEMPLATE_PARMS (r
)
10372 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10374 TYPE_NAME (new_type
) = r
;
10378 /* We might already have an instance of this template.
10379 The ARGS are for the surrounding class type, so the
10380 full args contain the tsubst'd args for the context,
10381 plus the innermost args from the template decl. */
10382 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10383 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10384 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10385 /* Because this is a template, the arguments will still be
10386 dependent, even after substitution. If
10387 PROCESSING_TEMPLATE_DECL is not set, the dependency
10388 predicates will short-circuit. */
10389 ++processing_template_decl
;
10390 full_args
= tsubst_template_args (tmpl_args
, args
,
10391 complain
, in_decl
);
10392 --processing_template_decl
;
10393 if (full_args
== error_mark_node
)
10394 RETURN (error_mark_node
);
10396 /* If this is a default template template argument,
10397 tsubst might not have changed anything. */
10398 if (full_args
== tmpl_args
)
10401 hash
= hash_tmpl_and_args (t
, full_args
);
10402 spec
= retrieve_specialization (t
, full_args
, hash
);
10403 if (spec
!= NULL_TREE
)
10409 /* Make a new template decl. It will be similar to the
10410 original, but will record the current template arguments.
10411 We also create a new function declaration, which is just
10412 like the old one, but points to this new template, rather
10413 than the old one. */
10415 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10416 DECL_CHAIN (r
) = NULL_TREE
;
10418 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10420 if (TREE_CODE (decl
) == TYPE_DECL
10421 && !TYPE_DECL_ALIAS_P (decl
))
10424 ++processing_template_decl
;
10425 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10426 --processing_template_decl
;
10427 if (new_type
== error_mark_node
)
10428 RETURN (error_mark_node
);
10430 TREE_TYPE (r
) = new_type
;
10431 /* For a partial specialization, we need to keep pointing to
10432 the primary template. */
10433 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10434 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10435 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10436 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10437 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10442 ++processing_template_decl
;
10443 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10444 --processing_template_decl
;
10445 if (new_decl
== error_mark_node
)
10446 RETURN (error_mark_node
);
10448 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10449 DECL_TI_TEMPLATE (new_decl
) = r
;
10450 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10451 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10452 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10455 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10456 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10457 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10459 /* The template parameters for this new template are all the
10460 template parameters for the old template, except the
10461 outermost level of parameters. */
10462 DECL_TEMPLATE_PARMS (r
)
10463 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10466 if (PRIMARY_TEMPLATE_P (t
))
10467 DECL_PRIMARY_TEMPLATE (r
) = r
;
10469 if (TREE_CODE (decl
) != TYPE_DECL
)
10470 /* Record this non-type partial instantiation. */
10471 register_specialization (r
, t
,
10472 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10477 case FUNCTION_DECL
:
10480 tree argvec
= NULL_TREE
;
10488 /* Nobody should be tsubst'ing into non-template functions. */
10489 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10491 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10496 /* If T is not dependent, just return it. We have to
10497 increment PROCESSING_TEMPLATE_DECL because
10498 value_dependent_expression_p assumes that nothing is
10499 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10500 ++processing_template_decl
;
10501 dependent_p
= value_dependent_expression_p (t
);
10502 --processing_template_decl
;
10506 /* Calculate the most general template of which R is a
10507 specialization, and the complete set of arguments used to
10509 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10510 argvec
= tsubst_template_args (DECL_TI_ARGS
10511 (DECL_TEMPLATE_RESULT
10512 (DECL_TI_TEMPLATE (t
))),
10513 args
, complain
, in_decl
);
10514 if (argvec
== error_mark_node
)
10515 RETURN (error_mark_node
);
10517 /* Check to see if we already have this specialization. */
10518 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10519 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10527 /* We can see more levels of arguments than parameters if
10528 there was a specialization of a member template, like
10531 template <class T> struct S { template <class U> void f(); }
10532 template <> template <class U> void S<int>::f(U);
10534 Here, we'll be substituting into the specialization,
10535 because that's where we can find the code we actually
10536 want to generate, but we'll have enough arguments for
10537 the most general template.
10539 We also deal with the peculiar case:
10541 template <class T> struct S {
10542 template <class U> friend void f();
10544 template <class U> void f() {}
10546 template void f<double>();
10548 Here, the ARGS for the instantiation of will be {int,
10549 double}. But, we only need as many ARGS as there are
10550 levels of template parameters in CODE_PATTERN. We are
10551 careful not to get fooled into reducing the ARGS in
10554 template <class T> struct S { template <class U> void f(U); }
10555 template <class T> template <> void S<T>::f(int) {}
10557 which we can spot because the pattern will be a
10558 specialization in this case. */
10559 args_depth
= TMPL_ARGS_DEPTH (args
);
10561 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10562 if (args_depth
> parms_depth
10563 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10564 args
= get_innermost_template_args (args
, parms_depth
);
10568 /* This special case arises when we have something like this:
10570 template <class T> struct S {
10571 friend void f<int>(int, double);
10574 Here, the DECL_TI_TEMPLATE for the friend declaration
10575 will be an IDENTIFIER_NODE. We are being called from
10576 tsubst_friend_function, and we want only to create a
10577 new decl (R) with appropriate types so that we can call
10578 determine_specialization. */
10579 gen_tmpl
= NULL_TREE
;
10582 if (DECL_CLASS_SCOPE_P (t
))
10584 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10588 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10589 complain
, t
, /*entering_scope=*/1);
10594 ctx
= DECL_CONTEXT (t
);
10596 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10597 if (type
== error_mark_node
)
10598 RETURN (error_mark_node
);
10600 /* If we hit excessive deduction depth, the type is bogus even if
10601 it isn't error_mark_node, so don't build a decl. */
10602 if (excessive_deduction_depth
)
10603 RETURN (error_mark_node
);
10605 /* We do NOT check for matching decls pushed separately at this
10606 point, as they may not represent instantiations of this
10607 template, and in any case are considered separate under the
10610 DECL_USE_TEMPLATE (r
) = 0;
10611 TREE_TYPE (r
) = type
;
10612 /* Clear out the mangled name and RTL for the instantiation. */
10613 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10614 SET_DECL_RTL (r
, NULL
);
10615 /* Leave DECL_INITIAL set on deleted instantiations. */
10616 if (!DECL_DELETED_FN (r
))
10617 DECL_INITIAL (r
) = NULL_TREE
;
10618 DECL_CONTEXT (r
) = ctx
;
10620 /* OpenMP UDRs have the only argument a reference to the declared
10621 type. We want to diagnose if the declared type is a reference,
10622 which is invalid, but as references to references are usually
10623 quietly merged, diagnose it here. */
10624 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10627 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10628 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10629 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10630 error_at (DECL_SOURCE_LOCATION (t
),
10631 "reference type %qT in "
10632 "%<#pragma omp declare reduction%>", argtype
);
10633 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10634 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10638 if (member
&& DECL_CONV_FN_P (r
))
10639 /* Type-conversion operator. Reconstruct the name, in
10640 case it's the name of one of the template's parameters. */
10641 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10643 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10645 DECL_RESULT (r
) = NULL_TREE
;
10647 TREE_STATIC (r
) = 0;
10648 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10649 DECL_EXTERNAL (r
) = 1;
10650 /* If this is an instantiation of a function with internal
10651 linkage, we already know what object file linkage will be
10652 assigned to the instantiation. */
10653 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10654 DECL_DEFER_OUTPUT (r
) = 0;
10655 DECL_CHAIN (r
) = NULL_TREE
;
10656 DECL_PENDING_INLINE_INFO (r
) = 0;
10657 DECL_PENDING_INLINE_P (r
) = 0;
10658 DECL_SAVED_TREE (r
) = NULL_TREE
;
10659 DECL_STRUCT_FUNCTION (r
) = NULL
;
10661 /* We'll re-clone as appropriate in instantiate_template. */
10662 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10664 /* If we aren't complaining now, return on error before we register
10665 the specialization so that we'll complain eventually. */
10666 if ((complain
& tf_error
) == 0
10667 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10668 && !grok_op_properties (r
, /*complain=*/false))
10669 RETURN (error_mark_node
);
10671 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10672 this in the special friend case mentioned above where
10673 GEN_TMPL is NULL. */
10676 DECL_TEMPLATE_INFO (r
)
10677 = build_template_info (gen_tmpl
, argvec
);
10678 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10681 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10683 /* We instantiated this while substituting into
10684 the type earlier (template/friend54.C). */
10687 /* We're not supposed to instantiate default arguments
10688 until they are called, for a template. But, for a
10691 template <class T> void f ()
10692 { extern void g(int i = T()); }
10694 we should do the substitution when the template is
10695 instantiated. We handle the member function case in
10696 instantiate_class_template since the default arguments
10697 might refer to other members of the class. */
10699 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10700 && !uses_template_parms (argvec
))
10701 tsubst_default_arguments (r
, complain
);
10704 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10706 /* Copy the list of befriending classes. */
10707 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10709 friends
= &TREE_CHAIN (*friends
))
10711 *friends
= copy_node (*friends
);
10712 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
10717 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
10719 maybe_retrofit_in_chrg (r
);
10720 if (DECL_CONSTRUCTOR_P (r
))
10721 grok_ctor_properties (ctx
, r
);
10722 if (DECL_INHERITED_CTOR_BASE (r
))
10723 deduce_inheriting_ctor (r
);
10724 /* If this is an instantiation of a member template, clone it.
10725 If it isn't, that'll be handled by
10726 clone_constructors_and_destructors. */
10727 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
10728 clone_function_decl (r
, /*update_method_vec_p=*/0);
10730 else if ((complain
& tf_error
) != 0
10731 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10732 && !grok_op_properties (r
, /*complain=*/true))
10733 RETURN (error_mark_node
);
10735 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
10736 SET_DECL_FRIEND_CONTEXT (r
,
10737 tsubst (DECL_FRIEND_CONTEXT (t
),
10738 args
, complain
, in_decl
));
10740 /* Possibly limit visibility based on template args. */
10741 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10742 if (DECL_VISIBILITY_SPECIFIED (t
))
10744 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10745 DECL_ATTRIBUTES (r
)
10746 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10748 determine_visibility (r
);
10749 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
10750 && !processing_template_decl
)
10751 defaulted_late_check (r
);
10753 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10754 args
, complain
, in_decl
);
10760 tree type
= NULL_TREE
;
10762 tree expanded_types
= NULL_TREE
;
10763 tree prev_r
= NULL_TREE
;
10764 tree first_r
= NULL_TREE
;
10766 if (DECL_PACK_P (t
))
10768 /* If there is a local specialization that isn't a
10769 parameter pack, it means that we're doing a "simple"
10770 substitution from inside tsubst_pack_expansion. Just
10771 return the local specialization (which will be a single
10773 tree spec
= retrieve_local_specialization (t
);
10775 && TREE_CODE (spec
) == PARM_DECL
10776 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
10779 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10780 the parameters in this function parameter pack. */
10781 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10782 complain
, in_decl
);
10783 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10785 len
= TREE_VEC_LENGTH (expanded_types
);
10787 /* Zero-length parameter packs are boring. Just substitute
10790 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
10795 /* All we did was update the type. Make a note of that. */
10796 type
= expanded_types
;
10797 expanded_types
= NULL_TREE
;
10801 /* Loop through all of the parameters we'll build. When T is
10802 a function parameter pack, LEN is the number of expanded
10803 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10805 for (i
= 0; i
< len
; ++i
)
10809 if (DECL_TEMPLATE_PARM_P (t
))
10810 SET_DECL_TEMPLATE_PARM_P (r
);
10812 if (expanded_types
)
10813 /* We're on the Ith parameter of the function parameter
10816 /* Get the Ith type. */
10817 type
= TREE_VEC_ELT (expanded_types
, i
);
10819 /* Rename the parameter to include the index. */
10821 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10824 /* We're dealing with a normal parameter. */
10825 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10827 type
= type_decays_to (type
);
10828 TREE_TYPE (r
) = type
;
10829 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10831 if (DECL_INITIAL (r
))
10833 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
10834 DECL_INITIAL (r
) = TREE_TYPE (r
);
10836 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
10837 complain
, in_decl
);
10840 DECL_CONTEXT (r
) = NULL_TREE
;
10842 if (!DECL_TEMPLATE_PARM_P (r
))
10843 DECL_ARG_TYPE (r
) = type_passed_as (type
);
10845 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10846 args
, complain
, in_decl
);
10848 /* Keep track of the first new parameter we
10849 generate. That's what will be returned to the
10854 /* Build a proper chain of parameters when substituting
10855 into a function parameter pack. */
10857 DECL_CHAIN (prev_r
) = r
;
10860 /* If cp_unevaluated_operand is set, we're just looking for a
10861 single dummy parameter, so don't keep going. */
10862 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
10863 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
10864 complain
, DECL_CHAIN (t
));
10866 /* FIRST_R contains the start of the chain we've built. */
10873 tree type
= NULL_TREE
;
10874 tree vec
= NULL_TREE
;
10875 tree expanded_types
= NULL_TREE
;
10878 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
10880 /* This field is a lambda capture pack. Return a TREE_VEC of
10881 the expanded fields to instantiate_class_template_1 and
10882 store them in the specializations hash table as a
10883 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
10884 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10885 complain
, in_decl
);
10886 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10888 len
= TREE_VEC_LENGTH (expanded_types
);
10889 vec
= make_tree_vec (len
);
10893 /* All we did was update the type. Make a note of that. */
10894 type
= expanded_types
;
10895 expanded_types
= NULL_TREE
;
10899 for (int i
= 0; i
< len
; ++i
)
10902 if (expanded_types
)
10904 type
= TREE_VEC_ELT (expanded_types
, i
);
10906 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10909 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10911 if (type
== error_mark_node
)
10912 RETURN (error_mark_node
);
10913 TREE_TYPE (r
) = type
;
10914 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10916 if (DECL_C_BIT_FIELD (r
))
10917 /* For bit-fields, DECL_INITIAL gives the number of bits. For
10918 non-bit-fields DECL_INITIAL is a non-static data member
10919 initializer, which gets deferred instantiation. */
10921 = tsubst_expr (DECL_INITIAL (t
), args
,
10923 /*integral_constant_expression_p=*/true);
10924 else if (DECL_INITIAL (t
))
10926 /* Set up DECL_TEMPLATE_INFO so that we can get at the
10927 NSDMI in perform_member_init. Still set DECL_INITIAL
10928 so that we know there is one. */
10929 DECL_INITIAL (r
) = void_node
;
10930 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
10931 retrofit_lang_decl (r
);
10932 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10934 /* We don't have to set DECL_CONTEXT here; it is set by
10935 finish_member_declaration. */
10936 DECL_CHAIN (r
) = NULL_TREE
;
10938 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10939 args
, complain
, in_decl
);
10942 TREE_VEC_ELT (vec
, i
) = r
;
10948 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
10949 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
10950 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
10951 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
10952 TREE_TYPE (pack
) = tpack
;
10953 register_specialization (pack
, t
, args
, false, 0);
10959 /* We reach here only for member using decls. We also need to check
10960 uses_template_parms because DECL_DEPENDENT_P is not set for a
10961 using-declaration that designates a member of the current
10962 instantiation (c++/53549). */
10963 if (DECL_DEPENDENT_P (t
)
10964 || uses_template_parms (USING_DECL_SCOPE (t
)))
10966 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
10967 complain
, in_decl
);
10968 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
10969 r
= do_class_using_decl (inst_scope
, name
);
10971 r
= error_mark_node
;
10974 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
10975 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
10981 DECL_CHAIN (r
) = NULL_TREE
;
10988 tree argvec
= NULL_TREE
;
10989 tree gen_tmpl
= NULL_TREE
;
10991 tree tmpl
= NULL_TREE
;
10993 tree type
= NULL_TREE
;
10996 if (TREE_TYPE (t
) == error_mark_node
)
10997 RETURN (error_mark_node
);
10999 if (TREE_CODE (t
) == TYPE_DECL
11000 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
11002 /* If this is the canonical decl, we don't have to
11003 mess with instantiations, and often we can't (for
11004 typename, template type parms and such). Note that
11005 TYPE_NAME is not correct for the above test if
11006 we've copied the type for a typedef. */
11007 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11008 if (type
== error_mark_node
)
11009 RETURN (error_mark_node
);
11010 r
= TYPE_NAME (type
);
11014 /* Check to see if we already have the specialization we
11017 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
11019 /* T is a static data member or namespace-scope entity.
11020 We have to substitute into namespace-scope variables
11021 (even though such entities are never templates) because
11024 template <class T> void f() { extern T t; }
11026 where the entity referenced is not known until
11027 instantiation time. */
11029 ctx
= DECL_CONTEXT (t
);
11030 if (DECL_CLASS_SCOPE_P (t
))
11032 ctx
= tsubst_aggr_type (ctx
, args
,
11034 in_decl
, /*entering_scope=*/1);
11035 /* If CTX is unchanged, then T is in fact the
11036 specialization we want. That situation occurs when
11037 referencing a static data member within in its own
11038 class. We can use pointer equality, rather than
11039 same_type_p, because DECL_CONTEXT is always
11041 if (ctx
== DECL_CONTEXT (t
)
11042 && (TREE_CODE (t
) != TYPE_DECL
11043 /* ... unless T is a member template; in which
11044 case our caller can be willing to create a
11045 specialization of that template represented
11047 || !(DECL_TI_TEMPLATE (t
)
11048 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))))
11054 tmpl
= DECL_TI_TEMPLATE (t
);
11055 gen_tmpl
= most_general_template (tmpl
);
11056 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11057 if (argvec
== error_mark_node
)
11058 RETURN (error_mark_node
);
11059 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11060 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11065 /* A local variable. */
11067 /* Subsequent calls to pushdecl will fill this in. */
11069 spec
= retrieve_local_specialization (t
);
11071 /* If we already have the specialization we need, there is
11072 nothing more to do. */
11079 /* Create a new node for the specialization we need. */
11081 if (type
== NULL_TREE
)
11083 if (is_typedef_decl (t
))
11084 type
= DECL_ORIGINAL_TYPE (t
);
11086 type
= TREE_TYPE (t
);
11088 && VAR_HAD_UNKNOWN_BOUND (t
)
11089 && type
!= error_mark_node
)
11090 type
= strip_array_domain (type
);
11091 type
= tsubst (type
, args
, complain
, in_decl
);
11095 /* Even if the original location is out of scope, the
11096 newly substituted one is not. */
11097 DECL_DEAD_FOR_LOCAL (r
) = 0;
11098 DECL_INITIALIZED_P (r
) = 0;
11099 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11100 if (type
== error_mark_node
)
11101 RETURN (error_mark_node
);
11102 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11104 /* It may seem that this case cannot occur, since:
11109 declares a function, not a variable. However:
11112 template <typename T> void g() { T t; }
11113 template void g<f>();
11115 is an attempt to declare a variable with function
11117 error ("variable %qD has function type",
11118 /* R is not yet sufficiently initialized, so we
11119 just use its name. */
11121 RETURN (error_mark_node
);
11123 type
= complete_type (type
);
11124 /* Wait until cp_finish_decl to set this again, to handle
11125 circular dependency (template/instantiate6.C). */
11126 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11127 type
= check_var_type (DECL_NAME (r
), type
);
11129 if (DECL_HAS_VALUE_EXPR_P (t
))
11131 tree ve
= DECL_VALUE_EXPR (t
);
11132 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11133 /*constant_expression_p=*/false);
11134 if (REFERENCE_REF_P (ve
))
11136 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11137 ve
= TREE_OPERAND (ve
, 0);
11139 SET_DECL_VALUE_EXPR (r
, ve
);
11142 else if (DECL_SELF_REFERENCE_P (t
))
11143 SET_DECL_SELF_REFERENCE_P (r
);
11144 TREE_TYPE (r
) = type
;
11145 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11146 DECL_CONTEXT (r
) = ctx
;
11147 /* Clear out the mangled name and RTL for the instantiation. */
11148 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11149 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11150 SET_DECL_RTL (r
, NULL
);
11151 /* The initializer must not be expanded until it is required;
11152 see [temp.inst]. */
11153 DECL_INITIAL (r
) = NULL_TREE
;
11154 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11155 SET_DECL_RTL (r
, NULL
);
11156 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11159 /* Possibly limit visibility based on template args. */
11160 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11161 if (DECL_VISIBILITY_SPECIFIED (t
))
11163 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11164 DECL_ATTRIBUTES (r
)
11165 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11167 determine_visibility (r
);
11172 /* A static data member declaration is always marked
11173 external when it is declared in-class, even if an
11174 initializer is present. We mimic the non-template
11175 processing here. */
11176 DECL_EXTERNAL (r
) = 1;
11178 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11179 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11180 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11182 else if (!cp_unevaluated_operand
)
11183 register_local_specialization (r
, t
);
11185 DECL_CHAIN (r
) = NULL_TREE
;
11187 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11189 args
, complain
, in_decl
);
11191 /* Preserve a typedef that names a type. */
11192 if (is_typedef_decl (r
))
11194 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11195 set_underlying_type (r
);
11198 layout_decl (r
, 0);
11203 gcc_unreachable ();
11208 /* Restore the file and line information. */
11209 input_location
= saved_loc
;
11214 /* Substitute into the ARG_TYPES of a function type.
11215 If END is a TREE_CHAIN, leave it and any following types
11219 tsubst_arg_types (tree arg_types
,
11222 tsubst_flags_t complain
,
11225 tree remaining_arg_types
;
11226 tree type
= NULL_TREE
;
11228 tree expanded_args
= NULL_TREE
;
11231 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11234 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11235 args
, end
, complain
, in_decl
);
11236 if (remaining_arg_types
== error_mark_node
)
11237 return error_mark_node
;
11239 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11241 /* For a pack expansion, perform substitution on the
11242 entire expression. Later on, we'll handle the arguments
11244 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11245 args
, complain
, in_decl
);
11247 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11248 /* So that we'll spin through the parameters, one by one. */
11249 i
= TREE_VEC_LENGTH (expanded_args
);
11252 /* We only partially substituted into the parameter
11253 pack. Our type is TYPE_PACK_EXPANSION. */
11254 type
= expanded_args
;
11255 expanded_args
= NULL_TREE
;
11263 type
= TREE_VEC_ELT (expanded_args
, i
);
11265 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11267 if (type
== error_mark_node
)
11268 return error_mark_node
;
11269 if (VOID_TYPE_P (type
))
11271 if (complain
& tf_error
)
11273 error ("invalid parameter type %qT", type
);
11275 error ("in declaration %q+D", in_decl
);
11277 return error_mark_node
;
11280 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11281 return error_mark_node
;
11283 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11284 top-level qualifiers as required. */
11285 type
= cv_unqualified (type_decays_to (type
));
11287 /* We do not substitute into default arguments here. The standard
11288 mandates that they be instantiated only when needed, which is
11289 done in build_over_call. */
11290 default_arg
= TREE_PURPOSE (arg_types
);
11292 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11294 /* We've instantiated a template before its default arguments
11295 have been parsed. This can happen for a nested template
11296 class, and is not an error unless we require the default
11297 argument in a call of this function. */
11298 remaining_arg_types
=
11299 tree_cons (default_arg
, type
, remaining_arg_types
);
11300 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11303 remaining_arg_types
=
11304 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11307 return remaining_arg_types
;
11310 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11311 *not* handle the exception-specification for FNTYPE, because the
11312 initial substitution of explicitly provided template parameters
11313 during argument deduction forbids substitution into the
11314 exception-specification:
11318 All references in the function type of the function template to the
11319 corresponding template parameters are replaced by the specified tem-
11320 plate argument values. If a substitution in a template parameter or
11321 in the function type of the function template results in an invalid
11322 type, type deduction fails. [Note: The equivalent substitution in
11323 exception specifications is done only when the function is instanti-
11324 ated, at which point a program is ill-formed if the substitution
11325 results in an invalid type.] */
11328 tsubst_function_type (tree t
,
11330 tsubst_flags_t complain
,
11334 tree arg_types
= NULL_TREE
;
11337 /* The TYPE_CONTEXT is not used for function/method types. */
11338 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11340 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11342 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11344 if (late_return_type_p
)
11346 /* Substitute the argument types. */
11347 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11348 complain
, in_decl
);
11349 if (arg_types
== error_mark_node
)
11350 return error_mark_node
;
11352 tree save_ccp
= current_class_ptr
;
11353 tree save_ccr
= current_class_ref
;
11354 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11355 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11356 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11359 /* DR 1207: 'this' is in scope in the trailing return type. */
11360 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11363 /* Substitute the return type. */
11364 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11368 current_class_ptr
= save_ccp
;
11369 current_class_ref
= save_ccr
;
11373 /* Substitute the return type. */
11374 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11376 if (return_type
== error_mark_node
)
11377 return error_mark_node
;
11378 /* DR 486 clarifies that creation of a function type with an
11379 invalid return type is a deduction failure. */
11380 if (TREE_CODE (return_type
) == ARRAY_TYPE
11381 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11383 if (complain
& tf_error
)
11385 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11386 error ("function returning an array");
11388 error ("function returning a function");
11390 return error_mark_node
;
11393 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11394 return error_mark_node
;
11396 if (!late_return_type_p
)
11398 /* Substitute the argument types. */
11399 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11400 complain
, in_decl
);
11401 if (arg_types
== error_mark_node
)
11402 return error_mark_node
;
11405 /* Construct a new type node and return it. */
11406 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11408 fntype
= build_function_type (return_type
, arg_types
);
11409 fntype
= apply_memfn_quals (fntype
,
11410 type_memfn_quals (t
),
11411 type_memfn_rqual (t
));
11415 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11416 /* Don't pick up extra function qualifiers from the basetype. */
11417 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11418 if (! MAYBE_CLASS_TYPE_P (r
))
11422 Type deduction may fail for any of the following
11425 -- Attempting to create "pointer to member of T" when T
11426 is not a class type. */
11427 if (complain
& tf_error
)
11428 error ("creating pointer to member function of non-class type %qT",
11430 return error_mark_node
;
11433 fntype
= build_method_type_directly (r
, return_type
,
11434 TREE_CHAIN (arg_types
));
11435 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11437 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11439 if (late_return_type_p
)
11440 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11445 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11446 ARGS into that specification, and return the substituted
11447 specification. If there is no specification, return NULL_TREE. */
11450 tsubst_exception_specification (tree fntype
,
11452 tsubst_flags_t complain
,
11459 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11460 new_specs
= NULL_TREE
;
11461 if (specs
&& TREE_PURPOSE (specs
))
11463 /* A noexcept-specifier. */
11464 tree expr
= TREE_PURPOSE (specs
);
11465 if (TREE_CODE (expr
) == INTEGER_CST
)
11469 /* Defer instantiation of noexcept-specifiers to avoid
11470 excessive instantiations (c++/49107). */
11471 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11472 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11474 /* We already partially instantiated this member template,
11475 so combine the new args with the old. */
11476 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11477 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11478 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11479 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11483 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11484 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11488 new_specs
= tsubst_copy_and_build
11489 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11490 /*integral_constant_expression_p=*/true);
11491 new_specs
= build_noexcept_spec (new_specs
, complain
);
11495 if (! TREE_VALUE (specs
))
11502 tree expanded_specs
= NULL_TREE
;
11504 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11506 /* Expand the pack expansion type. */
11507 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11511 if (expanded_specs
== error_mark_node
)
11512 return error_mark_node
;
11513 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11514 len
= TREE_VEC_LENGTH (expanded_specs
);
11517 /* We're substituting into a member template, so
11518 we got a TYPE_PACK_EXPANSION back. Add that
11519 expansion and move on. */
11520 gcc_assert (TREE_CODE (expanded_specs
)
11521 == TYPE_PACK_EXPANSION
);
11522 new_specs
= add_exception_specifier (new_specs
,
11525 specs
= TREE_CHAIN (specs
);
11530 for (i
= 0; i
< len
; ++i
)
11532 if (expanded_specs
)
11533 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11535 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11536 if (spec
== error_mark_node
)
11538 new_specs
= add_exception_specifier (new_specs
, spec
,
11542 specs
= TREE_CHAIN (specs
);
11548 /* Take the tree structure T and replace template parameters used
11549 therein with the argument vector ARGS. IN_DECL is an associated
11550 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11551 Issue error and warning messages under control of COMPLAIN. Note
11552 that we must be relatively non-tolerant of extensions here, in
11553 order to preserve conformance; if we allow substitutions that
11554 should not be allowed, we may allow argument deductions that should
11555 not succeed, and therefore report ambiguous overload situations
11556 where there are none. In theory, we could allow the substitution,
11557 but indicate that it should have failed, and allow our caller to
11558 make sure that the right thing happens, but we don't try to do this
11561 This function is used for dealing with types, decls and the like;
11562 for expressions, use tsubst_expr or tsubst_copy. */
11565 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11567 enum tree_code code
;
11568 tree type
, r
= NULL_TREE
;
11570 if (t
== NULL_TREE
|| t
== error_mark_node
11571 || t
== integer_type_node
11572 || t
== void_type_node
11573 || t
== char_type_node
11574 || t
== unknown_type_node
11575 || TREE_CODE (t
) == NAMESPACE_DECL
11576 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11580 return tsubst_decl (t
, args
, complain
);
11582 if (args
== NULL_TREE
)
11585 code
= TREE_CODE (t
);
11587 if (code
== IDENTIFIER_NODE
)
11588 type
= IDENTIFIER_TYPE_VALUE (t
);
11590 type
= TREE_TYPE (t
);
11592 gcc_assert (type
!= unknown_type_node
);
11594 /* Reuse typedefs. We need to do this to handle dependent attributes,
11595 such as attribute aligned. */
11597 && typedef_variant_p (t
))
11599 tree decl
= TYPE_NAME (t
);
11601 if (alias_template_specialization_p (t
))
11603 /* DECL represents an alias template and we want to
11605 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11606 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11607 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11609 else if (DECL_CLASS_SCOPE_P (decl
)
11610 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11611 && uses_template_parms (DECL_CONTEXT (decl
)))
11613 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11614 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11615 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11617 else if (DECL_FUNCTION_SCOPE_P (decl
)
11618 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11619 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11620 r
= retrieve_local_specialization (decl
);
11622 /* The typedef is from a non-template context. */
11628 r
= cp_build_qualified_type_real
11629 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11630 complain
| tf_ignore_bad_quals
);
11635 /* We don't have an instantiation yet, so drop the typedef. */
11636 int quals
= cp_type_quals (t
);
11637 t
= DECL_ORIGINAL_TYPE (decl
);
11638 t
= cp_build_qualified_type_real (t
, quals
,
11639 complain
| tf_ignore_bad_quals
);
11644 && code
!= TYPENAME_TYPE
11645 && code
!= TEMPLATE_TYPE_PARM
11646 && code
!= IDENTIFIER_NODE
11647 && code
!= FUNCTION_TYPE
11648 && code
!= METHOD_TYPE
)
11649 type
= tsubst (type
, args
, complain
, in_decl
);
11650 if (type
== error_mark_node
)
11651 return error_mark_node
;
11657 case ENUMERAL_TYPE
:
11658 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11659 /*entering_scope=*/0);
11662 case IDENTIFIER_NODE
:
11673 if (t
== integer_type_node
)
11676 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11677 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11681 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11683 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11684 /*integral_constant_expression_p=*/false);
11686 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11688 if (TREE_CODE (max
) == NOP_EXPR
11689 && TREE_SIDE_EFFECTS (omax
)
11690 && !TREE_TYPE (max
))
11691 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11693 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11694 with TREE_SIDE_EFFECTS that indicates this is not an integral
11695 constant expression. */
11696 if (processing_template_decl
11697 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11699 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11700 TREE_SIDE_EFFECTS (max
) = 1;
11703 return compute_array_index_type (NULL_TREE
, max
, complain
);
11706 case TEMPLATE_TYPE_PARM
:
11707 case TEMPLATE_TEMPLATE_PARM
:
11708 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11709 case TEMPLATE_PARM_INDEX
:
11714 tree arg
= NULL_TREE
;
11718 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
11719 template_parm_level_and_index (t
, &level
, &idx
);
11721 levels
= TMPL_ARGS_DEPTH (args
);
11722 if (level
<= levels
)
11724 arg
= TMPL_ARG (args
, level
, idx
);
11726 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
11728 /* See through ARGUMENT_PACK_SELECT arguments. */
11729 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
11730 /* If the selected argument is an expansion E, that most
11731 likely means we were called from
11732 gen_elem_of_pack_expansion_instantiation during the
11733 substituting of pack an argument pack (which Ith
11734 element is a pack expansion, where I is
11735 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11736 In this case, the Ith element resulting from this
11737 substituting is going to be a pack expansion, which
11738 pattern is the pattern of E. Let's return the
11740 gen_elem_of_pack_expansion_instantiation will
11741 build the resulting pack expansion from it. */
11742 if (PACK_EXPANSION_P (arg
))
11743 arg
= PACK_EXPANSION_PATTERN (arg
);
11747 if (arg
== error_mark_node
)
11748 return error_mark_node
;
11749 else if (arg
!= NULL_TREE
)
11751 if (ARGUMENT_PACK_P (arg
))
11752 /* If ARG is an argument pack, we don't actually want to
11753 perform a substitution here, because substitutions
11754 for argument packs are only done
11755 element-by-element. We can get to this point when
11756 substituting the type of a non-type template
11757 parameter pack, when that type actually contains
11758 template parameter packs from an outer template, e.g.,
11760 template<typename... Types> struct A {
11761 template<Types... Values> struct B { };
11765 if (code
== TEMPLATE_TYPE_PARM
)
11768 gcc_assert (TYPE_P (arg
));
11770 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
11772 return cp_build_qualified_type_real
11773 (arg
, quals
, complain
| tf_ignore_bad_quals
);
11775 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11777 /* We are processing a type constructed from a
11778 template template parameter. */
11779 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
11780 args
, complain
, in_decl
);
11781 if (argvec
== error_mark_node
)
11782 return error_mark_node
;
11784 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
11785 || TREE_CODE (arg
) == TEMPLATE_DECL
11786 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
11788 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
11789 /* Consider this code:
11791 template <template <class> class Template>
11793 template <class Arg> using Bind = Template<Arg>;
11796 template <template <class> class Template, class Arg>
11797 using Instantiate = Template<Arg>; //#0
11799 template <template <class> class Template,
11802 Instantiate<Internal<Template>::template Bind,
11805 When #1 is parsed, the
11806 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11807 parameter `Template' in #0 matches the
11808 UNBOUND_CLASS_TEMPLATE representing the argument
11809 `Internal<Template>::template Bind'; We then want
11810 to assemble the type `Bind<Argument>' that can't
11811 be fully created right now, because
11812 `Internal<Template>' not being complete, the Bind
11813 template cannot be looked up in that context. So
11814 we need to "store" `Bind<Argument>' for later
11815 when the context of Bind becomes complete. Let's
11816 store that in a TYPENAME_TYPE. */
11817 return make_typename_type (TYPE_CONTEXT (arg
),
11818 build_nt (TEMPLATE_ID_EXPR
,
11819 TYPE_IDENTIFIER (arg
),
11824 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11825 are resolving nested-types in the signature of a
11826 member function templates. Otherwise ARG is a
11827 TEMPLATE_DECL and is the real template to be
11829 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11830 arg
= TYPE_NAME (arg
);
11832 r
= lookup_template_class (arg
,
11834 DECL_CONTEXT (arg
),
11835 /*entering_scope=*/0,
11837 return cp_build_qualified_type_real
11838 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
11841 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11842 return convert_from_reference (unshare_expr (arg
));
11846 /* This can happen during the attempted tsubst'ing in
11847 unify. This means that we don't yet have any information
11848 about the template parameter in question. */
11851 /* Early in template argument deduction substitution, we don't
11852 want to reduce the level of 'auto', or it will be confused
11853 with a normal template parm in subsequent deduction. */
11854 if (is_auto (t
) && (complain
& tf_partial
))
11857 /* If we get here, we must have been looking at a parm for a
11858 more deeply nested template. Make a new version of this
11859 template parameter, but with a lower level. */
11862 case TEMPLATE_TYPE_PARM
:
11863 case TEMPLATE_TEMPLATE_PARM
:
11864 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11865 if (cp_type_quals (t
))
11867 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
11868 r
= cp_build_qualified_type_real
11869 (r
, cp_type_quals (t
),
11870 complain
| (code
== TEMPLATE_TYPE_PARM
11871 ? tf_ignore_bad_quals
: 0));
11876 TEMPLATE_TYPE_PARM_INDEX (r
)
11877 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
11878 r
, levels
, args
, complain
);
11879 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
11880 TYPE_MAIN_VARIANT (r
) = r
;
11881 TYPE_POINTER_TO (r
) = NULL_TREE
;
11882 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
11884 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
11885 /* We have reduced the level of the template
11886 template parameter, but not the levels of its
11887 template parameters, so canonical_type_parameter
11888 will not be able to find the canonical template
11889 template parameter for this level. Thus, we
11890 require structural equality checking to compare
11891 TEMPLATE_TEMPLATE_PARMs. */
11892 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11893 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
11894 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11896 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
11898 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11900 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
11901 complain
, in_decl
);
11902 if (argvec
== error_mark_node
)
11903 return error_mark_node
;
11905 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
11906 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
11911 case TEMPLATE_PARM_INDEX
:
11912 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
11916 gcc_unreachable ();
11924 tree purpose
, value
, chain
;
11926 if (t
== void_list_node
)
11929 purpose
= TREE_PURPOSE (t
);
11932 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
11933 if (purpose
== error_mark_node
)
11934 return error_mark_node
;
11936 value
= TREE_VALUE (t
);
11939 value
= tsubst (value
, args
, complain
, in_decl
);
11940 if (value
== error_mark_node
)
11941 return error_mark_node
;
11943 chain
= TREE_CHAIN (t
);
11944 if (chain
&& chain
!= void_type_node
)
11946 chain
= tsubst (chain
, args
, complain
, in_decl
);
11947 if (chain
== error_mark_node
)
11948 return error_mark_node
;
11950 if (purpose
== TREE_PURPOSE (t
)
11951 && value
== TREE_VALUE (t
)
11952 && chain
== TREE_CHAIN (t
))
11954 return hash_tree_cons (purpose
, value
, chain
);
11958 /* We should never be tsubsting a binfo. */
11959 gcc_unreachable ();
11962 /* A vector of template arguments. */
11963 gcc_assert (!type
);
11964 return tsubst_template_args (t
, args
, complain
, in_decl
);
11967 case REFERENCE_TYPE
:
11969 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
11974 Type deduction may fail for any of the following
11977 -- Attempting to create a pointer to reference type.
11978 -- Attempting to create a reference to a reference type or
11979 a reference to void.
11981 Core issue 106 says that creating a reference to a reference
11982 during instantiation is no longer a cause for failure. We
11983 only enforce this check in strict C++98 mode. */
11984 if ((TREE_CODE (type
) == REFERENCE_TYPE
11985 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
11986 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
11988 static location_t last_loc
;
11990 /* We keep track of the last time we issued this error
11991 message to avoid spewing a ton of messages during a
11992 single bad template instantiation. */
11993 if (complain
& tf_error
11994 && last_loc
!= input_location
)
11996 if (VOID_TYPE_P (type
))
11997 error ("forming reference to void");
11998 else if (code
== POINTER_TYPE
)
11999 error ("forming pointer to reference type %qT", type
);
12001 error ("forming reference to reference type %qT", type
);
12002 last_loc
= input_location
;
12005 return error_mark_node
;
12007 else if (TREE_CODE (type
) == FUNCTION_TYPE
12008 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
12009 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12011 if (complain
& tf_error
)
12013 if (code
== POINTER_TYPE
)
12014 error ("forming pointer to qualified function type %qT",
12017 error ("forming reference to qualified function type %qT",
12020 return error_mark_node
;
12022 else if (code
== POINTER_TYPE
)
12024 r
= build_pointer_type (type
);
12025 if (TREE_CODE (type
) == METHOD_TYPE
)
12026 r
= build_ptrmemfunc_type (r
);
12028 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12029 /* In C++0x, during template argument substitution, when there is an
12030 attempt to create a reference to a reference type, reference
12031 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12033 "If a template-argument for a template-parameter T names a type
12034 that is a reference to a type A, an attempt to create the type
12035 'lvalue reference to cv T' creates the type 'lvalue reference to
12036 A,' while an attempt to create the type type rvalue reference to
12037 cv T' creates the type T"
12039 r
= cp_build_reference_type
12041 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12043 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12044 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12046 if (cxx_dialect
>= cxx1y
12047 && !(TREE_CODE (t
) == REFERENCE_TYPE
&& REFERENCE_VLA_OK (t
))
12048 && array_of_runtime_bound_p (type
)
12049 && (flag_iso
|| warn_vla
> 0))
12051 if (complain
& tf_warning_or_error
)
12053 (input_location
, OPT_Wvla
,
12054 code
== REFERENCE_TYPE
12055 ? G_("cannot declare reference to array of runtime bound")
12056 : G_("cannot declare pointer to array of runtime bound"));
12058 r
= error_mark_node
;
12061 if (r
!= error_mark_node
)
12062 /* Will this ever be needed for TYPE_..._TO values? */
12069 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12070 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12074 Type deduction may fail for any of the following
12077 -- Attempting to create "pointer to member of T" when T
12078 is not a class type. */
12079 if (complain
& tf_error
)
12080 error ("creating pointer to member of non-class type %qT", r
);
12081 return error_mark_node
;
12083 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12085 if (complain
& tf_error
)
12086 error ("creating pointer to member reference type %qT", type
);
12087 return error_mark_node
;
12089 if (VOID_TYPE_P (type
))
12091 if (complain
& tf_error
)
12092 error ("creating pointer to member of type void");
12093 return error_mark_node
;
12095 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12096 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12098 /* The type of the implicit object parameter gets its
12099 cv-qualifiers from the FUNCTION_TYPE. */
12102 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12103 type_memfn_rqual (type
));
12104 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12105 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12109 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12113 case FUNCTION_TYPE
:
12118 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12119 if (fntype
== error_mark_node
)
12120 return error_mark_node
;
12122 /* Substitute the exception specification. */
12123 specs
= tsubst_exception_specification (t
, args
, complain
,
12124 in_decl
, /*defer_ok*/true);
12125 if (specs
== error_mark_node
)
12126 return error_mark_node
;
12128 fntype
= build_exception_variant (fntype
, specs
);
12133 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12134 if (domain
== error_mark_node
)
12135 return error_mark_node
;
12137 /* As an optimization, we avoid regenerating the array type if
12138 it will obviously be the same as T. */
12139 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12142 /* These checks should match the ones in create_array_type_for_decl.
12146 The deduction may fail for any of the following reasons:
12148 -- Attempting to create an array with an element type that
12149 is void, a function type, or a reference type, or [DR337]
12150 an abstract class type. */
12151 if (VOID_TYPE_P (type
)
12152 || TREE_CODE (type
) == FUNCTION_TYPE
12153 || (TREE_CODE (type
) == ARRAY_TYPE
12154 && TYPE_DOMAIN (type
) == NULL_TREE
)
12155 || TREE_CODE (type
) == REFERENCE_TYPE
)
12157 if (complain
& tf_error
)
12158 error ("creating array of %qT", type
);
12159 return error_mark_node
;
12162 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12163 return error_mark_node
;
12165 r
= build_cplus_array_type (type
, domain
);
12167 if (TYPE_USER_ALIGN (t
))
12169 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12170 TYPE_USER_ALIGN (r
) = 1;
12176 case TYPENAME_TYPE
:
12178 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12179 in_decl
, /*entering_scope=*/1);
12180 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12181 complain
, in_decl
);
12183 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12184 return error_mark_node
;
12186 if (!MAYBE_CLASS_TYPE_P (ctx
))
12188 if (complain
& tf_error
)
12189 error ("%qT is not a class, struct, or union type", ctx
);
12190 return error_mark_node
;
12192 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12194 /* Normally, make_typename_type does not require that the CTX
12195 have complete type in order to allow things like:
12197 template <class T> struct S { typename S<T>::X Y; };
12199 But, such constructs have already been resolved by this
12200 point, so here CTX really should have complete type, unless
12201 it's a partial instantiation. */
12202 ctx
= complete_type (ctx
);
12203 if (!COMPLETE_TYPE_P (ctx
))
12205 if (complain
& tf_error
)
12206 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12207 return error_mark_node
;
12211 f
= make_typename_type (ctx
, f
, typename_type
,
12212 complain
| tf_keep_type_decl
);
12213 if (f
== error_mark_node
)
12215 if (TREE_CODE (f
) == TYPE_DECL
)
12217 complain
|= tf_ignore_bad_quals
;
12221 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12223 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12225 if (complain
& tf_error
)
12226 error ("%qT resolves to %qT, which is not an enumeration type",
12229 return error_mark_node
;
12231 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12233 if (complain
& tf_error
)
12234 error ("%qT resolves to %qT, which is is not a class type",
12237 return error_mark_node
;
12241 return cp_build_qualified_type_real
12242 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12245 case UNBOUND_CLASS_TEMPLATE
:
12247 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12248 in_decl
, /*entering_scope=*/1);
12249 tree name
= TYPE_IDENTIFIER (t
);
12250 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12252 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12253 return error_mark_node
;
12256 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12257 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12264 ++cp_unevaluated_operand
;
12265 ++c_inhibit_evaluation_warnings
;
12267 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12269 /*integral_constant_expression_p=*/false);
12271 --cp_unevaluated_operand
;
12272 --c_inhibit_evaluation_warnings
;
12274 type
= finish_typeof (type
);
12275 return cp_build_qualified_type_real (type
,
12277 | cp_type_quals (type
),
12281 case DECLTYPE_TYPE
:
12285 ++cp_unevaluated_operand
;
12286 ++c_inhibit_evaluation_warnings
;
12288 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12289 complain
|tf_decltype
, in_decl
,
12290 /*function_p*/false,
12291 /*integral_constant_expression*/false);
12293 --cp_unevaluated_operand
;
12294 --c_inhibit_evaluation_warnings
;
12296 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12297 type
= lambda_capture_field_type (type
,
12298 DECLTYPE_FOR_INIT_CAPTURE (t
));
12299 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12300 type
= lambda_proxy_type (type
);
12303 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12304 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12306 /* In a template ~id could be either a complement expression
12307 or an unqualified-id naming a destructor; if instantiating
12308 it produces an expression, it's not an id-expression or
12311 type
= finish_decltype_type (type
, id
, complain
);
12313 return cp_build_qualified_type_real (type
,
12315 | cp_type_quals (type
),
12319 case UNDERLYING_TYPE
:
12321 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12322 complain
, in_decl
);
12323 return finish_underlying_type (type
);
12326 case TYPE_ARGUMENT_PACK
:
12327 case NONTYPE_ARGUMENT_PACK
:
12329 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12331 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12335 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12337 /* For template nontype argument packs, also substitute into
12339 if (code
== NONTYPE_ARGUMENT_PACK
)
12340 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12359 /* We should use one of the expression tsubsts for these codes. */
12360 gcc_unreachable ();
12363 sorry ("use of %qs in template", get_tree_code_name (code
));
12364 return error_mark_node
;
12368 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12369 type of the expression on the left-hand side of the "." or "->"
12373 tsubst_baselink (tree baselink
, tree object_type
,
12374 tree args
, tsubst_flags_t complain
, tree in_decl
)
12377 tree qualifying_scope
;
12380 tree template_args
= 0;
12381 bool template_id_p
= false;
12382 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12384 /* A baselink indicates a function from a base class. Both the
12385 BASELINK_ACCESS_BINFO and the base class referenced may
12386 indicate bases of the template class, rather than the
12387 instantiated class. In addition, lookups that were not
12388 ambiguous before may be ambiguous now. Therefore, we perform
12389 the lookup again. */
12390 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12391 qualifying_scope
= tsubst (qualifying_scope
, args
,
12392 complain
, in_decl
);
12393 fns
= BASELINK_FUNCTIONS (baselink
);
12394 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12395 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12397 template_id_p
= true;
12398 template_args
= TREE_OPERAND (fns
, 1);
12399 fns
= TREE_OPERAND (fns
, 0);
12401 template_args
= tsubst_template_args (template_args
, args
,
12402 complain
, in_decl
);
12404 name
= DECL_NAME (get_first_fn (fns
));
12405 if (IDENTIFIER_TYPENAME_P (name
))
12406 name
= mangle_conv_op_name_for_type (optype
);
12407 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12409 return error_mark_node
;
12411 /* If lookup found a single function, mark it as used at this
12412 point. (If it lookup found multiple functions the one selected
12413 later by overload resolution will be marked as used at that
12415 if (BASELINK_P (baselink
))
12416 fns
= BASELINK_FUNCTIONS (baselink
);
12417 if (!template_id_p
&& !really_overloaded_fn (fns
))
12418 mark_used (OVL_CURRENT (fns
));
12420 /* Add back the template arguments, if present. */
12421 if (BASELINK_P (baselink
) && template_id_p
)
12422 BASELINK_FUNCTIONS (baselink
)
12423 = build_nt (TEMPLATE_ID_EXPR
,
12424 BASELINK_FUNCTIONS (baselink
),
12426 /* Update the conversion operator type. */
12427 BASELINK_OPTYPE (baselink
) = optype
;
12430 object_type
= current_class_type
;
12433 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12439 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12440 true if the qualified-id will be a postfix-expression in-and-of
12441 itself; false if more of the postfix-expression follows the
12442 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12446 tsubst_qualified_id (tree qualified_id
, tree args
,
12447 tsubst_flags_t complain
, tree in_decl
,
12448 bool done
, bool address_p
)
12454 tree template_args
;
12455 location_t loc
= UNKNOWN_LOCATION
;
12457 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12459 /* Figure out what name to look up. */
12460 name
= TREE_OPERAND (qualified_id
, 1);
12461 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12463 is_template
= true;
12464 loc
= EXPR_LOCATION (name
);
12465 template_args
= TREE_OPERAND (name
, 1);
12467 template_args
= tsubst_template_args (template_args
, args
,
12468 complain
, in_decl
);
12469 name
= TREE_OPERAND (name
, 0);
12473 is_template
= false;
12474 template_args
= NULL_TREE
;
12477 /* Substitute into the qualifying scope. When there are no ARGS, we
12478 are just trying to simplify a non-dependent expression. In that
12479 case the qualifying scope may be dependent, and, in any case,
12480 substituting will not help. */
12481 scope
= TREE_OPERAND (qualified_id
, 0);
12484 scope
= tsubst (scope
, args
, complain
, in_decl
);
12485 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12490 if (dependent_scope_p (scope
))
12493 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12494 return build_qualified_name (NULL_TREE
, scope
, expr
,
12495 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12498 if (!BASELINK_P (name
) && !DECL_P (expr
))
12500 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12502 /* A BIT_NOT_EXPR is used to represent a destructor. */
12503 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12505 error ("qualifying type %qT does not match destructor name ~%qT",
12506 scope
, TREE_OPERAND (expr
, 0));
12507 expr
= error_mark_node
;
12510 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12511 /*is_type_p=*/0, false);
12514 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12515 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12516 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12518 if (complain
& tf_error
)
12520 error ("dependent-name %qE is parsed as a non-type, but "
12521 "instantiation yields a type", qualified_id
);
12522 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12524 return error_mark_node
;
12530 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12532 /* Remember that there was a reference to this entity. */
12536 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12538 if (complain
& tf_error
)
12539 qualified_name_lookup_error (scope
,
12540 TREE_OPERAND (qualified_id
, 1),
12541 expr
, input_location
);
12542 return error_mark_node
;
12546 expr
= lookup_template_function (expr
, template_args
);
12548 if (expr
== error_mark_node
&& complain
& tf_error
)
12549 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12550 expr
, input_location
);
12551 else if (TYPE_P (scope
))
12553 expr
= (adjust_result_of_qualified_name_lookup
12554 (expr
, scope
, current_nonlambda_class_type ()));
12555 expr
= (finish_qualified_id_expr
12556 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12557 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12558 /*template_arg_p=*/false, complain
));
12561 /* Expressions do not generally have reference type. */
12562 if (TREE_CODE (expr
) != SCOPE_REF
12563 /* However, if we're about to form a pointer-to-member, we just
12564 want the referenced member referenced. */
12565 && TREE_CODE (expr
) != OFFSET_REF
)
12566 expr
= convert_from_reference (expr
);
12571 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12572 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12576 tsubst_init (tree init
, tree decl
, tree args
,
12577 tsubst_flags_t complain
, tree in_decl
)
12582 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12586 /* If we had an initializer but it
12587 instantiated to nothing,
12588 value-initialize the object. This will
12589 only occur when the initializer was a
12590 pack expansion where the parameter packs
12591 used in that expansion were of length
12593 init
= build_value_init (TREE_TYPE (decl
),
12595 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12596 init
= get_target_expr_sfinae (init
, complain
);
12602 /* Like tsubst, but deals with expressions. This function just replaces
12603 template parms; to finish processing the resultant expression, use
12604 tsubst_copy_and_build or tsubst_expr. */
12607 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12609 enum tree_code code
;
12612 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12615 code
= TREE_CODE (t
);
12620 r
= retrieve_local_specialization (t
);
12622 if (r
== NULL_TREE
)
12624 /* We get here for a use of 'this' in an NSDMI. */
12625 if (DECL_NAME (t
) == this_identifier
12626 && current_function_decl
12627 && DECL_CONSTRUCTOR_P (current_function_decl
))
12628 return current_class_ptr
;
12630 /* This can happen for a parameter name used later in a function
12631 declaration (such as in a late-specified return type). Just
12632 make a dummy decl, since it's only used for its type. */
12633 gcc_assert (cp_unevaluated_operand
!= 0);
12634 r
= tsubst_decl (t
, args
, complain
);
12635 /* Give it the template pattern as its context; its true context
12636 hasn't been instantiated yet and this is good enough for
12638 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12641 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12642 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12651 if (DECL_TEMPLATE_PARM_P (t
))
12652 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12653 /* There is no need to substitute into namespace-scope
12655 if (DECL_NAMESPACE_SCOPE_P (t
))
12657 /* If ARGS is NULL, then T is known to be non-dependent. */
12658 if (args
== NULL_TREE
)
12659 return integral_constant_value (t
);
12661 /* Unfortunately, we cannot just call lookup_name here.
12664 template <int I> int f() {
12666 struct S { void g() { E e = a; } };
12669 When we instantiate f<7>::S::g(), say, lookup_name is not
12670 clever enough to find f<7>::a. */
12672 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12673 /*entering_scope=*/0);
12675 for (v
= TYPE_VALUES (enum_type
);
12677 v
= TREE_CHAIN (v
))
12678 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12679 return TREE_VALUE (v
);
12681 /* We didn't find the name. That should never happen; if
12682 name-lookup found it during preliminary parsing, we
12683 should find it again here during instantiation. */
12684 gcc_unreachable ();
12689 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12691 /* Check for a local specialization set up by
12692 tsubst_pack_expansion. */
12693 if (tree r
= retrieve_local_specialization (t
))
12695 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12696 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12700 /* When retrieving a capture pack from a generic lambda, remove the
12701 lambda call op's own template argument list from ARGS. Only the
12702 template arguments active for the closure type should be used to
12703 retrieve the pack specialization. */
12704 if (LAMBDA_FUNCTION_P (current_function_decl
)
12705 && (template_class_depth (DECL_CONTEXT (t
))
12706 != TMPL_ARGS_DEPTH (args
)))
12707 args
= strip_innermost_template_args (args
, 1);
12709 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12710 tsubst_decl put in the hash table. */
12711 return retrieve_specialization (t
, args
, 0);
12714 if (DECL_CONTEXT (t
))
12718 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12719 /*entering_scope=*/1);
12720 if (ctx
!= DECL_CONTEXT (t
))
12722 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
12725 if (complain
& tf_error
)
12726 error ("using invalid field %qD", t
);
12727 return error_mark_node
;
12736 case FUNCTION_DECL
:
12737 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
12738 r
= tsubst (t
, args
, complain
, in_decl
);
12739 else if (local_variable_p (t
))
12741 r
= retrieve_local_specialization (t
);
12742 if (r
== NULL_TREE
)
12744 /* First try name lookup to find the instantiation. */
12745 r
= lookup_name (DECL_NAME (t
));
12748 /* Make sure that the one we found is the one we want. */
12749 tree ctx
= tsubst (DECL_CONTEXT (t
), args
,
12750 complain
, in_decl
);
12751 if (ctx
!= DECL_CONTEXT (r
))
12759 /* This can happen for a variable used in a
12760 late-specified return type of a local lambda, or for a
12761 local static or constant. Building a new VAR_DECL
12762 should be OK in all those cases. */
12763 r
= tsubst_decl (t
, args
, complain
);
12764 if (decl_maybe_constant_var_p (r
))
12766 /* We can't call cp_finish_decl, so handle the
12767 initializer by hand. */
12768 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
12769 complain
, in_decl
);
12770 if (!processing_template_decl
)
12771 init
= maybe_constant_init (init
);
12772 if (processing_template_decl
12773 ? potential_constant_expression (init
)
12774 : reduced_constant_expression_p (init
))
12775 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
12776 = TREE_CONSTANT (r
) = true;
12777 DECL_INITIAL (r
) = init
;
12779 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
12780 || decl_constant_var_p (r
)
12781 || errorcount
|| sorrycount
);
12782 if (!processing_template_decl
)
12784 if (TREE_STATIC (r
))
12785 rest_of_decl_compilation (r
, toplevel_bindings_p (),
12787 else if (decl_constant_var_p (r
))
12788 /* A use of a local constant decays to its value.
12789 FIXME update for core DR 696. */
12790 r
= integral_constant_value (r
);
12793 /* Remember this for subsequent uses. */
12794 if (local_specializations
)
12795 register_local_specialization (r
, t
);
12803 case NAMESPACE_DECL
:
12807 /* An OVERLOAD will always be a non-dependent overload set; an
12808 overload set from function scope will just be represented with an
12809 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12810 gcc_assert (!uses_template_parms (t
));
12814 return tsubst_baselink (t
, current_nonlambda_class_type (),
12815 args
, complain
, in_decl
);
12817 case TEMPLATE_DECL
:
12818 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12819 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
12820 args
, complain
, in_decl
);
12821 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
12822 return tsubst (t
, args
, complain
, in_decl
);
12823 else if (DECL_CLASS_SCOPE_P (t
)
12824 && uses_template_parms (DECL_CONTEXT (t
)))
12826 /* Template template argument like the following example need
12829 template <template <class> class TT> struct C {};
12830 template <class T> struct D {
12831 template <class U> struct E {};
12836 We are processing the template argument `E' in #1 for
12837 the template instantiation #2. Originally, `E' is a
12838 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12839 have to substitute this with one having context `D<int>'. */
12841 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
12842 return lookup_field (context
, DECL_NAME(t
), 0, false);
12845 /* Ordinary template template argument. */
12849 case REINTERPRET_CAST_EXPR
:
12850 case CONST_CAST_EXPR
:
12851 case STATIC_CAST_EXPR
:
12852 case DYNAMIC_CAST_EXPR
:
12853 case IMPLICIT_CONV_EXPR
:
12857 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12858 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12859 return build1 (code
, type
, op0
);
12863 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
12866 tree expanded
, op
= TREE_OPERAND (t
, 0);
12869 if (SIZEOF_EXPR_TYPE_P (t
))
12870 op
= TREE_TYPE (op
);
12872 ++cp_unevaluated_operand
;
12873 ++c_inhibit_evaluation_warnings
;
12874 /* We only want to compute the number of arguments. */
12875 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
12876 --cp_unevaluated_operand
;
12877 --c_inhibit_evaluation_warnings
;
12879 if (TREE_CODE (expanded
) == TREE_VEC
)
12880 len
= TREE_VEC_LENGTH (expanded
);
12882 if (expanded
== error_mark_node
)
12883 return error_mark_node
;
12884 else if (PACK_EXPANSION_P (expanded
)
12885 || (TREE_CODE (expanded
) == TREE_VEC
12887 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
12889 if (TREE_CODE (expanded
) == TREE_VEC
)
12890 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
12892 if (TYPE_P (expanded
))
12893 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
12894 complain
& tf_error
);
12896 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
12897 complain
& tf_error
);
12900 return build_int_cst (size_type_node
, len
);
12902 if (SIZEOF_EXPR_TYPE_P (t
))
12904 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
12905 args
, complain
, in_decl
);
12906 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
12907 r
= build1 (SIZEOF_EXPR
,
12908 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
12909 SIZEOF_EXPR_TYPE_P (r
) = 1;
12916 case TRUTH_NOT_EXPR
:
12919 case UNARY_PLUS_EXPR
: /* Unary + */
12921 case AT_ENCODE_EXPR
:
12925 case REALPART_EXPR
:
12926 case IMAGPART_EXPR
:
12929 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12930 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12931 return build1 (code
, type
, op0
);
12934 case COMPONENT_REF
:
12939 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12940 name
= TREE_OPERAND (t
, 1);
12941 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
12943 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12944 complain
, in_decl
);
12945 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12947 else if (TREE_CODE (name
) == SCOPE_REF
12948 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
12950 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12951 complain
, in_decl
);
12952 name
= TREE_OPERAND (name
, 1);
12953 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12954 complain
, in_decl
);
12955 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12956 name
= build_qualified_name (/*type=*/NULL_TREE
,
12958 /*template_p=*/false);
12960 else if (BASELINK_P (name
))
12961 name
= tsubst_baselink (name
,
12962 non_reference (TREE_TYPE (object
)),
12966 name
= tsubst_copy (name
, args
, complain
, in_decl
);
12967 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
12973 case TRUNC_DIV_EXPR
:
12974 case CEIL_DIV_EXPR
:
12975 case FLOOR_DIV_EXPR
:
12976 case ROUND_DIV_EXPR
:
12977 case EXACT_DIV_EXPR
:
12981 case TRUNC_MOD_EXPR
:
12982 case FLOOR_MOD_EXPR
:
12983 case TRUTH_ANDIF_EXPR
:
12984 case TRUTH_ORIF_EXPR
:
12985 case TRUTH_AND_EXPR
:
12986 case TRUTH_OR_EXPR
:
12999 case COMPOUND_EXPR
:
13002 case PREDECREMENT_EXPR
:
13003 case PREINCREMENT_EXPR
:
13004 case POSTDECREMENT_EXPR
:
13005 case POSTINCREMENT_EXPR
:
13007 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13008 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13009 return build_nt (code
, op0
, op1
);
13014 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13015 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13016 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
13017 QUALIFIED_NAME_IS_TEMPLATE (t
));
13022 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13023 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13024 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13029 int n
= VL_EXP_OPERAND_LENGTH (t
);
13030 tree result
= build_vl_exp (CALL_EXPR
, n
);
13032 for (i
= 0; i
< n
; i
++)
13033 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13034 complain
, in_decl
);
13040 case PSEUDO_DTOR_EXPR
:
13041 case VEC_PERM_EXPR
:
13043 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13044 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13045 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13046 r
= build_nt (code
, op0
, op1
, op2
);
13047 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13053 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13054 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13055 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13056 r
= build_nt (code
, op0
, op1
, op2
);
13057 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13063 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13064 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13065 r
= build_nt (code
, op0
, op1
);
13066 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13067 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13071 case TEMPLATE_ID_EXPR
:
13073 /* Substituted template arguments */
13074 tree fn
= TREE_OPERAND (t
, 0);
13075 tree targs
= TREE_OPERAND (t
, 1);
13077 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13079 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13081 return lookup_template_function (fn
, targs
);
13086 tree purpose
, value
, chain
;
13088 if (t
== void_list_node
)
13091 purpose
= TREE_PURPOSE (t
);
13093 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13094 value
= TREE_VALUE (t
);
13096 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13097 chain
= TREE_CHAIN (t
);
13098 if (chain
&& chain
!= void_type_node
)
13099 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13100 if (purpose
== TREE_PURPOSE (t
)
13101 && value
== TREE_VALUE (t
)
13102 && chain
== TREE_CHAIN (t
))
13104 return tree_cons (purpose
, value
, chain
);
13109 case ENUMERAL_TYPE
:
13111 case TEMPLATE_TYPE_PARM
:
13112 case TEMPLATE_TEMPLATE_PARM
:
13113 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13114 case TEMPLATE_PARM_INDEX
:
13116 case REFERENCE_TYPE
:
13118 case FUNCTION_TYPE
:
13121 case TYPENAME_TYPE
:
13122 case UNBOUND_CLASS_TEMPLATE
:
13124 case DECLTYPE_TYPE
:
13126 return tsubst (t
, args
, complain
, in_decl
);
13130 /* Fall through. */
13131 case IDENTIFIER_NODE
:
13132 if (IDENTIFIER_TYPENAME_P (t
))
13134 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13135 return mangle_conv_op_name_for_type (new_type
);
13141 /* This is handled by tsubst_copy_and_build. */
13142 gcc_unreachable ();
13146 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13147 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13148 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13151 case CLEANUP_POINT_EXPR
:
13152 /* We shouldn't have built any of these during initial template
13153 generation. Instead, they should be built during instantiation
13154 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13155 gcc_unreachable ();
13159 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13160 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13161 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13162 r
= build2 (code
, type
, op0
, op1
);
13163 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13164 mark_used (TREE_OPERAND (r
, 1));
13168 case EXPR_PACK_EXPANSION
:
13169 error ("invalid use of pack expansion expression");
13170 return error_mark_node
;
13172 case NONTYPE_ARGUMENT_PACK
:
13173 error ("use %<...%> to expand argument pack");
13174 return error_mark_node
;
13177 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13185 /* Instantiate any typedefs in the type. */
13186 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13187 r
= fold_convert (type
, t
);
13188 gcc_assert (TREE_CODE (r
) == code
);
13193 /* These can sometimes show up in a partial instantiation, but never
13194 involve template parms. */
13195 gcc_assert (!uses_template_parms (t
));
13199 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13200 gcc_checking_assert (false);
13205 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13208 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13209 tree args
, tsubst_flags_t complain
, tree in_decl
)
13211 tree new_clauses
= NULL
, nc
, oc
;
13213 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13215 nc
= copy_node (oc
);
13216 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13219 switch (OMP_CLAUSE_CODE (nc
))
13221 case OMP_CLAUSE_LASTPRIVATE
:
13222 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13224 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13225 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13226 in_decl
, /*integral_constant_expression_p=*/false);
13227 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13228 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13231 case OMP_CLAUSE_PRIVATE
:
13232 case OMP_CLAUSE_SHARED
:
13233 case OMP_CLAUSE_FIRSTPRIVATE
:
13234 case OMP_CLAUSE_COPYIN
:
13235 case OMP_CLAUSE_COPYPRIVATE
:
13236 case OMP_CLAUSE_IF
:
13237 case OMP_CLAUSE_NUM_THREADS
:
13238 case OMP_CLAUSE_SCHEDULE
:
13239 case OMP_CLAUSE_COLLAPSE
:
13240 case OMP_CLAUSE_FINAL
:
13241 case OMP_CLAUSE_DEPEND
:
13242 case OMP_CLAUSE_FROM
:
13243 case OMP_CLAUSE_TO
:
13244 case OMP_CLAUSE_UNIFORM
:
13245 case OMP_CLAUSE_MAP
:
13246 case OMP_CLAUSE_DEVICE
:
13247 case OMP_CLAUSE_DIST_SCHEDULE
:
13248 case OMP_CLAUSE_NUM_TEAMS
:
13249 case OMP_CLAUSE_THREAD_LIMIT
:
13250 case OMP_CLAUSE_SAFELEN
:
13251 case OMP_CLAUSE_SIMDLEN
:
13252 OMP_CLAUSE_OPERAND (nc
, 0)
13253 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13254 in_decl
, /*integral_constant_expression_p=*/false);
13256 case OMP_CLAUSE_REDUCTION
:
13257 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13259 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13260 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13262 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13263 complain
, in_decl
);
13264 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13265 = build_qualified_name (NULL_TREE
, scope
,
13266 TREE_OPERAND (placeholder
, 1),
13270 gcc_assert (identifier_p (placeholder
));
13272 OMP_CLAUSE_OPERAND (nc
, 0)
13273 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13274 in_decl
, /*integral_constant_expression_p=*/false);
13276 case OMP_CLAUSE_LINEAR
:
13277 case OMP_CLAUSE_ALIGNED
:
13278 OMP_CLAUSE_OPERAND (nc
, 0)
13279 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13280 in_decl
, /*integral_constant_expression_p=*/false);
13281 OMP_CLAUSE_OPERAND (nc
, 1)
13282 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13283 in_decl
, /*integral_constant_expression_p=*/false);
13286 case OMP_CLAUSE_NOWAIT
:
13287 case OMP_CLAUSE_ORDERED
:
13288 case OMP_CLAUSE_DEFAULT
:
13289 case OMP_CLAUSE_UNTIED
:
13290 case OMP_CLAUSE_MERGEABLE
:
13291 case OMP_CLAUSE_INBRANCH
:
13292 case OMP_CLAUSE_NOTINBRANCH
:
13293 case OMP_CLAUSE_PROC_BIND
:
13294 case OMP_CLAUSE_FOR
:
13295 case OMP_CLAUSE_PARALLEL
:
13296 case OMP_CLAUSE_SECTIONS
:
13297 case OMP_CLAUSE_TASKGROUP
:
13300 gcc_unreachable ();
13304 new_clauses
= nreverse (new_clauses
);
13306 new_clauses
= finish_omp_clauses (new_clauses
);
13307 return new_clauses
;
13310 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13313 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13316 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13318 tree purpose
, value
, chain
;
13323 if (TREE_CODE (t
) != TREE_LIST
)
13324 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13325 /*function_p=*/false,
13326 /*integral_constant_expression_p=*/false);
13328 if (t
== void_list_node
)
13331 purpose
= TREE_PURPOSE (t
);
13333 purpose
= RECUR (purpose
);
13334 value
= TREE_VALUE (t
);
13337 if (TREE_CODE (value
) != LABEL_DECL
)
13338 value
= RECUR (value
);
13341 value
= lookup_label (DECL_NAME (value
));
13342 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13343 TREE_USED (value
) = 1;
13346 chain
= TREE_CHAIN (t
);
13347 if (chain
&& chain
!= void_type_node
)
13348 chain
= RECUR (chain
);
13349 return tree_cons (purpose
, value
, chain
);
13353 /* Substitute one OMP_FOR iterator. */
13356 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13357 tree condv
, tree incrv
, tree
*clauses
,
13358 tree args
, tsubst_flags_t complain
, tree in_decl
,
13359 bool integral_constant_expression_p
)
13361 #define RECUR(NODE) \
13362 tsubst_expr ((NODE), args, complain, in_decl, \
13363 integral_constant_expression_p)
13364 tree decl
, init
, cond
, incr
;
13366 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13367 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13368 decl
= TREE_OPERAND (init
, 0);
13369 init
= TREE_OPERAND (init
, 1);
13370 tree decl_expr
= NULL_TREE
;
13371 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13373 /* We need to jump through some hoops to handle declarations in the
13374 for-init-statement, since we might need to handle auto deduction,
13375 but we need to keep control of initialization. */
13377 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13378 decl
= tsubst_decl (decl
, args
, complain
);
13381 decl
= RECUR (decl
);
13382 init
= RECUR (init
);
13384 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13385 if (auto_node
&& init
)
13387 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13389 gcc_assert (!type_dependent_expression_p (decl
));
13391 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13395 /* Declare the variable, but don't let that initialize it. */
13396 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13397 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13399 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13402 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13403 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13404 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13406 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13407 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13408 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13409 NOP_EXPR
, rhs
, complain
);
13412 incr
= RECUR (incr
);
13413 TREE_VEC_ELT (declv
, i
) = decl
;
13414 TREE_VEC_ELT (initv
, i
) = init
;
13415 TREE_VEC_ELT (condv
, i
) = cond
;
13416 TREE_VEC_ELT (incrv
, i
) = incr
;
13422 /* Declare and initialize the variable. */
13429 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13431 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13432 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13433 && OMP_CLAUSE_DECL (c
) == decl
)
13435 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13436 && OMP_CLAUSE_DECL (c
) == decl
)
13437 error ("iteration variable %qD should not be firstprivate", decl
);
13438 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13439 && OMP_CLAUSE_DECL (c
) == decl
)
13440 error ("iteration variable %qD should not be reduction", decl
);
13444 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13445 OMP_CLAUSE_DECL (c
) = decl
;
13446 c
= finish_omp_clauses (c
);
13449 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13454 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13455 if (COMPARISON_CLASS_P (cond
))
13457 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13458 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13459 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13462 cond
= RECUR (cond
);
13463 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13464 switch (TREE_CODE (incr
))
13466 case PREINCREMENT_EXPR
:
13467 case PREDECREMENT_EXPR
:
13468 case POSTINCREMENT_EXPR
:
13469 case POSTDECREMENT_EXPR
:
13470 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13471 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13474 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13475 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13477 tree rhs
= TREE_OPERAND (incr
, 1);
13478 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13479 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13480 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13481 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13482 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13486 incr
= RECUR (incr
);
13489 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13490 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13492 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13493 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13494 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13495 TREE_TYPE (decl
), lhs
,
13496 RECUR (TREE_OPERAND (incr
, 2))));
13498 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13499 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13500 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13502 tree rhs
= TREE_OPERAND (incr
, 2);
13503 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13504 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13505 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13506 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13507 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13511 incr
= RECUR (incr
);
13514 incr
= RECUR (incr
);
13518 TREE_VEC_ELT (declv
, i
) = decl
;
13519 TREE_VEC_ELT (initv
, i
) = init
;
13520 TREE_VEC_ELT (condv
, i
) = cond
;
13521 TREE_VEC_ELT (incrv
, i
) = incr
;
13525 /* Like tsubst_copy for expressions, etc. but also does semantic
13529 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13530 bool integral_constant_expression_p
)
13532 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13533 #define RECUR(NODE) \
13534 tsubst_expr ((NODE), args, complain, in_decl, \
13535 integral_constant_expression_p)
13541 if (t
== NULL_TREE
|| t
== error_mark_node
)
13544 loc
= input_location
;
13545 if (EXPR_HAS_LOCATION (t
))
13546 input_location
= EXPR_LOCATION (t
);
13547 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13548 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13550 switch (TREE_CODE (t
))
13552 case STATEMENT_LIST
:
13554 tree_stmt_iterator i
;
13555 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13556 RECUR (tsi_stmt (i
));
13560 case CTOR_INITIALIZER
:
13561 finish_mem_initializers (tsubst_initializer_list
13562 (TREE_OPERAND (t
, 0), args
));
13566 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13570 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13571 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13572 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13574 finish_expr_stmt (tmp
);
13578 do_using_directive (USING_STMT_NAMESPACE (t
));
13583 tree decl
, pattern_decl
;
13586 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13587 if (TREE_CODE (decl
) == LABEL_DECL
)
13588 finish_label_decl (DECL_NAME (decl
));
13589 else if (TREE_CODE (decl
) == USING_DECL
)
13591 tree scope
= USING_DECL_SCOPE (decl
);
13592 tree name
= DECL_NAME (decl
);
13595 scope
= tsubst (scope
, args
, complain
, in_decl
);
13596 decl
= lookup_qualified_name (scope
, name
,
13597 /*is_type_p=*/false,
13598 /*complain=*/false);
13599 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13600 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13602 do_local_using_decl (decl
, scope
, name
);
13604 else if (DECL_PACK_P (decl
))
13606 /* Don't build up decls for a variadic capture proxy, we'll
13607 instantiate the elements directly as needed. */
13612 init
= DECL_INITIAL (decl
);
13613 decl
= tsubst (decl
, args
, complain
, in_decl
);
13614 if (decl
!= error_mark_node
)
13616 /* By marking the declaration as instantiated, we avoid
13617 trying to instantiate it. Since instantiate_decl can't
13618 handle local variables, and since we've already done
13619 all that needs to be done, that's the right thing to
13622 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13624 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13625 /* Anonymous aggregates are a special case. */
13626 finish_anon_union (decl
);
13627 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13629 DECL_CONTEXT (decl
) = current_function_decl
;
13630 if (DECL_NAME (decl
) == this_identifier
)
13632 tree lam
= DECL_CONTEXT (current_function_decl
);
13633 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13634 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13636 insert_capture_proxy (decl
);
13638 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13639 /* We already did a pushtag. */;
13640 else if (TREE_CODE (decl
) == FUNCTION_DECL
13641 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13642 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13644 DECL_CONTEXT (decl
) = NULL_TREE
;
13646 DECL_CONTEXT (decl
) = current_function_decl
;
13647 cp_check_omp_declare_reduction (decl
);
13651 int const_init
= false;
13652 maybe_push_decl (decl
);
13654 && DECL_PRETTY_FUNCTION_P (decl
))
13656 /* For __PRETTY_FUNCTION__ we have to adjust the
13658 const char *const name
13659 = cxx_printable_name (current_function_decl
, 2);
13660 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13663 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
13666 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13668 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13677 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13678 RECUR (FOR_INIT_STMT (t
));
13679 finish_for_init_stmt (stmt
);
13680 tmp
= RECUR (FOR_COND (t
));
13681 finish_for_cond (tmp
, stmt
, false);
13682 tmp
= RECUR (FOR_EXPR (t
));
13683 finish_for_expr (tmp
, stmt
);
13684 RECUR (FOR_BODY (t
));
13685 finish_for_stmt (stmt
);
13688 case RANGE_FOR_STMT
:
13691 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13692 decl
= RANGE_FOR_DECL (t
);
13693 decl
= tsubst (decl
, args
, complain
, in_decl
);
13694 maybe_push_decl (decl
);
13695 expr
= RECUR (RANGE_FOR_EXPR (t
));
13696 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13697 RECUR (RANGE_FOR_BODY (t
));
13698 finish_for_stmt (stmt
);
13703 stmt
= begin_while_stmt ();
13704 tmp
= RECUR (WHILE_COND (t
));
13705 finish_while_stmt_cond (tmp
, stmt
, false);
13706 RECUR (WHILE_BODY (t
));
13707 finish_while_stmt (stmt
);
13711 stmt
= begin_do_stmt ();
13712 RECUR (DO_BODY (t
));
13713 finish_do_body (stmt
);
13714 tmp
= RECUR (DO_COND (t
));
13715 finish_do_stmt (tmp
, stmt
, false);
13719 stmt
= begin_if_stmt ();
13720 tmp
= RECUR (IF_COND (t
));
13721 finish_if_stmt_cond (tmp
, stmt
);
13722 RECUR (THEN_CLAUSE (t
));
13723 finish_then_clause (stmt
);
13725 if (ELSE_CLAUSE (t
))
13727 begin_else_clause (stmt
);
13728 RECUR (ELSE_CLAUSE (t
));
13729 finish_else_clause (stmt
);
13732 finish_if_stmt (stmt
);
13736 if (BIND_EXPR_BODY_BLOCK (t
))
13737 stmt
= begin_function_body ();
13739 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
13740 ? BCS_TRY_BLOCK
: 0);
13742 RECUR (BIND_EXPR_BODY (t
));
13744 if (BIND_EXPR_BODY_BLOCK (t
))
13745 finish_function_body (stmt
);
13747 finish_compound_stmt (stmt
);
13751 finish_break_stmt ();
13754 case CONTINUE_STMT
:
13755 finish_continue_stmt ();
13759 stmt
= begin_switch_stmt ();
13760 tmp
= RECUR (SWITCH_STMT_COND (t
));
13761 finish_switch_cond (tmp
, stmt
);
13762 RECUR (SWITCH_STMT_BODY (t
));
13763 finish_switch_stmt (stmt
);
13766 case CASE_LABEL_EXPR
:
13768 tree low
= RECUR (CASE_LOW (t
));
13769 tree high
= RECUR (CASE_HIGH (t
));
13770 finish_case_label (EXPR_LOCATION (t
), low
, high
);
13776 tree decl
= LABEL_EXPR_LABEL (t
);
13779 label
= finish_label_stmt (DECL_NAME (decl
));
13780 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13781 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13786 tmp
= GOTO_DESTINATION (t
);
13787 if (TREE_CODE (tmp
) != LABEL_DECL
)
13788 /* Computed goto's must be tsubst'd into. On the other hand,
13789 non-computed gotos must not be; the identifier in question
13790 will have no binding. */
13793 tmp
= DECL_NAME (tmp
);
13794 finish_goto_stmt (tmp
);
13799 tree string
= RECUR (ASM_STRING (t
));
13800 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
13801 complain
, in_decl
);
13802 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
13803 complain
, in_decl
);
13804 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
13805 complain
, in_decl
);
13806 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
13807 complain
, in_decl
);
13808 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
13810 tree asm_expr
= tmp
;
13811 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
13812 asm_expr
= TREE_OPERAND (asm_expr
, 0);
13813 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
13820 stmt
= begin_try_block ();
13821 RECUR (TRY_STMTS (t
));
13822 finish_cleanup_try_block (stmt
);
13823 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
13827 tree compound_stmt
= NULL_TREE
;
13829 if (FN_TRY_BLOCK_P (t
))
13830 stmt
= begin_function_try_block (&compound_stmt
);
13832 stmt
= begin_try_block ();
13834 RECUR (TRY_STMTS (t
));
13836 if (FN_TRY_BLOCK_P (t
))
13837 finish_function_try_block (stmt
);
13839 finish_try_block (stmt
);
13841 RECUR (TRY_HANDLERS (t
));
13842 if (FN_TRY_BLOCK_P (t
))
13843 finish_function_handler_sequence (stmt
, compound_stmt
);
13845 finish_handler_sequence (stmt
);
13851 tree decl
= HANDLER_PARMS (t
);
13855 decl
= tsubst (decl
, args
, complain
, in_decl
);
13856 /* Prevent instantiate_decl from trying to instantiate
13857 this variable. We've already done all that needs to be
13859 if (decl
!= error_mark_node
)
13860 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13862 stmt
= begin_handler ();
13863 finish_handler_parms (decl
, stmt
);
13864 RECUR (HANDLER_BODY (t
));
13865 finish_handler (stmt
);
13870 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
13871 if (CLASS_TYPE_P (tmp
))
13873 /* Local classes are not independent templates; they are
13874 instantiated along with their containing function. And this
13875 way we don't have to deal with pushing out of one local class
13876 to instantiate a member of another local class. */
13878 /* Closures are handled by the LAMBDA_EXPR. */
13879 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
13880 complete_type (tmp
);
13881 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
13882 if (!DECL_ARTIFICIAL (fn
))
13883 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
13887 case STATIC_ASSERT
:
13891 ++c_inhibit_evaluation_warnings
;
13893 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
13896 /*integral_constant_expression_p=*/true);
13897 --c_inhibit_evaluation_warnings
;
13899 finish_static_assert (condition
,
13900 STATIC_ASSERT_MESSAGE (t
),
13901 STATIC_ASSERT_SOURCE_LOCATION (t
),
13902 /*member_p=*/false);
13907 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
13908 args
, complain
, in_decl
);
13909 stmt
= begin_omp_parallel ();
13910 RECUR (OMP_PARALLEL_BODY (t
));
13911 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
13912 = OMP_PARALLEL_COMBINED (t
);
13916 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
13917 args
, complain
, in_decl
);
13918 stmt
= begin_omp_task ();
13919 RECUR (OMP_TASK_BODY (t
));
13920 finish_omp_task (tmp
, stmt
);
13926 case OMP_DISTRIBUTE
:
13928 tree clauses
, body
, pre_body
;
13929 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
13930 tree incrv
= NULL_TREE
;
13933 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
13934 args
, complain
, in_decl
);
13935 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13937 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13938 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13939 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13940 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13943 stmt
= begin_omp_structured_block ();
13945 pre_body
= push_stmt_list ();
13946 RECUR (OMP_FOR_PRE_BODY (t
));
13947 pre_body
= pop_stmt_list (pre_body
);
13949 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13950 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
13951 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
13952 &clauses
, args
, complain
, in_decl
,
13953 integral_constant_expression_p
);
13955 body
= push_stmt_list ();
13956 RECUR (OMP_FOR_BODY (t
));
13957 body
= pop_stmt_list (body
);
13959 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13960 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
13961 condv
, incrv
, body
, pre_body
, clauses
);
13964 t
= make_node (TREE_CODE (t
));
13965 TREE_TYPE (t
) = void_type_node
;
13966 OMP_FOR_BODY (t
) = body
;
13967 OMP_FOR_PRE_BODY (t
) = pre_body
;
13968 OMP_FOR_CLAUSES (t
) = clauses
;
13969 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
13973 add_stmt (finish_omp_structured_block (stmt
));
13980 case OMP_TARGET_DATA
:
13982 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
13983 args
, complain
, in_decl
);
13984 stmt
= push_stmt_list ();
13985 RECUR (OMP_BODY (t
));
13986 stmt
= pop_stmt_list (stmt
);
13989 OMP_BODY (t
) = stmt
;
13990 OMP_CLAUSES (t
) = tmp
;
13994 case OMP_TARGET_UPDATE
:
13995 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
13996 args
, complain
, in_decl
);
13998 OMP_CLAUSES (t
) = tmp
;
14005 case OMP_TASKGROUP
:
14007 stmt
= push_stmt_list ();
14008 RECUR (OMP_BODY (t
));
14009 stmt
= pop_stmt_list (stmt
);
14012 OMP_BODY (t
) = stmt
;
14017 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14018 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14020 tree op1
= TREE_OPERAND (t
, 1);
14021 tree rhs1
= NULL_TREE
;
14023 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14025 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14026 op1
= TREE_OPERAND (op1
, 1);
14028 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14029 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14030 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14031 NULL_TREE
, NULL_TREE
, rhs1
,
14032 OMP_ATOMIC_SEQ_CST (t
));
14036 tree op1
= TREE_OPERAND (t
, 1);
14037 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14038 tree rhs1
= NULL_TREE
;
14039 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14040 enum tree_code opcode
= NOP_EXPR
;
14041 if (code
== OMP_ATOMIC_READ
)
14043 v
= RECUR (TREE_OPERAND (op1
, 0));
14044 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14046 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14047 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14049 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14050 v
= RECUR (TREE_OPERAND (op1
, 0));
14051 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14052 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14054 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14055 op11
= TREE_OPERAND (op11
, 1);
14057 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14058 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14059 opcode
= TREE_CODE (op11
);
14060 if (opcode
== MODIFY_EXPR
)
14066 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14067 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14069 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14070 OMP_ATOMIC_SEQ_CST (t
));
14074 case TRANSACTION_EXPR
:
14077 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14078 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14080 if (TRANSACTION_EXPR_IS_STMT (t
))
14082 tree body
= TRANSACTION_EXPR_BODY (t
);
14083 tree noex
= NULL_TREE
;
14084 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14086 noex
= MUST_NOT_THROW_COND (body
);
14087 if (noex
== NULL_TREE
)
14088 noex
= boolean_true_node
;
14089 body
= TREE_OPERAND (body
, 0);
14091 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14093 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14097 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14098 RECUR (TRANSACTION_EXPR_BODY (t
)),
14105 case MUST_NOT_THROW_EXPR
:
14107 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14108 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14109 RETURN (build_must_not_throw_expr (op0
, cond
));
14112 case EXPR_PACK_EXPANSION
:
14113 error ("invalid use of pack expansion expression");
14114 RETURN (error_mark_node
);
14116 case NONTYPE_ARGUMENT_PACK
:
14117 error ("use %<...%> to expand argument pack");
14118 RETURN (error_mark_node
);
14120 case CILK_SPAWN_STMT
:
14121 cfun
->calls_cilk_spawn
= 1;
14122 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14124 case CILK_SYNC_STMT
:
14125 RETURN (build_cilk_sync ());
14127 case COMPOUND_EXPR
:
14128 tmp
= RECUR (TREE_OPERAND (t
, 0));
14129 if (tmp
== NULL_TREE
)
14130 /* If the first operand was a statement, we're done with it. */
14131 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14132 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14133 RECUR (TREE_OPERAND (t
, 1)),
14136 case ANNOTATE_EXPR
:
14137 tmp
= RECUR (TREE_OPERAND (t
, 0));
14138 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14139 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14142 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14144 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14145 /*function_p=*/false,
14146 integral_constant_expression_p
));
14149 RETURN (NULL_TREE
);
14151 input_location
= loc
;
14157 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14158 function. For description of the body see comment above
14159 cp_parser_omp_declare_reduction_exprs. */
14162 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14164 if (t
== NULL_TREE
|| t
== error_mark_node
)
14167 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14169 tree_stmt_iterator tsi
;
14172 memset (stmts
, 0, sizeof stmts
);
14173 for (i
= 0, tsi
= tsi_start (t
);
14174 i
< 7 && !tsi_end_p (tsi
);
14175 i
++, tsi_next (&tsi
))
14176 stmts
[i
] = tsi_stmt (tsi
);
14177 gcc_assert (tsi_end_p (tsi
));
14181 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14182 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14183 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14184 args
, complain
, in_decl
);
14185 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14186 args
, complain
, in_decl
);
14187 DECL_CONTEXT (omp_out
) = current_function_decl
;
14188 DECL_CONTEXT (omp_in
) = current_function_decl
;
14189 keep_next_level (true);
14190 tree block
= begin_omp_structured_block ();
14191 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14192 block
= finish_omp_structured_block (block
);
14193 block
= maybe_cleanup_point_expr_void (block
);
14194 add_decl_expr (omp_out
);
14195 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14196 TREE_NO_WARNING (omp_out
) = 1;
14197 add_decl_expr (omp_in
);
14198 finish_expr_stmt (block
);
14202 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14203 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14204 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14205 args
, complain
, in_decl
);
14206 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14207 args
, complain
, in_decl
);
14208 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14209 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14210 keep_next_level (true);
14211 tree block
= begin_omp_structured_block ();
14212 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14213 block
= finish_omp_structured_block (block
);
14214 block
= maybe_cleanup_point_expr_void (block
);
14215 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14216 add_decl_expr (omp_priv
);
14217 add_decl_expr (omp_orig
);
14218 finish_expr_stmt (block
);
14220 add_decl_expr (omp_orig
);
14224 /* T is a postfix-expression that is not being used in a function
14225 call. Return the substituted version of T. */
14228 tsubst_non_call_postfix_expression (tree t
, tree args
,
14229 tsubst_flags_t complain
,
14232 if (TREE_CODE (t
) == SCOPE_REF
)
14233 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14234 /*done=*/false, /*address_p=*/false);
14236 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14237 /*function_p=*/false,
14238 /*integral_constant_expression_p=*/false);
14243 /* Sentinel to disable certain warnings during template substitution. */
14245 struct warning_sentinel
{
14248 warning_sentinel(int& flag
, bool suppress
=true)
14249 : flag(flag
), val(flag
) { if (suppress
) flag
= 0; }
14250 ~warning_sentinel() { flag
= val
; }
14253 /* Like tsubst but deals with expressions and performs semantic
14254 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14257 tsubst_copy_and_build (tree t
,
14259 tsubst_flags_t complain
,
14262 bool integral_constant_expression_p
)
14264 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14265 #define RECUR(NODE) \
14266 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14267 /*function_p=*/false, \
14268 integral_constant_expression_p)
14273 if (t
== NULL_TREE
|| t
== error_mark_node
)
14276 loc
= input_location
;
14277 if (EXPR_HAS_LOCATION (t
))
14278 input_location
= EXPR_LOCATION (t
);
14280 /* N3276 decltype magic only applies to calls at the top level or on the
14281 right side of a comma. */
14282 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14283 complain
&= ~tf_decltype
;
14285 switch (TREE_CODE (t
))
14289 /* Fall through. */
14290 case IDENTIFIER_NODE
:
14294 bool non_integral_constant_expression_p
;
14295 const char *error_msg
;
14297 if (IDENTIFIER_TYPENAME_P (t
))
14299 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14300 t
= mangle_conv_op_name_for_type (new_type
);
14303 /* Look up the name. */
14304 decl
= lookup_name (t
);
14306 /* By convention, expressions use ERROR_MARK_NODE to indicate
14307 failure, not NULL_TREE. */
14308 if (decl
== NULL_TREE
)
14309 decl
= error_mark_node
;
14311 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14313 integral_constant_expression_p
,
14314 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14315 &non_integral_constant_expression_p
,
14316 /*template_p=*/false,
14318 /*address_p=*/false,
14319 /*template_arg_p=*/false,
14324 if (!function_p
&& identifier_p (decl
))
14326 if (complain
& tf_error
)
14327 unqualified_name_lookup_error (decl
);
14328 decl
= error_mark_node
;
14333 case TEMPLATE_ID_EXPR
:
14336 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14337 tree targs
= TREE_OPERAND (t
, 1);
14340 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14342 if (TREE_CODE (templ
) == COMPONENT_REF
)
14344 object
= TREE_OPERAND (templ
, 0);
14345 templ
= TREE_OPERAND (templ
, 1);
14348 object
= NULL_TREE
;
14349 templ
= lookup_template_function (templ
, targs
);
14352 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14353 object
, templ
, NULL_TREE
));
14355 RETURN (baselink_for_fns (templ
));
14360 tree r
= RECUR (TREE_OPERAND (t
, 0));
14362 if (REFERENCE_REF_P (t
))
14364 /* A type conversion to reference type will be enclosed in
14365 such an indirect ref, but the substitution of the cast
14366 will have also added such an indirect ref. */
14367 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14368 r
= convert_from_reference (r
);
14371 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14372 complain
|decltype_flag
);
14378 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14379 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14380 RETURN (build_nop (type
, op0
));
14383 case IMPLICIT_CONV_EXPR
:
14385 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14386 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14387 int flags
= LOOKUP_IMPLICIT
;
14388 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14389 flags
= LOOKUP_NORMAL
;
14390 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14396 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14397 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14398 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14402 case REINTERPRET_CAST_EXPR
:
14403 case CONST_CAST_EXPR
:
14404 case DYNAMIC_CAST_EXPR
:
14405 case STATIC_CAST_EXPR
:
14408 tree op
, r
= NULL_TREE
;
14410 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14411 if (integral_constant_expression_p
14412 && !cast_valid_in_integral_constant_expression_p (type
))
14414 if (complain
& tf_error
)
14415 error ("a cast to a type other than an integral or "
14416 "enumeration type cannot appear in a constant-expression");
14417 RETURN (error_mark_node
);
14420 op
= RECUR (TREE_OPERAND (t
, 0));
14422 warning_sentinel
s(warn_useless_cast
);
14423 switch (TREE_CODE (t
))
14426 r
= build_functional_cast (type
, op
, complain
);
14428 case REINTERPRET_CAST_EXPR
:
14429 r
= build_reinterpret_cast (type
, op
, complain
);
14431 case CONST_CAST_EXPR
:
14432 r
= build_const_cast (type
, op
, complain
);
14434 case DYNAMIC_CAST_EXPR
:
14435 r
= build_dynamic_cast (type
, op
, complain
);
14437 case STATIC_CAST_EXPR
:
14438 r
= build_static_cast (type
, op
, complain
);
14441 gcc_unreachable ();
14447 case POSTDECREMENT_EXPR
:
14448 case POSTINCREMENT_EXPR
:
14449 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14450 args
, complain
, in_decl
);
14451 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14452 complain
|decltype_flag
));
14454 case PREDECREMENT_EXPR
:
14455 case PREINCREMENT_EXPR
:
14459 case TRUTH_NOT_EXPR
:
14460 case UNARY_PLUS_EXPR
: /* Unary + */
14461 case REALPART_EXPR
:
14462 case IMAGPART_EXPR
:
14463 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14464 RECUR (TREE_OPERAND (t
, 0)),
14465 complain
|decltype_flag
));
14467 case FIX_TRUNC_EXPR
:
14468 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14472 op1
= TREE_OPERAND (t
, 0);
14473 if (TREE_CODE (op1
) == LABEL_DECL
)
14474 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14475 EXPR_LOCATION (op1
)));
14476 if (TREE_CODE (op1
) == SCOPE_REF
)
14477 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14478 /*done=*/true, /*address_p=*/true);
14480 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14482 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14483 complain
|decltype_flag
));
14488 case TRUNC_DIV_EXPR
:
14489 case CEIL_DIV_EXPR
:
14490 case FLOOR_DIV_EXPR
:
14491 case ROUND_DIV_EXPR
:
14492 case EXACT_DIV_EXPR
:
14496 case TRUNC_MOD_EXPR
:
14497 case FLOOR_MOD_EXPR
:
14498 case TRUTH_ANDIF_EXPR
:
14499 case TRUTH_ORIF_EXPR
:
14500 case TRUTH_AND_EXPR
:
14501 case TRUTH_OR_EXPR
:
14517 warning_sentinel
s1(warn_type_limits
);
14518 warning_sentinel
s2(warn_div_by_zero
);
14519 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14520 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14521 tree r
= build_x_binary_op
14522 (input_location
, TREE_CODE (t
),
14524 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14526 : TREE_CODE (TREE_OPERAND (t
, 0))),
14528 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14530 : TREE_CODE (TREE_OPERAND (t
, 1))),
14532 complain
|decltype_flag
);
14533 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14534 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14539 case POINTER_PLUS_EXPR
:
14541 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14542 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14543 return fold_build_pointer_plus (op0
, op1
);
14547 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14548 /*address_p=*/false));
14550 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14551 args
, complain
, in_decl
);
14552 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14553 RECUR (TREE_OPERAND (t
, 1)),
14554 complain
|decltype_flag
));
14556 case ARRAY_NOTATION_REF
:
14558 tree start_index
, length
, stride
;
14559 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14560 args
, complain
, in_decl
);
14561 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14562 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14563 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14564 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14565 length
, stride
, TREE_TYPE (op1
)));
14568 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14569 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14576 op1
= TREE_OPERAND (t
, 0);
14577 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14578 op1
= TREE_TYPE (op1
);
14581 /* When there are no ARGS, we are trying to evaluate a
14582 non-dependent expression from the parser. Trying to do
14583 the substitutions may not work. */
14585 op1
= TREE_TYPE (op1
);
14589 ++cp_unevaluated_operand
;
14590 ++c_inhibit_evaluation_warnings
;
14592 op1
= tsubst (op1
, args
, complain
, in_decl
);
14594 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14595 /*function_p=*/false,
14596 /*integral_constant_expression_p=*/
14598 --cp_unevaluated_operand
;
14599 --c_inhibit_evaluation_warnings
;
14602 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14603 complain
& tf_error
);
14605 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14606 complain
& tf_error
);
14607 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14609 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14611 if (!processing_template_decl
&& TYPE_P (op1
))
14613 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14614 build1 (NOP_EXPR
, op1
, error_mark_node
));
14615 SIZEOF_EXPR_TYPE_P (r
) = 1;
14618 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14619 TREE_SIDE_EFFECTS (r
) = 0;
14620 TREE_READONLY (r
) = 1;
14622 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14627 case AT_ENCODE_EXPR
:
14629 op1
= TREE_OPERAND (t
, 0);
14630 ++cp_unevaluated_operand
;
14631 ++c_inhibit_evaluation_warnings
;
14632 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14633 /*function_p=*/false,
14634 /*integral_constant_expression_p=*/false);
14635 --cp_unevaluated_operand
;
14636 --c_inhibit_evaluation_warnings
;
14637 RETURN (objc_build_encode_expr (op1
));
14640 case NOEXCEPT_EXPR
:
14641 op1
= TREE_OPERAND (t
, 0);
14642 ++cp_unevaluated_operand
;
14643 ++c_inhibit_evaluation_warnings
;
14644 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14645 /*function_p=*/false,
14646 /*integral_constant_expression_p=*/false);
14647 --cp_unevaluated_operand
;
14648 --c_inhibit_evaluation_warnings
;
14649 RETURN (finish_noexcept_expr (op1
, complain
));
14653 warning_sentinel
s(warn_div_by_zero
);
14654 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
14655 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
14656 tree r
= build_x_modify_expr
14657 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
14658 complain
|decltype_flag
);
14659 /* TREE_NO_WARNING must be set if either the expression was
14660 parenthesized or it uses an operator such as >>= rather
14661 than plain assignment. In the former case, it was already
14662 set and must be copied. In the latter case,
14663 build_x_modify_expr sets it and it must not be reset
14665 if (TREE_NO_WARNING (t
))
14666 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14672 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14673 args
, complain
, in_decl
);
14674 /* Remember that there was a reference to this entity. */
14677 RETURN (build_x_arrow (input_location
, op1
, complain
));
14681 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14682 tree init
= RECUR (TREE_OPERAND (t
, 3));
14683 vec
<tree
, va_gc
> *placement_vec
;
14684 vec
<tree
, va_gc
> *init_vec
;
14687 if (placement
== NULL_TREE
)
14688 placement_vec
= NULL
;
14691 placement_vec
= make_tree_vector ();
14692 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14693 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14696 /* If there was an initializer in the original tree, but it
14697 instantiated to an empty list, then we should pass a
14698 non-NULL empty vector to tell build_new that it was an
14699 empty initializer() rather than no initializer. This can
14700 only happen when the initializer is a pack expansion whose
14701 parameter packs are of length zero. */
14702 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
14706 init_vec
= make_tree_vector ();
14707 if (init
== void_node
)
14708 gcc_assert (init_vec
!= NULL
);
14711 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
14712 vec_safe_push (init_vec
, TREE_VALUE (init
));
14716 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14717 tree op2
= RECUR (TREE_OPERAND (t
, 2));
14718 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
14719 NEW_EXPR_USE_GLOBAL (t
),
14722 if (placement_vec
!= NULL
)
14723 release_tree_vector (placement_vec
);
14724 if (init_vec
!= NULL
)
14725 release_tree_vector (init_vec
);
14732 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14733 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14734 RETURN (delete_sanity (op0
, op1
,
14735 DELETE_EXPR_USE_VEC (t
),
14736 DELETE_EXPR_USE_GLOBAL (t
),
14740 case COMPOUND_EXPR
:
14742 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
14743 complain
& ~tf_decltype
, in_decl
,
14744 /*function_p=*/false,
14745 integral_constant_expression_p
);
14746 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
14748 RECUR (TREE_OPERAND (t
, 1)),
14749 complain
|decltype_flag
));
14755 vec
<tree
, va_gc
> *call_args
;
14756 unsigned int nargs
, i
;
14761 function
= CALL_EXPR_FN (t
);
14762 /* When we parsed the expression, we determined whether or
14763 not Koenig lookup should be performed. */
14764 koenig_p
= KOENIG_LOOKUP_P (t
);
14765 if (TREE_CODE (function
) == SCOPE_REF
)
14767 qualified_p
= true;
14768 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
14770 /*address_p=*/false);
14772 else if (koenig_p
&& identifier_p (function
))
14774 /* Do nothing; calling tsubst_copy_and_build on an identifier
14775 would incorrectly perform unqualified lookup again.
14777 Note that we can also have an IDENTIFIER_NODE if the earlier
14778 unqualified lookup found a member function; in that case
14779 koenig_p will be false and we do want to do the lookup
14780 again to find the instantiated member function.
14782 FIXME but doing that causes c++/15272, so we need to stop
14783 using IDENTIFIER_NODE in that situation. */
14784 qualified_p
= false;
14788 if (TREE_CODE (function
) == COMPONENT_REF
)
14790 tree op
= TREE_OPERAND (function
, 1);
14792 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
14793 || (BASELINK_P (op
)
14794 && BASELINK_QUALIFIED_P (op
)));
14797 qualified_p
= false;
14799 if (TREE_CODE (function
) == ADDR_EXPR
14800 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
14801 /* Avoid error about taking the address of a constructor. */
14802 function
= TREE_OPERAND (function
, 0);
14804 function
= tsubst_copy_and_build (function
, args
, complain
,
14807 integral_constant_expression_p
);
14809 if (BASELINK_P (function
))
14810 qualified_p
= true;
14813 nargs
= call_expr_nargs (t
);
14814 call_args
= make_tree_vector ();
14815 for (i
= 0; i
< nargs
; ++i
)
14817 tree arg
= CALL_EXPR_ARG (t
, i
);
14819 if (!PACK_EXPANSION_P (arg
))
14820 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
14823 /* Expand the pack expansion and push each entry onto
14825 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
14826 if (TREE_CODE (arg
) == TREE_VEC
)
14828 unsigned int len
, j
;
14830 len
= TREE_VEC_LENGTH (arg
);
14831 for (j
= 0; j
< len
; ++j
)
14833 tree value
= TREE_VEC_ELT (arg
, j
);
14834 if (value
!= NULL_TREE
)
14835 value
= convert_from_reference (value
);
14836 vec_safe_push (call_args
, value
);
14841 /* A partial substitution. Add one entry. */
14842 vec_safe_push (call_args
, arg
);
14847 /* We do not perform argument-dependent lookup if normal
14848 lookup finds a non-function, in accordance with the
14849 expected resolution of DR 218. */
14851 && ((is_overloaded_fn (function
)
14852 /* If lookup found a member function, the Koenig lookup is
14853 not appropriate, even if an unqualified-name was used
14854 to denote the function. */
14855 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
14856 || identifier_p (function
))
14857 /* Only do this when substitution turns a dependent call
14858 into a non-dependent call. */
14859 && type_dependent_expression_p_push (t
)
14860 && !any_type_dependent_arguments_p (call_args
))
14861 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
14863 if (identifier_p (function
)
14864 && !any_type_dependent_arguments_p (call_args
))
14866 if (koenig_p
&& (complain
& tf_warning_or_error
))
14868 /* For backwards compatibility and good diagnostics, try
14869 the unqualified lookup again if we aren't in SFINAE
14871 tree unq
= (tsubst_copy_and_build
14872 (function
, args
, complain
, in_decl
, true,
14873 integral_constant_expression_p
));
14874 if (unq
== error_mark_node
)
14875 RETURN (error_mark_node
);
14877 if (unq
!= function
)
14880 if (INDIRECT_REF_P (fn
))
14881 fn
= TREE_OPERAND (fn
, 0);
14882 if (TREE_CODE (fn
) == COMPONENT_REF
)
14883 fn
= TREE_OPERAND (fn
, 1);
14884 if (is_overloaded_fn (fn
))
14885 fn
= get_first_fn (fn
);
14886 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
14887 "%qD was not declared in this scope, "
14888 "and no declarations were found by "
14889 "argument-dependent lookup at the point "
14890 "of instantiation", function
))
14893 /* Can't say anything more. */;
14894 else if (DECL_CLASS_SCOPE_P (fn
))
14896 location_t loc
= EXPR_LOC_OR_LOC (t
,
14899 "declarations in dependent base %qT are "
14900 "not found by unqualified lookup",
14901 DECL_CLASS_CONTEXT (fn
));
14902 if (current_class_ptr
)
14904 "use %<this->%D%> instead", function
);
14907 "use %<%T::%D%> instead",
14908 current_class_name
, function
);
14911 inform (0, "%q+D declared here, later in the "
14912 "translation unit", fn
);
14917 if (identifier_p (function
))
14919 if (complain
& tf_error
)
14920 unqualified_name_lookup_error (function
);
14921 release_tree_vector (call_args
);
14922 RETURN (error_mark_node
);
14926 /* Remember that there was a reference to this entity. */
14927 if (DECL_P (function
))
14928 mark_used (function
);
14930 /* Put back tf_decltype for the actual call. */
14931 complain
|= decltype_flag
;
14933 if (TREE_CODE (function
) == OFFSET_REF
)
14934 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
14936 else if (TREE_CODE (function
) == COMPONENT_REF
)
14938 tree instance
= TREE_OPERAND (function
, 0);
14939 tree fn
= TREE_OPERAND (function
, 1);
14941 if (processing_template_decl
14942 && (type_dependent_expression_p (instance
)
14943 || (!BASELINK_P (fn
)
14944 && TREE_CODE (fn
) != FIELD_DECL
)
14945 || type_dependent_expression_p (fn
)
14946 || any_type_dependent_arguments_p (call_args
)))
14947 ret
= build_nt_call_vec (function
, call_args
);
14948 else if (!BASELINK_P (fn
))
14949 ret
= finish_call_expr (function
, &call_args
,
14950 /*disallow_virtual=*/false,
14951 /*koenig_p=*/false,
14954 ret
= (build_new_method_call
14956 &call_args
, NULL_TREE
,
14957 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
14962 ret
= finish_call_expr (function
, &call_args
,
14963 /*disallow_virtual=*/qualified_p
,
14967 release_tree_vector (call_args
);
14974 tree cond
= RECUR (TREE_OPERAND (t
, 0));
14977 if (TREE_CODE (cond
) == INTEGER_CST
)
14979 if (integer_zerop (cond
))
14981 ++c_inhibit_evaluation_warnings
;
14982 exp1
= RECUR (TREE_OPERAND (t
, 1));
14983 --c_inhibit_evaluation_warnings
;
14984 exp2
= RECUR (TREE_OPERAND (t
, 2));
14988 exp1
= RECUR (TREE_OPERAND (t
, 1));
14989 ++c_inhibit_evaluation_warnings
;
14990 exp2
= RECUR (TREE_OPERAND (t
, 2));
14991 --c_inhibit_evaluation_warnings
;
14996 exp1
= RECUR (TREE_OPERAND (t
, 1));
14997 exp2
= RECUR (TREE_OPERAND (t
, 2));
15000 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
15001 cond
, exp1
, exp2
, complain
));
15004 case PSEUDO_DTOR_EXPR
:
15006 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15007 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15008 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15009 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
15015 tree purpose
, value
, chain
;
15017 if (t
== void_list_node
)
15020 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15021 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15023 /* We have pack expansions, so expand those and
15024 create a new list out of it. */
15025 tree purposevec
= NULL_TREE
;
15026 tree valuevec
= NULL_TREE
;
15030 /* Expand the argument expressions. */
15031 if (TREE_PURPOSE (t
))
15032 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15033 complain
, in_decl
);
15034 if (TREE_VALUE (t
))
15035 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15036 complain
, in_decl
);
15038 /* Build the rest of the list. */
15039 chain
= TREE_CHAIN (t
);
15040 if (chain
&& chain
!= void_type_node
)
15041 chain
= RECUR (chain
);
15043 /* Determine the number of arguments. */
15044 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15046 len
= TREE_VEC_LENGTH (purposevec
);
15047 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15049 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15050 len
= TREE_VEC_LENGTH (valuevec
);
15053 /* Since we only performed a partial substitution into
15054 the argument pack, we only RETURN (a single list
15056 if (purposevec
== TREE_PURPOSE (t
)
15057 && valuevec
== TREE_VALUE (t
)
15058 && chain
== TREE_CHAIN (t
))
15061 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15064 /* Convert the argument vectors into a TREE_LIST */
15068 /* Grab the Ith values. */
15070 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15073 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15076 /* Build the list (backwards). */
15077 chain
= tree_cons (purpose
, value
, chain
);
15083 purpose
= TREE_PURPOSE (t
);
15085 purpose
= RECUR (purpose
);
15086 value
= TREE_VALUE (t
);
15088 value
= RECUR (value
);
15089 chain
= TREE_CHAIN (t
);
15090 if (chain
&& chain
!= void_type_node
)
15091 chain
= RECUR (chain
);
15092 if (purpose
== TREE_PURPOSE (t
)
15093 && value
== TREE_VALUE (t
)
15094 && chain
== TREE_CHAIN (t
))
15096 RETURN (tree_cons (purpose
, value
, chain
));
15099 case COMPONENT_REF
:
15106 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15107 args
, complain
, in_decl
);
15108 /* Remember that there was a reference to this entity. */
15109 if (DECL_P (object
))
15110 mark_used (object
);
15111 object_type
= TREE_TYPE (object
);
15113 member
= TREE_OPERAND (t
, 1);
15114 if (BASELINK_P (member
))
15115 member
= tsubst_baselink (member
,
15116 non_reference (TREE_TYPE (object
)),
15117 args
, complain
, in_decl
);
15119 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15120 if (member
== error_mark_node
)
15121 RETURN (error_mark_node
);
15123 if (type_dependent_expression_p (object
))
15124 /* We can't do much here. */;
15125 else if (!CLASS_TYPE_P (object_type
))
15127 if (scalarish_type_p (object_type
))
15129 tree s
= NULL_TREE
;
15130 tree dtor
= member
;
15132 if (TREE_CODE (dtor
) == SCOPE_REF
)
15134 s
= TREE_OPERAND (dtor
, 0);
15135 dtor
= TREE_OPERAND (dtor
, 1);
15137 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15139 dtor
= TREE_OPERAND (dtor
, 0);
15141 RETURN (finish_pseudo_destructor_expr
15142 (object
, s
, dtor
, input_location
));
15146 else if (TREE_CODE (member
) == SCOPE_REF
15147 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15149 /* Lookup the template functions now that we know what the
15151 tree scope
= TREE_OPERAND (member
, 0);
15152 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15153 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15154 member
= lookup_qualified_name (scope
, tmpl
,
15155 /*is_type_p=*/false,
15156 /*complain=*/false);
15157 if (BASELINK_P (member
))
15159 BASELINK_FUNCTIONS (member
)
15160 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15162 member
= (adjust_result_of_qualified_name_lookup
15163 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15168 qualified_name_lookup_error (scope
, tmpl
, member
,
15170 RETURN (error_mark_node
);
15173 else if (TREE_CODE (member
) == SCOPE_REF
15174 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15175 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15177 if (complain
& tf_error
)
15179 if (TYPE_P (TREE_OPERAND (member
, 0)))
15180 error ("%qT is not a class or namespace",
15181 TREE_OPERAND (member
, 0));
15183 error ("%qD is not a class or namespace",
15184 TREE_OPERAND (member
, 0));
15186 RETURN (error_mark_node
);
15188 else if (TREE_CODE (member
) == FIELD_DECL
)
15190 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15191 if (TREE_CODE (r
) == COMPONENT_REF
)
15192 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15196 r
= finish_class_member_access_expr (object
, member
,
15197 /*template_p=*/false,
15199 if (TREE_CODE (r
) == COMPONENT_REF
)
15200 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15205 RETURN (build_throw
15206 (RECUR (TREE_OPERAND (t
, 0))));
15210 vec
<constructor_elt
, va_gc
> *n
;
15211 constructor_elt
*ce
;
15212 unsigned HOST_WIDE_INT idx
;
15213 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15214 bool process_index_p
;
15216 bool need_copy_p
= false;
15219 if (type
== error_mark_node
)
15220 RETURN (error_mark_node
);
15222 /* digest_init will do the wrong thing if we let it. */
15223 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15226 /* We do not want to process the index of aggregate
15227 initializers as they are identifier nodes which will be
15228 looked up by digest_init. */
15229 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15231 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15232 newlen
= vec_safe_length (n
);
15233 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15235 if (ce
->index
&& process_index_p
15236 /* An identifier index is looked up in the type
15237 being initialized, not the current scope. */
15238 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15239 ce
->index
= RECUR (ce
->index
);
15241 if (PACK_EXPANSION_P (ce
->value
))
15243 /* Substitute into the pack expansion. */
15244 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15247 if (ce
->value
== error_mark_node
15248 || PACK_EXPANSION_P (ce
->value
))
15250 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15251 /* Just move the argument into place. */
15252 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15255 /* Update the length of the final CONSTRUCTOR
15256 arguments vector, and note that we will need to
15258 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15259 need_copy_p
= true;
15263 ce
->value
= RECUR (ce
->value
);
15268 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15270 vec_alloc (n
, newlen
);
15271 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15273 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15275 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15276 for (i
= 0; i
< len
; ++i
)
15277 CONSTRUCTOR_APPEND_ELT (n
, 0,
15278 TREE_VEC_ELT (ce
->value
, i
));
15281 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15285 r
= build_constructor (init_list_type_node
, n
);
15286 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15288 if (TREE_HAS_CONSTRUCTOR (t
))
15289 RETURN (finish_compound_literal (type
, r
, complain
));
15291 TREE_TYPE (r
) = type
;
15297 tree operand_0
= TREE_OPERAND (t
, 0);
15298 if (TYPE_P (operand_0
))
15300 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15301 RETURN (get_typeid (operand_0
, complain
));
15305 operand_0
= RECUR (operand_0
);
15306 RETURN (build_typeid (operand_0
, complain
));
15313 else if (DECL_PACK_P (t
))
15315 /* We don't build decls for an instantiation of a
15316 variadic capture proxy, we instantiate the elements
15318 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15319 return RECUR (DECL_VALUE_EXPR (t
));
15325 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15327 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15328 /* If the original type was a reference, we'll be wrapped in
15329 the appropriate INDIRECT_REF. */
15330 r
= convert_from_reference (r
);
15336 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15337 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15338 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15341 case OFFSETOF_EXPR
:
15342 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0))));
15346 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15347 complain
, in_decl
);
15349 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15351 type2
= tsubst (type2
, args
, complain
, in_decl
);
15353 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15358 tree old_stmt_expr
= cur_stmt_expr
;
15359 tree stmt_expr
= begin_stmt_expr ();
15361 cur_stmt_expr
= stmt_expr
;
15362 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15363 integral_constant_expression_p
);
15364 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15365 cur_stmt_expr
= old_stmt_expr
;
15367 /* If the resulting list of expression statement is empty,
15368 fold it further into void_node. */
15369 if (empty_expr_stmt_p (stmt_expr
))
15370 stmt_expr
= void_node
;
15372 RETURN (stmt_expr
);
15377 tree r
= build_lambda_expr ();
15379 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15380 LAMBDA_EXPR_CLOSURE (r
) = type
;
15381 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15383 LAMBDA_EXPR_LOCATION (r
)
15384 = LAMBDA_EXPR_LOCATION (t
);
15385 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15386 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15387 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15388 LAMBDA_EXPR_DISCRIMINATOR (r
)
15389 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15390 /* For a function scope, we want to use tsubst so that we don't
15391 complain about referring to an auto function before its return
15392 type has been deduced. Otherwise, we want to use tsubst_copy so
15393 that we look up the existing field/parameter/variable rather
15394 than build a new one. */
15395 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15396 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15397 scope
= tsubst (scope
, args
, complain
, in_decl
);
15398 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15400 /* Look up the parameter we want directly, as tsubst_copy
15401 doesn't do what we need. */
15402 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15403 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15404 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15405 parm
= DECL_CHAIN (parm
);
15407 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15408 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15409 DECL_CONTEXT (scope
) = fn
;
15412 scope
= RECUR (scope
);
15413 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15414 LAMBDA_EXPR_RETURN_TYPE (r
)
15415 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15417 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15418 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15420 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15421 determine_visibility (TYPE_NAME (type
));
15422 /* Now that we know visibility, instantiate the type so we have a
15423 declaration of the op() for later calls to lambda_function. */
15424 complete_type (type
);
15426 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15428 RETURN (build_lambda_object (r
));
15432 /* We can get here for a constant initializer of non-dependent type.
15433 FIXME stop folding in cp_parser_initializer_clause. */
15435 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15440 case TRANSACTION_EXPR
:
15441 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15442 integral_constant_expression_p
));
15445 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15447 case VEC_PERM_EXPR
:
15449 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15450 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15451 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15452 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15457 /* Handle Objective-C++ constructs, if appropriate. */
15460 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15461 in_decl
, /*function_p=*/false);
15465 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15471 input_location
= loc
;
15475 /* Verify that the instantiated ARGS are valid. For type arguments,
15476 make sure that the type's linkage is ok. For non-type arguments,
15477 make sure they are constants if they are integral or enumerations.
15478 Emit an error under control of COMPLAIN, and return TRUE on error. */
15481 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15483 if (dependent_template_arg_p (t
))
15485 if (ARGUMENT_PACK_P (t
))
15487 tree vec
= ARGUMENT_PACK_ARGS (t
);
15488 int len
= TREE_VEC_LENGTH (vec
);
15489 bool result
= false;
15492 for (i
= 0; i
< len
; ++i
)
15493 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15497 else if (TYPE_P (t
))
15499 /* [basic.link]: A name with no linkage (notably, the name
15500 of a class or enumeration declared in a local scope)
15501 shall not be used to declare an entity with linkage.
15502 This implies that names with no linkage cannot be used as
15505 DR 757 relaxes this restriction for C++0x. */
15506 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15507 : no_linkage_check (t
, /*relaxed_p=*/false));
15511 /* DR 488 makes use of a type with no linkage cause
15512 type deduction to fail. */
15513 if (complain
& tf_error
)
15515 if (TYPE_ANONYMOUS_P (nt
))
15516 error ("%qT is/uses anonymous type", t
);
15518 error ("template argument for %qD uses local type %qT",
15523 /* In order to avoid all sorts of complications, we do not
15524 allow variably-modified types as template arguments. */
15525 else if (variably_modified_type_p (t
, NULL_TREE
))
15527 if (complain
& tf_error
)
15528 error ("%qT is a variably modified type", t
);
15532 /* Class template and alias template arguments should be OK. */
15533 else if (DECL_TYPE_TEMPLATE_P (t
))
15535 /* A non-type argument of integral or enumerated type must be a
15537 else if (TREE_TYPE (t
)
15538 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15539 && !TREE_CONSTANT (t
))
15541 if (complain
& tf_error
)
15542 error ("integral expression %qE is not constant", t
);
15549 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15551 int ix
, len
= DECL_NTPARMS (tmpl
);
15552 bool result
= false;
15554 for (ix
= 0; ix
!= len
; ix
++)
15556 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15559 if (result
&& (complain
& tf_error
))
15560 error (" trying to instantiate %qD", tmpl
);
15564 /* We're out of SFINAE context now, so generate diagnostics for the access
15565 errors we saw earlier when instantiating D from TMPL and ARGS. */
15568 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15570 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15571 tree type
= TREE_TYPE (pattern
);
15572 location_t loc
= input_location
;
15574 push_access_scope (d
);
15575 push_deferring_access_checks (dk_no_deferred
);
15576 input_location
= DECL_SOURCE_LOCATION (pattern
);
15577 tsubst (type
, args
, tf_warning_or_error
, d
);
15578 input_location
= loc
;
15579 pop_deferring_access_checks ();
15580 pop_access_scope (d
);
15583 /* Instantiate the indicated variable, function, or alias template TMPL with
15584 the template arguments in TARG_PTR. */
15587 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15589 tree targ_ptr
= orig_args
;
15593 bool access_ok
= true;
15595 if (tmpl
== error_mark_node
)
15596 return error_mark_node
;
15598 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15600 /* If this function is a clone, handle it specially. */
15601 if (DECL_CLONED_FUNCTION_P (tmpl
))
15606 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15607 DECL_CLONED_FUNCTION. */
15608 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15609 targ_ptr
, complain
);
15610 if (spec
== error_mark_node
)
15611 return error_mark_node
;
15613 /* Look for the clone. */
15614 FOR_EACH_CLONE (clone
, spec
)
15615 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15617 /* We should always have found the clone by now. */
15618 gcc_unreachable ();
15622 if (targ_ptr
== error_mark_node
)
15623 return error_mark_node
;
15625 /* Check to see if we already have this specialization. */
15626 gen_tmpl
= most_general_template (tmpl
);
15627 if (tmpl
!= gen_tmpl
)
15628 /* The TMPL is a partial instantiation. To get a full set of
15629 arguments we must add the arguments used to perform the
15630 partial instantiation. */
15631 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15634 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15635 but it doesn't seem to be on the hot path. */
15636 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15638 gcc_assert (tmpl
== gen_tmpl
15639 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15641 || fndecl
== NULL_TREE
);
15643 if (spec
!= NULL_TREE
)
15645 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15647 if (complain
& tf_error
)
15648 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15649 return error_mark_node
;
15654 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15656 return error_mark_node
;
15658 /* We are building a FUNCTION_DECL, during which the access of its
15659 parameters and return types have to be checked. However this
15660 FUNCTION_DECL which is the desired context for access checking
15661 is not built yet. We solve this chicken-and-egg problem by
15662 deferring all checks until we have the FUNCTION_DECL. */
15663 push_deferring_access_checks (dk_deferred
);
15665 /* Instantiation of the function happens in the context of the function
15666 template, not the context of the overload resolution we're doing. */
15667 push_to_top_level ();
15668 /* If there are dependent arguments, e.g. because we're doing partial
15669 ordering, make sure processing_template_decl stays set. */
15670 if (uses_template_parms (targ_ptr
))
15671 ++processing_template_decl
;
15672 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15674 tree ctx
= tsubst (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15675 complain
, gen_tmpl
);
15676 push_nested_class (ctx
);
15678 /* Substitute template parameters to obtain the specialization. */
15679 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
15680 targ_ptr
, complain
, gen_tmpl
);
15681 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15682 pop_nested_class ();
15683 pop_from_top_level ();
15685 if (fndecl
== error_mark_node
)
15687 pop_deferring_access_checks ();
15688 return error_mark_node
;
15691 /* The DECL_TI_TEMPLATE should always be the immediate parent
15692 template, not the most general template. */
15693 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
15695 /* Now we know the specialization, compute access previously
15697 push_access_scope (fndecl
);
15698 if (!perform_deferred_access_checks (complain
))
15700 pop_access_scope (fndecl
);
15701 pop_deferring_access_checks ();
15703 /* If we've just instantiated the main entry point for a function,
15704 instantiate all the alternate entry points as well. We do this
15705 by cloning the instantiation of the main entry point, not by
15706 instantiating the template clones. */
15707 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
15708 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
15712 if (!(complain
& tf_error
))
15714 /* Remember to reinstantiate when we're out of SFINAE so the user
15715 can see the errors. */
15716 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
15718 return error_mark_node
;
15723 /* Wrapper for instantiate_template_1. */
15726 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15729 timevar_push (TV_TEMPLATE_INST
);
15730 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
15731 timevar_pop (TV_TEMPLATE_INST
);
15735 /* Instantiate the alias template TMPL with ARGS. Also push a template
15736 instantiation level, which instantiate_template doesn't do because
15737 functions and variables have sufficient context established by the
15741 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
15743 struct pending_template
*old_last_pend
= last_pending_template
;
15744 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15745 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
15746 return error_mark_node
;
15747 tree tinst
= build_tree_list (tmpl
, args
);
15748 if (!push_tinst_level (tinst
))
15751 return error_mark_node
;
15755 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
15756 args
, tmpl
, complain
,
15757 /*require_all_args=*/true,
15758 /*use_default_args=*/true);
15760 tree r
= instantiate_template (tmpl
, args
, complain
);
15761 pop_tinst_level ();
15762 /* We can't free this if a pending_template entry or last_error_tinst_level
15763 is pointing at it. */
15764 if (last_pending_template
== old_last_pend
15765 && last_error_tinst_level
== old_error_tinst
)
15771 /* PARM is a template parameter pack for FN. Returns true iff
15772 PARM is used in a deducible way in the argument list of FN. */
15775 pack_deducible_p (tree parm
, tree fn
)
15777 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
15778 for (; t
; t
= TREE_CHAIN (t
))
15780 tree type
= TREE_VALUE (t
);
15782 if (!PACK_EXPANSION_P (type
))
15784 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
15785 packs
; packs
= TREE_CHAIN (packs
))
15786 if (template_args_equal (TREE_VALUE (packs
), parm
))
15788 /* The template parameter pack is used in a function parameter
15789 pack. If this is the end of the parameter list, the
15790 template parameter pack is deducible. */
15791 if (TREE_CHAIN (t
) == void_list_node
)
15794 /* Otherwise, not. Well, it could be deduced from
15795 a non-pack parameter, but doing so would end up with
15796 a deduction mismatch, so don't bother. */
15800 /* The template parameter pack isn't used in any function parameter
15801 packs, but it might be used deeper, e.g. tuple<Args...>. */
15805 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
15806 NARGS elements of the arguments that are being used when calling
15807 it. TARGS is a vector into which the deduced template arguments
15810 Returns either a FUNCTION_DECL for the matching specialization of FN or
15811 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
15812 true, diagnostics will be printed to explain why it failed.
15814 If FN is a conversion operator, or we are trying to produce a specific
15815 specialization, RETURN_TYPE is the return type desired.
15817 The EXPLICIT_TARGS are explicit template arguments provided via a
15820 The parameter STRICT is one of:
15823 We are deducing arguments for a function call, as in
15824 [temp.deduct.call].
15827 We are deducing arguments for a conversion function, as in
15828 [temp.deduct.conv].
15831 We are deducing arguments when doing an explicit instantiation
15832 as in [temp.explicit], when determining an explicit specialization
15833 as in [temp.expl.spec], or when taking the address of a function
15834 template, as in [temp.deduct.funcaddr]. */
15837 fn_type_unification (tree fn
,
15838 tree explicit_targs
,
15841 unsigned int nargs
,
15843 unification_kind_t strict
,
15850 tree decl
= NULL_TREE
;
15851 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
15853 static int deduction_depth
;
15854 struct pending_template
*old_last_pend
= last_pending_template
;
15855 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15856 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
15858 tree r
= error_mark_node
;
15861 complain
|= tf_decltype
;
15863 /* In C++0x, it's possible to have a function template whose type depends
15864 on itself recursively. This is most obvious with decltype, but can also
15865 occur with enumeration scope (c++/48969). So we need to catch infinite
15866 recursion and reject the substitution at deduction time; this function
15867 will return error_mark_node for any repeated substitution.
15869 This also catches excessive recursion such as when f<N> depends on
15870 f<N-1> across all integers, and returns error_mark_node for all the
15871 substitutions back up to the initial one.
15873 This is, of course, not reentrant. */
15874 if (excessive_deduction_depth
)
15875 return error_mark_node
;
15876 tinst
= build_tree_list (fn
, NULL_TREE
);
15879 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
15881 fntype
= TREE_TYPE (fn
);
15882 if (explicit_targs
)
15886 The specified template arguments must match the template
15887 parameters in kind (i.e., type, nontype, template), and there
15888 must not be more arguments than there are parameters;
15889 otherwise type deduction fails.
15891 Nontype arguments must match the types of the corresponding
15892 nontype template parameters, or must be convertible to the
15893 types of the corresponding nontype parameters as specified in
15894 _temp.arg.nontype_, otherwise type deduction fails.
15896 All references in the function type of the function template
15897 to the corresponding template parameters are replaced by the
15898 specified template argument values. If a substitution in a
15899 template parameter or in the function type of the function
15900 template results in an invalid type, type deduction fails. */
15901 int i
, len
= TREE_VEC_LENGTH (tparms
);
15902 location_t loc
= input_location
;
15903 bool incomplete
= false;
15905 /* Adjust any explicit template arguments before entering the
15906 substitution context. */
15908 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
15910 /*require_all_args=*/false,
15911 /*use_default_args=*/false));
15912 if (explicit_targs
== error_mark_node
)
15915 /* Substitute the explicit args into the function type. This is
15916 necessary so that, for instance, explicitly declared function
15917 arguments can match null pointed constants. If we were given
15918 an incomplete set of explicit args, we must not do semantic
15919 processing during substitution as we could create partial
15921 for (i
= 0; i
< len
; i
++)
15923 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
15924 bool parameter_pack
= false;
15925 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
15927 /* Dig out the actual parm. */
15928 if (TREE_CODE (parm
) == TYPE_DECL
15929 || TREE_CODE (parm
) == TEMPLATE_DECL
)
15931 parm
= TREE_TYPE (parm
);
15932 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
15934 else if (TREE_CODE (parm
) == PARM_DECL
)
15936 parm
= DECL_INITIAL (parm
);
15937 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
15940 if (!parameter_pack
&& targ
== NULL_TREE
)
15941 /* No explicit argument for this template parameter. */
15944 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
15946 /* Mark the argument pack as "incomplete". We could
15947 still deduce more arguments during unification.
15948 We remove this mark in type_unification_real. */
15951 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
15952 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
15953 = ARGUMENT_PACK_ARGS (targ
);
15956 /* We have some incomplete argument packs. */
15961 TREE_VALUE (tinst
) = explicit_targs
;
15962 if (!push_tinst_level (tinst
))
15964 excessive_deduction_depth
= true;
15967 processing_template_decl
+= incomplete
;
15968 input_location
= DECL_SOURCE_LOCATION (fn
);
15969 /* Ignore any access checks; we'll see them again in
15970 instantiate_template and they might have the wrong
15971 access path at this point. */
15972 push_deferring_access_checks (dk_deferred
);
15973 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
15974 complain
| tf_partial
, NULL_TREE
);
15975 pop_deferring_access_checks ();
15976 input_location
= loc
;
15977 processing_template_decl
-= incomplete
;
15978 pop_tinst_level ();
15980 if (fntype
== error_mark_node
)
15983 /* Place the explicitly specified arguments in TARGS. */
15984 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
15985 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
15988 /* Never do unification on the 'this' parameter. */
15989 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
15995 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
15996 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
15997 new_args
[0] = return_type
;
15998 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
16003 /* We allow incomplete unification without an error message here
16004 because the standard doesn't seem to explicitly prohibit it. Our
16005 callers must be ready to deal with unification failures in any
16008 TREE_VALUE (tinst
) = targs
;
16009 /* If we aren't explaining yet, push tinst context so we can see where
16010 any errors (e.g. from class instantiations triggered by instantiation
16011 of default template arguments) come from. If we are explaining, this
16012 context is redundant. */
16013 if (!explain_p
&& !push_tinst_level (tinst
))
16015 excessive_deduction_depth
= true;
16019 /* type_unification_real will pass back any access checks from default
16020 template argument substitution. */
16021 vec
<deferred_access_check
, va_gc
> *checks
;
16024 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16025 targs
, parms
, args
, nargs
, /*subr=*/0,
16026 strict
, flags
, &checks
, explain_p
);
16028 pop_tinst_level ();
16032 /* Now that we have bindings for all of the template arguments,
16033 ensure that the arguments deduced for the template template
16034 parameters have compatible template parameter lists. We cannot
16035 check this property before we have deduced all template
16036 arguments, because the template parameter types of a template
16037 template parameter might depend on prior template parameters
16038 deduced after the template template parameter. The following
16039 ill-formed example illustrates this issue:
16041 template<typename T, template<T> class C> void f(C<5>, T);
16043 template<int N> struct X {};
16046 f(X<5>(), 5l); // error: template argument deduction fails
16049 The template parameter list of 'C' depends on the template type
16050 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16051 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16052 time that we deduce 'C'. */
16053 if (!template_template_parm_bindings_ok_p
16054 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16056 unify_inconsistent_template_template_parameters (explain_p
);
16060 /* All is well so far. Now, check:
16064 When all template arguments have been deduced, all uses of
16065 template parameters in nondeduced contexts are replaced with
16066 the corresponding deduced argument values. If the
16067 substitution results in an invalid type, as described above,
16068 type deduction fails. */
16069 TREE_VALUE (tinst
) = targs
;
16070 if (!push_tinst_level (tinst
))
16072 excessive_deduction_depth
= true;
16076 /* Also collect access checks from the instantiation. */
16077 reopen_deferring_access_checks (checks
);
16079 decl
= instantiate_template (fn
, targs
, complain
);
16081 checks
= get_deferred_access_checks ();
16082 pop_deferring_access_checks ();
16084 pop_tinst_level ();
16086 if (decl
== error_mark_node
)
16089 /* Now perform any access checks encountered during substitution. */
16090 push_access_scope (decl
);
16091 ok
= perform_access_checks (checks
, complain
);
16092 pop_access_scope (decl
);
16096 /* If we're looking for an exact match, check that what we got
16097 is indeed an exact match. It might not be if some template
16098 parameters are used in non-deduced contexts. But don't check
16099 for an exact match if we have dependent template arguments;
16100 in that case we're doing partial ordering, and we already know
16101 that we have two candidates that will provide the actual type. */
16102 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16104 tree substed
= TREE_TYPE (decl
);
16108 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16110 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16111 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16112 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16114 unify_type_mismatch (explain_p
, args
[i
],
16115 TREE_VALUE (sarg
));
16124 if (excessive_deduction_depth
)
16126 if (deduction_depth
== 0)
16127 /* Reset once we're all the way out. */
16128 excessive_deduction_depth
= false;
16131 /* We can't free this if a pending_template entry or last_error_tinst_level
16132 is pointing at it. */
16133 if (last_pending_template
== old_last_pend
16134 && last_error_tinst_level
== old_error_tinst
)
16140 /* Adjust types before performing type deduction, as described in
16141 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16142 sections are symmetric. PARM is the type of a function parameter
16143 or the return type of the conversion function. ARG is the type of
16144 the argument passed to the call, or the type of the value
16145 initialized with the result of the conversion function.
16146 ARG_EXPR is the original argument expression, which may be null. */
16149 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16163 /* Swap PARM and ARG throughout the remainder of this
16164 function; the handling is precisely symmetric since PARM
16165 will initialize ARG rather than vice versa. */
16173 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16174 too, but here handle it by stripping the reference from PARM
16175 rather than by adding it to ARG. */
16176 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16177 && TYPE_REF_IS_RVALUE (*parm
)
16178 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16179 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16180 && TREE_CODE (*arg
) == REFERENCE_TYPE
16181 && !TYPE_REF_IS_RVALUE (*arg
))
16182 *parm
= TREE_TYPE (*parm
);
16183 /* Nothing else to do in this case. */
16187 gcc_unreachable ();
16190 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16192 /* [temp.deduct.call]
16194 If P is not a reference type:
16196 --If A is an array type, the pointer type produced by the
16197 array-to-pointer standard conversion (_conv.array_) is
16198 used in place of A for type deduction; otherwise,
16200 --If A is a function type, the pointer type produced by
16201 the function-to-pointer standard conversion
16202 (_conv.func_) is used in place of A for type deduction;
16205 --If A is a cv-qualified type, the top level
16206 cv-qualifiers of A's type are ignored for type
16208 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16209 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16210 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16211 *arg
= build_pointer_type (*arg
);
16213 *arg
= TYPE_MAIN_VARIANT (*arg
);
16216 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16217 of the form T&&, where T is a template parameter, and the argument
16218 is an lvalue, T is deduced as A& */
16219 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16220 && TYPE_REF_IS_RVALUE (*parm
)
16221 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16222 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16223 && (arg_expr
? real_lvalue_p (arg_expr
)
16224 /* try_one_overload doesn't provide an arg_expr, but
16225 functions are always lvalues. */
16226 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16227 *arg
= build_reference_type (*arg
);
16229 /* [temp.deduct.call]
16231 If P is a cv-qualified type, the top level cv-qualifiers
16232 of P's type are ignored for type deduction. If P is a
16233 reference type, the type referred to by P is used for
16235 *parm
= TYPE_MAIN_VARIANT (*parm
);
16236 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16238 *parm
= TREE_TYPE (*parm
);
16239 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16242 /* DR 322. For conversion deduction, remove a reference type on parm
16243 too (which has been swapped into ARG). */
16244 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16245 *arg
= TREE_TYPE (*arg
);
16250 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16251 template which does contain any deducible template parameters; check if
16252 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16253 unify_one_argument. */
16256 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16257 int flags
, bool explain_p
)
16262 type
= TREE_TYPE (arg
);
16266 if (same_type_p (parm
, type
))
16267 return unify_success (explain_p
);
16269 if (strict
== DEDUCE_CONV
)
16271 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16272 explain_p
? tf_warning_or_error
: tf_none
))
16273 return unify_success (explain_p
);
16275 else if (strict
!= DEDUCE_EXACT
)
16277 if (can_convert_arg (parm
, type
,
16278 TYPE_P (arg
) ? NULL_TREE
: arg
,
16279 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16280 return unify_success (explain_p
);
16283 if (strict
== DEDUCE_EXACT
)
16284 return unify_type_mismatch (explain_p
, parm
, arg
);
16286 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16289 static bool uses_deducible_template_parms (tree type
);
16291 /* Returns true iff the expression EXPR is one from which a template
16292 argument can be deduced. In other words, if it's an undecorated
16293 use of a template non-type parameter. */
16296 deducible_expression (tree expr
)
16298 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16301 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16302 deducible way; that is, if it has a max value of <PARM> - 1. */
16305 deducible_array_bound (tree domain
)
16307 if (domain
== NULL_TREE
)
16310 tree max
= TYPE_MAX_VALUE (domain
);
16311 if (TREE_CODE (max
) != MINUS_EXPR
)
16314 return deducible_expression (TREE_OPERAND (max
, 0));
16317 /* Returns true iff the template arguments ARGS use a template parameter
16318 in a deducible way. */
16321 deducible_template_args (tree args
)
16323 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16326 tree elt
= TREE_VEC_ELT (args
, i
);
16327 if (ARGUMENT_PACK_P (elt
))
16328 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16331 if (PACK_EXPANSION_P (elt
))
16332 elt
= PACK_EXPANSION_PATTERN (elt
);
16333 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16335 else if (TYPE_P (elt
))
16336 deducible
= uses_deducible_template_parms (elt
);
16338 deducible
= deducible_expression (elt
);
16346 /* Returns true iff TYPE contains any deducible references to template
16347 parameters, as per 14.8.2.5. */
16350 uses_deducible_template_parms (tree type
)
16352 if (PACK_EXPANSION_P (type
))
16353 type
= PACK_EXPANSION_PATTERN (type
);
16360 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16361 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16367 if (POINTER_TYPE_P (type
))
16368 return uses_deducible_template_parms (TREE_TYPE (type
));
16370 /* T[integer-constant ]
16372 if (TREE_CODE (type
) == ARRAY_TYPE
)
16373 return (uses_deducible_template_parms (TREE_TYPE (type
))
16374 || deducible_array_bound (TYPE_DOMAIN (type
)));
16386 if (TYPE_PTRMEM_P (type
))
16387 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16388 || (uses_deducible_template_parms
16389 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16391 /* template-name <T> (where template-name refers to a class template)
16392 template-name <i> (where template-name refers to a class template) */
16393 if (CLASS_TYPE_P (type
)
16394 && CLASSTYPE_TEMPLATE_INFO (type
)
16395 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16396 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16397 (CLASSTYPE_TI_ARGS (type
)));
16402 if (TREE_CODE (type
) == FUNCTION_TYPE
16403 || TREE_CODE (type
) == METHOD_TYPE
)
16405 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16407 tree parm
= TYPE_ARG_TYPES (type
);
16408 if (TREE_CODE (type
) == METHOD_TYPE
)
16409 parm
= TREE_CHAIN (parm
);
16410 for (; parm
; parm
= TREE_CHAIN (parm
))
16411 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16418 /* Subroutine of type_unification_real and unify_pack_expansion to
16419 handle unification of a single P/A pair. Parameters are as
16420 for those functions. */
16423 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16424 int subr
, unification_kind_t strict
, int flags
,
16427 tree arg_expr
= NULL_TREE
;
16430 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16431 return unify_invalid (explain_p
);
16432 if (arg
== unknown_type_node
)
16433 /* We can't deduce anything from this, but we might get all the
16434 template args from other function args. */
16435 return unify_success (explain_p
);
16437 /* Implicit conversions (Clause 4) will be performed on a function
16438 argument to convert it to the type of the corresponding function
16439 parameter if the parameter type contains no template-parameters that
16440 participate in template argument deduction. */
16441 if (TYPE_P (parm
) && !uses_template_parms (parm
))
16442 /* For function parameters that contain no template-parameters at all,
16443 we have historically checked for convertibility in order to shortcut
16444 consideration of this candidate. */
16445 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
16447 else if (strict
== DEDUCE_CALL
16448 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16449 /* For function parameters with only non-deducible template parameters,
16451 return unify_success (explain_p
);
16456 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16457 | UNIFY_ALLOW_MORE_CV_QUAL
16458 | UNIFY_ALLOW_DERIVED
);
16462 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16466 arg_strict
= UNIFY_ALLOW_NONE
;
16470 gcc_unreachable ();
16473 /* We only do these transformations if this is the top-level
16474 parameter_type_list in a call or declaration matching; in other
16475 situations (nested function declarators, template argument lists) we
16476 won't be comparing a type to an expression, and we don't do any type
16482 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16483 if (type_unknown_p (arg
))
16485 /* [temp.deduct.type] A template-argument can be
16486 deduced from a pointer to function or pointer
16487 to member function argument if the set of
16488 overloaded functions does not contain function
16489 templates and at most one of a set of
16490 overloaded functions provides a unique
16493 if (resolve_overloaded_unification
16494 (tparms
, targs
, parm
, arg
, strict
,
16495 arg_strict
, explain_p
))
16496 return unify_success (explain_p
);
16497 return unify_overload_resolution_failure (explain_p
, arg
);
16501 arg
= unlowered_expr_type (arg
);
16502 if (arg
== error_mark_node
)
16503 return unify_invalid (explain_p
);
16507 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16510 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16511 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
16512 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16514 /* For deduction from an init-list we need the actual list. */
16515 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16517 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16520 /* Most parms like fn_type_unification.
16522 If SUBR is 1, we're being called recursively (to unify the
16523 arguments of a function or method parameter of a function
16526 CHECKS is a pointer to a vector of access checks encountered while
16527 substituting default template arguments. */
16530 type_unification_real (tree tparms
,
16534 unsigned int xnargs
,
16536 unification_kind_t strict
,
16538 vec
<deferred_access_check
, va_gc
> **checks
,
16543 int ntparms
= TREE_VEC_LENGTH (tparms
);
16544 int saw_undeduced
= 0;
16547 unsigned int nargs
;
16550 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16551 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16552 gcc_assert (ntparms
> 0);
16554 /* Reset the number of non-defaulted template arguments contained
16556 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16564 while (parms
&& parms
!= void_list_node
16567 parm
= TREE_VALUE (parms
);
16569 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16570 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16571 /* For a function parameter pack that occurs at the end of the
16572 parameter-declaration-list, the type A of each remaining
16573 argument of the call is compared with the type P of the
16574 declarator-id of the function parameter pack. */
16577 parms
= TREE_CHAIN (parms
);
16579 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16580 /* For a function parameter pack that does not occur at the
16581 end of the parameter-declaration-list, the type of the
16582 parameter pack is a non-deduced context. */
16588 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16594 && parms
!= void_list_node
16595 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16597 /* Unify the remaining arguments with the pack expansion type. */
16599 tree parmvec
= make_tree_vec (1);
16601 /* Allocate a TREE_VEC and copy in all of the arguments */
16602 argvec
= make_tree_vec (nargs
- ia
);
16603 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16604 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16606 /* Copy the parameter into parmvec. */
16607 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16608 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16609 /*subr=*/subr
, explain_p
))
16612 /* Advance to the end of the list of parameters. */
16613 parms
= TREE_CHAIN (parms
);
16616 /* Fail if we've reached the end of the parm list, and more args
16617 are present, and the parm list isn't variadic. */
16618 if (ia
< nargs
&& parms
== void_list_node
)
16619 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16620 /* Fail if parms are left and they don't have default values. */
16621 if (parms
&& parms
!= void_list_node
16622 && TREE_PURPOSE (parms
) == NULL_TREE
)
16624 unsigned int count
= nargs
;
16626 while (p
&& p
!= void_list_node
)
16629 p
= TREE_CHAIN (p
);
16631 return unify_too_few_arguments (explain_p
, ia
, count
);
16636 tsubst_flags_t complain
= (explain_p
16637 ? tf_warning_or_error
16640 for (i
= 0; i
< ntparms
; i
++)
16642 tree targ
= TREE_VEC_ELT (targs
, i
);
16643 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16645 /* Clear the "incomplete" flags on all argument packs now so that
16646 substituting them into later default arguments works. */
16647 if (targ
&& ARGUMENT_PACK_P (targ
))
16649 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16650 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16653 if (targ
|| tparm
== error_mark_node
)
16655 tparm
= TREE_VALUE (tparm
);
16657 /* If this is an undeduced nontype parameter that depends on
16658 a type parameter, try another pass; its type may have been
16659 deduced from a later argument than the one from which
16660 this parameter can be deduced. */
16661 if (TREE_CODE (tparm
) == PARM_DECL
16662 && uses_template_parms (TREE_TYPE (tparm
))
16663 && !saw_undeduced
++)
16666 /* Core issue #226 (C++0x) [temp.deduct]:
16668 If a template argument has not been deduced, its
16669 default template argument, if any, is used.
16671 When we are in C++98 mode, TREE_PURPOSE will either
16672 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16673 to explicitly check cxx_dialect here. */
16674 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
16676 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16677 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
16678 reopen_deferring_access_checks (*checks
);
16679 location_t save_loc
= input_location
;
16681 input_location
= DECL_SOURCE_LOCATION (parm
);
16682 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
16683 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
16685 input_location
= save_loc
;
16686 *checks
= get_deferred_access_checks ();
16687 pop_deferring_access_checks ();
16688 if (arg
== error_mark_node
)
16692 TREE_VEC_ELT (targs
, i
) = arg
;
16693 /* The position of the first default template argument,
16694 is also the number of non-defaulted arguments in TARGS.
16696 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16697 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
16702 /* If the type parameter is a parameter pack, then it will
16703 be deduced to an empty parameter pack. */
16704 if (template_parameter_pack_p (tparm
))
16708 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
16710 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
16711 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
16712 TREE_CONSTANT (arg
) = 1;
16715 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16717 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
16719 TREE_VEC_ELT (targs
, i
) = arg
;
16723 return unify_parameter_deduction_failure (explain_p
, tparm
);
16726 #ifdef ENABLE_CHECKING
16727 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16728 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
16731 return unify_success (explain_p
);
16734 /* Subroutine of type_unification_real. Args are like the variables
16735 at the call site. ARG is an overloaded function (or template-id);
16736 we try deducing template args from each of the overloads, and if
16737 only one succeeds, we go with that. Modifies TARGS and returns
16738 true on success. */
16741 resolve_overloaded_unification (tree tparms
,
16745 unification_kind_t strict
,
16749 tree tempargs
= copy_node (targs
);
16751 tree goodfn
= NULL_TREE
;
16754 if (TREE_CODE (arg
) == ADDR_EXPR
)
16756 arg
= TREE_OPERAND (arg
, 0);
16762 if (TREE_CODE (arg
) == COMPONENT_REF
)
16763 /* Handle `&x' where `x' is some static or non-static member
16765 arg
= TREE_OPERAND (arg
, 1);
16767 if (TREE_CODE (arg
) == OFFSET_REF
)
16768 arg
= TREE_OPERAND (arg
, 1);
16770 /* Strip baselink information. */
16771 if (BASELINK_P (arg
))
16772 arg
= BASELINK_FUNCTIONS (arg
);
16774 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
16776 /* If we got some explicit template args, we need to plug them into
16777 the affected templates before we try to unify, in case the
16778 explicit args will completely resolve the templates in question. */
16781 tree expl_subargs
= TREE_OPERAND (arg
, 1);
16782 arg
= TREE_OPERAND (arg
, 0);
16784 for (; arg
; arg
= OVL_NEXT (arg
))
16786 tree fn
= OVL_CURRENT (arg
);
16787 tree subargs
, elem
;
16789 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16792 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16793 expl_subargs
, NULL_TREE
, tf_none
,
16794 /*require_all_args=*/true,
16795 /*use_default_args=*/true);
16796 if (subargs
!= error_mark_node
16797 && !any_dependent_template_arguments_p (subargs
))
16799 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
16800 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16801 elem
, strict
, sub_strict
, addr_p
, explain_p
)
16802 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
16811 /* If no templates (or more than one) are fully resolved by the
16812 explicit arguments, this template-id is a non-deduced context; it
16813 could still be OK if we deduce all template arguments for the
16814 enclosing call through other arguments. */
16818 else if (TREE_CODE (arg
) != OVERLOAD
16819 && TREE_CODE (arg
) != FUNCTION_DECL
)
16820 /* If ARG is, for example, "(0, &f)" then its type will be unknown
16821 -- but the deduction does not succeed because the expression is
16822 not just the function on its own. */
16825 for (; arg
; arg
= OVL_NEXT (arg
))
16826 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16827 TREE_TYPE (OVL_CURRENT (arg
)),
16828 strict
, sub_strict
, addr_p
, explain_p
)
16829 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
16831 goodfn
= OVL_CURRENT (arg
);
16835 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16836 to function or pointer to member function argument if the set of
16837 overloaded functions does not contain function templates and at most
16838 one of a set of overloaded functions provides a unique match.
16840 So if we found multiple possibilities, we return success but don't
16841 deduce anything. */
16845 int i
= TREE_VEC_LENGTH (targs
);
16847 if (TREE_VEC_ELT (tempargs
, i
))
16849 tree old
= TREE_VEC_ELT (targs
, i
);
16850 tree new_
= TREE_VEC_ELT (tempargs
, i
);
16851 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
16852 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
16853 /* Don't forget explicit template arguments in a pack. */
16854 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
16855 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
16856 TREE_VEC_ELT (targs
, i
) = new_
;
16865 /* Core DR 115: In contexts where deduction is done and fails, or in
16866 contexts where deduction is not done, if a template argument list is
16867 specified and it, along with any default template arguments, identifies
16868 a single function template specialization, then the template-id is an
16869 lvalue for the function template specialization. */
16872 resolve_nondeduced_context (tree orig_expr
)
16874 tree expr
, offset
, baselink
;
16877 if (!type_unknown_p (orig_expr
))
16882 offset
= NULL_TREE
;
16883 baselink
= NULL_TREE
;
16885 if (TREE_CODE (expr
) == ADDR_EXPR
)
16887 expr
= TREE_OPERAND (expr
, 0);
16890 if (TREE_CODE (expr
) == OFFSET_REF
)
16893 expr
= TREE_OPERAND (expr
, 1);
16895 if (BASELINK_P (expr
))
16898 expr
= BASELINK_FUNCTIONS (expr
);
16901 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
16904 tree goodfn
= NULL_TREE
;
16906 /* If we got some explicit template args, we need to plug them into
16907 the affected templates before we try to unify, in case the
16908 explicit args will completely resolve the templates in question. */
16910 tree expl_subargs
= TREE_OPERAND (expr
, 1);
16911 tree arg
= TREE_OPERAND (expr
, 0);
16912 tree badfn
= NULL_TREE
;
16913 tree badargs
= NULL_TREE
;
16915 for (; arg
; arg
= OVL_NEXT (arg
))
16917 tree fn
= OVL_CURRENT (arg
);
16918 tree subargs
, elem
;
16920 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16923 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16924 expl_subargs
, NULL_TREE
, tf_none
,
16925 /*require_all_args=*/true,
16926 /*use_default_args=*/true);
16927 if (subargs
!= error_mark_node
16928 && !any_dependent_template_arguments_p (subargs
))
16930 elem
= instantiate_template (fn
, subargs
, tf_none
);
16931 if (elem
== error_mark_node
)
16936 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
16945 mark_used (goodfn
);
16948 expr
= build_baselink (BASELINK_BINFO (baselink
),
16949 BASELINK_ACCESS_BINFO (baselink
),
16950 expr
, BASELINK_OPTYPE (baselink
));
16954 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
16955 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
16958 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
16961 else if (good
== 0 && badargs
)
16962 /* There were no good options and at least one bad one, so let the
16963 user know what the problem is. */
16964 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
16969 /* Subroutine of resolve_overloaded_unification; does deduction for a single
16970 overload. Fills TARGS with any deduced arguments, or error_mark_node if
16971 different overloads deduce different arguments for a given parm.
16972 ADDR_P is true if the expression for which deduction is being
16973 performed was of the form "& fn" rather than simply "fn".
16975 Returns 1 on success. */
16978 try_one_overload (tree tparms
,
16983 unification_kind_t strict
,
16992 if (arg
== error_mark_node
)
16995 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16996 to function or pointer to member function argument if the set of
16997 overloaded functions does not contain function templates and at most
16998 one of a set of overloaded functions provides a unique match.
17000 So if this is a template, just return success. */
17002 if (uses_template_parms (arg
))
17005 if (TREE_CODE (arg
) == METHOD_TYPE
)
17006 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
17008 arg
= build_pointer_type (arg
);
17010 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
17012 /* We don't copy orig_targs for this because if we have already deduced
17013 some template args from previous args, unify would complain when we
17014 try to deduce a template parameter for the same argument, even though
17015 there isn't really a conflict. */
17016 nargs
= TREE_VEC_LENGTH (targs
);
17017 tempargs
= make_tree_vec (nargs
);
17019 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
17022 /* First make sure we didn't deduce anything that conflicts with
17023 explicitly specified args. */
17024 for (i
= nargs
; i
--; )
17026 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17027 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17031 else if (uses_template_parms (elt
))
17032 /* Since we're unifying against ourselves, we will fill in
17033 template args used in the function parm list with our own
17034 template parms. Discard them. */
17035 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17036 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17040 for (i
= nargs
; i
--; )
17042 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17045 TREE_VEC_ELT (targs
, i
) = elt
;
17051 /* PARM is a template class (perhaps with unbound template
17052 parameters). ARG is a fully instantiated type. If ARG can be
17053 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17054 TARGS are as for unify. */
17057 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17060 tree copy_of_targs
;
17062 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17063 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17064 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17067 /* We need to make a new template argument vector for the call to
17068 unify. If we used TARGS, we'd clutter it up with the result of
17069 the attempted unification, even if this class didn't work out.
17070 We also don't want to commit ourselves to all the unifications
17071 we've already done, since unification is supposed to be done on
17072 an argument-by-argument basis. In other words, consider the
17073 following pathological case:
17075 template <int I, int J, int K>
17078 template <int I, int J>
17079 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17081 template <int I, int J, int K>
17082 void f(S<I, J, K>, S<I, I, I>);
17091 Now, by the time we consider the unification involving `s2', we
17092 already know that we must have `f<0, 0, 0>'. But, even though
17093 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17094 because there are two ways to unify base classes of S<0, 1, 2>
17095 with S<I, I, I>. If we kept the already deduced knowledge, we
17096 would reject the possibility I=1. */
17097 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17099 /* If unification failed, we're done. */
17100 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17101 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17107 /* Given a template type PARM and a class type ARG, find the unique
17108 base type in ARG that is an instance of PARM. We do not examine
17109 ARG itself; only its base-classes. If there is not exactly one
17110 appropriate base class, return NULL_TREE. PARM may be the type of
17111 a partial specialization, as well as a plain template type. Used
17114 static enum template_base_result
17115 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17116 bool explain_p
, tree
*result
)
17118 tree rval
= NULL_TREE
;
17121 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17123 binfo
= TYPE_BINFO (complete_type (arg
));
17126 /* The type could not be completed. */
17127 *result
= NULL_TREE
;
17128 return tbr_incomplete_type
;
17131 /* Walk in inheritance graph order. The search order is not
17132 important, and this avoids multiple walks of virtual bases. */
17133 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17135 tree r
= try_class_unification (tparms
, targs
, parm
,
17136 BINFO_TYPE (binfo
), explain_p
);
17140 /* If there is more than one satisfactory baseclass, then:
17144 If they yield more than one possible deduced A, the type
17148 if (rval
&& !same_type_p (r
, rval
))
17150 *result
= NULL_TREE
;
17151 return tbr_ambiguous_baseclass
;
17159 return tbr_success
;
17162 /* Returns the level of DECL, which declares a template parameter. */
17165 template_decl_level (tree decl
)
17167 switch (TREE_CODE (decl
))
17170 case TEMPLATE_DECL
:
17171 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17174 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17177 gcc_unreachable ();
17182 /* Decide whether ARG can be unified with PARM, considering only the
17183 cv-qualifiers of each type, given STRICT as documented for unify.
17184 Returns nonzero iff the unification is OK on that basis. */
17187 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17189 int arg_quals
= cp_type_quals (arg
);
17190 int parm_quals
= cp_type_quals (parm
);
17192 /* DR 1584: cv-qualification of a deduced function type is
17193 ignored; see 8.3.5 [dcl.fct]. */
17194 if (TREE_CODE (arg
) == FUNCTION_TYPE
)
17197 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17198 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17200 /* Although a CVR qualifier is ignored when being applied to a
17201 substituted template parameter ([8.3.2]/1 for example), that
17202 does not allow us to unify "const T" with "int&" because both
17203 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17204 It is ok when we're allowing additional CV qualifiers
17205 at the outer level [14.8.2.1]/3,1st bullet. */
17206 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17207 || TREE_CODE (arg
) == FUNCTION_TYPE
17208 || TREE_CODE (arg
) == METHOD_TYPE
)
17209 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17212 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17213 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17217 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17218 && (arg_quals
& parm_quals
) != parm_quals
)
17221 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17222 && (parm_quals
& arg_quals
) != arg_quals
)
17228 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17230 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17232 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17233 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17234 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17236 *index
= TEMPLATE_TYPE_IDX (parm
);
17237 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17241 *index
= TEMPLATE_PARM_IDX (parm
);
17242 *level
= TEMPLATE_PARM_LEVEL (parm
);
17246 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17248 if (unify (TP, TA, P, A, S, EP)) \
17252 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17253 expansion at the end of PACKED_PARMS. Returns 0 if the type
17254 deduction succeeds, 1 otherwise. STRICT is the same as in
17255 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17256 call argument list. We'll need to adjust the arguments to make them
17257 types. SUBR tells us if this is from a recursive call to
17258 type_unification_real, or for comparing two template argument
17262 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17263 tree packed_args
, unification_kind_t strict
,
17264 bool subr
, bool explain_p
)
17267 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17268 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17269 tree pack
, packs
= NULL_TREE
;
17270 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17272 packed_args
= expand_template_argument_pack (packed_args
);
17274 int len
= TREE_VEC_LENGTH (packed_args
);
17276 /* Determine the parameter packs we will be deducing from the
17277 pattern, and record their current deductions. */
17278 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17279 pack
; pack
= TREE_CHAIN (pack
))
17281 tree parm_pack
= TREE_VALUE (pack
);
17284 /* Determine the index and level of this parameter pack. */
17285 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17287 /* Keep track of the parameter packs and their corresponding
17289 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17290 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17293 /* Loop through all of the arguments that have not yet been
17294 unified and unify each with the pattern. */
17295 for (i
= start
; i
< len
; i
++)
17298 bool any_explicit
= false;
17299 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17301 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17302 or the element of its argument pack at the current index if
17303 this argument was explicitly specified. */
17304 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17308 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17311 if (TREE_VALUE (pack
)
17312 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17313 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17315 any_explicit
= true;
17316 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17318 TMPL_ARG (targs
, level
, idx
) = arg
;
17321 /* If we had explicit template arguments, substitute them into the
17322 pattern before deduction. */
17325 /* Some arguments might still be unspecified or dependent. */
17327 ++processing_template_decl
;
17328 dependent
= any_dependent_template_arguments_p (targs
);
17330 --processing_template_decl
;
17331 parm
= tsubst (pattern
, targs
,
17332 explain_p
? tf_warning_or_error
: tf_none
,
17335 --processing_template_decl
;
17336 if (parm
== error_mark_node
)
17342 /* Unify the pattern with the current argument. */
17343 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17344 LOOKUP_IMPLICIT
, explain_p
))
17347 /* For each parameter pack, collect the deduced value. */
17348 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17351 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17353 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17354 TMPL_ARG (targs
, level
, idx
);
17358 /* Verify that the results of unification with the parameter packs
17359 produce results consistent with what we've seen before, and make
17360 the deduced argument packs available. */
17361 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17363 tree old_pack
= TREE_VALUE (pack
);
17364 tree new_args
= TREE_TYPE (pack
);
17365 int i
, len
= TREE_VEC_LENGTH (new_args
);
17367 bool nondeduced_p
= false;
17369 /* By default keep the original deduced argument pack.
17370 If necessary, more specific code is going to update the
17371 resulting deduced argument later down in this function. */
17372 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17373 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17375 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17376 actually deduce anything. */
17377 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17378 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17379 nondeduced_p
= true;
17383 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17385 /* If we had fewer function args than explicit template args,
17386 just use the explicits. */
17387 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17388 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17389 if (len
< explicit_len
)
17390 new_args
= explicit_args
;
17396 /* Build the deduced *_ARGUMENT_PACK. */
17397 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17399 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17400 TREE_TYPE (result
) =
17401 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17402 TREE_CONSTANT (result
) = 1;
17405 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17407 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17409 /* Note the deduced argument packs for this parameter
17411 TMPL_ARG (targs
, level
, idx
) = result
;
17413 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17414 && (ARGUMENT_PACK_ARGS (old_pack
)
17415 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17417 /* We only had the explicitly-provided arguments before, but
17418 now we have a complete set of arguments. */
17419 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17421 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17422 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17423 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17427 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17428 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17430 if (!comp_template_args_with_info (old_args
, new_args
,
17431 &bad_old_arg
, &bad_new_arg
))
17432 /* Inconsistent unification of this parameter pack. */
17433 return unify_parameter_pack_inconsistent (explain_p
,
17439 return unify_success (explain_p
);
17442 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17443 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17444 parameters and return value are as for unify. */
17447 unify_array_domain (tree tparms
, tree targs
,
17448 tree parm_dom
, tree arg_dom
,
17456 /* Our representation of array types uses "N - 1" as the
17457 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17458 not an integer constant. We cannot unify arbitrarily
17459 complex expressions, so we eliminate the MINUS_EXPRs
17461 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17462 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17465 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17466 parm_max
= TREE_OPERAND (parm_max
, 0);
17468 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17469 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17472 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17473 trying to unify the type of a variable with the type
17474 of a template parameter. For example:
17476 template <unsigned int N>
17477 void f (char (&) [N]);
17484 Here, the type of the ARG will be "int [g(i)]", and
17485 may be a SAVE_EXPR, etc. */
17486 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17487 return unify_vla_arg (explain_p
, arg_dom
);
17488 arg_max
= TREE_OPERAND (arg_max
, 0);
17491 /* If only one of the bounds used a MINUS_EXPR, compensate
17492 by adding one to the other bound. */
17493 if (parm_cst
&& !arg_cst
)
17494 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17498 else if (arg_cst
&& !parm_cst
)
17499 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17504 return unify (tparms
, targs
, parm_max
, arg_max
,
17505 UNIFY_ALLOW_INTEGER
, explain_p
);
17508 /* Deduce the value of template parameters. TPARMS is the (innermost)
17509 set of template parameters to a template. TARGS is the bindings
17510 for those template parameters, as determined thus far; TARGS may
17511 include template arguments for outer levels of template parameters
17512 as well. PARM is a parameter to a template function, or a
17513 subcomponent of that parameter; ARG is the corresponding argument.
17514 This function attempts to match PARM with ARG in a manner
17515 consistent with the existing assignments in TARGS. If more values
17516 are deduced, then TARGS is updated.
17518 Returns 0 if the type deduction succeeds, 1 otherwise. The
17519 parameter STRICT is a bitwise or of the following flags:
17522 Require an exact match between PARM and ARG.
17523 UNIFY_ALLOW_MORE_CV_QUAL:
17524 Allow the deduced ARG to be more cv-qualified (by qualification
17525 conversion) than ARG.
17526 UNIFY_ALLOW_LESS_CV_QUAL:
17527 Allow the deduced ARG to be less cv-qualified than ARG.
17528 UNIFY_ALLOW_DERIVED:
17529 Allow the deduced ARG to be a template base class of ARG,
17530 or a pointer to a template base class of the type pointed to by
17532 UNIFY_ALLOW_INTEGER:
17533 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17534 case for more information.
17535 UNIFY_ALLOW_OUTER_LEVEL:
17536 This is the outermost level of a deduction. Used to determine validity
17537 of qualification conversions. A valid qualification conversion must
17538 have const qualified pointers leading up to the inner type which
17539 requires additional CV quals, except at the outer level, where const
17540 is not required [conv.qual]. It would be normal to set this flag in
17541 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17542 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17543 This is the outermost level of a deduction, and PARM can be more CV
17544 qualified at this point.
17545 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17546 This is the outermost level of a deduction, and PARM can be less CV
17547 qualified at this point. */
17550 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17556 int strict_in
= strict
;
17558 /* I don't think this will do the right thing with respect to types.
17559 But the only case I've seen it in so far has been array bounds, where
17560 signedness is the only information lost, and I think that will be
17562 while (TREE_CODE (parm
) == NOP_EXPR
)
17563 parm
= TREE_OPERAND (parm
, 0);
17565 if (arg
== error_mark_node
)
17566 return unify_invalid (explain_p
);
17567 if (arg
== unknown_type_node
17568 || arg
== init_list_type_node
)
17569 /* We can't deduce anything from this, but we might get all the
17570 template args from other function args. */
17571 return unify_success (explain_p
);
17573 /* If PARM uses template parameters, then we can't bail out here,
17574 even if ARG == PARM, since we won't record unifications for the
17575 template parameters. We might need them if we're trying to
17576 figure out which of two things is more specialized. */
17577 if (arg
== parm
&& !uses_template_parms (parm
))
17578 return unify_success (explain_p
);
17580 /* Handle init lists early, so the rest of the function can assume
17581 we're dealing with a type. */
17582 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17586 tree orig_parm
= parm
;
17588 /* Replace T with std::initializer_list<T> for deduction. */
17589 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17590 && flag_deduce_init_list
)
17591 parm
= listify (parm
);
17593 if (!is_std_init_list (parm
)
17594 && TREE_CODE (parm
) != ARRAY_TYPE
)
17595 /* We can only deduce from an initializer list argument if the
17596 parameter is std::initializer_list or an array; otherwise this
17597 is a non-deduced context. */
17598 return unify_success (explain_p
);
17600 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17601 elttype
= TREE_TYPE (parm
);
17603 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17605 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
17607 int elt_strict
= strict
;
17609 if (elt
== error_mark_node
)
17610 return unify_invalid (explain_p
);
17612 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
17614 tree type
= TREE_TYPE (elt
);
17615 /* It should only be possible to get here for a call. */
17616 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
17617 elt_strict
|= maybe_adjust_types_for_deduction
17618 (DEDUCE_CALL
, &elttype
, &type
, elt
);
17622 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
17626 if (TREE_CODE (parm
) == ARRAY_TYPE
17627 && deducible_array_bound (TYPE_DOMAIN (parm
)))
17629 /* Also deduce from the length of the initializer list. */
17630 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
17631 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
17632 if (idx
== error_mark_node
)
17633 return unify_invalid (explain_p
);
17634 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17638 /* If the std::initializer_list<T> deduction worked, replace the
17639 deduced A with std::initializer_list<A>. */
17640 if (orig_parm
!= parm
)
17642 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
17643 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17644 targ
= listify (targ
);
17645 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
17647 return unify_success (explain_p
);
17650 /* Immediately reject some pairs that won't unify because of
17651 cv-qualification mismatches. */
17652 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17654 /* It is the elements of the array which hold the cv quals of an array
17655 type, and the elements might be template type parms. We'll check
17656 when we recurse. */
17657 && TREE_CODE (arg
) != ARRAY_TYPE
17658 /* We check the cv-qualifiers when unifying with template type
17659 parameters below. We want to allow ARG `const T' to unify with
17660 PARM `T' for example, when computing which of two templates
17661 is more specialized, for example. */
17662 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
17663 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
17664 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17666 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
17667 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
17668 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
17669 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
17670 strict
&= ~UNIFY_ALLOW_DERIVED
;
17671 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17672 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
17674 switch (TREE_CODE (parm
))
17676 case TYPENAME_TYPE
:
17678 case UNBOUND_CLASS_TEMPLATE
:
17679 /* In a type which contains a nested-name-specifier, template
17680 argument values cannot be deduced for template parameters used
17681 within the nested-name-specifier. */
17682 return unify_success (explain_p
);
17684 case TEMPLATE_TYPE_PARM
:
17685 case TEMPLATE_TEMPLATE_PARM
:
17686 case BOUND_TEMPLATE_TEMPLATE_PARM
:
17687 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17688 if (error_operand_p (tparm
))
17689 return unify_invalid (explain_p
);
17691 if (TEMPLATE_TYPE_LEVEL (parm
)
17692 != template_decl_level (tparm
))
17693 /* The PARM is not one we're trying to unify. Just check
17694 to see if it matches ARG. */
17696 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17697 && (is_auto (parm
) ? is_auto (arg
)
17698 : same_type_p (parm
, arg
)))
17699 return unify_success (explain_p
);
17701 return unify_type_mismatch (explain_p
, parm
, arg
);
17703 idx
= TEMPLATE_TYPE_IDX (parm
);
17704 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17705 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
17706 if (error_operand_p (tparm
))
17707 return unify_invalid (explain_p
);
17709 /* Check for mixed types and values. */
17710 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17711 && TREE_CODE (tparm
) != TYPE_DECL
)
17712 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17713 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
17714 gcc_unreachable ();
17716 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17718 /* ARG must be constructed from a template class or a template
17719 template parameter. */
17720 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
17721 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
17722 return unify_template_deduction_failure (explain_p
, parm
, arg
);
17724 tree parmvec
= TYPE_TI_ARGS (parm
);
17725 /* An alias template name is never deduced. */
17726 if (TYPE_ALIAS_P (arg
))
17727 arg
= strip_typedefs (arg
);
17728 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
17729 tree full_argvec
= add_to_template_args (targs
, argvec
);
17731 = DECL_INNERMOST_TEMPLATE_PARMS
17732 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
17734 int parm_variadic_p
= 0;
17736 /* The resolution to DR150 makes clear that default
17737 arguments for an N-argument may not be used to bind T
17738 to a template template parameter with fewer than N
17739 parameters. It is not safe to permit the binding of
17740 default arguments as an extension, as that may change
17741 the meaning of a conforming program. Consider:
17743 struct Dense { static const unsigned int dim = 1; };
17745 template <template <typename> class View,
17747 void operator+(float, View<Block> const&);
17749 template <typename Block,
17750 unsigned int Dim = Block::dim>
17751 struct Lvalue_proxy { operator float() const; };
17755 Lvalue_proxy<Dense> p;
17760 Here, if Lvalue_proxy is permitted to bind to View, then
17761 the global operator+ will be used; if they are not, the
17762 Lvalue_proxy will be converted to float. */
17763 if (coerce_template_parms (parm_parms
,
17765 TYPE_TI_TEMPLATE (parm
),
17767 ? tf_warning_or_error
17769 /*require_all_args=*/true,
17770 /*use_default_args=*/false)
17771 == error_mark_node
)
17774 /* Deduce arguments T, i from TT<T> or TT<i>.
17775 We check each element of PARMVEC and ARGVEC individually
17776 rather than the whole TREE_VEC since they can have
17777 different number of elements. */
17779 parmvec
= expand_template_argument_pack (parmvec
);
17780 argvec
= expand_template_argument_pack (argvec
);
17782 len
= TREE_VEC_LENGTH (parmvec
);
17784 /* Check if the parameters end in a pack, making them
17787 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
17788 parm_variadic_p
= 1;
17790 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17791 /* If the template argument list of P contains a pack
17792 expansion that is not the last template argument, the
17793 entire template argument list is a non-deduced
17795 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
17796 return unify_success (explain_p
);
17798 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
17799 return unify_too_few_arguments (explain_p
,
17800 TREE_VEC_LENGTH (argvec
), len
);
17802 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17804 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17805 TREE_VEC_ELT (parmvec
, i
),
17806 TREE_VEC_ELT (argvec
, i
),
17807 UNIFY_ALLOW_NONE
, explain_p
);
17810 if (parm_variadic_p
17811 && unify_pack_expansion (tparms
, targs
,
17814 /*subr=*/true, explain_p
))
17817 arg
= TYPE_TI_TEMPLATE (arg
);
17819 /* Fall through to deduce template name. */
17822 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17823 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17825 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
17827 /* Simple cases: Value already set, does match or doesn't. */
17828 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
17829 return unify_success (explain_p
);
17831 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17835 /* If PARM is `const T' and ARG is only `int', we don't have
17836 a match unless we are allowing additional qualification.
17837 If ARG is `const int' and PARM is just `T' that's OK;
17838 that binds `const int' to `T'. */
17839 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
17841 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17843 /* Consider the case where ARG is `const volatile int' and
17844 PARM is `const T'. Then, T should be `volatile int'. */
17845 arg
= cp_build_qualified_type_real
17846 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
17847 if (arg
== error_mark_node
)
17848 return unify_invalid (explain_p
);
17850 /* Simple cases: Value already set, does match or doesn't. */
17851 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
17852 return unify_success (explain_p
);
17854 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17856 /* Make sure that ARG is not a variable-sized array. (Note
17857 that were talking about variable-sized arrays (like
17858 `int[n]'), rather than arrays of unknown size (like
17859 `int[]').) We'll get very confused by such a type since
17860 the bound of the array is not constant, and therefore
17861 not mangleable. Besides, such types are not allowed in
17862 ISO C++, so we can do as we please here. We do allow
17863 them for 'auto' deduction, since that isn't ABI-exposed. */
17864 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
17865 return unify_vla_arg (explain_p
, arg
);
17867 /* Strip typedefs as in convert_template_argument. */
17868 arg
= canonicalize_type_argument (arg
, tf_none
);
17871 /* If ARG is a parameter pack or an expansion, we cannot unify
17872 against it unless PARM is also a parameter pack. */
17873 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17874 && !template_parameter_pack_p (parm
))
17875 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17877 /* If the argument deduction results is a METHOD_TYPE,
17878 then there is a problem.
17879 METHOD_TYPE doesn't map to any real C++ type the result of
17880 the deduction can not be of that type. */
17881 if (TREE_CODE (arg
) == METHOD_TYPE
)
17882 return unify_method_type_error (explain_p
, arg
);
17884 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17885 return unify_success (explain_p
);
17887 case TEMPLATE_PARM_INDEX
:
17888 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17889 if (error_operand_p (tparm
))
17890 return unify_invalid (explain_p
);
17892 if (TEMPLATE_PARM_LEVEL (parm
)
17893 != template_decl_level (tparm
))
17895 /* The PARM is not one we're trying to unify. Just check
17896 to see if it matches ARG. */
17897 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
17898 && cp_tree_equal (parm
, arg
));
17900 unify_expression_unequal (explain_p
, parm
, arg
);
17904 idx
= TEMPLATE_PARM_IDX (parm
);
17905 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17909 int x
= !cp_tree_equal (targ
, arg
);
17911 unify_inconsistency (explain_p
, parm
, targ
, arg
);
17915 /* [temp.deduct.type] If, in the declaration of a function template
17916 with a non-type template-parameter, the non-type
17917 template-parameter is used in an expression in the function
17918 parameter-list and, if the corresponding template-argument is
17919 deduced, the template-argument type shall match the type of the
17920 template-parameter exactly, except that a template-argument
17921 deduced from an array bound may be of any integral type.
17922 The non-type parameter might use already deduced type parameters. */
17923 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
17924 if (!TREE_TYPE (arg
))
17925 /* Template-parameter dependent expression. Just accept it for now.
17926 It will later be processed in convert_template_argument. */
17928 else if (same_type_p (TREE_TYPE (arg
), tparm
))
17930 else if ((strict
& UNIFY_ALLOW_INTEGER
)
17931 && CP_INTEGRAL_TYPE_P (tparm
))
17932 /* Convert the ARG to the type of PARM; the deduced non-type
17933 template argument must exactly match the types of the
17934 corresponding parameter. */
17935 arg
= fold (build_nop (tparm
, arg
));
17936 else if (uses_template_parms (tparm
))
17937 /* We haven't deduced the type of this parameter yet. Try again
17939 return unify_success (explain_p
);
17941 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
17943 /* If ARG is a parameter pack or an expansion, we cannot unify
17944 against it unless PARM is also a parameter pack. */
17945 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17946 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
17947 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17949 arg
= strip_typedefs_expr (arg
);
17950 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17951 return unify_success (explain_p
);
17955 /* A pointer-to-member constant can be unified only with
17956 another constant. */
17957 if (TREE_CODE (arg
) != PTRMEM_CST
)
17958 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
17960 /* Just unify the class member. It would be useless (and possibly
17961 wrong, depending on the strict flags) to unify also
17962 PTRMEM_CST_CLASS, because we want to be sure that both parm and
17963 arg refer to the same variable, even if through different
17964 classes. For instance:
17966 struct A { int x; };
17969 Unification of &A::x and &B::x must succeed. */
17970 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
17971 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
17976 if (!TYPE_PTR_P (arg
))
17977 return unify_type_mismatch (explain_p
, parm
, arg
);
17979 /* [temp.deduct.call]
17981 A can be another pointer or pointer to member type that can
17982 be converted to the deduced A via a qualification
17983 conversion (_conv.qual_).
17985 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
17986 This will allow for additional cv-qualification of the
17987 pointed-to types if appropriate. */
17989 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
17990 /* The derived-to-base conversion only persists through one
17991 level of pointers. */
17992 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
17994 return unify (tparms
, targs
, TREE_TYPE (parm
),
17995 TREE_TYPE (arg
), strict
, explain_p
);
17998 case REFERENCE_TYPE
:
17999 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
18000 return unify_type_mismatch (explain_p
, parm
, arg
);
18001 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18002 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18005 if (TREE_CODE (arg
) != ARRAY_TYPE
)
18006 return unify_type_mismatch (explain_p
, parm
, arg
);
18007 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
18008 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
18009 return unify_type_mismatch (explain_p
, parm
, arg
);
18010 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18011 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18012 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
18013 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18014 TYPE_DOMAIN (arg
), explain_p
);
18015 return unify_success (explain_p
);
18022 case ENUMERAL_TYPE
:
18025 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18026 return unify_type_mismatch (explain_p
, parm
, arg
);
18028 /* We have already checked cv-qualification at the top of the
18030 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
18031 return unify_type_mismatch (explain_p
, parm
, arg
);
18033 /* As far as unification is concerned, this wins. Later checks
18034 will invalidate it if necessary. */
18035 return unify_success (explain_p
);
18037 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18038 /* Type INTEGER_CST can come from ordinary constant template args. */
18040 while (TREE_CODE (arg
) == NOP_EXPR
)
18041 arg
= TREE_OPERAND (arg
, 0);
18043 if (TREE_CODE (arg
) != INTEGER_CST
)
18044 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18045 return (tree_int_cst_equal (parm
, arg
)
18046 ? unify_success (explain_p
)
18047 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18051 int i
, len
, argslen
;
18052 int parm_variadic_p
= 0;
18054 if (TREE_CODE (arg
) != TREE_VEC
)
18055 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18057 len
= TREE_VEC_LENGTH (parm
);
18058 argslen
= TREE_VEC_LENGTH (arg
);
18060 /* Check for pack expansions in the parameters. */
18061 for (i
= 0; i
< len
; ++i
)
18063 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18066 /* We can unify against something with a trailing
18068 parm_variadic_p
= 1;
18070 /* [temp.deduct.type]/9: If the template argument list of
18071 P contains a pack expansion that is not the last
18072 template argument, the entire template argument list
18073 is a non-deduced context. */
18074 return unify_success (explain_p
);
18078 /* If we don't have enough arguments to satisfy the parameters
18079 (not counting the pack expression at the end), or we have
18080 too many arguments for a parameter list that doesn't end in
18081 a pack expression, we can't unify. */
18082 if (parm_variadic_p
18083 ? argslen
< len
- parm_variadic_p
18085 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18087 /* Unify all of the parameters that precede the (optional)
18088 pack expression. */
18089 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18091 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18092 TREE_VEC_ELT (parm
, i
),
18093 TREE_VEC_ELT (arg
, i
),
18094 UNIFY_ALLOW_NONE
, explain_p
);
18096 if (parm_variadic_p
)
18097 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18099 /*subr=*/true, explain_p
);
18100 return unify_success (explain_p
);
18105 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18106 return unify_type_mismatch (explain_p
, parm
, arg
);
18108 if (TYPE_PTRMEMFUNC_P (parm
))
18110 if (!TYPE_PTRMEMFUNC_P (arg
))
18111 return unify_type_mismatch (explain_p
, parm
, arg
);
18113 return unify (tparms
, targs
,
18114 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18115 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18116 strict
, explain_p
);
18118 else if (TYPE_PTRMEMFUNC_P (arg
))
18119 return unify_type_mismatch (explain_p
, parm
, arg
);
18121 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18123 tree t
= NULL_TREE
;
18125 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18127 /* First, we try to unify the PARM and ARG directly. */
18128 t
= try_class_unification (tparms
, targs
,
18129 parm
, arg
, explain_p
);
18133 /* Fallback to the special case allowed in
18134 [temp.deduct.call]:
18136 If P is a class, and P has the form
18137 template-id, then A can be a derived class of
18138 the deduced A. Likewise, if P is a pointer to
18139 a class of the form template-id, A can be a
18140 pointer to a derived class pointed to by the
18142 enum template_base_result r
;
18143 r
= get_template_base (tparms
, targs
, parm
, arg
,
18147 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18150 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18151 && (CLASSTYPE_TI_TEMPLATE (parm
)
18152 == CLASSTYPE_TI_TEMPLATE (arg
)))
18153 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18154 Then, we should unify `int' and `U'. */
18157 /* There's no chance of unification succeeding. */
18158 return unify_type_mismatch (explain_p
, parm
, arg
);
18160 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18161 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18163 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18164 return unify_type_mismatch (explain_p
, parm
, arg
);
18165 return unify_success (explain_p
);
18168 case FUNCTION_TYPE
:
18170 unsigned int nargs
;
18175 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18176 return unify_type_mismatch (explain_p
, parm
, arg
);
18178 /* CV qualifications for methods can never be deduced, they must
18179 match exactly. We need to check them explicitly here,
18180 because type_unification_real treats them as any other
18181 cv-qualified parameter. */
18182 if (TREE_CODE (parm
) == METHOD_TYPE
18183 && (!check_cv_quals_for_unify
18185 class_of_this_parm (arg
),
18186 class_of_this_parm (parm
))))
18187 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18189 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18190 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18192 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18193 args
= XALLOCAVEC (tree
, nargs
);
18194 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18195 a
!= NULL_TREE
&& a
!= void_list_node
;
18196 a
= TREE_CHAIN (a
), ++i
)
18197 args
[i
] = TREE_VALUE (a
);
18200 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18201 args
, nargs
, 1, DEDUCE_EXACT
,
18202 LOOKUP_NORMAL
, NULL
, explain_p
);
18206 /* Unify a pointer to member with a pointer to member function, which
18207 deduces the type of the member as a function type. */
18208 if (TYPE_PTRMEMFUNC_P (arg
))
18210 /* Check top-level cv qualifiers */
18211 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18212 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18214 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18215 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18216 UNIFY_ALLOW_NONE
, explain_p
);
18218 /* Determine the type of the function we are unifying against. */
18219 tree fntype
= static_fn_type (arg
);
18221 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18224 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18225 return unify_type_mismatch (explain_p
, parm
, arg
);
18226 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18227 TYPE_OFFSET_BASETYPE (arg
),
18228 UNIFY_ALLOW_NONE
, explain_p
);
18229 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18230 strict
, explain_p
);
18233 if (DECL_TEMPLATE_PARM_P (parm
))
18234 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18235 if (arg
!= integral_constant_value (parm
))
18236 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18237 return unify_success (explain_p
);
18240 case TEMPLATE_DECL
:
18241 /* Matched cases are handled by the ARG == PARM test above. */
18242 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18245 /* A non-type template parameter that is a variable should be a
18246 an integral constant, in which case, it whould have been
18247 folded into its (constant) value. So we should not be getting
18248 a variable here. */
18249 gcc_unreachable ();
18251 case TYPE_ARGUMENT_PACK
:
18252 case NONTYPE_ARGUMENT_PACK
:
18253 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18254 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18257 case DECLTYPE_TYPE
:
18258 case UNDERLYING_TYPE
:
18259 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18260 or UNDERLYING_TYPE nodes. */
18261 return unify_success (explain_p
);
18264 /* Unification fails if we hit an error node. */
18265 return unify_invalid (explain_p
);
18268 if (REFERENCE_REF_P (parm
))
18269 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18270 strict
, explain_p
);
18274 /* An unresolved overload is a nondeduced context. */
18275 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18276 return unify_success (explain_p
);
18277 gcc_assert (EXPR_P (parm
));
18279 /* We must be looking at an expression. This can happen with
18283 void foo(S<I>, S<I + 2>);
18285 This is a "nondeduced context":
18289 The nondeduced contexts are:
18291 --A type that is a template-id in which one or more of
18292 the template-arguments is an expression that references
18293 a template-parameter.
18295 In these cases, we assume deduction succeeded, but don't
18296 actually infer any unifications. */
18298 if (!uses_template_parms (parm
)
18299 && !template_args_equal (parm
, arg
))
18300 return unify_expression_unequal (explain_p
, parm
, arg
);
18302 return unify_success (explain_p
);
18305 #undef RECUR_AND_CHECK_FAILURE
18307 /* Note that DECL can be defined in this translation unit, if
18311 mark_definable (tree decl
)
18314 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18315 FOR_EACH_CLONE (clone
, decl
)
18316 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18319 /* Called if RESULT is explicitly instantiated, or is a member of an
18320 explicitly instantiated class. */
18323 mark_decl_instantiated (tree result
, int extern_p
)
18325 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18327 /* If this entity has already been written out, it's too late to
18328 make any modifications. */
18329 if (TREE_ASM_WRITTEN (result
))
18332 /* For anonymous namespace we don't need to do anything. */
18333 if (decl_anon_ns_mem_p (result
))
18335 gcc_assert (!TREE_PUBLIC (result
));
18339 if (TREE_CODE (result
) != FUNCTION_DECL
)
18340 /* The TREE_PUBLIC flag for function declarations will have been
18341 set correctly by tsubst. */
18342 TREE_PUBLIC (result
) = 1;
18344 /* This might have been set by an earlier implicit instantiation. */
18345 DECL_COMDAT (result
) = 0;
18348 DECL_NOT_REALLY_EXTERN (result
) = 0;
18351 mark_definable (result
);
18352 mark_needed (result
);
18353 /* Always make artificials weak. */
18354 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18355 comdat_linkage (result
);
18356 /* For WIN32 we also want to put explicit instantiations in
18357 linkonce sections. */
18358 else if (TREE_PUBLIC (result
))
18359 maybe_make_one_only (result
);
18362 /* If EXTERN_P, then this function will not be emitted -- unless
18363 followed by an explicit instantiation, at which point its linkage
18364 will be adjusted. If !EXTERN_P, then this function will be
18365 emitted here. In neither circumstance do we want
18366 import_export_decl to adjust the linkage. */
18367 DECL_INTERFACE_KNOWN (result
) = 1;
18370 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18371 important template arguments. If any are missing, we check whether
18372 they're important by using error_mark_node for substituting into any
18373 args that were used for partial ordering (the ones between ARGS and END)
18374 and seeing if it bubbles up. */
18377 check_undeduced_parms (tree targs
, tree args
, tree end
)
18379 bool found
= false;
18381 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18382 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18385 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18389 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18390 if (substed
== error_mark_node
)
18396 /* Given two function templates PAT1 and PAT2, return:
18398 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18399 -1 if PAT2 is more specialized than PAT1.
18400 0 if neither is more specialized.
18402 LEN indicates the number of parameters we should consider
18403 (defaulted parameters should not be considered).
18405 The 1998 std underspecified function template partial ordering, and
18406 DR214 addresses the issue. We take pairs of arguments, one from
18407 each of the templates, and deduce them against each other. One of
18408 the templates will be more specialized if all the *other*
18409 template's arguments deduce against its arguments and at least one
18410 of its arguments *does* *not* deduce against the other template's
18411 corresponding argument. Deduction is done as for class templates.
18412 The arguments used in deduction have reference and top level cv
18413 qualifiers removed. Iff both arguments were originally reference
18414 types *and* deduction succeeds in both directions, an lvalue reference
18415 wins against an rvalue reference and otherwise the template
18416 with the more cv-qualified argument wins for that pairing (if
18417 neither is more cv-qualified, they both are equal). Unlike regular
18418 deduction, after all the arguments have been deduced in this way,
18419 we do *not* verify the deduced template argument values can be
18420 substituted into non-deduced contexts.
18422 The logic can be a bit confusing here, because we look at deduce1 and
18423 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18424 can find template arguments for pat1 to make arg1 look like arg2, that
18425 means that arg2 is at least as specialized as arg1. */
18428 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18430 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18431 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18432 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18433 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18434 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18435 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18436 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18437 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18438 tree origs1
, origs2
;
18439 bool lose1
= false;
18440 bool lose2
= false;
18442 /* Remove the this parameter from non-static member functions. If
18443 one is a non-static member function and the other is not a static
18444 member function, remove the first parameter from that function
18445 also. This situation occurs for operator functions where we
18446 locate both a member function (with this pointer) and non-member
18447 operator (with explicit first operand). */
18448 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18450 len
--; /* LEN is the number of significant arguments for DECL1 */
18451 args1
= TREE_CHAIN (args1
);
18452 if (!DECL_STATIC_FUNCTION_P (decl2
))
18453 args2
= TREE_CHAIN (args2
);
18455 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18457 args2
= TREE_CHAIN (args2
);
18458 if (!DECL_STATIC_FUNCTION_P (decl1
))
18461 args1
= TREE_CHAIN (args1
);
18465 /* If only one is a conversion operator, they are unordered. */
18466 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18469 /* Consider the return type for a conversion function */
18470 if (DECL_CONV_FN_P (decl1
))
18472 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18473 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18477 processing_template_decl
++;
18483 /* Stop when an ellipsis is seen. */
18484 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18486 tree arg1
= TREE_VALUE (args1
);
18487 tree arg2
= TREE_VALUE (args2
);
18488 int deduce1
, deduce2
;
18494 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18495 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18497 /* When both arguments are pack expansions, we need only
18498 unify the patterns themselves. */
18499 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18500 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18502 /* This is the last comparison we need to do. */
18506 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18508 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18509 arg1
= TREE_TYPE (arg1
);
18510 quals1
= cp_type_quals (arg1
);
18513 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18515 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18516 arg2
= TREE_TYPE (arg2
);
18517 quals2
= cp_type_quals (arg2
);
18520 arg1
= TYPE_MAIN_VARIANT (arg1
);
18521 arg2
= TYPE_MAIN_VARIANT (arg2
);
18523 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18525 int i
, len2
= list_length (args2
);
18526 tree parmvec
= make_tree_vec (1);
18527 tree argvec
= make_tree_vec (len2
);
18530 /* Setup the parameter vector, which contains only ARG1. */
18531 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18533 /* Setup the argument vector, which contains the remaining
18535 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18536 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18538 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18539 argvec
, DEDUCE_EXACT
,
18540 /*subr=*/true, /*explain_p=*/false)
18543 /* We cannot deduce in the other direction, because ARG1 is
18544 a pack expansion but ARG2 is not. */
18547 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18549 int i
, len1
= list_length (args1
);
18550 tree parmvec
= make_tree_vec (1);
18551 tree argvec
= make_tree_vec (len1
);
18554 /* Setup the parameter vector, which contains only ARG1. */
18555 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18557 /* Setup the argument vector, which contains the remaining
18559 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18560 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18562 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18563 argvec
, DEDUCE_EXACT
,
18564 /*subr=*/true, /*explain_p=*/false)
18567 /* We cannot deduce in the other direction, because ARG2 is
18568 a pack expansion but ARG1 is not.*/
18574 /* The normal case, where neither argument is a pack
18576 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18577 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18579 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18580 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18584 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18585 arg2, then arg2 is not as specialized as arg1. */
18591 /* "If, for a given type, deduction succeeds in both directions
18592 (i.e., the types are identical after the transformations above)
18593 and both P and A were reference types (before being replaced with
18594 the type referred to above):
18595 - if the type from the argument template was an lvalue reference and
18596 the type from the parameter template was not, the argument type is
18597 considered to be more specialized than the other; otherwise,
18598 - if the type from the argument template is more cv-qualified
18599 than the type from the parameter template (as described above),
18600 the argument type is considered to be more specialized than the other;
18602 - neither type is more specialized than the other." */
18604 if (deduce1
&& deduce2
)
18606 if (ref1
&& ref2
&& ref1
!= ref2
)
18613 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
18615 if ((quals1
& quals2
) == quals2
)
18617 if ((quals1
& quals2
) == quals1
)
18622 if (lose1
&& lose2
)
18623 /* We've failed to deduce something in either direction.
18624 These must be unordered. */
18627 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18628 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18629 /* We have already processed all of the arguments in our
18630 handing of the pack expansion type. */
18633 args1
= TREE_CHAIN (args1
);
18634 args2
= TREE_CHAIN (args2
);
18637 /* "In most cases, all template parameters must have values in order for
18638 deduction to succeed, but for partial ordering purposes a template
18639 parameter may remain without a value provided it is not used in the
18640 types being used for partial ordering."
18642 Thus, if we are missing any of the targs1 we need to substitute into
18643 origs1, then pat2 is not as specialized as pat1. This can happen when
18644 there is a nondeduced context. */
18645 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
18647 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
18650 processing_template_decl
--;
18652 /* All things being equal, if the next argument is a pack expansion
18653 for one function but not for the other, prefer the
18654 non-variadic function. FIXME this is bogus; see c++/41958. */
18656 && args1
&& TREE_VALUE (args1
)
18657 && args2
&& TREE_VALUE (args2
))
18659 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
18660 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
18663 if (lose1
== lose2
)
18671 /* Determine which of two partial specializations of TMPL is more
18674 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18675 to the first partial specialization. The TREE_VALUE is the
18676 innermost set of template parameters for the partial
18677 specialization. PAT2 is similar, but for the second template.
18679 Return 1 if the first partial specialization is more specialized;
18680 -1 if the second is more specialized; 0 if neither is more
18683 See [temp.class.order] for information about determining which of
18684 two templates is more specialized. */
18687 more_specialized_class (tree tmpl
, tree pat1
, tree pat2
)
18692 bool any_deductions
= false;
18694 tmpl1
= TREE_TYPE (pat1
);
18695 tmpl2
= TREE_TYPE (pat2
);
18697 /* Just like what happens for functions, if we are ordering between
18698 different class template specializations, we may encounter dependent
18699 types in the arguments, and we need our dependency check functions
18700 to behave correctly. */
18701 ++processing_template_decl
;
18702 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat1
),
18703 CLASSTYPE_TI_ARGS (tmpl1
),
18704 CLASSTYPE_TI_ARGS (tmpl2
));
18708 any_deductions
= true;
18711 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat2
),
18712 CLASSTYPE_TI_ARGS (tmpl2
),
18713 CLASSTYPE_TI_ARGS (tmpl1
));
18717 any_deductions
= true;
18719 --processing_template_decl
;
18721 /* In the case of a tie where at least one of the class templates
18722 has a parameter pack at the end, the template with the most
18723 non-packed parameters wins. */
18726 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
18727 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
18729 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
18730 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
18731 int len1
= TREE_VEC_LENGTH (args1
);
18732 int len2
= TREE_VEC_LENGTH (args2
);
18734 /* We don't count the pack expansion at the end. */
18735 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
18737 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
18742 else if (len1
< len2
)
18749 /* Return the template arguments that will produce the function signature
18750 DECL from the function template FN, with the explicit template
18751 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18752 also match. Return NULL_TREE if no satisfactory arguments could be
18756 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
18758 int ntparms
= DECL_NTPARMS (fn
);
18759 tree targs
= make_tree_vec (ntparms
);
18760 tree decl_type
= TREE_TYPE (decl
);
18761 tree decl_arg_types
;
18763 unsigned int nargs
, ix
;
18766 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
18768 /* Never do unification on the 'this' parameter. */
18769 decl_arg_types
= skip_artificial_parms_for (decl
,
18770 TYPE_ARG_TYPES (decl_type
));
18772 nargs
= list_length (decl_arg_types
);
18773 args
= XALLOCAVEC (tree
, nargs
);
18774 for (arg
= decl_arg_types
, ix
= 0;
18775 arg
!= NULL_TREE
&& arg
!= void_list_node
;
18776 arg
= TREE_CHAIN (arg
), ++ix
)
18777 args
[ix
] = TREE_VALUE (arg
);
18779 if (fn_type_unification (fn
, explicit_args
, targs
,
18781 (check_rettype
|| DECL_CONV_FN_P (fn
)
18782 ? TREE_TYPE (decl_type
) : NULL_TREE
),
18783 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
18785 == error_mark_node
)
18791 /* Return the innermost template arguments that, when applied to a partial
18792 specialization of TMPL whose innermost template parameters are
18793 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
18796 For example, suppose we have:
18798 template <class T, class U> struct S {};
18799 template <class T> struct S<T*, int> {};
18801 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
18802 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
18803 int}. The resulting vector will be {double}, indicating that `T'
18804 is bound to `double'. */
18807 get_class_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
18809 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
18811 tree innermost_deduced_args
;
18813 innermost_deduced_args
= make_tree_vec (ntparms
);
18814 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18816 deduced_args
= copy_node (args
);
18817 SET_TMPL_ARGS_LEVEL (deduced_args
,
18818 TMPL_ARGS_DEPTH (deduced_args
),
18819 innermost_deduced_args
);
18822 deduced_args
= innermost_deduced_args
;
18824 if (unify (tparms
, deduced_args
,
18825 INNERMOST_TEMPLATE_ARGS (spec_args
),
18826 INNERMOST_TEMPLATE_ARGS (args
),
18827 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
18830 for (i
= 0; i
< ntparms
; ++i
)
18831 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
18834 /* Verify that nondeduced template arguments agree with the type
18835 obtained from argument deduction.
18839 struct A { typedef int X; };
18840 template <class T, class U> struct C {};
18841 template <class T> struct C<T, typename T::X> {};
18843 Then with the instantiation `C<A, int>', we can deduce that
18844 `T' is `A' but unify () does not check whether `typename T::X'
18846 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
18847 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
18849 tf_none
, false, false);
18850 if (spec_args
== error_mark_node
18851 /* We only need to check the innermost arguments; the other
18852 arguments will always agree. */
18853 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
18854 INNERMOST_TEMPLATE_ARGS (args
)))
18857 /* Now that we have bindings for all of the template arguments,
18858 ensure that the arguments deduced for the template template
18859 parameters have compatible template parameter lists. See the use
18860 of template_template_parm_bindings_ok_p in fn_type_unification
18861 for more information. */
18862 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
18865 return deduced_args
;
18868 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
18869 Return the TREE_LIST node with the most specialized template, if
18870 any. If there is no most specialized template, the error_mark_node
18873 Note that this function does not look at, or modify, the
18874 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
18875 returned is one of the elements of INSTANTIATIONS, callers may
18876 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
18877 and retrieve it from the value returned. */
18880 most_specialized_instantiation (tree templates
)
18884 ++processing_template_decl
;
18887 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
18891 if (get_bindings (TREE_VALUE (champ
),
18892 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18893 NULL_TREE
, /*check_ret=*/true))
18896 if (get_bindings (TREE_VALUE (fn
),
18897 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18898 NULL_TREE
, /*check_ret=*/true))
18905 /* Equally specialized, move to next function. If there
18906 is no next function, nothing's most specialized. */
18907 fn
= TREE_CHAIN (fn
);
18915 /* Now verify that champ is better than everything earlier in the
18916 instantiation list. */
18917 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
18918 if (get_bindings (TREE_VALUE (champ
),
18919 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18920 NULL_TREE
, /*check_ret=*/true)
18921 || !get_bindings (TREE_VALUE (fn
),
18922 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18923 NULL_TREE
, /*check_ret=*/true))
18929 processing_template_decl
--;
18932 return error_mark_node
;
18937 /* If DECL is a specialization of some template, return the most
18938 general such template. Otherwise, returns NULL_TREE.
18940 For example, given:
18942 template <class T> struct S { template <class U> void f(U); };
18944 if TMPL is `template <class U> void S<int>::f(U)' this will return
18945 the full template. This function will not trace past partial
18946 specializations, however. For example, given in addition:
18948 template <class T> struct S<T*> { template <class U> void f(U); };
18950 if TMPL is `template <class U> void S<int*>::f(U)' this will return
18951 `template <class T> template <class U> S<T*>::f(U)'. */
18954 most_general_template (tree decl
)
18956 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18958 if (tree tinfo
= get_template_info (decl
))
18959 decl
= TI_TEMPLATE (tinfo
);
18960 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
18961 template friend, or a FIELD_DECL for a capture pack. */
18962 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18966 /* Look for more and more general templates. */
18967 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
18969 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
18970 (See cp-tree.h for details.) */
18971 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
18974 if (CLASS_TYPE_P (TREE_TYPE (decl
))
18975 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
18978 /* Stop if we run into an explicitly specialized class template. */
18979 if (!DECL_NAMESPACE_SCOPE_P (decl
)
18980 && DECL_CONTEXT (decl
)
18981 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
18984 decl
= DECL_TI_TEMPLATE (decl
);
18990 /* Return the most specialized of the class template partial
18991 specializations which can produce TYPE, a specialization of some class
18992 template. The value returned is actually a TREE_LIST; the TREE_TYPE is
18993 a _TYPE node corresponding to the partial specialization, while the
18994 TREE_PURPOSE is the set of template arguments that must be
18995 substituted into the TREE_TYPE in order to generate TYPE.
18997 If the choice of partial specialization is ambiguous, a diagnostic
18998 is issued, and the error_mark_node is returned. If there are no
18999 partial specializations matching TYPE, then NULL_TREE is
19000 returned, indicating that the primary template should be used. */
19003 most_specialized_class (tree type
, tsubst_flags_t complain
)
19005 tree list
= NULL_TREE
;
19010 tree outer_args
= NULL_TREE
;
19012 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
19013 tree main_tmpl
= most_general_template (tmpl
);
19014 tree args
= CLASSTYPE_TI_ARGS (type
);
19016 /* For determining which partial specialization to use, only the
19017 innermost args are interesting. */
19018 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19020 outer_args
= strip_innermost_template_args (args
, 1);
19021 args
= INNERMOST_TEMPLATE_ARGS (args
);
19024 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
19026 tree partial_spec_args
;
19028 tree spec_tmpl
= TREE_VALUE (t
);
19029 tree orig_parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19031 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
19033 ++processing_template_decl
;
19037 /* Discard the outer levels of args, and then substitute in the
19038 template args from the enclosing class. */
19039 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19040 partial_spec_args
= tsubst_template_args
19041 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19043 /* And the same for the partial specialization TEMPLATE_DECL. */
19044 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19047 partial_spec_args
=
19048 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19051 /*require_all_args=*/true,
19052 /*use_default_args=*/true);
19054 --processing_template_decl
;
19056 if (partial_spec_args
== error_mark_node
)
19057 return error_mark_node
;
19058 if (spec_tmpl
== error_mark_node
)
19059 return error_mark_node
;
19061 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19062 spec_args
= get_class_bindings (tmpl
, parms
,
19068 spec_args
= add_to_template_args (outer_args
, spec_args
);
19069 list
= tree_cons (spec_args
, orig_parms
, list
);
19070 TREE_TYPE (list
) = TREE_TYPE (t
);
19077 ambiguous_p
= false;
19080 t
= TREE_CHAIN (t
);
19081 for (; t
; t
= TREE_CHAIN (t
))
19083 fate
= more_specialized_class (tmpl
, champ
, t
);
19090 t
= TREE_CHAIN (t
);
19093 ambiguous_p
= true;
19102 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19104 fate
= more_specialized_class (tmpl
, champ
, t
);
19107 ambiguous_p
= true;
19115 char *spaces
= NULL
;
19116 if (!(complain
& tf_error
))
19117 return error_mark_node
;
19118 error ("ambiguous class template instantiation for %q#T", type
);
19119 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19120 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19122 error ("%s %+#T", spaces
? spaces
: str
, TREE_TYPE (t
));
19123 spaces
= spaces
? spaces
: get_spaces (str
);
19126 return error_mark_node
;
19132 /* Explicitly instantiate DECL. */
19135 do_decl_instantiation (tree decl
, tree storage
)
19137 tree result
= NULL_TREE
;
19140 if (!decl
|| decl
== error_mark_node
)
19141 /* An error occurred, for which grokdeclarator has already issued
19142 an appropriate message. */
19144 else if (! DECL_LANG_SPECIFIC (decl
))
19146 error ("explicit instantiation of non-template %q#D", decl
);
19149 else if (VAR_P (decl
))
19151 /* There is an asymmetry here in the way VAR_DECLs and
19152 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19153 the latter, the DECL we get back will be marked as a
19154 template instantiation, and the appropriate
19155 DECL_TEMPLATE_INFO will be set up. This does not happen for
19156 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19157 should handle VAR_DECLs as it currently handles
19159 if (!DECL_CLASS_SCOPE_P (decl
))
19161 error ("%qD is not a static data member of a class template", decl
);
19164 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19165 if (!result
|| !VAR_P (result
))
19167 error ("no matching template for %qD found", decl
);
19170 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19172 error ("type %qT for explicit instantiation %qD does not match "
19173 "declared type %qT", TREE_TYPE (result
), decl
,
19178 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
19180 error ("explicit instantiation of %q#D", decl
);
19186 /* Check for various error cases. Note that if the explicit
19187 instantiation is valid the RESULT will currently be marked as an
19188 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19189 until we get here. */
19191 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19193 /* DR 259 [temp.spec].
19195 Both an explicit instantiation and a declaration of an explicit
19196 specialization shall not appear in a program unless the explicit
19197 instantiation follows a declaration of the explicit specialization.
19199 For a given set of template parameters, if an explicit
19200 instantiation of a template appears after a declaration of an
19201 explicit specialization for that template, the explicit
19202 instantiation has no effect. */
19205 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19209 No program shall explicitly instantiate any template more
19212 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19213 the first instantiation was `extern' and the second is not,
19214 and EXTERN_P for the opposite case. */
19215 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19216 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19217 /* If an "extern" explicit instantiation follows an ordinary
19218 explicit instantiation, the template is instantiated. */
19222 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19224 error ("no matching template for %qD found", result
);
19227 else if (!DECL_TEMPLATE_INFO (result
))
19229 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19233 if (storage
== NULL_TREE
)
19235 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19237 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19238 pedwarn (input_location
, OPT_Wpedantic
,
19239 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19244 error ("storage class %qD applied to template instantiation", storage
);
19246 check_explicit_instantiation_namespace (result
);
19247 mark_decl_instantiated (result
, extern_p
);
19249 instantiate_decl (result
, /*defer_ok=*/1,
19250 /*expl_inst_class_mem_p=*/false);
19254 mark_class_instantiated (tree t
, int extern_p
)
19256 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19257 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19258 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19259 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19262 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19263 rest_of_type_compilation (t
, 1);
19267 /* Called from do_type_instantiation through binding_table_foreach to
19268 do recursive instantiation for the type bound in ENTRY. */
19270 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19272 tree storage
= *(tree
*) data
;
19274 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19275 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19276 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19279 /* Called from do_type_instantiation to instantiate a member
19280 (a member function or a static member variable) of an
19281 explicitly instantiated class template. */
19283 instantiate_class_member (tree decl
, int extern_p
)
19285 mark_decl_instantiated (decl
, extern_p
);
19287 instantiate_decl (decl
, /*defer_ok=*/1,
19288 /*expl_inst_class_mem_p=*/true);
19291 /* Perform an explicit instantiation of template class T. STORAGE, if
19292 non-null, is the RID for extern, inline or static. COMPLAIN is
19293 nonzero if this is called from the parser, zero if called recursively,
19294 since the standard is unclear (as detailed below). */
19297 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19302 int previous_instantiation_extern_p
= 0;
19304 if (TREE_CODE (t
) == TYPE_DECL
)
19307 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19310 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19312 error ("explicit instantiation of non-class template %qD", tmpl
);
19314 error ("explicit instantiation of non-template type %qT", t
);
19320 if (!COMPLETE_TYPE_P (t
))
19322 if (complain
& tf_error
)
19323 error ("explicit instantiation of %q#T before definition of template",
19328 if (storage
!= NULL_TREE
)
19330 if (!in_system_header_at (input_location
))
19332 if (storage
== ridpointers
[(int) RID_EXTERN
])
19334 if (cxx_dialect
== cxx98
)
19335 pedwarn (input_location
, OPT_Wpedantic
,
19336 "ISO C++ 1998 forbids the use of %<extern%> on "
19337 "explicit instantiations");
19340 pedwarn (input_location
, OPT_Wpedantic
,
19341 "ISO C++ forbids the use of %qE"
19342 " on explicit instantiations", storage
);
19345 if (storage
== ridpointers
[(int) RID_INLINE
])
19347 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19349 else if (storage
== ridpointers
[(int) RID_STATIC
])
19353 error ("storage class %qD applied to template instantiation",
19359 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19361 /* DR 259 [temp.spec].
19363 Both an explicit instantiation and a declaration of an explicit
19364 specialization shall not appear in a program unless the explicit
19365 instantiation follows a declaration of the explicit specialization.
19367 For a given set of template parameters, if an explicit
19368 instantiation of a template appears after a declaration of an
19369 explicit specialization for that template, the explicit
19370 instantiation has no effect. */
19373 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19377 No program shall explicitly instantiate any template more
19380 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19381 instantiation was `extern'. If EXTERN_P then the second is.
19382 These cases are OK. */
19383 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19385 if (!previous_instantiation_extern_p
&& !extern_p
19386 && (complain
& tf_error
))
19387 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19389 /* If we've already instantiated the template, just return now. */
19390 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19394 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19395 mark_class_instantiated (t
, extern_p
);
19403 /* In contrast to implicit instantiation, where only the
19404 declarations, and not the definitions, of members are
19405 instantiated, we have here:
19409 The explicit instantiation of a class template specialization
19410 implies the instantiation of all of its members not
19411 previously explicitly specialized in the translation unit
19412 containing the explicit instantiation.
19414 Of course, we can't instantiate member template classes, since
19415 we don't have any arguments for them. Note that the standard
19416 is unclear on whether the instantiation of the members are
19417 *explicit* instantiations or not. However, the most natural
19418 interpretation is that it should be an explicit instantiation. */
19421 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19422 if (TREE_CODE (tmp
) == FUNCTION_DECL
19423 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19424 instantiate_class_member (tmp
, extern_p
);
19426 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19427 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19428 instantiate_class_member (tmp
, extern_p
);
19430 if (CLASSTYPE_NESTED_UTDS (t
))
19431 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19432 bt_instantiate_type_proc
, &storage
);
19436 /* Given a function DECL, which is a specialization of TMPL, modify
19437 DECL to be a re-instantiation of TMPL with the same template
19438 arguments. TMPL should be the template into which tsubst'ing
19439 should occur for DECL, not the most general template.
19441 One reason for doing this is a scenario like this:
19444 void f(const T&, int i);
19446 void g() { f(3, 7); }
19449 void f(const T& t, const int i) { }
19451 Note that when the template is first instantiated, with
19452 instantiate_template, the resulting DECL will have no name for the
19453 first parameter, and the wrong type for the second. So, when we go
19454 to instantiate the DECL, we regenerate it. */
19457 regenerate_decl_from_template (tree decl
, tree tmpl
)
19459 /* The arguments used to instantiate DECL, from the most general
19464 args
= DECL_TI_ARGS (decl
);
19465 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19467 /* Make sure that we can see identifiers, and compute access
19469 push_access_scope (decl
);
19471 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19479 args_depth
= TMPL_ARGS_DEPTH (args
);
19480 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19481 if (args_depth
> parms_depth
)
19482 args
= get_innermost_template_args (args
, parms_depth
);
19484 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19485 args
, tf_error
, NULL_TREE
,
19486 /*defer_ok*/false);
19487 if (specs
&& specs
!= error_mark_node
)
19488 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19491 /* Merge parameter declarations. */
19492 decl_parm
= skip_artificial_parms_for (decl
,
19493 DECL_ARGUMENTS (decl
));
19495 = skip_artificial_parms_for (code_pattern
,
19496 DECL_ARGUMENTS (code_pattern
));
19497 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19502 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19503 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19504 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19506 parm_type
= type_decays_to (parm_type
);
19507 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19508 TREE_TYPE (decl_parm
) = parm_type
;
19509 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19510 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19512 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19513 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19515 decl_parm
= DECL_CHAIN (decl_parm
);
19516 pattern_parm
= DECL_CHAIN (pattern_parm
);
19518 /* Merge any parameters that match with the function parameter
19520 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19523 tree expanded_types
;
19524 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19525 the parameters in this function parameter pack. */
19526 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19527 args
, tf_error
, NULL_TREE
);
19528 len
= TREE_VEC_LENGTH (expanded_types
);
19529 for (i
= 0; i
< len
; i
++)
19534 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19535 /* Rename the parameter to include the index. */
19536 DECL_NAME (decl_parm
) =
19537 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19538 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19539 parm_type
= type_decays_to (parm_type
);
19540 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19541 TREE_TYPE (decl_parm
) = parm_type
;
19542 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19543 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19545 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19546 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19548 decl_parm
= DECL_CHAIN (decl_parm
);
19551 /* Merge additional specifiers from the CODE_PATTERN. */
19552 if (DECL_DECLARED_INLINE_P (code_pattern
)
19553 && !DECL_DECLARED_INLINE_P (decl
))
19554 DECL_DECLARED_INLINE_P (decl
) = 1;
19556 else if (VAR_P (decl
))
19558 DECL_INITIAL (decl
) =
19559 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19560 tf_error
, DECL_TI_TEMPLATE (decl
),
19561 /*integral_constant_expression_p=*/false);
19562 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19563 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19564 tf_error
, DECL_TI_TEMPLATE (decl
));
19567 gcc_unreachable ();
19569 pop_access_scope (decl
);
19572 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19573 substituted to get DECL. */
19576 template_for_substitution (tree decl
)
19578 tree tmpl
= DECL_TI_TEMPLATE (decl
);
19580 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19581 for the instantiation. This is not always the most general
19582 template. Consider, for example:
19585 struct S { template <class U> void f();
19586 template <> void f<int>(); };
19588 and an instantiation of S<double>::f<int>. We want TD to be the
19589 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19590 while (/* An instantiation cannot have a definition, so we need a
19591 more general template. */
19592 DECL_TEMPLATE_INSTANTIATION (tmpl
)
19593 /* We must also deal with friend templates. Given:
19595 template <class T> struct S {
19596 template <class U> friend void f() {};
19599 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19600 so far as the language is concerned, but that's still
19601 where we get the pattern for the instantiation from. On
19602 other hand, if the definition comes outside the class, say:
19604 template <class T> struct S {
19605 template <class U> friend void f();
19607 template <class U> friend void f() {}
19609 we don't need to look any further. That's what the check for
19610 DECL_INITIAL is for. */
19611 || (TREE_CODE (decl
) == FUNCTION_DECL
19612 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
19613 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
19615 /* The present template, TD, should not be a definition. If it
19616 were a definition, we should be using it! Note that we
19617 cannot restructure the loop to just keep going until we find
19618 a template with a definition, since that might go too far if
19619 a specialization was declared, but not defined. */
19620 gcc_assert (!VAR_P (decl
)
19621 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl
)));
19623 /* Fetch the more general template. */
19624 tmpl
= DECL_TI_TEMPLATE (tmpl
);
19630 /* Returns true if we need to instantiate this template instance even if we
19631 know we aren't going to emit it.. */
19634 always_instantiate_p (tree decl
)
19636 /* We always instantiate inline functions so that we can inline them. An
19637 explicit instantiation declaration prohibits implicit instantiation of
19638 non-inline functions. With high levels of optimization, we would
19639 normally inline non-inline functions -- but we're not allowed to do
19640 that for "extern template" functions. Therefore, we check
19641 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19642 return ((TREE_CODE (decl
) == FUNCTION_DECL
19643 && (DECL_DECLARED_INLINE_P (decl
)
19644 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
19645 /* And we need to instantiate static data members so that
19646 their initializers are available in integral constant
19649 && decl_maybe_constant_var_p (decl
)));
19652 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19653 instantiate it now, modifying TREE_TYPE (fn). */
19656 maybe_instantiate_noexcept (tree fn
)
19658 tree fntype
, spec
, noex
, clone
;
19660 /* Don't instantiate a noexcept-specification from template context. */
19661 if (processing_template_decl
)
19664 if (DECL_CLONED_FUNCTION_P (fn
))
19665 fn
= DECL_CLONED_FUNCTION (fn
);
19666 fntype
= TREE_TYPE (fn
);
19667 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
19669 if (!spec
|| !TREE_PURPOSE (spec
))
19672 noex
= TREE_PURPOSE (spec
);
19674 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
19676 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
19677 spec
= get_defaulted_eh_spec (fn
);
19678 else if (push_tinst_level (fn
))
19680 push_access_scope (fn
);
19681 push_deferring_access_checks (dk_no_deferred
);
19682 input_location
= DECL_SOURCE_LOCATION (fn
);
19683 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
19684 DEFERRED_NOEXCEPT_ARGS (noex
),
19685 tf_warning_or_error
, fn
,
19686 /*function_p=*/false,
19687 /*integral_constant_expression_p=*/true);
19688 pop_deferring_access_checks ();
19689 pop_access_scope (fn
);
19690 pop_tinst_level ();
19691 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
19692 if (spec
== error_mark_node
)
19693 spec
= noexcept_false_spec
;
19696 spec
= noexcept_false_spec
;
19698 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
19701 FOR_EACH_CLONE (clone
, fn
)
19703 if (TREE_TYPE (clone
) == fntype
)
19704 TREE_TYPE (clone
) = TREE_TYPE (fn
);
19706 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
19710 /* Produce the definition of D, a _DECL generated from a template. If
19711 DEFER_OK is nonzero, then we don't have to actually do the
19712 instantiation now; we just have to do it sometime. Normally it is
19713 an error if this is an explicit instantiation but D is undefined.
19714 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19715 explicitly instantiated class template. */
19718 instantiate_decl (tree d
, int defer_ok
,
19719 bool expl_inst_class_mem_p
)
19721 tree tmpl
= DECL_TI_TEMPLATE (d
);
19728 bool pattern_defined
;
19729 location_t saved_loc
= input_location
;
19730 int saved_unevaluated_operand
= cp_unevaluated_operand
;
19731 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
19737 /* This function should only be used to instantiate templates for
19738 functions and static member variables. */
19739 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
19741 /* Variables are never deferred; if instantiation is required, they
19742 are instantiated right away. That allows for better code in the
19743 case that an expression refers to the value of the variable --
19744 if the variable has a constant value the referring expression can
19745 take advantage of that fact. */
19747 || DECL_DECLARED_CONSTEXPR_P (d
))
19750 /* Don't instantiate cloned functions. Instead, instantiate the
19751 functions they cloned. */
19752 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
19753 d
= DECL_CLONED_FUNCTION (d
);
19755 if (DECL_TEMPLATE_INSTANTIATED (d
)
19756 || (TREE_CODE (d
) == FUNCTION_DECL
19757 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
19758 || DECL_TEMPLATE_SPECIALIZATION (d
))
19759 /* D has already been instantiated or explicitly specialized, so
19760 there's nothing for us to do here.
19762 It might seem reasonable to check whether or not D is an explicit
19763 instantiation, and, if so, stop here. But when an explicit
19764 instantiation is deferred until the end of the compilation,
19765 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
19766 the instantiation. */
19769 /* Check to see whether we know that this template will be
19770 instantiated in some other file, as with "extern template"
19772 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
19774 /* In general, we do not instantiate such templates. */
19775 if (external_p
&& !always_instantiate_p (d
))
19778 gen_tmpl
= most_general_template (tmpl
);
19779 gen_args
= DECL_TI_ARGS (d
);
19781 if (tmpl
!= gen_tmpl
)
19782 /* We should already have the extra args. */
19783 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
19784 == TMPL_ARGS_DEPTH (gen_args
));
19785 /* And what's in the hash table should match D. */
19786 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
19787 || spec
== NULL_TREE
);
19789 /* This needs to happen before any tsubsting. */
19790 if (! push_tinst_level (d
))
19793 timevar_push (TV_TEMPLATE_INST
);
19795 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
19796 for the instantiation. */
19797 td
= template_for_substitution (d
);
19798 code_pattern
= DECL_TEMPLATE_RESULT (td
);
19800 /* We should never be trying to instantiate a member of a class
19801 template or partial specialization. */
19802 gcc_assert (d
!= code_pattern
);
19804 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
19805 || DECL_TEMPLATE_SPECIALIZATION (td
))
19806 /* In the case of a friend template whose definition is provided
19807 outside the class, we may have too many arguments. Drop the
19808 ones we don't need. The same is true for specializations. */
19809 args
= get_innermost_template_args
19810 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
19814 if (TREE_CODE (d
) == FUNCTION_DECL
)
19816 deleted_p
= DECL_DELETED_FN (code_pattern
);
19817 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
19818 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
19824 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
19827 /* We may be in the middle of deferred access check. Disable it now. */
19828 push_deferring_access_checks (dk_no_deferred
);
19830 /* Unless an explicit instantiation directive has already determined
19831 the linkage of D, remember that a definition is available for
19833 if (pattern_defined
19834 && !DECL_INTERFACE_KNOWN (d
)
19835 && !DECL_NOT_REALLY_EXTERN (d
))
19836 mark_definable (d
);
19838 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
19839 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
19840 input_location
= DECL_SOURCE_LOCATION (d
);
19842 /* If D is a member of an explicitly instantiated class template,
19843 and no definition is available, treat it like an implicit
19845 if (!pattern_defined
&& expl_inst_class_mem_p
19846 && DECL_EXPLICIT_INSTANTIATION (d
))
19848 /* Leave linkage flags alone on instantiations with anonymous
19850 if (TREE_PUBLIC (d
))
19852 DECL_NOT_REALLY_EXTERN (d
) = 0;
19853 DECL_INTERFACE_KNOWN (d
) = 0;
19855 SET_DECL_IMPLICIT_INSTANTIATION (d
);
19858 /* Defer all other templates, unless we have been explicitly
19859 forbidden from doing so. */
19860 if (/* If there is no definition, we cannot instantiate the
19863 /* If it's OK to postpone instantiation, do so. */
19865 /* If this is a static data member that will be defined
19866 elsewhere, we don't want to instantiate the entire data
19867 member, but we do want to instantiate the initializer so that
19868 we can substitute that elsewhere. */
19869 || (external_p
&& VAR_P (d
))
19870 /* Handle here a deleted function too, avoid generating
19871 its body (c++/61080). */
19874 /* The definition of the static data member is now required so
19875 we must substitute the initializer. */
19877 && !DECL_INITIAL (d
)
19878 && DECL_INITIAL (code_pattern
))
19882 bool const_init
= false;
19884 ns
= decl_namespace_context (d
);
19885 push_nested_namespace (ns
);
19886 push_nested_class (DECL_CONTEXT (d
));
19887 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
19889 tf_warning_or_error
, NULL_TREE
,
19890 /*integral_constant_expression_p=*/false);
19891 /* Make sure the initializer is still constant, in case of
19892 circular dependency (template/instantiate6.C). */
19894 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19895 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
19896 /*asmspec_tree=*/NULL_TREE
,
19897 LOOKUP_ONLYCONVERTING
);
19898 pop_nested_class ();
19899 pop_nested_namespace (ns
);
19902 /* We restore the source position here because it's used by
19903 add_pending_template. */
19904 input_location
= saved_loc
;
19906 if (at_eof
&& !pattern_defined
19907 && DECL_EXPLICIT_INSTANTIATION (d
)
19908 && DECL_NOT_REALLY_EXTERN (d
))
19911 The definition of a non-exported function template, a
19912 non-exported member function template, or a non-exported
19913 member function or static data member of a class template
19914 shall be present in every translation unit in which it is
19915 explicitly instantiated. */
19916 permerror (input_location
, "explicit instantiation of %qD "
19917 "but no definition available", d
);
19919 /* If we're in unevaluated context, we just wanted to get the
19920 constant value; this isn't an odr use, so don't queue
19921 a full instantiation. */
19922 if (cp_unevaluated_operand
!= 0)
19924 /* ??? Historically, we have instantiated inline functions, even
19925 when marked as "extern template". */
19926 if (!(external_p
&& VAR_P (d
)))
19927 add_pending_template (d
);
19930 /* Tell the repository that D is available in this translation unit
19931 -- and see if it is supposed to be instantiated here. */
19932 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
19934 /* In a PCH file, despite the fact that the repository hasn't
19935 requested instantiation in the PCH it is still possible that
19936 an instantiation will be required in a file that includes the
19939 add_pending_template (d
);
19940 /* Instantiate inline functions so that the inliner can do its
19941 job, even though we'll not be emitting a copy of this
19943 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
19947 fn_context
= decl_function_context (d
);
19948 nested
= (current_function_decl
!= NULL_TREE
);
19950 push_to_top_level ();
19954 push_function_context ();
19955 cp_unevaluated_operand
= 0;
19956 c_inhibit_evaluation_warnings
= 0;
19959 /* Mark D as instantiated so that recursive calls to
19960 instantiate_decl do not try to instantiate it again. */
19961 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
19963 /* Regenerate the declaration in case the template has been modified
19964 by a subsequent redeclaration. */
19965 regenerate_decl_from_template (d
, td
);
19967 /* We already set the file and line above. Reset them now in case
19968 they changed as a result of calling regenerate_decl_from_template. */
19969 input_location
= DECL_SOURCE_LOCATION (d
);
19974 bool const_init
= false;
19976 /* Clear out DECL_RTL; whatever was there before may not be right
19977 since we've reset the type of the declaration. */
19978 SET_DECL_RTL (d
, NULL
);
19979 DECL_IN_AGGR_P (d
) = 0;
19981 /* The initializer is placed in DECL_INITIAL by
19982 regenerate_decl_from_template so we don't need to
19983 push/pop_access_scope again here. Pull it out so that
19984 cp_finish_decl can process it. */
19985 init
= DECL_INITIAL (d
);
19986 DECL_INITIAL (d
) = NULL_TREE
;
19987 DECL_INITIALIZED_P (d
) = 0;
19989 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
19990 initializer. That function will defer actual emission until
19991 we have a chance to determine linkage. */
19992 DECL_EXTERNAL (d
) = 0;
19994 /* Enter the scope of D so that access-checking works correctly. */
19995 push_nested_class (DECL_CONTEXT (d
));
19996 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19997 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
19998 pop_nested_class ();
20000 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
20001 synthesize_method (d
);
20002 else if (TREE_CODE (d
) == FUNCTION_DECL
)
20004 struct pointer_map_t
*saved_local_specializations
;
20008 tree block
= NULL_TREE
;
20010 /* Save away the current list, in case we are instantiating one
20011 template from within the body of another. */
20012 saved_local_specializations
= local_specializations
;
20014 /* Set up the list of local specializations. */
20015 local_specializations
= pointer_map_create ();
20017 /* Set up context. */
20018 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20019 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20020 block
= push_stmt_list ();
20022 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
20024 /* Some typedefs referenced from within the template code need to be
20025 access checked at template instantiation time, i.e now. These
20026 types were added to the template at parsing time. Let's get those
20027 and perform the access checks then. */
20028 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20031 /* Create substitution entries for the parameters. */
20032 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20033 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20034 spec_parm
= DECL_ARGUMENTS (d
);
20035 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20037 register_local_specialization (spec_parm
, tmpl_parm
);
20038 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20039 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20041 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20043 if (!DECL_PACK_P (tmpl_parm
))
20045 register_local_specialization (spec_parm
, tmpl_parm
);
20046 spec_parm
= DECL_CHAIN (spec_parm
);
20050 /* Register the (value) argument pack as a specialization of
20051 TMPL_PARM, then move on. */
20052 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20053 register_local_specialization (argpack
, tmpl_parm
);
20056 gcc_assert (!spec_parm
);
20058 /* Substitute into the body of the function. */
20059 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20060 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20061 tf_warning_or_error
, tmpl
);
20064 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20065 tf_warning_or_error
, tmpl
,
20066 /*integral_constant_expression_p=*/false);
20068 /* Set the current input_location to the end of the function
20069 so that finish_function knows where we are. */
20071 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20073 /* Remember if we saw an infinite loop in the template. */
20074 current_function_infinite_loop
20075 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20078 /* We don't need the local specializations any more. */
20079 pointer_map_destroy (local_specializations
);
20080 local_specializations
= saved_local_specializations
;
20082 /* Finish the function. */
20083 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20084 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20085 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20088 d
= finish_function (0);
20089 expand_or_defer_fn (d
);
20092 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20093 cp_check_omp_declare_reduction (d
);
20096 /* We're not deferring instantiation any more. */
20097 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20100 pop_from_top_level ();
20102 pop_function_context ();
20105 input_location
= saved_loc
;
20106 cp_unevaluated_operand
= saved_unevaluated_operand
;
20107 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20108 pop_deferring_access_checks ();
20109 pop_tinst_level ();
20111 timevar_pop (TV_TEMPLATE_INST
);
20116 /* Run through the list of templates that we wish we could
20117 instantiate, and instantiate any we can. RETRIES is the
20118 number of times we retry pending template instantiation. */
20121 instantiate_pending_templates (int retries
)
20124 location_t saved_loc
= input_location
;
20126 /* Instantiating templates may trigger vtable generation. This in turn
20127 may require further template instantiations. We place a limit here
20128 to avoid infinite loop. */
20129 if (pending_templates
&& retries
>= max_tinst_depth
)
20131 tree decl
= pending_templates
->tinst
->decl
;
20133 error ("template instantiation depth exceeds maximum of %d"
20134 " instantiating %q+D, possibly from virtual table generation"
20135 " (use -ftemplate-depth= to increase the maximum)",
20136 max_tinst_depth
, decl
);
20137 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20138 /* Pretend that we defined it. */
20139 DECL_INITIAL (decl
) = error_mark_node
;
20145 struct pending_template
**t
= &pending_templates
;
20146 struct pending_template
*last
= NULL
;
20150 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20151 bool complete
= false;
20153 if (TYPE_P (instantiation
))
20157 if (!COMPLETE_TYPE_P (instantiation
))
20159 instantiate_class_template (instantiation
);
20160 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20161 for (fn
= TYPE_METHODS (instantiation
);
20163 fn
= TREE_CHAIN (fn
))
20164 if (! DECL_ARTIFICIAL (fn
))
20165 instantiate_decl (fn
,
20167 /*expl_inst_class_mem_p=*/false);
20168 if (COMPLETE_TYPE_P (instantiation
))
20172 complete
= COMPLETE_TYPE_P (instantiation
);
20176 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20177 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20180 = instantiate_decl (instantiation
,
20182 /*expl_inst_class_mem_p=*/false);
20183 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20187 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20188 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20192 /* If INSTANTIATION has been instantiated, then we don't
20193 need to consider it again in the future. */
20201 current_tinst_level
= NULL
;
20203 last_pending_template
= last
;
20205 while (reconsider
);
20207 input_location
= saved_loc
;
20210 /* Substitute ARGVEC into T, which is a list of initializers for
20211 either base class or a non-static data member. The TREE_PURPOSEs
20212 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20213 instantiate_decl. */
20216 tsubst_initializer_list (tree t
, tree argvec
)
20218 tree inits
= NULL_TREE
;
20220 for (; t
; t
= TREE_CHAIN (t
))
20224 tree expanded_bases
= NULL_TREE
;
20225 tree expanded_arguments
= NULL_TREE
;
20228 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20233 /* Expand the base class expansion type into separate base
20235 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20236 tf_warning_or_error
,
20238 if (expanded_bases
== error_mark_node
)
20241 /* We'll be building separate TREE_LISTs of arguments for
20243 len
= TREE_VEC_LENGTH (expanded_bases
);
20244 expanded_arguments
= make_tree_vec (len
);
20245 for (i
= 0; i
< len
; i
++)
20246 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20248 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20249 expand each argument in the TREE_VALUE of t. */
20250 expr
= make_node (EXPR_PACK_EXPANSION
);
20251 PACK_EXPANSION_LOCAL_P (expr
) = true;
20252 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20253 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20255 if (TREE_VALUE (t
) == void_type_node
)
20256 /* VOID_TYPE_NODE is used to indicate
20257 value-initialization. */
20259 for (i
= 0; i
< len
; i
++)
20260 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20264 /* Substitute parameter packs into each argument in the
20266 in_base_initializer
= 1;
20267 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20269 tree expanded_exprs
;
20271 /* Expand the argument. */
20272 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20274 = tsubst_pack_expansion (expr
, argvec
,
20275 tf_warning_or_error
,
20277 if (expanded_exprs
== error_mark_node
)
20280 /* Prepend each of the expanded expressions to the
20281 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20282 for (i
= 0; i
< len
; i
++)
20284 TREE_VEC_ELT (expanded_arguments
, i
) =
20285 tree_cons (NULL_TREE
,
20286 TREE_VEC_ELT (expanded_exprs
, i
),
20287 TREE_VEC_ELT (expanded_arguments
, i
));
20290 in_base_initializer
= 0;
20292 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20293 since we built them backwards. */
20294 for (i
= 0; i
< len
; i
++)
20296 TREE_VEC_ELT (expanded_arguments
, i
) =
20297 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20302 for (i
= 0; i
< len
; ++i
)
20304 if (expanded_bases
)
20306 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20307 decl
= expand_member_init (decl
);
20308 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20313 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20314 tf_warning_or_error
, NULL_TREE
);
20316 decl
= expand_member_init (decl
);
20317 if (decl
&& !DECL_P (decl
))
20318 in_base_initializer
= 1;
20320 init
= TREE_VALUE (t
);
20322 if (init
!= void_type_node
)
20323 init
= tsubst_expr (init
, argvec
,
20324 tf_warning_or_error
, NULL_TREE
,
20325 /*integral_constant_expression_p=*/false);
20326 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20327 /* If we had an initializer but it instantiated to nothing,
20328 value-initialize the object. This will only occur when
20329 the initializer was a pack expansion where the parameter
20330 packs used in that expansion were of length zero. */
20331 init
= void_type_node
;
20332 in_base_initializer
= 0;
20337 init
= build_tree_list (decl
, init
);
20338 TREE_CHAIN (init
) = inits
;
20346 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20349 set_current_access_from_decl (tree decl
)
20351 if (TREE_PRIVATE (decl
))
20352 current_access_specifier
= access_private_node
;
20353 else if (TREE_PROTECTED (decl
))
20354 current_access_specifier
= access_protected_node
;
20356 current_access_specifier
= access_public_node
;
20359 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20360 is the instantiation (which should have been created with
20361 start_enum) and ARGS are the template arguments to use. */
20364 tsubst_enum (tree tag
, tree newtag
, tree args
)
20368 if (SCOPED_ENUM_P (newtag
))
20369 begin_scope (sk_scoped_enum
, newtag
);
20371 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20376 decl
= TREE_VALUE (e
);
20377 /* Note that in a template enum, the TREE_VALUE is the
20378 CONST_DECL, not the corresponding INTEGER_CST. */
20379 value
= tsubst_expr (DECL_INITIAL (decl
),
20380 args
, tf_warning_or_error
, NULL_TREE
,
20381 /*integral_constant_expression_p=*/true);
20383 /* Give this enumeration constant the correct access. */
20384 set_current_access_from_decl (decl
);
20386 /* Actually build the enumerator itself. */
20388 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
20391 if (SCOPED_ENUM_P (newtag
))
20394 finish_enum_value_list (newtag
);
20395 finish_enum (newtag
);
20397 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20398 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20401 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20402 its type -- but without substituting the innermost set of template
20403 arguments. So, innermost set of template parameters will appear in
20407 get_mostly_instantiated_function_type (tree decl
)
20415 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
20416 targs
= DECL_TI_ARGS (decl
);
20417 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
20418 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
20420 /* There should be as many levels of arguments as there are levels
20422 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
20424 fn_type
= TREE_TYPE (tmpl
);
20426 if (parm_depth
== 1)
20427 /* No substitution is necessary. */
20434 /* Replace the innermost level of the TARGS with NULL_TREEs to
20435 let tsubst know not to substitute for those parameters. */
20436 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20437 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
20438 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
20439 TMPL_ARGS_LEVEL (targs
, i
));
20440 SET_TMPL_ARGS_LEVEL (partial_args
,
20441 TMPL_ARGS_DEPTH (targs
),
20442 make_tree_vec (DECL_NTPARMS (tmpl
)));
20444 /* Make sure that we can see identifiers, and compute access
20446 push_access_scope (decl
);
20448 ++processing_template_decl
;
20449 /* Now, do the (partial) substitution to figure out the
20450 appropriate function type. */
20451 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
20452 --processing_template_decl
;
20454 /* Substitute into the template parameters to obtain the real
20455 innermost set of parameters. This step is important if the
20456 innermost set of template parameters contains value
20457 parameters whose types depend on outer template parameters. */
20458 TREE_VEC_LENGTH (partial_args
)--;
20459 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
20461 pop_access_scope (decl
);
20467 /* Return truthvalue if we're processing a template different from
20468 the last one involved in diagnostics. */
20470 problematic_instantiation_changed (void)
20472 return current_tinst_level
!= last_error_tinst_level
;
20475 /* Remember current template involved in diagnostics. */
20477 record_last_problematic_instantiation (void)
20479 last_error_tinst_level
= current_tinst_level
;
20482 struct tinst_level
*
20483 current_instantiation (void)
20485 return current_tinst_level
;
20488 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20489 type. Return zero for ok, nonzero for disallowed. Issue error and
20490 warning messages under control of COMPLAIN. */
20493 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20495 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20497 else if (POINTER_TYPE_P (type
))
20499 else if (TYPE_PTRMEM_P (type
))
20501 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20503 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20505 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20507 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20510 if (complain
& tf_error
)
20512 if (type
== error_mark_node
)
20513 inform (input_location
, "invalid template non-type parameter");
20515 error ("%q#T is not a valid type for a template non-type parameter",
20521 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20522 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20525 dependent_type_p_r (tree type
)
20531 A type is dependent if it is:
20533 -- a template parameter. Template template parameters are types
20534 for us (since TYPE_P holds true for them) so we handle
20536 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20537 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20539 /* -- a qualified-id with a nested-name-specifier which contains a
20540 class-name that names a dependent type or whose unqualified-id
20541 names a dependent type. */
20542 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20544 /* -- a cv-qualified type where the cv-unqualified type is
20546 type
= TYPE_MAIN_VARIANT (type
);
20547 /* -- a compound type constructed from any dependent type. */
20548 if (TYPE_PTRMEM_P (type
))
20549 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20550 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20552 else if (TYPE_PTR_P (type
)
20553 || TREE_CODE (type
) == REFERENCE_TYPE
)
20554 return dependent_type_p (TREE_TYPE (type
));
20555 else if (TREE_CODE (type
) == FUNCTION_TYPE
20556 || TREE_CODE (type
) == METHOD_TYPE
)
20560 if (dependent_type_p (TREE_TYPE (type
)))
20562 for (arg_type
= TYPE_ARG_TYPES (type
);
20564 arg_type
= TREE_CHAIN (arg_type
))
20565 if (dependent_type_p (TREE_VALUE (arg_type
)))
20569 /* -- an array type constructed from any dependent type or whose
20570 size is specified by a constant expression that is
20573 We checked for type- and value-dependence of the bounds in
20574 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20575 if (TREE_CODE (type
) == ARRAY_TYPE
)
20577 if (TYPE_DOMAIN (type
)
20578 && dependent_type_p (TYPE_DOMAIN (type
)))
20580 return dependent_type_p (TREE_TYPE (type
));
20583 /* -- a template-id in which either the template name is a template
20585 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20587 /* ... or any of the template arguments is a dependent type or
20588 an expression that is type-dependent or value-dependent. */
20589 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
20590 && (any_dependent_template_arguments_p
20591 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
20594 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20595 dependent; if the argument of the `typeof' expression is not
20596 type-dependent, then it should already been have resolved. */
20597 if (TREE_CODE (type
) == TYPEOF_TYPE
20598 || TREE_CODE (type
) == DECLTYPE_TYPE
20599 || TREE_CODE (type
) == UNDERLYING_TYPE
)
20602 /* A template argument pack is dependent if any of its packed
20604 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
20606 tree args
= ARGUMENT_PACK_ARGS (type
);
20607 int i
, len
= TREE_VEC_LENGTH (args
);
20608 for (i
= 0; i
< len
; ++i
)
20609 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20613 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20614 be template parameters. */
20615 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
20618 /* The standard does not specifically mention types that are local
20619 to template functions or local classes, but they should be
20620 considered dependent too. For example:
20622 template <int I> void f() {
20627 The size of `E' cannot be known until the value of `I' has been
20628 determined. Therefore, `E' must be considered dependent. */
20629 scope
= TYPE_CONTEXT (type
);
20630 if (scope
&& TYPE_P (scope
))
20631 return dependent_type_p (scope
);
20632 /* Don't use type_dependent_expression_p here, as it can lead
20633 to infinite recursion trying to determine whether a lambda
20634 nested in a lambda is dependent (c++/47687). */
20635 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
20636 && DECL_LANG_SPECIFIC (scope
)
20637 && DECL_TEMPLATE_INFO (scope
)
20638 && (any_dependent_template_arguments_p
20639 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
20642 /* Other types are non-dependent. */
20646 /* Returns TRUE if TYPE is dependent, in the sense of
20647 [temp.dep.type]. Note that a NULL type is considered dependent. */
20650 dependent_type_p (tree type
)
20652 /* If there are no template parameters in scope, then there can't be
20653 any dependent types. */
20654 if (!processing_template_decl
)
20656 /* If we are not processing a template, then nobody should be
20657 providing us with a dependent type. */
20659 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
20663 /* If the type is NULL, we have not computed a type for the entity
20664 in question; in that case, the type is dependent. */
20668 /* Erroneous types can be considered non-dependent. */
20669 if (type
== error_mark_node
)
20672 /* If we have not already computed the appropriate value for TYPE,
20674 if (!TYPE_DEPENDENT_P_VALID (type
))
20676 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
20677 TYPE_DEPENDENT_P_VALID (type
) = 1;
20680 return TYPE_DEPENDENT_P (type
);
20683 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20684 lookup. In other words, a dependent type that is not the current
20688 dependent_scope_p (tree scope
)
20690 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
20691 && !currently_open_class (scope
));
20694 /* T is a SCOPE_REF; return whether we need to consider it
20695 instantiation-dependent so that we can check access at instantiation
20696 time even though we know which member it resolves to. */
20699 instantiation_dependent_scope_ref_p (tree t
)
20701 if (DECL_P (TREE_OPERAND (t
, 1))
20702 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
20703 && accessible_in_template_p (TREE_OPERAND (t
, 0),
20704 TREE_OPERAND (t
, 1)))
20710 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20711 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20714 /* Note that this predicate is not appropriate for general expressions;
20715 only constant expressions (that satisfy potential_constant_expression)
20716 can be tested for value dependence. */
20719 value_dependent_expression_p (tree expression
)
20721 if (!processing_template_decl
)
20724 /* A name declared with a dependent type. */
20725 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
20728 switch (TREE_CODE (expression
))
20730 case IDENTIFIER_NODE
:
20731 /* A name that has not been looked up -- must be dependent. */
20734 case TEMPLATE_PARM_INDEX
:
20735 /* A non-type template parm. */
20739 /* A non-type template parm. */
20740 if (DECL_TEMPLATE_PARM_P (expression
))
20742 return value_dependent_expression_p (DECL_INITIAL (expression
));
20745 /* A constant with literal type and is initialized
20746 with an expression that is value-dependent.
20748 Note that a non-dependent parenthesized initializer will have
20749 already been replaced with its constant value, so if we see
20750 a TREE_LIST it must be dependent. */
20751 if (DECL_INITIAL (expression
)
20752 && decl_constant_var_p (expression
)
20753 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
20754 || value_dependent_expression_p (DECL_INITIAL (expression
))))
20758 case DYNAMIC_CAST_EXPR
:
20759 case STATIC_CAST_EXPR
:
20760 case CONST_CAST_EXPR
:
20761 case REINTERPRET_CAST_EXPR
:
20763 /* These expressions are value-dependent if the type to which
20764 the cast occurs is dependent or the expression being casted
20765 is value-dependent. */
20767 tree type
= TREE_TYPE (expression
);
20769 if (dependent_type_p (type
))
20772 /* A functional cast has a list of operands. */
20773 expression
= TREE_OPERAND (expression
, 0);
20776 /* If there are no operands, it must be an expression such
20777 as "int()". This should not happen for aggregate types
20778 because it would form non-constant expressions. */
20779 gcc_assert (cxx_dialect
>= cxx11
20780 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
20785 if (TREE_CODE (expression
) == TREE_LIST
)
20786 return any_value_dependent_elements_p (expression
);
20788 return value_dependent_expression_p (expression
);
20792 if (SIZEOF_EXPR_TYPE_P (expression
))
20793 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
20797 /* A `sizeof' expression is value-dependent if the operand is
20798 type-dependent or is a pack expansion. */
20799 expression
= TREE_OPERAND (expression
, 0);
20800 if (PACK_EXPANSION_P (expression
))
20802 else if (TYPE_P (expression
))
20803 return dependent_type_p (expression
);
20804 return instantiation_dependent_expression_p (expression
);
20806 case AT_ENCODE_EXPR
:
20807 /* An 'encode' expression is value-dependent if the operand is
20809 expression
= TREE_OPERAND (expression
, 0);
20810 return dependent_type_p (expression
);
20812 case NOEXCEPT_EXPR
:
20813 expression
= TREE_OPERAND (expression
, 0);
20814 return instantiation_dependent_expression_p (expression
);
20817 /* All instantiation-dependent expressions should also be considered
20818 value-dependent. */
20819 return instantiation_dependent_scope_ref_p (expression
);
20821 case COMPONENT_REF
:
20822 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
20823 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
20825 case NONTYPE_ARGUMENT_PACK
:
20826 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
20827 is value-dependent. */
20829 tree values
= ARGUMENT_PACK_ARGS (expression
);
20830 int i
, len
= TREE_VEC_LENGTH (values
);
20832 for (i
= 0; i
< len
; ++i
)
20833 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
20841 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
20842 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
20843 || (type2
? dependent_type_p (type2
) : false));
20847 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20848 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
20851 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20852 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
20856 tree op
= TREE_OPERAND (expression
, 0);
20857 return (value_dependent_expression_p (op
)
20858 || has_value_dependent_address (op
));
20863 tree fn
= get_callee_fndecl (expression
);
20865 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
20867 nargs
= call_expr_nargs (expression
);
20868 for (i
= 0; i
< nargs
; ++i
)
20870 tree op
= CALL_EXPR_ARG (expression
, i
);
20871 /* In a call to a constexpr member function, look through the
20872 implicit ADDR_EXPR on the object argument so that it doesn't
20873 cause the call to be considered value-dependent. We also
20874 look through it in potential_constant_expression. */
20875 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
20876 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
20877 && TREE_CODE (op
) == ADDR_EXPR
)
20878 op
= TREE_OPERAND (op
, 0);
20879 if (value_dependent_expression_p (op
))
20885 case TEMPLATE_ID_EXPR
:
20886 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
20888 return type_dependent_expression_p (expression
);
20894 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
20895 if (value_dependent_expression_p (val
))
20901 /* Treat a GNU statement expression as dependent to avoid crashing
20902 under fold_non_dependent_expr; it can't be constant. */
20906 /* A constant expression is value-dependent if any subexpression is
20907 value-dependent. */
20908 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
20910 case tcc_reference
:
20912 case tcc_comparison
:
20914 case tcc_expression
:
20917 int i
, len
= cp_tree_operand_length (expression
);
20919 for (i
= 0; i
< len
; i
++)
20921 tree t
= TREE_OPERAND (expression
, i
);
20923 /* In some cases, some of the operands may be missing.l
20924 (For example, in the case of PREDECREMENT_EXPR, the
20925 amount to increment by may be missing.) That doesn't
20926 make the expression dependent. */
20927 if (t
&& value_dependent_expression_p (t
))
20938 /* The expression is not value-dependent. */
20942 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
20943 [temp.dep.expr]. Note that an expression with no type is
20944 considered dependent. Other parts of the compiler arrange for an
20945 expression with type-dependent subexpressions to have no type, so
20946 this function doesn't have to be fully recursive. */
20949 type_dependent_expression_p (tree expression
)
20951 if (!processing_template_decl
)
20954 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
20957 /* An unresolved name is always dependent. */
20958 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
20961 /* Some expression forms are never type-dependent. */
20962 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
20963 || TREE_CODE (expression
) == SIZEOF_EXPR
20964 || TREE_CODE (expression
) == ALIGNOF_EXPR
20965 || TREE_CODE (expression
) == AT_ENCODE_EXPR
20966 || TREE_CODE (expression
) == NOEXCEPT_EXPR
20967 || TREE_CODE (expression
) == TRAIT_EXPR
20968 || TREE_CODE (expression
) == TYPEID_EXPR
20969 || TREE_CODE (expression
) == DELETE_EXPR
20970 || TREE_CODE (expression
) == VEC_DELETE_EXPR
20971 || TREE_CODE (expression
) == THROW_EXPR
)
20974 /* The types of these expressions depends only on the type to which
20975 the cast occurs. */
20976 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
20977 || TREE_CODE (expression
) == STATIC_CAST_EXPR
20978 || TREE_CODE (expression
) == CONST_CAST_EXPR
20979 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
20980 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
20981 || TREE_CODE (expression
) == CAST_EXPR
)
20982 return dependent_type_p (TREE_TYPE (expression
));
20984 /* The types of these expressions depends only on the type created
20985 by the expression. */
20986 if (TREE_CODE (expression
) == NEW_EXPR
20987 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
20989 /* For NEW_EXPR tree nodes created inside a template, either
20990 the object type itself or a TREE_LIST may appear as the
20992 tree type
= TREE_OPERAND (expression
, 1);
20993 if (TREE_CODE (type
) == TREE_LIST
)
20994 /* This is an array type. We need to check array dimensions
20996 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
20997 || value_dependent_expression_p
20998 (TREE_OPERAND (TREE_VALUE (type
), 1));
21000 return dependent_type_p (type
);
21003 if (TREE_CODE (expression
) == SCOPE_REF
)
21005 tree scope
= TREE_OPERAND (expression
, 0);
21006 tree name
= TREE_OPERAND (expression
, 1);
21008 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21009 contains an identifier associated by name lookup with one or more
21010 declarations declared with a dependent type, or...a
21011 nested-name-specifier or qualified-id that names a member of an
21012 unknown specialization. */
21013 return (type_dependent_expression_p (name
)
21014 || dependent_scope_p (scope
));
21017 if (TREE_CODE (expression
) == FUNCTION_DECL
21018 && DECL_LANG_SPECIFIC (expression
)
21019 && DECL_TEMPLATE_INFO (expression
)
21020 && (any_dependent_template_arguments_p
21021 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
21024 if (TREE_CODE (expression
) == TEMPLATE_DECL
21025 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
21028 if (TREE_CODE (expression
) == STMT_EXPR
)
21029 expression
= stmt_expr_value_expr (expression
);
21031 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21036 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21038 if (type_dependent_expression_p (elt
))
21044 /* A static data member of the current instantiation with incomplete
21045 array type is type-dependent, as the definition and specializations
21046 can have different bounds. */
21047 if (VAR_P (expression
)
21048 && DECL_CLASS_SCOPE_P (expression
)
21049 && dependent_type_p (DECL_CONTEXT (expression
))
21050 && VAR_HAD_UNKNOWN_BOUND (expression
))
21053 /* An array of unknown bound depending on a variadic parameter, eg:
21055 template<typename... Args>
21056 void foo (Args... args)
21058 int arr[] = { args... };
21061 template<int... vals>
21064 int arr[] = { vals... };
21067 If the array has no length and has an initializer, it must be that
21068 we couldn't determine its length in cp_complete_array_type because
21069 it is dependent. */
21070 if (VAR_P (expression
)
21071 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21072 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21073 && DECL_INITIAL (expression
))
21076 if (TREE_TYPE (expression
) == unknown_type_node
)
21078 if (TREE_CODE (expression
) == ADDR_EXPR
)
21079 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21080 if (TREE_CODE (expression
) == COMPONENT_REF
21081 || TREE_CODE (expression
) == OFFSET_REF
)
21083 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21085 expression
= TREE_OPERAND (expression
, 1);
21086 if (identifier_p (expression
))
21089 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21090 if (TREE_CODE (expression
) == SCOPE_REF
)
21093 /* Always dependent, on the number of arguments if nothing else. */
21094 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21097 if (BASELINK_P (expression
))
21099 if (BASELINK_OPTYPE (expression
)
21100 && dependent_type_p (BASELINK_OPTYPE (expression
)))
21102 expression
= BASELINK_FUNCTIONS (expression
);
21105 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21107 if (any_dependent_template_arguments_p
21108 (TREE_OPERAND (expression
, 1)))
21110 expression
= TREE_OPERAND (expression
, 0);
21112 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21113 || TREE_CODE (expression
) == FUNCTION_DECL
);
21117 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21119 expression
= OVL_NEXT (expression
);
21124 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21126 return (dependent_type_p (TREE_TYPE (expression
)));
21129 /* walk_tree callback function for instantiation_dependent_expression_p,
21130 below. Returns non-zero if a dependent subexpression is found. */
21133 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21138 /* We don't have to worry about decltype currently because decltype
21139 of an instantiation-dependent expr is a dependent type. This
21140 might change depending on the resolution of DR 1172. */
21141 *walk_subtrees
= false;
21144 enum tree_code code
= TREE_CODE (*tp
);
21147 /* Don't treat an argument list as dependent just because it has no
21155 /* A constant with a dependent initializer is dependent. */
21156 if (value_dependent_expression_p (*tp
))
21160 case TEMPLATE_PARM_INDEX
:
21163 /* Handle expressions with type operands. */
21167 case AT_ENCODE_EXPR
:
21169 tree op
= TREE_OPERAND (*tp
, 0);
21170 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21171 op
= TREE_TYPE (op
);
21174 if (dependent_type_p (op
))
21178 *walk_subtrees
= false;
21186 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21187 || (TRAIT_EXPR_TYPE2 (*tp
)
21188 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21190 *walk_subtrees
= false;
21193 case COMPONENT_REF
:
21194 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21195 /* In a template, finish_class_member_access_expr creates a
21196 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21197 type-dependent, so that we can check access control at
21198 instantiation time (PR 42277). See also Core issue 1273. */
21203 if (instantiation_dependent_scope_ref_p (*tp
))
21208 /* Treat statement-expressions as dependent. */
21216 if (type_dependent_expression_p (*tp
))
21222 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21223 sense defined by the ABI:
21225 "An expression is instantiation-dependent if it is type-dependent
21226 or value-dependent, or it has a subexpression that is type-dependent
21227 or value-dependent." */
21230 instantiation_dependent_expression_p (tree expression
)
21234 if (!processing_template_decl
)
21237 if (expression
== error_mark_node
)
21240 result
= cp_walk_tree_without_duplicates (&expression
,
21241 instantiation_dependent_r
, NULL
);
21242 return result
!= NULL_TREE
;
21245 /* Like type_dependent_expression_p, but it also works while not processing
21246 a template definition, i.e. during substitution or mangling. */
21249 type_dependent_expression_p_push (tree expr
)
21252 ++processing_template_decl
;
21253 b
= type_dependent_expression_p (expr
);
21254 --processing_template_decl
;
21258 /* Returns TRUE if ARGS contains a type-dependent expression. */
21261 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21266 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21268 if (type_dependent_expression_p (arg
))
21274 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21275 expressions) contains any type-dependent expressions. */
21278 any_type_dependent_elements_p (const_tree list
)
21280 for (; list
; list
= TREE_CHAIN (list
))
21281 if (type_dependent_expression_p (TREE_VALUE (list
)))
21287 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21288 expressions) contains any value-dependent expressions. */
21291 any_value_dependent_elements_p (const_tree list
)
21293 for (; list
; list
= TREE_CHAIN (list
))
21294 if (value_dependent_expression_p (TREE_VALUE (list
)))
21300 /* Returns TRUE if the ARG (a template argument) is dependent. */
21303 dependent_template_arg_p (tree arg
)
21305 if (!processing_template_decl
)
21308 /* Assume a template argument that was wrongly written by the user
21309 is dependent. This is consistent with what
21310 any_dependent_template_arguments_p [that calls this function]
21312 if (!arg
|| arg
== error_mark_node
)
21315 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21316 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21318 if (TREE_CODE (arg
) == TEMPLATE_DECL
21319 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21320 return dependent_template_p (arg
);
21321 else if (ARGUMENT_PACK_P (arg
))
21323 tree args
= ARGUMENT_PACK_ARGS (arg
);
21324 int i
, len
= TREE_VEC_LENGTH (args
);
21325 for (i
= 0; i
< len
; ++i
)
21327 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21333 else if (TYPE_P (arg
))
21334 return dependent_type_p (arg
);
21336 return (type_dependent_expression_p (arg
)
21337 || value_dependent_expression_p (arg
));
21340 /* Returns true if ARGS (a collection of template arguments) contains
21341 any types that require structural equality testing. */
21344 any_template_arguments_need_structural_equality_p (tree args
)
21351 if (args
== error_mark_node
)
21354 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21356 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21357 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21359 tree arg
= TREE_VEC_ELT (level
, j
);
21360 tree packed_args
= NULL_TREE
;
21363 if (ARGUMENT_PACK_P (arg
))
21365 /* Look inside the argument pack. */
21366 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21367 len
= TREE_VEC_LENGTH (packed_args
);
21370 for (k
= 0; k
< len
; ++k
)
21373 arg
= TREE_VEC_ELT (packed_args
, k
);
21375 if (error_operand_p (arg
))
21377 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21379 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21381 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21382 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21391 /* Returns true if ARGS (a collection of template arguments) contains
21392 any dependent arguments. */
21395 any_dependent_template_arguments_p (const_tree args
)
21402 if (args
== error_mark_node
)
21405 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21407 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21408 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21409 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21416 /* Returns TRUE if the template TMPL is dependent. */
21419 dependent_template_p (tree tmpl
)
21421 if (TREE_CODE (tmpl
) == OVERLOAD
)
21425 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21427 tmpl
= OVL_NEXT (tmpl
);
21432 /* Template template parameters are dependent. */
21433 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21434 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21436 /* So are names that have not been looked up. */
21437 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21439 /* So are member templates of dependent classes. */
21440 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21441 return dependent_type_p (DECL_CONTEXT (tmpl
));
21445 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21448 dependent_template_id_p (tree tmpl
, tree args
)
21450 return (dependent_template_p (tmpl
)
21451 || any_dependent_template_arguments_p (args
));
21454 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21458 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21462 if (!processing_template_decl
)
21465 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21467 tree decl
= TREE_VEC_ELT (declv
, i
);
21468 tree init
= TREE_VEC_ELT (initv
, i
);
21469 tree cond
= TREE_VEC_ELT (condv
, i
);
21470 tree incr
= TREE_VEC_ELT (incrv
, i
);
21472 if (type_dependent_expression_p (decl
))
21475 if (init
&& type_dependent_expression_p (init
))
21478 if (type_dependent_expression_p (cond
))
21481 if (COMPARISON_CLASS_P (cond
)
21482 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21483 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21486 if (TREE_CODE (incr
) == MODOP_EXPR
)
21488 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21489 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21492 else if (type_dependent_expression_p (incr
))
21494 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21496 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21498 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21500 tree t
= TREE_OPERAND (incr
, 1);
21501 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21502 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21511 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21512 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21513 no such TYPE can be found. Note that this function peers inside
21514 uninstantiated templates and therefore should be used only in
21515 extremely limited situations. ONLY_CURRENT_P restricts this
21516 peering to the currently open classes hierarchy (which is required
21517 when comparing types). */
21520 resolve_typename_type (tree type
, bool only_current_p
)
21529 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21531 scope
= TYPE_CONTEXT (type
);
21532 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21533 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21534 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21535 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21536 identifier of the TYPENAME_TYPE anymore.
21537 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21538 TYPENAME_TYPE instead, we avoid messing up with a possible
21539 typedef variant case. */
21540 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21542 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21543 it first before we can figure out what NAME refers to. */
21544 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21546 if (TYPENAME_IS_RESOLVING_P (scope
))
21547 /* Given a class template A with a dependent base with nested type C,
21548 typedef typename A::C::C C will land us here, as trying to resolve
21549 the initial A::C leads to the local C typedef, which leads back to
21550 A::C::C. So we break the recursion now. */
21553 scope
= resolve_typename_type (scope
, only_current_p
);
21555 /* If we don't know what SCOPE refers to, then we cannot resolve the
21557 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21559 /* If the SCOPE is a template type parameter, we have no way of
21560 resolving the name. */
21561 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21563 /* If the SCOPE is not the current instantiation, there's no reason
21564 to look inside it. */
21565 if (only_current_p
&& !currently_open_class (scope
))
21567 /* If this is a typedef, we don't want to look inside (c++/11987). */
21568 if (typedef_variant_p (type
))
21570 /* If SCOPE isn't the template itself, it will not have a valid
21571 TYPE_FIELDS list. */
21572 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21573 /* scope is either the template itself or a compatible instantiation
21574 like X<T>, so look up the name in the original template. */
21575 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
21577 /* scope is a partial instantiation, so we can't do the lookup or we
21578 will lose the template arguments. */
21580 /* Enter the SCOPE so that name lookup will be resolved as if we
21581 were in the class definition. In particular, SCOPE will no
21582 longer be considered a dependent type. */
21583 pushed_scope
= push_scope (scope
);
21584 /* Look up the declaration. */
21585 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
21586 tf_warning_or_error
);
21588 result
= NULL_TREE
;
21590 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21591 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21594 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
21595 && TREE_CODE (decl
) == TYPE_DECL
)
21597 result
= TREE_TYPE (decl
);
21598 if (result
== error_mark_node
)
21599 result
= NULL_TREE
;
21601 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
21602 && DECL_CLASS_TEMPLATE_P (decl
))
21606 /* Obtain the template and the arguments. */
21607 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
21608 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
21609 /* Instantiate the template. */
21610 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
21611 /*entering_scope=*/0,
21612 tf_error
| tf_user
);
21613 if (result
== error_mark_node
)
21614 result
= NULL_TREE
;
21617 /* Leave the SCOPE. */
21619 pop_scope (pushed_scope
);
21621 /* If we failed to resolve it, return the original typename. */
21625 /* If lookup found a typename type, resolve that too. */
21626 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
21628 /* Ill-formed programs can cause infinite recursion here, so we
21629 must catch that. */
21630 TYPENAME_IS_RESOLVING_P (type
) = 1;
21631 result
= resolve_typename_type (result
, only_current_p
);
21632 TYPENAME_IS_RESOLVING_P (type
) = 0;
21635 /* Qualify the resulting type. */
21636 quals
= cp_type_quals (type
);
21638 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
21643 /* EXPR is an expression which is not type-dependent. Return a proxy
21644 for EXPR that can be used to compute the types of larger
21645 expressions containing EXPR. */
21648 build_non_dependent_expr (tree expr
)
21652 #ifdef ENABLE_CHECKING
21653 /* Try to get a constant value for all non-dependent expressions in
21654 order to expose bugs in *_dependent_expression_p and constexpr. */
21655 if (cxx_dialect
>= cxx11
)
21656 maybe_constant_value (fold_non_dependent_expr_sfinae (expr
, tf_none
));
21659 /* Preserve OVERLOADs; the functions must be available to resolve
21662 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
21663 inner_expr
= stmt_expr_value_expr (inner_expr
);
21664 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
21665 inner_expr
= TREE_OPERAND (inner_expr
, 0);
21666 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
21667 inner_expr
= TREE_OPERAND (inner_expr
, 1);
21668 if (is_overloaded_fn (inner_expr
)
21669 || TREE_CODE (inner_expr
) == OFFSET_REF
)
21671 /* There is no need to return a proxy for a variable. */
21674 /* Preserve string constants; conversions from string constants to
21675 "char *" are allowed, even though normally a "const char *"
21676 cannot be used to initialize a "char *". */
21677 if (TREE_CODE (expr
) == STRING_CST
)
21679 /* Preserve void and arithmetic constants, as an optimization -- there is no
21680 reason to create a new node. */
21681 if (TREE_CODE (expr
) == VOID_CST
21682 || TREE_CODE (expr
) == INTEGER_CST
21683 || TREE_CODE (expr
) == REAL_CST
)
21685 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21686 There is at least one place where we want to know that a
21687 particular expression is a throw-expression: when checking a ?:
21688 expression, there are special rules if the second or third
21689 argument is a throw-expression. */
21690 if (TREE_CODE (expr
) == THROW_EXPR
)
21693 /* Don't wrap an initializer list, we need to be able to look inside. */
21694 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
21697 /* Don't wrap a dummy object, we need to be able to test for it. */
21698 if (is_dummy_object (expr
))
21701 if (TREE_CODE (expr
) == COND_EXPR
)
21702 return build3 (COND_EXPR
,
21704 TREE_OPERAND (expr
, 0),
21705 (TREE_OPERAND (expr
, 1)
21706 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
21707 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
21708 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
21709 if (TREE_CODE (expr
) == COMPOUND_EXPR
21710 && !COMPOUND_EXPR_OVERLOADED (expr
))
21711 return build2 (COMPOUND_EXPR
,
21713 TREE_OPERAND (expr
, 0),
21714 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
21716 /* If the type is unknown, it can't really be non-dependent */
21717 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
21719 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21720 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
21723 /* ARGS is a vector of expressions as arguments to a function call.
21724 Replace the arguments with equivalent non-dependent expressions.
21725 This modifies ARGS in place. */
21728 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
21733 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
21735 tree newarg
= build_non_dependent_expr (arg
);
21737 (*args
)[ix
] = newarg
;
21741 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21742 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21746 make_auto_1 (tree name
)
21748 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
21749 TYPE_NAME (au
) = build_decl (input_location
,
21750 TYPE_DECL
, name
, au
);
21751 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
21752 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
21753 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
21754 TYPE_NAME (au
), NULL_TREE
);
21755 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
21756 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
21757 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
21763 make_decltype_auto (void)
21765 return make_auto_1 (get_identifier ("decltype(auto)"));
21771 return make_auto_1 (get_identifier ("auto"));
21774 /* Given type ARG, return std::initializer_list<ARG>. */
21779 tree std_init_list
= namespace_binding
21780 (get_identifier ("initializer_list"), std_node
);
21782 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
21784 error ("deducing from brace-enclosed initializer list requires "
21785 "#include <initializer_list>");
21786 return error_mark_node
;
21788 argvec
= make_tree_vec (1);
21789 TREE_VEC_ELT (argvec
, 0) = arg
;
21790 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
21791 NULL_TREE
, 0, tf_warning_or_error
);
21794 /* Replace auto in TYPE with std::initializer_list<auto>. */
21797 listify_autos (tree type
, tree auto_node
)
21799 tree init_auto
= listify (auto_node
);
21800 tree argvec
= make_tree_vec (1);
21801 TREE_VEC_ELT (argvec
, 0) = init_auto
;
21802 if (processing_template_decl
)
21803 argvec
= add_to_template_args (current_template_args (), argvec
);
21804 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21807 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
21808 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
21811 do_auto_deduction (tree type
, tree init
, tree auto_node
)
21815 if (init
== error_mark_node
)
21816 return error_mark_node
;
21818 if (type_dependent_expression_p (init
))
21819 /* Defining a subset of type-dependent expressions that we can deduce
21820 from ahead of time isn't worth the trouble. */
21823 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
21824 with either a new invented type template parameter U or, if the
21825 initializer is a braced-init-list (8.5.4), with
21826 std::initializer_list<U>. */
21827 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
21828 type
= listify_autos (type
, auto_node
);
21830 init
= resolve_nondeduced_context (init
);
21832 targs
= make_tree_vec (1);
21833 if (AUTO_IS_DECLTYPE (auto_node
))
21835 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
21836 && !REF_PARENTHESIZED_P (init
)));
21837 TREE_VEC_ELT (targs
, 0)
21838 = finish_decltype_type (init
, id
, tf_warning_or_error
);
21839 if (type
!= auto_node
)
21841 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
21842 return error_mark_node
;
21847 tree parms
= build_tree_list (NULL_TREE
, type
);
21848 tree tparms
= make_tree_vec (1);
21851 TREE_VEC_ELT (tparms
, 0)
21852 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
21853 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
21854 DEDUCE_CALL
, LOOKUP_NORMAL
,
21855 NULL
, /*explain_p=*/false);
21858 if (processing_template_decl
)
21859 /* Try again at instantiation time. */
21861 if (type
&& type
!= error_mark_node
)
21862 /* If type is error_mark_node a diagnostic must have been
21863 emitted by now. Also, having a mention to '<type error>'
21864 in the diagnostic is not really useful to the user. */
21866 if (cfun
&& auto_node
== current_function_auto_return_pattern
21867 && LAMBDA_FUNCTION_P (current_function_decl
))
21868 error ("unable to deduce lambda return type from %qE", init
);
21870 error ("unable to deduce %qT from %qE", type
, init
);
21872 return error_mark_node
;
21876 /* If the list of declarators contains more than one declarator, the type
21877 of each declared variable is determined as described above. If the
21878 type deduced for the template parameter U is not the same in each
21879 deduction, the program is ill-formed. */
21880 if (TREE_TYPE (auto_node
)
21881 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
21883 if (cfun
&& auto_node
== current_function_auto_return_pattern
21884 && LAMBDA_FUNCTION_P (current_function_decl
))
21885 error ("inconsistent types %qT and %qT deduced for "
21886 "lambda return type", TREE_TYPE (auto_node
),
21887 TREE_VEC_ELT (targs
, 0));
21889 error ("inconsistent deduction for %qT: %qT and then %qT",
21890 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
21891 return error_mark_node
;
21893 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
21895 if (processing_template_decl
)
21896 targs
= add_to_template_args (current_template_args (), targs
);
21897 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
21900 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
21904 splice_late_return_type (tree type
, tree late_return_type
)
21908 if (late_return_type
== NULL_TREE
)
21910 argvec
= make_tree_vec (1);
21911 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
21912 if (processing_template_parmlist
)
21913 /* For a late-specified return type in a template type-parameter, we
21914 need to add a dummy argument level for its parmlist. */
21915 argvec
= add_to_template_args
21916 (make_tree_vec (processing_template_parmlist
), argvec
);
21917 if (current_template_parms
)
21918 argvec
= add_to_template_args (current_template_args (), argvec
);
21919 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21922 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
21923 'decltype(auto)'. */
21926 is_auto (const_tree type
)
21928 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
21929 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
21930 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
21936 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
21937 a use of `auto'. Returns NULL_TREE otherwise. */
21940 type_uses_auto (tree type
)
21942 return find_type_usage (type
, is_auto
);
21945 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
21946 'decltype(auto)' or a concept. */
21949 is_auto_or_concept (const_tree type
)
21951 return is_auto (type
); // or concept
21954 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
21955 a concept identifier) iff TYPE contains a use of a generic type. Returns
21956 NULL_TREE otherwise. */
21959 type_uses_auto_or_concept (tree type
)
21961 return find_type_usage (type
, is_auto_or_concept
);
21965 /* For a given template T, return the vector of typedefs referenced
21966 in T for which access check is needed at T instantiation time.
21967 T is either a FUNCTION_DECL or a RECORD_TYPE.
21968 Those typedefs were added to T by the function
21969 append_type_to_template_for_access_check. */
21971 vec
<qualified_typedef_usage_t
, va_gc
> *
21972 get_types_needing_access_check (tree t
)
21975 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
21977 if (!t
|| t
== error_mark_node
)
21980 if (!(ti
= get_template_info (t
)))
21983 if (CLASS_TYPE_P (t
)
21984 || TREE_CODE (t
) == FUNCTION_DECL
)
21986 if (!TI_TEMPLATE (ti
))
21989 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
21995 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
21996 tied to T. That list of typedefs will be access checked at
21997 T instantiation time.
21998 T is either a FUNCTION_DECL or a RECORD_TYPE.
21999 TYPE_DECL is a TYPE_DECL node representing a typedef.
22000 SCOPE is the scope through which TYPE_DECL is accessed.
22001 LOCATION is the location of the usage point of TYPE_DECL.
22003 This function is a subroutine of
22004 append_type_to_template_for_access_check. */
22007 append_type_to_template_for_access_check_1 (tree t
,
22010 location_t location
)
22012 qualified_typedef_usage_t typedef_usage
;
22015 if (!t
|| t
== error_mark_node
)
22018 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
22019 || CLASS_TYPE_P (t
))
22021 && TREE_CODE (type_decl
) == TYPE_DECL
22024 if (!(ti
= get_template_info (t
)))
22027 gcc_assert (TI_TEMPLATE (ti
));
22029 typedef_usage
.typedef_decl
= type_decl
;
22030 typedef_usage
.context
= scope
;
22031 typedef_usage
.locus
= location
;
22033 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22036 /* Append TYPE_DECL to the template TEMPL.
22037 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22038 At TEMPL instanciation time, TYPE_DECL will be checked to see
22039 if it can be accessed through SCOPE.
22040 LOCATION is the location of the usage point of TYPE_DECL.
22042 e.g. consider the following code snippet:
22049 template<class U> struct S
22051 C::myint mi; // <-- usage point of the typedef C::myint
22056 At S<char> instantiation time, we need to check the access of C::myint
22057 In other words, we need to check the access of the myint typedef through
22058 the C scope. For that purpose, this function will add the myint typedef
22059 and the scope C through which its being accessed to a list of typedefs
22060 tied to the template S. That list will be walked at template instantiation
22061 time and access check performed on each typedefs it contains.
22062 Note that this particular code snippet should yield an error because
22063 myint is private to C. */
22066 append_type_to_template_for_access_check (tree templ
,
22069 location_t location
)
22071 qualified_typedef_usage_t
*iter
;
22074 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22076 /* Make sure we don't append the type to the template twice. */
22077 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22078 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22081 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22085 /* Convert the generic type parameters in PARM that match the types given in the
22086 range [START_IDX, END_IDX) from the current_template_parms into generic type
22090 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22092 tree current
= current_template_parms
;
22093 int depth
= TMPL_PARMS_DEPTH (current
);
22094 current
= INNERMOST_TEMPLATE_PARMS (current
);
22095 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22097 for (int i
= 0; i
< start_idx
; ++i
)
22098 TREE_VEC_ELT (replacement
, i
)
22099 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22101 for (int i
= start_idx
; i
< end_idx
; ++i
)
22103 /* Create a distinct parameter pack type from the current parm and add it
22104 to the replacement args to tsubst below into the generic function
22107 tree o
= TREE_TYPE (TREE_VALUE
22108 (TREE_VEC_ELT (current
, i
)));
22109 tree t
= copy_type (o
);
22110 TEMPLATE_TYPE_PARM_INDEX (t
)
22111 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22113 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22114 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22115 TYPE_MAIN_VARIANT (t
) = t
;
22116 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22117 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22118 TREE_VEC_ELT (replacement
, i
) = t
;
22119 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22122 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22123 TREE_VEC_ELT (replacement
, i
)
22124 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22126 /* If there are more levels then build up the replacement with the outer
22129 replacement
= add_to_template_args (template_parms_to_args
22130 (TREE_CHAIN (current_template_parms
)),
22133 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22137 /* Set up the hash tables for template instantiations. */
22140 init_template_processing (void)
22142 decl_specializations
= htab_create_ggc (37,
22143 hash_specialization
,
22144 eq_specializations
,
22146 type_specializations
= htab_create_ggc (37,
22147 hash_specialization
,
22148 eq_specializations
,
22152 /* Print stats about the template hash tables for -fstats. */
22155 print_template_statistics (void)
22157 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22158 "%f collisions\n", (long) htab_size (decl_specializations
),
22159 (long) htab_elements (decl_specializations
),
22160 htab_collisions (decl_specializations
));
22161 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22162 "%f collisions\n", (long) htab_size (type_specializations
),
22163 (long) htab_elements (type_specializations
),
22164 htab_collisions (type_specializations
));
22167 #include "gt-cp-pt.h"