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
));
2259 TREE_TYPE (decl
) = new_type
;
2262 /* Return the number of template headers we expect to see for a definition
2263 or specialization of CTYPE or one of its non-template members. */
2266 num_template_headers_for_class (tree ctype
)
2268 int num_templates
= 0;
2270 while (ctype
&& CLASS_TYPE_P (ctype
))
2272 /* You're supposed to have one `template <...>' for every
2273 template class, but you don't need one for a full
2274 specialization. For example:
2276 template <class T> struct S{};
2277 template <> struct S<int> { void f(); };
2278 void S<int>::f () {}
2280 is correct; there shouldn't be a `template <>' for the
2281 definition of `S<int>::f'. */
2282 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2283 /* If CTYPE does not have template information of any
2284 kind, then it is not a template, nor is it nested
2285 within a template. */
2287 if (explicit_class_specialization_p (ctype
))
2289 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2292 ctype
= TYPE_CONTEXT (ctype
);
2295 return num_templates
;
2298 /* Do a simple sanity check on the template headers that precede the
2299 variable declaration DECL. */
2302 check_template_variable (tree decl
)
2304 tree ctx
= CP_DECL_CONTEXT (decl
);
2305 int wanted
= num_template_headers_for_class (ctx
);
2306 if (!TYPE_P (ctx
) || !CLASSTYPE_TEMPLATE_INFO (ctx
))
2307 permerror (DECL_SOURCE_LOCATION (decl
),
2308 "%qD is not a static data member of a class template", decl
);
2309 else if (template_header_count
> wanted
)
2311 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2312 "too many template headers for %D (should be %d)",
2314 if (warned
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2315 inform (DECL_SOURCE_LOCATION (decl
),
2316 "members of an explicitly specialized class are defined "
2317 "without a template header");
2321 /* Check to see if the function just declared, as indicated in
2322 DECLARATOR, and in DECL, is a specialization of a function
2323 template. We may also discover that the declaration is an explicit
2324 instantiation at this point.
2326 Returns DECL, or an equivalent declaration that should be used
2327 instead if all goes well. Issues an error message if something is
2328 amiss. Returns error_mark_node if the error is not easily
2331 FLAGS is a bitmask consisting of the following flags:
2333 2: The function has a definition.
2334 4: The function is a friend.
2336 The TEMPLATE_COUNT is the number of references to qualifying
2337 template classes that appeared in the name of the function. For
2340 template <class T> struct S { void f(); };
2343 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2344 classes are not counted in the TEMPLATE_COUNT, so that in
2346 template <class T> struct S {};
2347 template <> struct S<int> { void f(); }
2348 template <> void S<int>::f();
2350 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2351 invalid; there should be no template <>.)
2353 If the function is a specialization, it is marked as such via
2354 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2355 is set up correctly, and it is added to the list of specializations
2356 for that template. */
2359 check_explicit_specialization (tree declarator
,
2364 int have_def
= flags
& 2;
2365 int is_friend
= flags
& 4;
2366 int specialization
= 0;
2367 int explicit_instantiation
= 0;
2368 int member_specialization
= 0;
2369 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2370 tree dname
= DECL_NAME (decl
);
2375 if (!processing_specialization
)
2378 tsk
= tsk_excessive_parms
;
2381 tsk
= current_tmpl_spec_kind (template_count
);
2386 if (processing_specialization
)
2389 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2391 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2394 /* This could be something like:
2396 template <class T> void f(T);
2397 class S { friend void f<>(int); } */
2401 /* This case handles bogus declarations like template <>
2402 template <class T> void f<int>(); */
2404 error ("template-id %qD in declaration of primary template",
2411 case tsk_invalid_member_spec
:
2412 /* The error has already been reported in
2413 check_specialization_scope. */
2414 return error_mark_node
;
2416 case tsk_invalid_expl_inst
:
2417 error ("template parameter list used in explicit instantiation");
2423 error ("definition provided for explicit instantiation");
2425 explicit_instantiation
= 1;
2428 case tsk_excessive_parms
:
2429 case tsk_insufficient_parms
:
2430 if (tsk
== tsk_excessive_parms
)
2431 error ("too many template parameter lists in declaration of %qD",
2433 else if (template_header_count
)
2434 error("too few template parameter lists in declaration of %qD", decl
);
2436 error("explicit specialization of %qD must be introduced by "
2437 "%<template <>%>", decl
);
2441 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2443 member_specialization
= 1;
2449 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2451 /* This case handles bogus declarations like template <>
2452 template <class T> void f<int>(); */
2454 if (uses_template_parms (declarator
))
2455 error ("function template partial specialization %qD "
2456 "is not allowed", declarator
);
2458 error ("template-id %qD in declaration of primary template",
2463 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2464 /* This is a specialization of a member template, without
2465 specialization the containing class. Something like:
2467 template <class T> struct S {
2468 template <class U> void f (U);
2470 template <> template <class U> void S<int>::f(U) {}
2472 That's a specialization -- but of the entire template. */
2480 if (specialization
|| member_specialization
)
2482 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2483 for (; t
; t
= TREE_CHAIN (t
))
2484 if (TREE_PURPOSE (t
))
2486 permerror (input_location
,
2487 "default argument specified in explicit specialization");
2492 if (specialization
|| member_specialization
|| explicit_instantiation
)
2494 tree tmpl
= NULL_TREE
;
2495 tree targs
= NULL_TREE
;
2497 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2498 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2502 gcc_assert (identifier_p (declarator
));
2507 /* If there is no class context, the explicit instantiation
2508 must be at namespace scope. */
2509 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2511 /* Find the namespace binding, using the declaration
2513 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2515 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2517 error ("%qD is not a template function", dname
);
2518 fns
= error_mark_node
;
2522 tree fn
= OVL_CURRENT (fns
);
2523 if (!is_associated_namespace (CP_DECL_CONTEXT (decl
),
2524 CP_DECL_CONTEXT (fn
)))
2525 error ("%qD is not declared in %qD",
2526 decl
, current_namespace
);
2530 declarator
= lookup_template_function (fns
, NULL_TREE
);
2533 if (declarator
== error_mark_node
)
2534 return error_mark_node
;
2536 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2538 if (!explicit_instantiation
)
2539 /* A specialization in class scope. This is invalid,
2540 but the error will already have been flagged by
2541 check_specialization_scope. */
2542 return error_mark_node
;
2545 /* It's not valid to write an explicit instantiation in
2548 class C { template void f(); }
2550 This case is caught by the parser. However, on
2553 template class C { void f(); };
2555 (which is invalid) we can get here. The error will be
2562 else if (ctype
!= NULL_TREE
2563 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2565 /* Find the list of functions in ctype that have the same
2566 name as the declared function. */
2567 tree name
= TREE_OPERAND (declarator
, 0);
2568 tree fns
= NULL_TREE
;
2571 if (constructor_name_p (name
, ctype
))
2573 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2575 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2576 : !CLASSTYPE_DESTRUCTORS (ctype
))
2578 /* From [temp.expl.spec]:
2580 If such an explicit specialization for the member
2581 of a class template names an implicitly-declared
2582 special member function (clause _special_), the
2583 program is ill-formed.
2585 Similar language is found in [temp.explicit]. */
2586 error ("specialization of implicitly-declared special member function");
2587 return error_mark_node
;
2590 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2593 if (!DECL_CONV_FN_P (decl
))
2595 idx
= lookup_fnfields_1 (ctype
, name
);
2597 fns
= (*CLASSTYPE_METHOD_VEC (ctype
))[idx
];
2601 vec
<tree
, va_gc
> *methods
;
2604 /* For a type-conversion operator, we cannot do a
2605 name-based lookup. We might be looking for `operator
2606 int' which will be a specialization of `operator T'.
2607 So, we find *all* the conversion operators, and then
2608 select from them. */
2611 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2613 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2614 methods
->iterate (idx
, &ovl
);
2617 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2618 /* There are no more conversion functions. */
2621 /* Glue all these conversion functions together
2622 with those we already have. */
2623 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2624 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2628 if (fns
== NULL_TREE
)
2630 error ("no member function %qD declared in %qT", name
, ctype
);
2631 return error_mark_node
;
2634 TREE_OPERAND (declarator
, 0) = fns
;
2637 /* Figure out what exactly is being specialized at this point.
2638 Note that for an explicit instantiation, even one for a
2639 member function, we cannot tell apriori whether the
2640 instantiation is for a member template, or just a member
2641 function of a template class. Even if a member template is
2642 being instantiated, the member template arguments may be
2643 elided if they can be deduced from the rest of the
2645 tmpl
= determine_specialization (declarator
, decl
,
2647 member_specialization
,
2651 if (!tmpl
|| tmpl
== error_mark_node
)
2652 /* We couldn't figure out what this declaration was
2654 return error_mark_node
;
2657 tree gen_tmpl
= most_general_template (tmpl
);
2659 if (explicit_instantiation
)
2661 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2662 is done by do_decl_instantiation later. */
2664 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2665 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2667 if (arg_depth
> parm_depth
)
2669 /* If TMPL is not the most general template (for
2670 example, if TMPL is a friend template that is
2671 injected into namespace scope), then there will
2672 be too many levels of TARGS. Remove some of them
2677 new_targs
= make_tree_vec (parm_depth
);
2678 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2679 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2680 = TREE_VEC_ELT (targs
, i
);
2684 return instantiate_template (tmpl
, targs
, tf_error
);
2687 /* If we thought that the DECL was a member function, but it
2688 turns out to be specializing a static member function,
2689 make DECL a static member function as well. */
2690 if (DECL_STATIC_FUNCTION_P (tmpl
)
2691 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2692 revert_static_member_fn (decl
);
2694 /* If this is a specialization of a member template of a
2695 template class, we want to return the TEMPLATE_DECL, not
2696 the specialization of it. */
2697 if (tsk
== tsk_template
)
2699 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
2700 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2701 DECL_INITIAL (result
) = NULL_TREE
;
2705 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2706 DECL_SOURCE_LOCATION (result
)
2707 = DECL_SOURCE_LOCATION (decl
);
2708 /* We want to use the argument list specified in the
2709 definition, not in the original declaration. */
2710 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
2711 for (parm
= DECL_ARGUMENTS (result
); parm
;
2712 parm
= DECL_CHAIN (parm
))
2713 DECL_CONTEXT (parm
) = result
;
2715 return register_specialization (tmpl
, gen_tmpl
, targs
,
2719 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2720 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
2722 /* Inherit default function arguments from the template
2723 DECL is specializing. */
2724 copy_default_args_to_explicit_spec (decl
);
2726 /* This specialization has the same protection as the
2727 template it specializes. */
2728 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
2729 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
2731 /* 7.1.1-1 [dcl.stc]
2733 A storage-class-specifier shall not be specified in an
2734 explicit specialization...
2736 The parser rejects these, so unless action is taken here,
2737 explicit function specializations will always appear with
2740 The action recommended by the C++ CWG in response to C++
2741 defect report 605 is to make the storage class and linkage
2742 of the explicit specialization match the templated function:
2744 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2746 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
2748 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
2749 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
2751 /* This specialization has the same linkage and visibility as
2752 the function template it specializes. */
2753 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
2754 if (! TREE_PUBLIC (decl
))
2756 DECL_INTERFACE_KNOWN (decl
) = 1;
2757 DECL_NOT_REALLY_EXTERN (decl
) = 1;
2759 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
2760 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
2762 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
2763 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
2767 /* If DECL is a friend declaration, declared using an
2768 unqualified name, the namespace associated with DECL may
2769 have been set incorrectly. For example, in:
2771 template <typename T> void f(T);
2773 struct S { friend void f<int>(int); }
2776 we will have set the DECL_CONTEXT for the friend
2777 declaration to N, rather than to the global namespace. */
2778 if (DECL_NAMESPACE_SCOPE_P (decl
))
2779 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
2781 if (is_friend
&& !have_def
)
2782 /* This is not really a declaration of a specialization.
2783 It's just the name of an instantiation. But, it's not
2784 a request for an instantiation, either. */
2785 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
2787 /* Register this specialization so that we can find it
2789 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
, 0);
2791 /* A 'structor should already have clones. */
2792 gcc_assert (decl
== error_mark_node
2793 || !(DECL_CONSTRUCTOR_P (decl
)
2794 || DECL_DESTRUCTOR_P (decl
))
2795 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
2802 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2803 parameters. These are represented in the same format used for
2804 DECL_TEMPLATE_PARMS. */
2807 comp_template_parms (const_tree parms1
, const_tree parms2
)
2812 if (parms1
== parms2
)
2815 for (p1
= parms1
, p2
= parms2
;
2816 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2817 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2819 tree t1
= TREE_VALUE (p1
);
2820 tree t2
= TREE_VALUE (p2
);
2823 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2824 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2826 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2829 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2831 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2832 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2834 /* If either of the template parameters are invalid, assume
2835 they match for the sake of error recovery. */
2836 if (error_operand_p (parm1
) || error_operand_p (parm2
))
2839 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2842 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2843 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2844 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2846 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2851 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2852 /* One set of parameters has more parameters lists than the
2859 /* Determine whether PARM is a parameter pack. */
2862 template_parameter_pack_p (const_tree parm
)
2864 /* Determine if we have a non-type template parameter pack. */
2865 if (TREE_CODE (parm
) == PARM_DECL
)
2866 return (DECL_TEMPLATE_PARM_P (parm
)
2867 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2868 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
2869 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
2871 /* If this is a list of template parameters, we could get a
2872 TYPE_DECL or a TEMPLATE_DECL. */
2873 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2874 parm
= TREE_TYPE (parm
);
2876 /* Otherwise it must be a type template parameter. */
2877 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2878 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2879 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2882 /* Determine if T is a function parameter pack. */
2885 function_parameter_pack_p (const_tree t
)
2887 if (t
&& TREE_CODE (t
) == PARM_DECL
)
2888 return DECL_PACK_P (t
);
2892 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2893 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2896 get_function_template_decl (const_tree primary_func_tmpl_inst
)
2898 if (! primary_func_tmpl_inst
2899 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
2900 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
2903 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
2906 /* Return true iff the function parameter PARAM_DECL was expanded
2907 from the function parameter pack PACK. */
2910 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
2912 if (DECL_ARTIFICIAL (param_decl
)
2913 || !function_parameter_pack_p (pack
))
2916 /* The parameter pack and its pack arguments have the same
2918 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
2921 /* Determine whether ARGS describes a variadic template args list,
2922 i.e., one that is terminated by a template argument pack. */
2925 template_args_variadic_p (tree args
)
2930 if (args
== NULL_TREE
)
2933 args
= INNERMOST_TEMPLATE_ARGS (args
);
2934 nargs
= TREE_VEC_LENGTH (args
);
2939 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
2941 return ARGUMENT_PACK_P (last_parm
);
2944 /* Generate a new name for the parameter pack name NAME (an
2945 IDENTIFIER_NODE) that incorporates its */
2948 make_ith_pack_parameter_name (tree name
, int i
)
2950 /* Munge the name to include the parameter index. */
2951 #define NUMBUF_LEN 128
2952 char numbuf
[NUMBUF_LEN
];
2956 if (name
== NULL_TREE
)
2958 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
2959 newname_len
= IDENTIFIER_LENGTH (name
)
2960 + strlen (numbuf
) + 2;
2961 newname
= (char*)alloca (newname_len
);
2962 snprintf (newname
, newname_len
,
2963 "%s#%i", IDENTIFIER_POINTER (name
), i
);
2964 return get_identifier (newname
);
2967 /* Return true if T is a primary function, class or alias template
2971 primary_template_instantiation_p (const_tree t
)
2976 if (TREE_CODE (t
) == FUNCTION_DECL
)
2977 return DECL_LANG_SPECIFIC (t
)
2978 && DECL_TEMPLATE_INSTANTIATION (t
)
2979 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
2980 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
2981 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
2982 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
2983 else if (alias_template_specialization_p (t
))
2988 /* Return true if PARM is a template template parameter. */
2991 template_template_parameter_p (const_tree parm
)
2993 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
2996 /* Return true iff PARM is a DECL representing a type template
3000 template_type_parameter_p (const_tree parm
)
3003 && (TREE_CODE (parm
) == TYPE_DECL
3004 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3005 && DECL_TEMPLATE_PARM_P (parm
));
3008 /* Return the template parameters of T if T is a
3009 primary template instantiation, NULL otherwise. */
3012 get_primary_template_innermost_parameters (const_tree t
)
3014 tree parms
= NULL
, template_info
= NULL
;
3016 if ((template_info
= get_template_info (t
))
3017 && primary_template_instantiation_p (t
))
3018 parms
= INNERMOST_TEMPLATE_PARMS
3019 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3024 /* Return the template parameters of the LEVELth level from the full list
3025 of template parameters PARMS. */
3028 get_template_parms_at_level (tree parms
, int level
)
3032 || TREE_CODE (parms
) != TREE_LIST
3033 || level
> TMPL_PARMS_DEPTH (parms
))
3036 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3037 if (TMPL_PARMS_DEPTH (p
) == level
)
3043 /* Returns the template arguments of T if T is a template instantiation,
3047 get_template_innermost_arguments (const_tree t
)
3049 tree args
= NULL
, template_info
= NULL
;
3051 if ((template_info
= get_template_info (t
))
3052 && TI_ARGS (template_info
))
3053 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3058 /* Return the argument pack elements of T if T is a template argument pack,
3062 get_template_argument_pack_elems (const_tree t
)
3064 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3065 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3068 return ARGUMENT_PACK_ARGS (t
);
3071 /* Structure used to track the progress of find_parameter_packs_r. */
3072 struct find_parameter_pack_data
3074 /* TREE_LIST that will contain all of the parameter packs found by
3076 tree
* parameter_packs
;
3078 /* Set of AST nodes that have been visited by the traversal. */
3079 struct pointer_set_t
*visited
;
3082 /* Identifies all of the argument packs that occur in a template
3083 argument and appends them to the TREE_LIST inside DATA, which is a
3084 find_parameter_pack_data structure. This is a subroutine of
3085 make_pack_expansion and uses_parameter_packs. */
3087 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3090 struct find_parameter_pack_data
* ppd
=
3091 (struct find_parameter_pack_data
*)data
;
3092 bool parameter_pack_p
= false;
3094 /* Handle type aliases/typedefs. */
3095 if (TYPE_ALIAS_P (t
))
3097 if (TYPE_TEMPLATE_INFO (t
))
3098 cp_walk_tree (&TYPE_TI_ARGS (t
),
3099 &find_parameter_packs_r
,
3105 /* Identify whether this is a parameter pack or not. */
3106 switch (TREE_CODE (t
))
3108 case TEMPLATE_PARM_INDEX
:
3109 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3110 parameter_pack_p
= true;
3113 case TEMPLATE_TYPE_PARM
:
3114 t
= TYPE_MAIN_VARIANT (t
);
3115 case TEMPLATE_TEMPLATE_PARM
:
3116 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3117 parameter_pack_p
= true;
3122 if (DECL_PACK_P (t
))
3124 /* We don't want to walk into the type of a PARM_DECL,
3125 because we don't want to see the type parameter pack. */
3127 parameter_pack_p
= true;
3131 /* Look through a lambda capture proxy to the field pack. */
3133 if (DECL_HAS_VALUE_EXPR_P (t
))
3135 tree v
= DECL_VALUE_EXPR (t
);
3137 &find_parameter_packs_r
,
3144 parameter_pack_p
= true;
3147 /* Not a parameter pack. */
3151 if (parameter_pack_p
)
3153 /* Add this parameter pack to the list. */
3154 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3158 cp_walk_tree (&TYPE_CONTEXT (t
),
3159 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3161 /* This switch statement will return immediately if we don't find a
3163 switch (TREE_CODE (t
))
3165 case TEMPLATE_PARM_INDEX
:
3168 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3169 /* Check the template itself. */
3170 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3171 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3172 /* Check the template arguments. */
3173 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3178 case TEMPLATE_TYPE_PARM
:
3179 case TEMPLATE_TEMPLATE_PARM
:
3186 if (TYPE_PTRMEMFUNC_P (t
))
3192 if (TYPE_TEMPLATE_INFO (t
))
3193 cp_walk_tree (&TYPE_TI_ARGS (t
),
3194 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3201 cp_walk_tree (&TREE_TYPE (t
),
3202 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3206 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3211 case TYPE_PACK_EXPANSION
:
3212 case EXPR_PACK_EXPANSION
:
3217 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3222 case IDENTIFIER_NODE
:
3223 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3235 /* Determines if the expression or type T uses any parameter packs. */
3237 uses_parameter_packs (tree t
)
3239 tree parameter_packs
= NULL_TREE
;
3240 struct find_parameter_pack_data ppd
;
3241 ppd
.parameter_packs
= ¶meter_packs
;
3242 ppd
.visited
= pointer_set_create ();
3243 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3244 pointer_set_destroy (ppd
.visited
);
3245 return parameter_packs
!= NULL_TREE
;
3248 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3249 representation a base-class initializer into a parameter pack
3250 expansion. If all goes well, the resulting node will be an
3251 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3254 make_pack_expansion (tree arg
)
3257 tree parameter_packs
= NULL_TREE
;
3258 bool for_types
= false;
3259 struct find_parameter_pack_data ppd
;
3261 if (!arg
|| arg
== error_mark_node
)
3264 if (TREE_CODE (arg
) == TREE_LIST
)
3266 /* The only time we will see a TREE_LIST here is for a base
3267 class initializer. In this case, the TREE_PURPOSE will be a
3268 _TYPE node (representing the base class expansion we're
3269 initializing) and the TREE_VALUE will be a TREE_LIST
3270 containing the initialization arguments.
3272 The resulting expansion looks somewhat different from most
3273 expansions. Rather than returning just one _EXPANSION, we
3274 return a TREE_LIST whose TREE_PURPOSE is a
3275 TYPE_PACK_EXPANSION containing the bases that will be
3276 initialized. The TREE_VALUE will be identical to the
3277 original TREE_VALUE, which is a list of arguments that will
3278 be passed to each base. We do not introduce any new pack
3279 expansion nodes into the TREE_VALUE (although it is possible
3280 that some already exist), because the TREE_PURPOSE and
3281 TREE_VALUE all need to be expanded together with the same
3282 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3283 resulting TREE_PURPOSE will mention the parameter packs in
3284 both the bases and the arguments to the bases. */
3287 tree parameter_packs
= NULL_TREE
;
3289 /* Determine which parameter packs will be used by the base
3291 ppd
.visited
= pointer_set_create ();
3292 ppd
.parameter_packs
= ¶meter_packs
;
3293 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3296 if (parameter_packs
== NULL_TREE
)
3298 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3299 pointer_set_destroy (ppd
.visited
);
3300 return error_mark_node
;
3303 if (TREE_VALUE (arg
) != void_type_node
)
3305 /* Collect the sets of parameter packs used in each of the
3306 initialization arguments. */
3307 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3309 /* Determine which parameter packs will be expanded in this
3311 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3316 pointer_set_destroy (ppd
.visited
);
3318 /* Create the pack expansion type for the base type. */
3319 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3320 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3321 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3323 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3324 they will rarely be compared to anything. */
3325 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3327 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3330 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3333 /* Build the PACK_EXPANSION_* node. */
3335 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3336 : make_node (EXPR_PACK_EXPANSION
);
3337 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3338 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3340 /* Propagate type and const-expression information. */
3341 TREE_TYPE (result
) = TREE_TYPE (arg
);
3342 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3345 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3346 they will rarely be compared to anything. */
3347 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3349 /* Determine which parameter packs will be expanded. */
3350 ppd
.parameter_packs
= ¶meter_packs
;
3351 ppd
.visited
= pointer_set_create ();
3352 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3353 pointer_set_destroy (ppd
.visited
);
3355 /* Make sure we found some parameter packs. */
3356 if (parameter_packs
== NULL_TREE
)
3359 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3361 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3362 return error_mark_node
;
3364 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3366 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3371 /* Checks T for any "bare" parameter packs, which have not yet been
3372 expanded, and issues an error if any are found. This operation can
3373 only be done on full expressions or types (e.g., an expression
3374 statement, "if" condition, etc.), because we could have expressions like:
3376 foo(f(g(h(args)))...)
3378 where "args" is a parameter pack. check_for_bare_parameter_packs
3379 should not be called for the subexpressions args, h(args),
3380 g(h(args)), or f(g(h(args))), because we would produce erroneous
3383 Returns TRUE and emits an error if there were bare parameter packs,
3384 returns FALSE otherwise. */
3386 check_for_bare_parameter_packs (tree t
)
3388 tree parameter_packs
= NULL_TREE
;
3389 struct find_parameter_pack_data ppd
;
3391 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3394 if (TREE_CODE (t
) == TYPE_DECL
)
3397 ppd
.parameter_packs
= ¶meter_packs
;
3398 ppd
.visited
= pointer_set_create ();
3399 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3400 pointer_set_destroy (ppd
.visited
);
3402 if (parameter_packs
)
3404 error ("parameter packs not expanded with %<...%>:");
3405 while (parameter_packs
)
3407 tree pack
= TREE_VALUE (parameter_packs
);
3408 tree name
= NULL_TREE
;
3410 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3411 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3412 name
= TYPE_NAME (pack
);
3413 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3414 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3416 name
= DECL_NAME (pack
);
3419 inform (input_location
, " %qD", name
);
3421 inform (input_location
, " <anonymous>");
3423 parameter_packs
= TREE_CHAIN (parameter_packs
);
3432 /* Expand any parameter packs that occur in the template arguments in
3435 expand_template_argument_pack (tree args
)
3437 tree result_args
= NULL_TREE
;
3438 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3439 int num_result_args
= -1;
3440 int non_default_args_count
= -1;
3442 /* First, determine if we need to expand anything, and the number of
3443 slots we'll need. */
3444 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3446 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3447 if (arg
== NULL_TREE
)
3449 if (ARGUMENT_PACK_P (arg
))
3451 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3452 if (num_result_args
< 0)
3453 num_result_args
= in_arg
+ num_packed
;
3455 num_result_args
+= num_packed
;
3459 if (num_result_args
>= 0)
3464 /* If no expansion is necessary, we're done. */
3465 if (num_result_args
< 0)
3468 /* Expand arguments. */
3469 result_args
= make_tree_vec (num_result_args
);
3470 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3471 non_default_args_count
=
3472 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3473 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3475 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3476 if (ARGUMENT_PACK_P (arg
))
3478 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3479 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3480 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3481 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3482 if (non_default_args_count
> 0)
3483 non_default_args_count
+= num_packed
- 1;
3487 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3491 if (non_default_args_count
>= 0)
3492 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3496 /* Checks if DECL shadows a template parameter.
3498 [temp.local]: A template-parameter shall not be redeclared within its
3499 scope (including nested scopes).
3501 Emits an error and returns TRUE if the DECL shadows a parameter,
3502 returns FALSE otherwise. */
3505 check_template_shadow (tree decl
)
3509 /* If we're not in a template, we can't possibly shadow a template
3511 if (!current_template_parms
)
3514 /* Figure out what we're shadowing. */
3515 if (TREE_CODE (decl
) == OVERLOAD
)
3516 decl
= OVL_CURRENT (decl
);
3517 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3519 /* If there's no previous binding for this name, we're not shadowing
3520 anything, let alone a template parameter. */
3524 /* If we're not shadowing a template parameter, we're done. Note
3525 that OLDDECL might be an OVERLOAD (or perhaps even an
3526 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3528 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3531 /* We check for decl != olddecl to avoid bogus errors for using a
3532 name inside a class. We check TPFI to avoid duplicate errors for
3533 inline member templates. */
3535 || (DECL_TEMPLATE_PARM_P (decl
)
3536 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
3539 /* Don't complain about the injected class name, as we've already
3540 complained about the class itself. */
3541 if (DECL_SELF_REFERENCE_P (decl
))
3544 error ("declaration of %q+#D", decl
);
3545 error (" shadows template parm %q+#D", olddecl
);
3549 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3550 ORIG_LEVEL, DECL, and TYPE. */
3553 build_template_parm_index (int index
,
3559 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3560 TEMPLATE_PARM_IDX (t
) = index
;
3561 TEMPLATE_PARM_LEVEL (t
) = level
;
3562 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3563 TEMPLATE_PARM_DECL (t
) = decl
;
3564 TREE_TYPE (t
) = type
;
3565 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3566 TREE_READONLY (t
) = TREE_READONLY (decl
);
3571 /* Find the canonical type parameter for the given template type
3572 parameter. Returns the canonical type parameter, which may be TYPE
3573 if no such parameter existed. */
3576 canonical_type_parameter (tree type
)
3579 int idx
= TEMPLATE_TYPE_IDX (type
);
3580 if (!canonical_template_parms
)
3581 vec_alloc (canonical_template_parms
, idx
+1);
3583 while (canonical_template_parms
->length () <= (unsigned)idx
)
3584 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3586 list
= (*canonical_template_parms
)[idx
];
3587 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3588 list
= TREE_CHAIN (list
);
3591 return TREE_VALUE (list
);
3594 (*canonical_template_parms
)[idx
]
3595 = tree_cons (NULL_TREE
, type
,
3596 (*canonical_template_parms
)[idx
]);
3601 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3602 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3603 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3604 new one is created. */
3607 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3608 tsubst_flags_t complain
)
3610 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3611 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3612 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3613 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3615 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3618 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3619 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3620 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3621 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3622 DECL_ARTIFICIAL (decl
) = 1;
3623 SET_DECL_TEMPLATE_PARM_P (decl
);
3625 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3626 TEMPLATE_PARM_LEVEL (index
) - levels
,
3627 TEMPLATE_PARM_ORIG_LEVEL (index
),
3629 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3630 TEMPLATE_PARM_PARAMETER_PACK (t
)
3631 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3633 /* Template template parameters need this. */
3634 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3635 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3636 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
)),
3640 return TEMPLATE_PARM_DESCENDANTS (index
);
3643 /* Process information from new template parameter PARM and append it
3644 to the LIST being built. This new parameter is a non-type
3645 parameter iff IS_NON_TYPE is true. This new parameter is a
3646 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3650 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
3651 bool is_non_type
, bool is_parameter_pack
)
3657 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
3658 defval
= TREE_PURPOSE (parm
);
3662 tree p
= tree_last (list
);
3664 if (p
&& TREE_VALUE (p
) != error_mark_node
)
3667 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
3668 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
3670 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
3678 parm
= TREE_VALUE (parm
);
3680 SET_DECL_TEMPLATE_PARM_P (parm
);
3682 if (TREE_TYPE (parm
) != error_mark_node
)
3686 The top-level cv-qualifiers on the template-parameter are
3687 ignored when determining its type. */
3688 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
3689 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
3690 TREE_TYPE (parm
) = error_mark_node
;
3691 else if (uses_parameter_packs (TREE_TYPE (parm
))
3692 && !is_parameter_pack
3693 /* If we're in a nested template parameter list, the template
3694 template parameter could be a parameter pack. */
3695 && processing_template_parmlist
== 1)
3697 /* This template parameter is not a parameter pack, but it
3698 should be. Complain about "bare" parameter packs. */
3699 check_for_bare_parameter_packs (TREE_TYPE (parm
));
3701 /* Recover by calling this a parameter pack. */
3702 is_parameter_pack
= true;
3706 /* A template parameter is not modifiable. */
3707 TREE_CONSTANT (parm
) = 1;
3708 TREE_READONLY (parm
) = 1;
3709 decl
= build_decl (parm_loc
,
3710 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
3711 TREE_CONSTANT (decl
) = 1;
3712 TREE_READONLY (decl
) = 1;
3713 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
3714 = build_template_parm_index (idx
, processing_template_decl
,
3715 processing_template_decl
,
3716 decl
, TREE_TYPE (parm
));
3718 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
3719 = is_parameter_pack
;
3724 parm
= TREE_VALUE (TREE_VALUE (parm
));
3726 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
3728 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
3729 /* This is for distinguishing between real templates and template
3730 template parameters */
3731 TREE_TYPE (parm
) = t
;
3732 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
3737 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
3738 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3739 decl
= build_decl (parm_loc
,
3740 TYPE_DECL
, parm
, t
);
3743 TYPE_NAME (t
) = decl
;
3744 TYPE_STUB_DECL (t
) = decl
;
3746 TEMPLATE_TYPE_PARM_INDEX (t
)
3747 = build_template_parm_index (idx
, processing_template_decl
,
3748 processing_template_decl
,
3749 decl
, TREE_TYPE (parm
));
3750 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
3751 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
3753 DECL_ARTIFICIAL (decl
) = 1;
3754 SET_DECL_TEMPLATE_PARM_P (decl
);
3756 parm
= build_tree_list (defval
, parm
);
3757 return chainon (list
, parm
);
3760 /* The end of a template parameter list has been reached. Process the
3761 tree list into a parameter vector, converting each parameter into a more
3762 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3766 end_template_parm_list (tree parms
)
3770 tree saved_parmlist
= make_tree_vec (list_length (parms
));
3772 current_template_parms
3773 = tree_cons (size_int (processing_template_decl
),
3774 saved_parmlist
, current_template_parms
);
3776 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3778 next
= TREE_CHAIN (parm
);
3779 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3780 TREE_CHAIN (parm
) = NULL_TREE
;
3783 --processing_template_parmlist
;
3785 return saved_parmlist
;
3788 /* end_template_decl is called after a template declaration is seen. */
3791 end_template_decl (void)
3793 reset_specialization ();
3795 if (! processing_template_decl
)
3798 /* This matches the pushlevel in begin_template_parm_list. */
3801 --processing_template_decl
;
3802 current_template_parms
= TREE_CHAIN (current_template_parms
);
3805 /* Takes a TREE_LIST representing a template parameter and convert it
3806 into an argument suitable to be passed to the type substitution
3807 functions. Note that If the TREE_LIST contains an error_mark
3808 node, the returned argument is error_mark_node. */
3811 template_parm_to_arg (tree t
)
3815 || TREE_CODE (t
) != TREE_LIST
)
3818 if (error_operand_p (TREE_VALUE (t
)))
3819 return error_mark_node
;
3823 if (TREE_CODE (t
) == TYPE_DECL
3824 || TREE_CODE (t
) == TEMPLATE_DECL
)
3828 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3830 /* Turn this argument into a TYPE_ARGUMENT_PACK
3831 with a single element, which expands T. */
3832 tree vec
= make_tree_vec (1);
3833 #ifdef ENABLE_CHECKING
3834 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3835 (vec
, TREE_VEC_LENGTH (vec
));
3837 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3839 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
3840 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3845 t
= DECL_INITIAL (t
);
3847 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3849 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3850 with a single element, which expands T. */
3851 tree vec
= make_tree_vec (1);
3852 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3853 #ifdef ENABLE_CHECKING
3854 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3855 (vec
, TREE_VEC_LENGTH (vec
));
3857 t
= convert_from_reference (t
);
3858 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3860 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3861 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3862 TREE_TYPE (t
) = type
;
3865 t
= convert_from_reference (t
);
3870 /* Given a set of template parameters, return them as a set of template
3871 arguments. The template parameters are represented as a TREE_VEC, in
3872 the form documented in cp-tree.h for template arguments. */
3875 template_parms_to_args (tree parms
)
3878 tree args
= NULL_TREE
;
3879 int length
= TMPL_PARMS_DEPTH (parms
);
3882 /* If there is only one level of template parameters, we do not
3883 create a TREE_VEC of TREE_VECs. Instead, we return a single
3884 TREE_VEC containing the arguments. */
3886 args
= make_tree_vec (length
);
3888 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
3890 tree a
= copy_node (TREE_VALUE (header
));
3893 TREE_TYPE (a
) = NULL_TREE
;
3894 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
3895 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
3897 #ifdef ENABLE_CHECKING
3898 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
3902 TREE_VEC_ELT (args
, --l
) = a
;
3907 if (length
> 1 && TREE_VEC_ELT (args
, 0) == NULL_TREE
)
3908 /* This can happen for template parms of a template template
3911 template<template<class T, class U> class TT> struct S;
3913 Consider the level of the parms of TT; T and U both have
3914 level 2; TT has no template parm of level 1. So in this case
3915 the first element of full_template_args is NULL_TREE. If we
3916 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
3917 of 2. This will make tsubst wrongly consider that T and U
3918 have level 1. Instead, let's create a dummy vector as the
3919 first element of full_template_args so that TMPL_ARGS_DEPTH
3920 returns the correct depth for args. */
3921 TREE_VEC_ELT (args
, 0) = make_tree_vec (1);
3925 /* Within the declaration of a template, return the currently active
3926 template parameters as an argument TREE_VEC. */
3929 current_template_args (void)
3931 return template_parms_to_args (current_template_parms
);
3934 /* Update the declared TYPE by doing any lookups which were thought to be
3935 dependent, but are not now that we know the SCOPE of the declarator. */
3938 maybe_update_decl_type (tree orig_type
, tree scope
)
3940 tree type
= orig_type
;
3942 if (type
== NULL_TREE
)
3945 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3946 type
= TREE_TYPE (type
);
3948 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
3949 && dependent_type_p (type
)
3950 /* Don't bother building up the args in this case. */
3951 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
3953 /* tsubst in the args corresponding to the template parameters,
3954 including auto if present. Most things will be unchanged, but
3955 make_typename_type and tsubst_qualified_id will resolve
3956 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3957 tree args
= current_template_args ();
3958 tree auto_node
= type_uses_auto (type
);
3962 tree auto_vec
= make_tree_vec (1);
3963 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
3964 args
= add_to_template_args (args
, auto_vec
);
3966 pushed
= push_scope (scope
);
3967 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
3972 if (type
== error_mark_node
)
3975 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3977 if (same_type_p (type
, TREE_TYPE (orig_type
)))
3980 type
= TYPE_NAME (type
);
3985 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3986 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3987 a member template. Used by push_template_decl below. */
3990 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
3992 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
3993 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
3994 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
3995 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
3996 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4001 struct template_parm_data
4003 /* The level of the template parameters we are currently
4007 /* The index of the specialization argument we are currently
4011 /* An array whose size is the number of template parameters. The
4012 elements are nonzero if the parameter has been used in any one
4013 of the arguments processed so far. */
4016 /* An array whose size is the number of template arguments. The
4017 elements are nonzero if the argument makes use of template
4018 parameters of this level. */
4019 int* arg_uses_template_parms
;
4022 /* Subroutine of push_template_decl used to see if each template
4023 parameter in a partial specialization is used in the explicit
4024 argument list. If T is of the LEVEL given in DATA (which is
4025 treated as a template_parm_data*), then DATA->PARMS is marked
4029 mark_template_parm (tree t
, void* data
)
4033 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4035 template_parm_level_and_index (t
, &level
, &idx
);
4037 if (level
== tpd
->level
)
4039 tpd
->parms
[idx
] = 1;
4040 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4043 /* Return zero so that for_each_template_parm will continue the
4044 traversal of the tree; we want to mark *every* template parm. */
4048 /* Process the partial specialization DECL. */
4051 process_partial_specialization (tree decl
)
4053 tree type
= TREE_TYPE (decl
);
4054 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
4055 tree specargs
= CLASSTYPE_TI_ARGS (type
);
4056 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4057 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4060 int nargs
= TREE_VEC_LENGTH (inner_args
);
4063 bool did_error_intro
= false;
4064 struct template_parm_data tpd
;
4065 struct template_parm_data tpd2
;
4067 gcc_assert (current_template_parms
);
4069 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4070 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4072 /* We check that each of the template parameters given in the
4073 partial specialization is used in the argument list to the
4074 specialization. For example:
4076 template <class T> struct S;
4077 template <class T> struct S<T*>;
4079 The second declaration is OK because `T*' uses the template
4080 parameter T, whereas
4082 template <class T> struct S<int>;
4084 is no good. Even trickier is:
4095 The S2<T> declaration is actually invalid; it is a
4096 full-specialization. Of course,
4099 struct S2<T (*)(U)>;
4101 or some such would have been OK. */
4102 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4103 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4104 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4106 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4107 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4108 for (i
= 0; i
< nargs
; ++i
)
4110 tpd
.current_arg
= i
;
4111 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4112 &mark_template_parm
,
4115 /*include_nondeduced_p=*/false);
4117 for (i
= 0; i
< ntparms
; ++i
)
4118 if (tpd
.parms
[i
] == 0)
4120 /* One of the template parms was not used in a deduced context in the
4122 if (!did_error_intro
)
4124 error ("template parameters not deducible in "
4125 "partial specialization:");
4126 did_error_intro
= true;
4129 inform (input_location
, " %qD",
4130 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4133 if (did_error_intro
)
4134 return error_mark_node
;
4136 /* [temp.class.spec]
4138 The argument list of the specialization shall not be identical to
4139 the implicit argument list of the primary template. */
4140 if (comp_template_args
4142 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
4144 error ("partial specialization %qT does not specialize any template arguments", type
);
4146 /* A partial specialization that replaces multiple parameters of the
4147 primary template with a pack expansion is less specialized for those
4149 if (nargs
< DECL_NTPARMS (maintmpl
))
4151 error ("partial specialization is not more specialized than the "
4152 "primary template because it replaces multiple parameters "
4153 "with a pack expansion");
4154 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4158 /* [temp.class.spec]
4160 A partially specialized non-type argument expression shall not
4161 involve template parameters of the partial specialization except
4162 when the argument expression is a simple identifier.
4164 The type of a template parameter corresponding to a specialized
4165 non-type argument shall not be dependent on a parameter of the
4168 Also, we verify that pack expansions only occur at the
4169 end of the argument list. */
4170 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4172 for (i
= 0; i
< nargs
; ++i
)
4174 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4175 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4176 tree packed_args
= NULL_TREE
;
4179 if (ARGUMENT_PACK_P (arg
))
4181 /* Extract the arguments from the argument pack. We'll be
4182 iterating over these in the following loop. */
4183 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4184 len
= TREE_VEC_LENGTH (packed_args
);
4187 for (j
= 0; j
< len
; j
++)
4190 /* Get the Jth argument in the parameter pack. */
4191 arg
= TREE_VEC_ELT (packed_args
, j
);
4193 if (PACK_EXPANSION_P (arg
))
4195 /* Pack expansions must come at the end of the
4197 if ((packed_args
&& j
< len
- 1)
4198 || (!packed_args
&& i
< nargs
- 1))
4200 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4201 error ("parameter pack argument %qE must be at the "
4202 "end of the template argument list", arg
);
4204 error ("parameter pack argument %qT must be at the "
4205 "end of the template argument list", arg
);
4209 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4210 /* We only care about the pattern. */
4211 arg
= PACK_EXPANSION_PATTERN (arg
);
4213 if (/* These first two lines are the `non-type' bit. */
4215 && TREE_CODE (arg
) != TEMPLATE_DECL
4216 /* This next two lines are the `argument expression is not just a
4217 simple identifier' condition and also the `specialized
4218 non-type argument' bit. */
4219 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4220 && !(REFERENCE_REF_P (arg
)
4221 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4223 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4224 || (packed_args
&& uses_template_parms (arg
)))
4225 error ("template argument %qE involves template parameter(s)",
4229 /* Look at the corresponding template parameter,
4230 marking which template parameters its type depends
4232 tree type
= TREE_TYPE (parm
);
4236 /* We haven't yet initialized TPD2. Do so now. */
4237 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4238 /* The number of parameters here is the number in the
4239 main template, which, as checked in the assertion
4241 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4243 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4246 /* Mark the template parameters. But this time, we're
4247 looking for the template parameters of the main
4248 template, not in the specialization. */
4249 tpd2
.current_arg
= i
;
4250 tpd2
.arg_uses_template_parms
[i
] = 0;
4251 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4252 for_each_template_parm (type
,
4253 &mark_template_parm
,
4256 /*include_nondeduced_p=*/false);
4258 if (tpd2
.arg_uses_template_parms
[i
])
4260 /* The type depended on some template parameters.
4261 If they are fully specialized in the
4262 specialization, that's OK. */
4265 for (j
= 0; j
< nargs
; ++j
)
4266 if (tpd2
.parms
[j
] != 0
4267 && tpd
.arg_uses_template_parms
[j
])
4270 error_n (input_location
, count
,
4271 "type %qT of template argument %qE depends "
4272 "on a template parameter",
4273 "type %qT of template argument %qE depends "
4274 "on template parameters",
4283 /* We should only get here once. */
4284 gcc_assert (!COMPLETE_TYPE_P (type
));
4286 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4287 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4288 TREE_TYPE (tmpl
) = type
;
4289 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4290 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4291 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4292 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4294 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4295 = tree_cons (specargs
, tmpl
,
4296 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4297 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4299 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4300 inst
= TREE_CHAIN (inst
))
4302 tree inst_type
= TREE_VALUE (inst
);
4303 if (COMPLETE_TYPE_P (inst_type
)
4304 && CLASSTYPE_IMPLICIT_INSTANTIATION (inst_type
))
4306 tree spec
= most_specialized_class (inst_type
, tf_none
);
4307 if (spec
&& TREE_TYPE (spec
) == type
)
4308 permerror (input_location
,
4309 "partial specialization of %qT after instantiation "
4310 "of %qT", type
, inst_type
);
4317 /* PARM is a template parameter of some form; return the corresponding
4318 TEMPLATE_PARM_INDEX. */
4321 get_template_parm_index (tree parm
)
4323 if (TREE_CODE (parm
) == PARM_DECL
4324 || TREE_CODE (parm
) == CONST_DECL
)
4325 parm
= DECL_INITIAL (parm
);
4326 else if (TREE_CODE (parm
) == TYPE_DECL
4327 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4328 parm
= TREE_TYPE (parm
);
4329 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4330 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4331 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4332 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4336 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4337 parameter packs used by the template parameter PARM. */
4340 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4342 /* A type parm can't refer to another parm. */
4343 if (TREE_CODE (parm
) == TYPE_DECL
)
4345 else if (TREE_CODE (parm
) == PARM_DECL
)
4347 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4352 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4354 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4355 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4356 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4359 /* PARM is a template parameter pack. Return any parameter packs used in
4360 its type or the type of any of its template parameters. If there are
4361 any such packs, it will be instantiated into a fixed template parameter
4362 list by partial instantiation rather than be fully deduced. */
4365 fixed_parameter_pack_p (tree parm
)
4367 /* This can only be true in a member template. */
4368 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4370 /* This can only be true for a parameter pack. */
4371 if (!template_parameter_pack_p (parm
))
4373 /* A type parm can't refer to another parm. */
4374 if (TREE_CODE (parm
) == TYPE_DECL
)
4377 tree parameter_packs
= NULL_TREE
;
4378 struct find_parameter_pack_data ppd
;
4379 ppd
.parameter_packs
= ¶meter_packs
;
4380 ppd
.visited
= pointer_set_create ();
4382 fixed_parameter_pack_p_1 (parm
, &ppd
);
4384 pointer_set_destroy (ppd
.visited
);
4385 return parameter_packs
;
4388 /* Check that a template declaration's use of default arguments and
4389 parameter packs is not invalid. Here, PARMS are the template
4390 parameters. IS_PRIMARY is true if DECL is the thing declared by
4391 a primary template. IS_PARTIAL is true if DECL is a partial
4394 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4395 declaration (but not a definition); 1 indicates a declaration, 2
4396 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4397 emitted for extraneous default arguments.
4399 Returns TRUE if there were no errors found, FALSE otherwise. */
4402 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4403 bool is_partial
, int is_friend_decl
)
4406 int last_level_to_check
;
4408 bool no_errors
= true;
4412 A default template-argument shall not be specified in a
4413 function template declaration or a function template definition, nor
4414 in the template-parameter-list of the definition of a member of a
4417 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
4418 /* You can't have a function template declaration in a local
4419 scope, nor you can you define a member of a class template in a
4423 if (TREE_CODE (decl
) == TYPE_DECL
4425 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4426 /* A lambda doesn't have an explicit declaration; don't complain
4427 about the parms of the enclosing class. */
4430 if (current_class_type
4431 && !TYPE_BEING_DEFINED (current_class_type
)
4432 && DECL_LANG_SPECIFIC (decl
)
4433 && DECL_DECLARES_FUNCTION_P (decl
)
4434 /* If this is either a friend defined in the scope of the class
4435 or a member function. */
4436 && (DECL_FUNCTION_MEMBER_P (decl
)
4437 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4438 : DECL_FRIEND_CONTEXT (decl
)
4439 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4441 /* And, if it was a member function, it really was defined in
4442 the scope of the class. */
4443 && (!DECL_FUNCTION_MEMBER_P (decl
)
4444 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4445 /* We already checked these parameters when the template was
4446 declared, so there's no need to do it again now. This function
4447 was defined in class scope, but we're processing its body now
4448 that the class is complete. */
4451 /* Core issue 226 (C++0x only): the following only applies to class
4454 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4458 If a template-parameter has a default template-argument, all
4459 subsequent template-parameters shall have a default
4460 template-argument supplied. */
4461 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4463 tree inner_parms
= TREE_VALUE (parm_level
);
4464 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4465 int seen_def_arg_p
= 0;
4468 for (i
= 0; i
< ntparms
; ++i
)
4470 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4472 if (parm
== error_mark_node
)
4475 if (TREE_PURPOSE (parm
))
4477 else if (seen_def_arg_p
4478 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4480 error ("no default argument for %qD", TREE_VALUE (parm
));
4481 /* For better subsequent error-recovery, we indicate that
4482 there should have been a default argument. */
4483 TREE_PURPOSE (parm
) = error_mark_node
;
4486 else if (!is_partial
4488 /* Don't complain about an enclosing partial
4490 && parm_level
== parms
4491 && TREE_CODE (decl
) == TYPE_DECL
4493 && template_parameter_pack_p (TREE_VALUE (parm
))
4494 /* A fixed parameter pack will be partially
4495 instantiated into a fixed length list. */
4496 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4498 /* A primary class template can only have one
4499 parameter pack, at the end of the template
4502 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
4503 error ("parameter pack %qE must be at the end of the"
4504 " template parameter list", TREE_VALUE (parm
));
4506 error ("parameter pack %qT must be at the end of the"
4507 " template parameter list",
4508 TREE_TYPE (TREE_VALUE (parm
)));
4510 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4518 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4522 /* For an ordinary class template, default template arguments are
4523 allowed at the innermost level, e.g.:
4524 template <class T = int>
4526 but, in a partial specialization, they're not allowed even
4527 there, as we have in [temp.class.spec]:
4529 The template parameter list of a specialization shall not
4530 contain default template argument values.
4532 So, for a partial specialization, or for a function template
4533 (in C++98/C++03), we look at all of them. */
4536 /* But, for a primary class template that is not a partial
4537 specialization we look at all template parameters except the
4539 parms
= TREE_CHAIN (parms
);
4541 /* Figure out what error message to issue. */
4542 if (is_friend_decl
== 2)
4543 msg
= G_("default template arguments may not be used in function template "
4544 "friend re-declaration");
4545 else if (is_friend_decl
)
4546 msg
= G_("default template arguments may not be used in function template "
4547 "friend declarations");
4548 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4549 msg
= G_("default template arguments may not be used in function templates "
4550 "without -std=c++11 or -std=gnu++11");
4551 else if (is_partial
)
4552 msg
= G_("default template arguments may not be used in "
4553 "partial specializations");
4555 msg
= G_("default argument for template parameter for class enclosing %qD");
4557 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4558 /* If we're inside a class definition, there's no need to
4559 examine the parameters to the class itself. On the one
4560 hand, they will be checked when the class is defined, and,
4561 on the other, default arguments are valid in things like:
4562 template <class T = double>
4563 struct S { template <class U> void f(U); };
4564 Here the default argument for `S' has no bearing on the
4565 declaration of `f'. */
4566 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4568 /* Check everything. */
4569 last_level_to_check
= 0;
4571 for (parm_level
= parms
;
4572 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4573 parm_level
= TREE_CHAIN (parm_level
))
4575 tree inner_parms
= TREE_VALUE (parm_level
);
4579 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4580 for (i
= 0; i
< ntparms
; ++i
)
4582 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4585 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4590 if (is_friend_decl
== 2)
4597 /* Clear out the default argument so that we are not
4599 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
4603 /* At this point, if we're still interested in issuing messages,
4604 they must apply to classes surrounding the object declared. */
4606 msg
= G_("default argument for template parameter for class "
4613 /* Worker for push_template_decl_real, called via
4614 for_each_template_parm. DATA is really an int, indicating the
4615 level of the parameters we are interested in. If T is a template
4616 parameter of that level, return nonzero. */
4619 template_parm_this_level_p (tree t
, void* data
)
4621 int this_level
= *(int *)data
;
4624 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4625 level
= TEMPLATE_PARM_LEVEL (t
);
4627 level
= TEMPLATE_TYPE_LEVEL (t
);
4628 return level
== this_level
;
4631 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4632 parameters given by current_template_args, or reuses a
4633 previously existing one, if appropriate. Returns the DECL, or an
4634 equivalent one, if it is replaced via a call to duplicate_decls.
4636 If IS_FRIEND is true, DECL is a friend declaration. */
4639 push_template_decl_real (tree decl
, bool is_friend
)
4647 int new_template_p
= 0;
4648 /* True if the template is a member template, in the sense of
4650 bool member_template_p
= false;
4652 if (decl
== error_mark_node
|| !current_template_parms
)
4653 return error_mark_node
;
4655 /* See if this is a partial specialization. */
4656 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
4657 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
4658 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
4660 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
4664 /* For a friend, we want the context of the friend function, not
4665 the type of which it is a friend. */
4666 ctx
= CP_DECL_CONTEXT (decl
);
4667 else if (CP_DECL_CONTEXT (decl
)
4668 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4669 /* In the case of a virtual function, we want the class in which
4671 ctx
= CP_DECL_CONTEXT (decl
);
4673 /* Otherwise, if we're currently defining some class, the DECL
4674 is assumed to be a member of the class. */
4675 ctx
= current_scope ();
4677 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
4680 if (!DECL_CONTEXT (decl
))
4681 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
4683 /* See if this is a primary template. */
4684 if (is_friend
&& ctx
4685 && uses_template_parms_level (ctx
, processing_template_decl
))
4686 /* A friend template that specifies a class context, i.e.
4687 template <typename T> friend void A<T>::f();
4691 is_primary
= template_parm_scope_p ();
4695 if (DECL_CLASS_SCOPE_P (decl
))
4696 member_template_p
= true;
4697 if (TREE_CODE (decl
) == TYPE_DECL
4698 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
4700 error ("template class without a name");
4701 return error_mark_node
;
4703 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
4705 if (DECL_DESTRUCTOR_P (decl
))
4709 A destructor shall not be a member template. */
4710 error ("destructor %qD declared as member template", decl
);
4711 return error_mark_node
;
4713 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
4714 && (!prototype_p (TREE_TYPE (decl
))
4715 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
4716 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
4717 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
4718 == void_list_node
)))
4720 /* [basic.stc.dynamic.allocation]
4722 An allocation function can be a function
4723 template. ... Template allocation functions shall
4724 have two or more parameters. */
4725 error ("invalid template declaration of %qD", decl
);
4726 return error_mark_node
;
4729 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4730 && CLASS_TYPE_P (TREE_TYPE (decl
)))
4732 else if (TREE_CODE (decl
) == TYPE_DECL
4733 && TYPE_DECL_ALIAS_P (decl
))
4734 /* alias-declaration */
4735 gcc_assert (!DECL_ARTIFICIAL (decl
));
4738 error ("template declaration of %q#D", decl
);
4739 return error_mark_node
;
4743 /* Check to see that the rules regarding the use of default
4744 arguments are not being violated. */
4745 check_default_tmpl_args (decl
, current_template_parms
,
4746 is_primary
, is_partial
, /*is_friend_decl=*/0);
4748 /* Ensure that there are no parameter packs in the type of this
4749 declaration that have not been expanded. */
4750 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4752 /* Check each of the arguments individually to see if there are
4753 any bare parameter packs. */
4754 tree type
= TREE_TYPE (decl
);
4755 tree arg
= DECL_ARGUMENTS (decl
);
4756 tree argtype
= TYPE_ARG_TYPES (type
);
4758 while (arg
&& argtype
)
4760 if (!DECL_PACK_P (arg
)
4761 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
4763 /* This is a PARM_DECL that contains unexpanded parameter
4764 packs. We have already complained about this in the
4765 check_for_bare_parameter_packs call, so just replace
4766 these types with ERROR_MARK_NODE. */
4767 TREE_TYPE (arg
) = error_mark_node
;
4768 TREE_VALUE (argtype
) = error_mark_node
;
4771 arg
= DECL_CHAIN (arg
);
4772 argtype
= TREE_CHAIN (argtype
);
4775 /* Check for bare parameter packs in the return type and the
4776 exception specifiers. */
4777 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
4778 /* Errors were already issued, set return type to int
4779 as the frontend doesn't expect error_mark_node as
4781 TREE_TYPE (type
) = integer_type_node
;
4782 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
4783 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
4785 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
4786 && TYPE_DECL_ALIAS_P (decl
))
4787 ? DECL_ORIGINAL_TYPE (decl
)
4788 : TREE_TYPE (decl
)))
4790 TREE_TYPE (decl
) = error_mark_node
;
4791 return error_mark_node
;
4795 return process_partial_specialization (decl
);
4797 args
= current_template_args ();
4800 || TREE_CODE (ctx
) == FUNCTION_DECL
4801 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
4802 || (TREE_CODE (decl
) == TYPE_DECL
4803 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4804 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
4806 if (DECL_LANG_SPECIFIC (decl
)
4807 && DECL_TEMPLATE_INFO (decl
)
4808 && DECL_TI_TEMPLATE (decl
))
4809 tmpl
= DECL_TI_TEMPLATE (decl
);
4810 /* If DECL is a TYPE_DECL for a class-template, then there won't
4811 be DECL_LANG_SPECIFIC. The information equivalent to
4812 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4813 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4814 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
4815 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
4817 /* Since a template declaration already existed for this
4818 class-type, we must be redeclaring it here. Make sure
4819 that the redeclaration is valid. */
4820 redeclare_class_template (TREE_TYPE (decl
),
4821 current_template_parms
);
4822 /* We don't need to create a new TEMPLATE_DECL; just use the
4823 one we already had. */
4824 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
4828 tmpl
= build_template_decl (decl
, current_template_parms
,
4832 if (DECL_LANG_SPECIFIC (decl
)
4833 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4835 /* A specialization of a member template of a template
4837 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4838 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
4839 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
4845 tree a
, t
, current
, parms
;
4847 tree tinfo
= get_template_info (decl
);
4851 error ("template definition of non-template %q#D", decl
);
4852 return error_mark_node
;
4855 tmpl
= TI_TEMPLATE (tinfo
);
4857 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
4858 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
4859 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4860 && DECL_MEMBER_TEMPLATE_P (tmpl
))
4864 /* The declaration is a specialization of a member
4865 template, declared outside the class. Therefore, the
4866 innermost template arguments will be NULL, so we
4867 replace them with the arguments determined by the
4868 earlier call to check_explicit_specialization. */
4869 args
= DECL_TI_ARGS (decl
);
4872 = build_template_decl (decl
, current_template_parms
,
4874 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
4875 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
4876 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
4877 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
4878 DECL_TEMPLATE_INFO (new_tmpl
)
4879 = build_template_info (tmpl
, args
);
4881 register_specialization (new_tmpl
,
4882 most_general_template (tmpl
),
4888 /* Make sure the template headers we got make sense. */
4890 parms
= DECL_TEMPLATE_PARMS (tmpl
);
4891 i
= TMPL_PARMS_DEPTH (parms
);
4892 if (TMPL_ARGS_DEPTH (args
) != i
)
4894 error ("expected %d levels of template parms for %q#D, got %d",
4895 i
, decl
, TMPL_ARGS_DEPTH (args
));
4896 DECL_INTERFACE_KNOWN (decl
) = 1;
4897 return error_mark_node
;
4900 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
4902 a
= TMPL_ARGS_LEVEL (args
, i
);
4903 t
= INNERMOST_TEMPLATE_PARMS (parms
);
4905 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
4907 if (current
== decl
)
4908 error ("got %d template parameters for %q#D",
4909 TREE_VEC_LENGTH (a
), decl
);
4911 error ("got %d template parameters for %q#T",
4912 TREE_VEC_LENGTH (a
), current
);
4913 error (" but %d required", TREE_VEC_LENGTH (t
));
4914 /* Avoid crash in import_export_decl. */
4915 DECL_INTERFACE_KNOWN (decl
) = 1;
4916 return error_mark_node
;
4919 if (current
== decl
)
4921 else if (current
== NULL_TREE
)
4922 /* Can happen in erroneous input. */
4925 current
= get_containing_scope (current
);
4928 /* Check that the parms are used in the appropriate qualifying scopes
4929 in the declarator. */
4930 if (!comp_template_args
4932 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
4935 template arguments to %qD do not match original template %qD",
4936 decl
, DECL_TEMPLATE_RESULT (tmpl
));
4937 if (!uses_template_parms (TI_ARGS (tinfo
)))
4938 inform (input_location
, "use template<> for an explicit specialization");
4939 /* Avoid crash in import_export_decl. */
4940 DECL_INTERFACE_KNOWN (decl
) = 1;
4941 return error_mark_node
;
4945 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4946 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
4948 /* Push template declarations for global functions and types. Note
4949 that we do not try to push a global template friend declared in a
4950 template class; such a thing may well depend on the template
4951 parameters of the class. */
4952 if (new_template_p
&& !ctx
4953 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
4955 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
4956 if (tmpl
== error_mark_node
)
4957 return error_mark_node
;
4959 /* Hide template friend classes that haven't been declared yet. */
4960 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
4962 DECL_ANTICIPATED (tmpl
) = 1;
4963 DECL_FRIEND_P (tmpl
) = 1;
4969 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
4972 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
4973 if (DECL_CONV_FN_P (tmpl
))
4975 int depth
= TMPL_PARMS_DEPTH (parms
);
4977 /* It is a conversion operator. See if the type converted to
4978 depends on innermost template operands. */
4980 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
4982 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
4985 /* Give template template parms a DECL_CONTEXT of the template
4986 for which they are a parameter. */
4987 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
4988 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
4990 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
4991 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
4992 DECL_CONTEXT (parm
) = tmpl
;
4996 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4997 back to its most general template. If TMPL is a specialization,
4998 ARGS may only have the innermost set of arguments. Add the missing
4999 argument levels if necessary. */
5000 if (DECL_TEMPLATE_INFO (tmpl
))
5001 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5003 info
= build_template_info (tmpl
, args
);
5005 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5006 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5009 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5010 retrofit_lang_decl (decl
);
5011 if (DECL_LANG_SPECIFIC (decl
))
5012 DECL_TEMPLATE_INFO (decl
) = info
;
5015 return DECL_TEMPLATE_RESULT (tmpl
);
5019 push_template_decl (tree decl
)
5021 return push_template_decl_real (decl
, false);
5024 /* FN is an inheriting constructor that inherits from the constructor
5025 template INHERITED; turn FN into a constructor template with a matching
5029 add_inherited_template_parms (tree fn
, tree inherited
)
5032 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5033 inner_parms
= copy_node (inner_parms
);
5035 = tree_cons (size_int (processing_template_decl
+ 1),
5036 inner_parms
, current_template_parms
);
5037 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5038 tree args
= template_parms_to_args (parms
);
5039 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5040 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5041 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5042 DECL_ARTIFICIAL (tmpl
) = true;
5043 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5047 /* Called when a class template TYPE is redeclared with the indicated
5048 template PARMS, e.g.:
5050 template <class T> struct S;
5051 template <class T> struct S {}; */
5054 redeclare_class_template (tree type
, tree parms
)
5060 if (!TYPE_TEMPLATE_INFO (type
))
5062 error ("%qT is not a template type", type
);
5066 tmpl
= TYPE_TI_TEMPLATE (type
);
5067 if (!PRIMARY_TEMPLATE_P (tmpl
))
5068 /* The type is nested in some template class. Nothing to worry
5069 about here; there are no new template parameters for the nested
5075 error ("template specifiers not specified in declaration of %qD",
5080 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5081 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5083 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5085 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5086 "redeclared with %d template parameter",
5087 "redeclared with %d template parameters",
5088 TREE_VEC_LENGTH (parms
));
5089 inform_n (input_location
, TREE_VEC_LENGTH (tmpl_parms
),
5090 "previous declaration %q+D used %d template parameter",
5091 "previous declaration %q+D used %d template parameters",
5092 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5096 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5103 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5104 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5107 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5108 if (error_operand_p (tmpl_parm
))
5111 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5112 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5113 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5115 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5117 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5118 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5119 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5120 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5121 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5122 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5123 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5124 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5125 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5127 error ("template parameter %q+#D", tmpl_parm
);
5128 error ("redeclared here as %q#D", parm
);
5132 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5134 /* We have in [temp.param]:
5136 A template-parameter may not be given default arguments
5137 by two different declarations in the same scope. */
5138 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5139 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5140 "original definition appeared here");
5144 if (parm_default
!= NULL_TREE
)
5145 /* Update the previous template parameters (which are the ones
5146 that will really count) with the new default value. */
5147 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5148 else if (tmpl_default
!= NULL_TREE
)
5149 /* Update the new parameters, too; they'll be used as the
5150 parameters for any members. */
5151 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5157 /* Simplify EXPR if it is a non-dependent expression. Returns the
5158 (possibly simplified) expression. */
5161 fold_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5163 if (expr
== NULL_TREE
)
5166 /* If we're in a template, but EXPR isn't value dependent, simplify
5167 it. We're supposed to treat:
5169 template <typename T> void f(T[1 + 1]);
5170 template <typename T> void f(T[2]);
5172 as two declarations of the same function, for example. */
5173 if (processing_template_decl
5174 && !instantiation_dependent_expression_p (expr
)
5175 && potential_constant_expression (expr
))
5177 HOST_WIDE_INT saved_processing_template_decl
;
5179 saved_processing_template_decl
= processing_template_decl
;
5180 processing_template_decl
= 0;
5181 expr
= tsubst_copy_and_build (expr
,
5184 /*in_decl=*/NULL_TREE
,
5185 /*function_p=*/false,
5186 /*integral_constant_expression_p=*/true);
5187 processing_template_decl
= saved_processing_template_decl
;
5193 fold_non_dependent_expr (tree expr
)
5195 return fold_non_dependent_expr_sfinae (expr
, tf_error
);
5198 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5199 template declaration, or a TYPE_DECL for an alias declaration. */
5202 alias_type_or_template_p (tree t
)
5206 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5209 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5210 || DECL_ALIAS_TEMPLATE_P (t
));
5213 /* Return TRUE iff is a specialization of an alias template. */
5216 alias_template_specialization_p (const_tree t
)
5222 && TYPE_TEMPLATE_INFO (t
)
5223 && PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (t
))
5224 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (t
)));
5227 /* Return the number of innermost template parameters in TMPL. */
5230 num_innermost_template_parms (tree tmpl
)
5232 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5233 return TREE_VEC_LENGTH (parms
);
5236 /* Return either TMPL or another template that it is equivalent to under DR
5237 1286: An alias that just changes the name of a template is equivalent to
5238 the other template. */
5241 get_underlying_template (tree tmpl
)
5243 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5244 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5246 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5247 if (TYPE_TEMPLATE_INFO (result
))
5249 tree sub
= TYPE_TI_TEMPLATE (result
);
5250 if (PRIMARY_TEMPLATE_P (sub
)
5251 && (num_innermost_template_parms (tmpl
)
5252 == num_innermost_template_parms (sub
)))
5254 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5255 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5256 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5258 /* The alias type is equivalent to the pattern of the
5259 underlying template, so strip the alias. */
5269 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5270 must be a function or a pointer-to-function type, as specified
5271 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5272 and check that the resulting function has external linkage. */
5275 convert_nontype_argument_function (tree type
, tree expr
,
5276 tsubst_flags_t complain
)
5280 linkage_kind linkage
;
5282 fn
= instantiate_type (type
, fns
, tf_none
);
5283 if (fn
== error_mark_node
)
5284 return error_mark_node
;
5287 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5288 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5289 if (BASELINK_P (fn_no_ptr
))
5290 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5292 /* [temp.arg.nontype]/1
5294 A template-argument for a non-type, non-template template-parameter
5297 -- the address of an object or function with external [C++11: or
5298 internal] linkage. */
5300 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5302 if (complain
& tf_error
)
5304 error ("%qE is not a valid template argument for type %qT",
5306 if (TYPE_PTR_P (type
))
5307 error ("it must be the address of a function with "
5308 "external linkage");
5310 error ("it must be the name of a function with "
5311 "external linkage");
5316 linkage
= decl_linkage (fn_no_ptr
);
5317 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5319 if (complain
& tf_error
)
5321 if (cxx_dialect
>= cxx11
)
5322 error ("%qE is not a valid template argument for type %qT "
5323 "because %qD has no linkage",
5324 expr
, type
, fn_no_ptr
);
5326 error ("%qE is not a valid template argument for type %qT "
5327 "because %qD does not have external linkage",
5328 expr
, type
, fn_no_ptr
);
5336 /* Subroutine of convert_nontype_argument.
5337 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5338 Emit an error otherwise. */
5341 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5342 tsubst_flags_t complain
)
5345 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5347 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5349 if (complain
& tf_error
)
5351 error ("%qE is not a valid template argument for type %qT",
5353 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5358 /* Returns TRUE iff the address of OP is value-dependent.
5360 14.6.2.4 [temp.dep.temp]:
5361 A non-integral non-type template-argument is dependent if its type is
5362 dependent or it has either of the following forms
5365 and contains a nested-name-specifier which specifies a class-name that
5366 names a dependent type.
5368 We generalize this to just say that the address of a member of a
5369 dependent class is value-dependent; the above doesn't cover the
5370 address of a static data member named with an unqualified-id. */
5373 has_value_dependent_address (tree op
)
5375 /* We could use get_inner_reference here, but there's no need;
5376 this is only relevant for template non-type arguments, which
5377 can only be expressed as &id-expression. */
5380 tree ctx
= CP_DECL_CONTEXT (op
);
5381 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5388 /* The next set of functions are used for providing helpful explanatory
5389 diagnostics for failed overload resolution. Their messages should be
5390 indented by two spaces for consistency with the messages in
5394 unify_success (bool /*explain_p*/)
5400 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5403 inform (input_location
,
5404 " couldn't deduce template parameter %qD", parm
);
5409 unify_invalid (bool /*explain_p*/)
5415 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5418 inform (input_location
,
5419 " types %qT and %qT have incompatible cv-qualifiers",
5425 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5428 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5433 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5436 inform (input_location
,
5437 " template parameter %qD is not a parameter pack, but "
5444 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5447 inform (input_location
,
5448 " template argument %qE does not match "
5449 "pointer-to-member constant %qE",
5455 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5458 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5463 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5466 inform (input_location
,
5467 " inconsistent parameter pack deduction with %qT and %qT",
5473 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5478 inform (input_location
,
5479 " deduced conflicting types for parameter %qT (%qT and %qT)",
5480 parm
, first
, second
);
5482 inform (input_location
,
5483 " deduced conflicting values for non-type parameter "
5484 "%qE (%qE and %qE)", parm
, first
, second
);
5490 unify_vla_arg (bool explain_p
, tree arg
)
5493 inform (input_location
,
5494 " variable-sized array type %qT is not "
5495 "a valid template argument",
5501 unify_method_type_error (bool explain_p
, tree arg
)
5504 inform (input_location
,
5505 " member function type %qT is not a valid template argument",
5511 unify_arity (bool explain_p
, int have
, int wanted
)
5514 inform_n (input_location
, wanted
,
5515 " candidate expects %d argument, %d provided",
5516 " candidate expects %d arguments, %d provided",
5522 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5524 return unify_arity (explain_p
, have
, wanted
);
5528 unify_too_few_arguments (bool explain_p
, int have
, int wanted
)
5530 return unify_arity (explain_p
, have
, wanted
);
5534 unify_arg_conversion (bool explain_p
, tree to_type
,
5535 tree from_type
, tree arg
)
5538 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5539 " cannot convert %qE (type %qT) to type %qT",
5540 arg
, from_type
, to_type
);
5545 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5546 tree parm
, tree arg
)
5551 case tbr_ambiguous_baseclass
:
5552 inform (input_location
, " %qT is an ambiguous base class of %qT",
5556 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5563 unify_inconsistent_template_template_parameters (bool explain_p
)
5566 inform (input_location
,
5567 " template parameters of a template template argument are "
5568 "inconsistent with other deduced template arguments");
5573 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5576 inform (input_location
,
5577 " can't deduce a template for %qT from non-template type %qT",
5583 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5586 inform (input_location
,
5587 " template argument %qE does not match %qD", arg
, parm
);
5592 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5595 inform (input_location
,
5596 " could not resolve address from overloaded function %qE",
5601 /* Attempt to convert the non-type template parameter EXPR to the
5602 indicated TYPE. If the conversion is successful, return the
5603 converted value. If the conversion is unsuccessful, return
5604 NULL_TREE if we issued an error message, or error_mark_node if we
5605 did not. We issue error messages for out-and-out bad template
5606 parameters, but not simply because the conversion failed, since we
5607 might be just trying to do argument deduction. Both TYPE and EXPR
5608 must be non-dependent.
5610 The conversion follows the special rules described in
5611 [temp.arg.nontype], and it is much more strict than an implicit
5614 This function is called twice for each template argument (see
5615 lookup_template_class for a more accurate description of this
5616 problem). This means that we need to handle expressions which
5617 are not valid in a C++ source, but can be created from the
5618 first call (for instance, casts to perform conversions). These
5619 hacks can go away after we fix the double coercion problem. */
5622 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5626 /* Detect immediately string literals as invalid non-type argument.
5627 This special-case is not needed for correctness (we would easily
5628 catch this later), but only to provide better diagnostic for this
5629 common user mistake. As suggested by DR 100, we do not mention
5630 linkage issues in the diagnostic as this is not the point. */
5631 /* FIXME we're making this OK. */
5632 if (TREE_CODE (expr
) == STRING_CST
)
5634 if (complain
& tf_error
)
5635 error ("%qE is not a valid template argument for type %qT "
5636 "because string literals can never be used in this context",
5641 /* Add the ADDR_EXPR now for the benefit of
5642 value_dependent_expression_p. */
5643 if (TYPE_PTROBV_P (type
)
5644 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5646 expr
= decay_conversion (expr
, complain
);
5647 if (expr
== error_mark_node
)
5648 return error_mark_node
;
5651 /* If we are in a template, EXPR may be non-dependent, but still
5652 have a syntactic, rather than semantic, form. For example, EXPR
5653 might be a SCOPE_REF, rather than the VAR_DECL to which the
5654 SCOPE_REF refers. Preserving the qualifying scope is necessary
5655 so that access checking can be performed when the template is
5656 instantiated -- but here we need the resolved form so that we can
5657 convert the argument. */
5658 if (TYPE_REF_OBJ_P (type
)
5659 && has_value_dependent_address (expr
))
5660 /* If we want the address and it's value-dependent, don't fold. */;
5661 else if (!type_unknown_p (expr
))
5662 expr
= fold_non_dependent_expr_sfinae (expr
, complain
);
5663 if (error_operand_p (expr
))
5664 return error_mark_node
;
5665 expr_type
= TREE_TYPE (expr
);
5666 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5667 expr
= mark_lvalue_use (expr
);
5669 expr
= mark_rvalue_use (expr
);
5671 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5672 to a non-type argument of "nullptr". */
5673 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5674 expr
= convert (type
, expr
);
5676 /* In C++11, integral or enumeration non-type template arguments can be
5677 arbitrary constant expressions. Pointer and pointer to
5678 member arguments can be general constant expressions that evaluate
5679 to a null value, but otherwise still need to be of a specific form. */
5680 if (cxx_dialect
>= cxx11
)
5682 if (TREE_CODE (expr
) == PTRMEM_CST
)
5683 /* A PTRMEM_CST is already constant, and a valid template
5684 argument for a parameter of pointer to member type, we just want
5685 to leave it in that form rather than lower it to a
5687 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5688 expr
= maybe_constant_value (expr
);
5689 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5691 tree folded
= maybe_constant_value (expr
);
5692 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5693 : null_member_pointer_value_p (folded
))
5698 /* HACK: Due to double coercion, we can get a
5699 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5700 which is the tree that we built on the first call (see
5701 below when coercing to reference to object or to reference to
5702 function). We just strip everything and get to the arg.
5703 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5705 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5707 tree probe_type
, probe
= expr
;
5708 if (REFERENCE_REF_P (probe
))
5709 probe
= TREE_OPERAND (probe
, 0);
5710 probe_type
= TREE_TYPE (probe
);
5711 if (TREE_CODE (probe
) == NOP_EXPR
)
5713 /* ??? Maybe we could use convert_from_reference here, but we
5714 would need to relax its constraints because the NOP_EXPR
5715 could actually change the type to something more cv-qualified,
5716 and this is not folded by convert_from_reference. */
5717 tree addr
= TREE_OPERAND (probe
, 0);
5718 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5719 && TREE_CODE (addr
) == ADDR_EXPR
5720 && TYPE_PTR_P (TREE_TYPE (addr
))
5721 && (same_type_ignoring_top_level_qualifiers_p
5722 (TREE_TYPE (probe_type
),
5723 TREE_TYPE (TREE_TYPE (addr
)))))
5725 expr
= TREE_OPERAND (addr
, 0);
5726 expr_type
= TREE_TYPE (probe_type
);
5731 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5732 parameter is a pointer to object, through decay and
5733 qualification conversion. Let's strip everything. */
5734 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5738 if (TREE_CODE (probe
) == ADDR_EXPR
5739 && TYPE_PTR_P (TREE_TYPE (probe
)))
5741 /* Skip the ADDR_EXPR only if it is part of the decay for
5742 an array. Otherwise, it is part of the original argument
5743 in the source code. */
5744 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5745 probe
= TREE_OPERAND (probe
, 0);
5747 expr_type
= TREE_TYPE (expr
);
5751 /* [temp.arg.nontype]/5, bullet 1
5753 For a non-type template-parameter of integral or enumeration type,
5754 integral promotions (_conv.prom_) and integral conversions
5755 (_conv.integral_) are applied. */
5756 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5758 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5759 t
= maybe_constant_value (t
);
5760 if (t
!= error_mark_node
)
5763 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5764 return error_mark_node
;
5766 /* Notice that there are constant expressions like '4 % 0' which
5767 do not fold into integer constants. */
5768 if (TREE_CODE (expr
) != INTEGER_CST
)
5770 if (complain
& tf_error
)
5772 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
5773 if (processing_template_decl
5774 && !require_potential_constant_expression (expr
))
5776 expr
= cxx_constant_value (expr
);
5777 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
5778 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
5779 "in template argument for type %qT ", type
);
5780 if (expr
== error_mark_node
)
5782 /* else cxx_constant_value complained but gave us
5783 a real constant, so go ahead. */
5784 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
5790 /* Avoid typedef problems. */
5791 if (TREE_TYPE (expr
) != type
)
5792 expr
= fold_convert (type
, expr
);
5794 /* [temp.arg.nontype]/5, bullet 2
5796 For a non-type template-parameter of type pointer to object,
5797 qualification conversions (_conv.qual_) and the array-to-pointer
5798 conversion (_conv.array_) are applied. */
5799 else if (TYPE_PTROBV_P (type
))
5801 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5803 A template-argument for a non-type, non-template template-parameter
5804 shall be one of: [...]
5806 -- the name of a non-type template-parameter;
5807 -- the address of an object or function with external linkage, [...]
5808 expressed as "& id-expression" where the & is optional if the name
5809 refers to a function or array, or if the corresponding
5810 template-parameter is a reference.
5812 Here, we do not care about functions, as they are invalid anyway
5813 for a parameter of type pointer-to-object. */
5815 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
5816 /* Non-type template parameters are OK. */
5818 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5819 /* Null pointer values are OK in C++11. */;
5820 else if (TREE_CODE (expr
) != ADDR_EXPR
5821 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
5825 if (complain
& tf_error
)
5826 error ("%qD is not a valid template argument "
5827 "because %qD is a variable, not the address of "
5828 "a variable", expr
, expr
);
5831 if (POINTER_TYPE_P (expr_type
))
5833 if (complain
& tf_error
)
5834 error ("%qE is not a valid template argument for %qT "
5835 "because it is not the address of a variable",
5839 /* Other values, like integer constants, might be valid
5840 non-type arguments of some other type. */
5841 return error_mark_node
;
5847 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
5848 ? TREE_OPERAND (expr
, 0) : expr
);
5851 if (complain
& tf_error
)
5852 error ("%qE is not a valid template argument of type %qT "
5853 "because %qE is not a variable", expr
, type
, decl
);
5856 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
5858 if (complain
& tf_error
)
5859 error ("%qE is not a valid template argument of type %qT "
5860 "because %qD does not have external linkage",
5864 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
5866 if (complain
& tf_error
)
5867 error ("%qE is not a valid template argument of type %qT "
5868 "because %qD has no linkage", expr
, type
, decl
);
5873 expr
= decay_conversion (expr
, complain
);
5874 if (expr
== error_mark_node
)
5875 return error_mark_node
;
5877 expr
= perform_qualification_conversions (type
, expr
);
5878 if (expr
== error_mark_node
)
5879 return error_mark_node
;
5881 /* [temp.arg.nontype]/5, bullet 3
5883 For a non-type template-parameter of type reference to object, no
5884 conversions apply. The type referred to by the reference may be more
5885 cv-qualified than the (otherwise identical) type of the
5886 template-argument. The template-parameter is bound directly to the
5887 template-argument, which must be an lvalue. */
5888 else if (TYPE_REF_OBJ_P (type
))
5890 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
5892 return error_mark_node
;
5894 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
5896 if (complain
& tf_error
)
5897 error ("%qE is not a valid template argument for type %qT "
5898 "because of conflicts in cv-qualification", expr
, type
);
5902 if (!real_lvalue_p (expr
))
5904 if (complain
& tf_error
)
5905 error ("%qE is not a valid template argument for type %qT "
5906 "because it is not an lvalue", expr
, type
);
5910 /* [temp.arg.nontype]/1
5912 A template-argument for a non-type, non-template template-parameter
5913 shall be one of: [...]
5915 -- the address of an object or function with external linkage. */
5916 if (INDIRECT_REF_P (expr
)
5917 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
5919 expr
= TREE_OPERAND (expr
, 0);
5922 if (complain
& tf_error
)
5923 error ("%q#D is not a valid template argument for type %qT "
5924 "because a reference variable does not have a constant "
5925 "address", expr
, type
);
5932 if (complain
& tf_error
)
5933 error ("%qE is not a valid template argument for type %qT "
5934 "because it is not an object with external linkage",
5939 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
5941 if (complain
& tf_error
)
5942 error ("%qE is not a valid template argument for type %qT "
5943 "because object %qD has not external linkage",
5948 expr
= build_nop (type
, build_address (expr
));
5950 /* [temp.arg.nontype]/5, bullet 4
5952 For a non-type template-parameter of type pointer to function, only
5953 the function-to-pointer conversion (_conv.func_) is applied. If the
5954 template-argument represents a set of overloaded functions (or a
5955 pointer to such), the matching function is selected from the set
5957 else if (TYPE_PTRFN_P (type
))
5959 /* If the argument is a template-id, we might not have enough
5960 context information to decay the pointer. */
5961 if (!type_unknown_p (expr_type
))
5963 expr
= decay_conversion (expr
, complain
);
5964 if (expr
== error_mark_node
)
5965 return error_mark_node
;
5968 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5969 /* Null pointer values are OK in C++11. */
5970 return perform_qualification_conversions (type
, expr
);
5972 expr
= convert_nontype_argument_function (type
, expr
, complain
);
5973 if (!expr
|| expr
== error_mark_node
)
5976 /* [temp.arg.nontype]/5, bullet 5
5978 For a non-type template-parameter of type reference to function, no
5979 conversions apply. If the template-argument represents a set of
5980 overloaded functions, the matching function is selected from the set
5982 else if (TYPE_REFFN_P (type
))
5984 if (TREE_CODE (expr
) == ADDR_EXPR
)
5986 if (complain
& tf_error
)
5988 error ("%qE is not a valid template argument for type %qT "
5989 "because it is a pointer", expr
, type
);
5990 inform (input_location
, "try using %qE instead",
5991 TREE_OPERAND (expr
, 0));
5996 expr
= convert_nontype_argument_function (type
, expr
, complain
);
5997 if (!expr
|| expr
== error_mark_node
)
6000 expr
= build_nop (type
, build_address (expr
));
6002 /* [temp.arg.nontype]/5, bullet 6
6004 For a non-type template-parameter of type pointer to member function,
6005 no conversions apply. If the template-argument represents a set of
6006 overloaded member functions, the matching member function is selected
6007 from the set (_over.over_). */
6008 else if (TYPE_PTRMEMFUNC_P (type
))
6010 expr
= instantiate_type (type
, expr
, tf_none
);
6011 if (expr
== error_mark_node
)
6012 return error_mark_node
;
6014 /* [temp.arg.nontype] bullet 1 says the pointer to member
6015 expression must be a pointer-to-member constant. */
6016 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6017 return error_mark_node
;
6019 /* There is no way to disable standard conversions in
6020 resolve_address_of_overloaded_function (called by
6021 instantiate_type). It is possible that the call succeeded by
6022 converting &B::I to &D::I (where B is a base of D), so we need
6023 to reject this conversion here.
6025 Actually, even if there was a way to disable standard conversions,
6026 it would still be better to reject them here so that we can
6027 provide a superior diagnostic. */
6028 if (!same_type_p (TREE_TYPE (expr
), type
))
6030 if (complain
& tf_error
)
6032 error ("%qE is not a valid template argument for type %qT "
6033 "because it is of type %qT", expr
, type
,
6035 /* If we are just one standard conversion off, explain. */
6036 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6037 inform (input_location
,
6038 "standard conversions are not allowed in this context");
6043 /* [temp.arg.nontype]/5, bullet 7
6045 For a non-type template-parameter of type pointer to data member,
6046 qualification conversions (_conv.qual_) are applied. */
6047 else if (TYPE_PTRDATAMEM_P (type
))
6049 /* [temp.arg.nontype] bullet 1 says the pointer to member
6050 expression must be a pointer-to-member constant. */
6051 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6052 return error_mark_node
;
6054 expr
= perform_qualification_conversions (type
, expr
);
6055 if (expr
== error_mark_node
)
6058 else if (NULLPTR_TYPE_P (type
))
6060 if (expr
!= nullptr_node
)
6062 if (complain
& tf_error
)
6063 error ("%qE is not a valid template argument for type %qT "
6064 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6069 /* A template non-type parameter must be one of the above. */
6073 /* Sanity check: did we actually convert the argument to the
6075 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6076 (type
, TREE_TYPE (expr
)));
6080 /* Subroutine of coerce_template_template_parms, which returns 1 if
6081 PARM_PARM and ARG_PARM match using the rule for the template
6082 parameters of template template parameters. Both PARM and ARG are
6083 template parameters; the rest of the arguments are the same as for
6084 coerce_template_template_parms.
6087 coerce_template_template_parm (tree parm
,
6089 tsubst_flags_t complain
,
6093 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6094 || parm
== NULL_TREE
|| error_operand_p (parm
))
6097 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6100 switch (TREE_CODE (parm
))
6103 /* We encounter instantiations of templates like
6104 template <template <template <class> class> class TT>
6107 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6108 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6110 if (!coerce_template_template_parms
6111 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6117 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6118 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6119 /* Argument is a parameter pack but parameter is not. */
6124 /* The tsubst call is used to handle cases such as
6126 template <int> class C {};
6127 template <class T, template <T> class TT> class D {};
6130 i.e. the parameter list of TT depends on earlier parameters. */
6131 if (!uses_template_parms (TREE_TYPE (arg
))
6133 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6137 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6138 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6139 /* Argument is a parameter pack but parameter is not. */
6152 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6153 template template parameters. Both PARM_PARMS and ARG_PARMS are
6154 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6157 Consider the example:
6158 template <class T> class A;
6159 template<template <class U> class TT> class B;
6161 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6162 the parameters to A, and OUTER_ARGS contains A. */
6165 coerce_template_template_parms (tree parm_parms
,
6167 tsubst_flags_t complain
,
6171 int nparms
, nargs
, i
;
6175 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6176 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6178 nparms
= TREE_VEC_LENGTH (parm_parms
);
6179 nargs
= TREE_VEC_LENGTH (arg_parms
);
6181 /* Determine whether we have a parameter pack at the end of the
6182 template template parameter's template parameter list. */
6183 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6185 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6187 if (error_operand_p (parm
))
6190 switch (TREE_CODE (parm
))
6194 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6199 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6209 && !(variadic_p
&& nargs
>= nparms
- 1))
6212 /* Check all of the template parameters except the parameter pack at
6213 the end (if any). */
6214 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6216 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6217 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6220 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6221 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6223 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6231 /* Check each of the template parameters in the template
6232 argument against the template parameter pack at the end of
6233 the template template parameter. */
6234 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6237 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6239 for (; i
< nargs
; ++i
)
6241 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6244 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6246 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6255 /* Verifies that the deduced template arguments (in TARGS) for the
6256 template template parameters (in TPARMS) represent valid bindings,
6257 by comparing the template parameter list of each template argument
6258 to the template parameter list of its corresponding template
6259 template parameter, in accordance with DR150. This
6260 routine can only be called after all template arguments have been
6261 deduced. It will return TRUE if all of the template template
6262 parameter bindings are okay, FALSE otherwise. */
6264 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6266 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6269 /* We're dealing with template parms in this process. */
6270 ++processing_template_decl
;
6272 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6274 for (i
= 0; i
< ntparms
; ++i
)
6276 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6277 tree targ
= TREE_VEC_ELT (targs
, i
);
6279 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6281 tree packed_args
= NULL_TREE
;
6284 if (ARGUMENT_PACK_P (targ
))
6286 /* Look inside the argument pack. */
6287 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6288 len
= TREE_VEC_LENGTH (packed_args
);
6291 for (idx
= 0; idx
< len
; ++idx
)
6293 tree targ_parms
= NULL_TREE
;
6296 /* Extract the next argument from the argument
6298 targ
= TREE_VEC_ELT (packed_args
, idx
);
6300 if (PACK_EXPANSION_P (targ
))
6301 /* Look at the pattern of the pack expansion. */
6302 targ
= PACK_EXPANSION_PATTERN (targ
);
6304 /* Extract the template parameters from the template
6306 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6307 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6308 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6309 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6311 /* Verify that we can coerce the template template
6312 parameters from the template argument to the template
6313 parameter. This requires an exact match. */
6315 && !coerce_template_template_parms
6316 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6331 --processing_template_decl
;
6335 /* Since type attributes aren't mangled, we need to strip them from
6336 template type arguments. */
6339 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6342 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6344 mv
= TYPE_MAIN_VARIANT (arg
);
6345 arg
= strip_typedefs (arg
);
6346 if (TYPE_ALIGN (arg
) != TYPE_ALIGN (mv
)
6347 || TYPE_ATTRIBUTES (arg
) != TYPE_ATTRIBUTES (mv
))
6349 if (complain
& tf_warning
)
6350 warning (0, "ignoring attributes on template argument %qT", arg
);
6351 arg
= build_aligned_type (arg
, TYPE_ALIGN (mv
));
6352 arg
= cp_build_type_attribute_variant (arg
, TYPE_ATTRIBUTES (mv
));
6357 /* Convert the indicated template ARG as necessary to match the
6358 indicated template PARM. Returns the converted ARG, or
6359 error_mark_node if the conversion was unsuccessful. Error and
6360 warning messages are issued under control of COMPLAIN. This
6361 conversion is for the Ith parameter in the parameter list. ARGS is
6362 the full set of template arguments deduced so far. */
6365 convert_template_argument (tree parm
,
6368 tsubst_flags_t complain
,
6374 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6376 if (TREE_CODE (arg
) == TREE_LIST
6377 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6379 /* The template argument was the name of some
6380 member function. That's usually
6381 invalid, but static members are OK. In any
6382 case, grab the underlying fields/functions
6383 and issue an error later if required. */
6384 orig_arg
= TREE_VALUE (arg
);
6385 TREE_TYPE (arg
) = unknown_type_node
;
6390 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6391 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6392 || requires_tmpl_type
);
6394 /* When determining whether an argument pack expansion is a template,
6395 look at the pattern. */
6396 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6397 arg
= PACK_EXPANSION_PATTERN (arg
);
6399 /* Deal with an injected-class-name used as a template template arg. */
6400 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6402 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6403 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6405 if (cxx_dialect
>= cxx11
)
6406 /* OK under DR 1004. */;
6407 else if (complain
& tf_warning_or_error
)
6408 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6409 " used as template template argument", TYPE_NAME (arg
));
6410 else if (flag_pedantic_errors
)
6418 ((TREE_CODE (arg
) == TEMPLATE_DECL
6419 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6420 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6421 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6422 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6425 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6426 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6427 arg
= TYPE_STUB_DECL (arg
);
6429 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6431 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6432 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6434 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6436 if (complain
& tf_error
)
6437 error ("invalid use of destructor %qE as a type", orig_arg
);
6438 return error_mark_node
;
6441 permerror (input_location
,
6442 "to refer to a type member of a template parameter, "
6443 "use %<typename %E%>", orig_arg
);
6445 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6446 TREE_OPERAND (arg
, 1),
6452 if (is_type
!= requires_type
)
6456 if (complain
& tf_error
)
6458 error ("type/value mismatch at argument %d in template "
6459 "parameter list for %qD",
6462 error (" expected a constant of type %qT, got %qT",
6464 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6465 else if (requires_tmpl_type
)
6466 error (" expected a class template, got %qE", orig_arg
);
6468 error (" expected a type, got %qE", orig_arg
);
6471 return error_mark_node
;
6473 if (is_tmpl_type
^ requires_tmpl_type
)
6475 if (in_decl
&& (complain
& tf_error
))
6477 error ("type/value mismatch at argument %d in template "
6478 "parameter list for %qD",
6481 error (" expected a type, got %qT", DECL_NAME (arg
));
6483 error (" expected a class template, got %qT", orig_arg
);
6485 return error_mark_node
;
6490 if (requires_tmpl_type
)
6492 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6494 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6495 /* The number of argument required is not known yet.
6496 Just accept it for now. */
6497 val
= TREE_TYPE (arg
);
6500 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6503 /* Strip alias templates that are equivalent to another
6505 arg
= get_underlying_template (arg
);
6506 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6508 if (coerce_template_template_parms (parmparm
, argparm
,
6514 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6516 if (val
!= error_mark_node
)
6518 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6519 val
= TREE_TYPE (val
);
6520 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6521 val
= make_pack_expansion (val
);
6526 if (in_decl
&& (complain
& tf_error
))
6528 error ("type/value mismatch at argument %d in "
6529 "template parameter list for %qD",
6531 error (" expected a template of type %qD, got %qT",
6535 val
= error_mark_node
;
6541 /* We only form one instance of each template specialization.
6542 Therefore, if we use a non-canonical variant (i.e., a
6543 typedef), any future messages referring to the type will use
6544 the typedef, which is confusing if those future uses do not
6545 themselves also use the typedef. */
6547 val
= canonicalize_type_argument (val
, complain
);
6551 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6553 if (invalid_nontype_parm_type_p (t
, complain
))
6554 return error_mark_node
;
6556 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6558 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6562 /* Not sure if this is reachable, but it doesn't hurt
6564 error ("type mismatch in nontype parameter pack");
6565 val
= error_mark_node
;
6568 else if (!dependent_template_arg_p (orig_arg
)
6569 && !uses_template_parms (t
))
6570 /* We used to call digest_init here. However, digest_init
6571 will report errors, which we don't want when complain
6572 is zero. More importantly, digest_init will try too
6573 hard to convert things: for example, `0' should not be
6574 converted to pointer type at this point according to
6575 the standard. Accepting this is not merely an
6576 extension, since deciding whether or not these
6577 conversions can occur is part of determining which
6578 function template to call, or whether a given explicit
6579 argument specification is valid. */
6580 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6582 val
= strip_typedefs_expr (orig_arg
);
6584 if (val
== NULL_TREE
)
6585 val
= error_mark_node
;
6586 else if (val
== error_mark_node
&& (complain
& tf_error
))
6587 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6589 if (TREE_CODE (val
) == SCOPE_REF
)
6591 /* Strip typedefs from the SCOPE_REF. */
6592 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6593 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6595 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6596 QUALIFIED_NAME_IS_TEMPLATE (val
));
6603 /* Coerces the remaining template arguments in INNER_ARGS (from
6604 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6605 Returns the coerced argument pack. PARM_IDX is the position of this
6606 parameter in the template parameter list. ARGS is the original
6607 template argument list. */
6609 coerce_template_parameter_pack (tree parms
,
6617 tsubst_flags_t complain
)
6619 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6620 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6623 tree packed_parms
= NULL_TREE
;
6625 if (arg_idx
> nargs
)
6628 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6630 /* When the template parameter is a non-type template parameter pack
6631 or template template parameter pack whose type or template
6632 parameters use parameter packs, we know exactly how many arguments
6633 we are looking for. Build a vector of the instantiated decls for
6634 these template parameters in PACKED_PARMS. */
6635 /* We can't use make_pack_expansion here because it would interpret a
6636 _DECL as a use rather than a declaration. */
6637 tree decl
= TREE_VALUE (parm
);
6638 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6639 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6640 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6641 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6643 TREE_VEC_LENGTH (args
)--;
6644 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6645 TREE_VEC_LENGTH (args
)++;
6647 if (packed_parms
== error_mark_node
)
6648 return error_mark_node
;
6650 /* If we're doing a partial instantiation of a member template,
6651 verify that all of the types used for the non-type
6652 template parameter pack are, in fact, valid for non-type
6653 template parameters. */
6655 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6657 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6658 for (j
= 0; j
< len
; ++j
)
6660 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6661 if (invalid_nontype_parm_type_p (t
, complain
))
6662 return error_mark_node
;
6666 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6669 packed_args
= make_tree_vec (nargs
- arg_idx
);
6671 /* Convert the remaining arguments, which will be a part of the
6672 parameter pack "parm". */
6673 for (; arg_idx
< nargs
; ++arg_idx
)
6675 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6676 tree actual_parm
= TREE_VALUE (parm
);
6677 int pack_idx
= arg_idx
- parm_idx
;
6681 /* Once we've packed as many args as we have types, stop. */
6682 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6684 else if (PACK_EXPANSION_P (arg
))
6685 /* We don't know how many args we have yet, just
6686 use the unconverted ones for now. */
6689 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6692 if (arg
== error_mark_node
)
6694 if (complain
& tf_error
)
6695 error ("template argument %d is invalid", arg_idx
+ 1);
6698 arg
= convert_template_argument (actual_parm
,
6699 arg
, new_args
, complain
, parm_idx
,
6701 if (arg
== error_mark_node
)
6703 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6706 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6707 && TREE_VEC_LENGTH (packed_args
) > 0)
6709 if (complain
& tf_error
)
6710 error ("wrong number of template arguments (%d, should be %d)",
6711 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6712 return error_mark_node
;
6715 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6716 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6717 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6720 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6721 TREE_TYPE (argument_pack
)
6722 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6723 TREE_CONSTANT (argument_pack
) = 1;
6726 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6727 #ifdef ENABLE_CHECKING
6728 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6729 TREE_VEC_LENGTH (packed_args
));
6731 return argument_pack
;
6734 /* Returns the number of pack expansions in the template argument vector
6738 pack_expansion_args_count (tree args
)
6743 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6745 tree elt
= TREE_VEC_ELT (args
, i
);
6746 if (elt
&& PACK_EXPANSION_P (elt
))
6752 /* Convert all template arguments to their appropriate types, and
6753 return a vector containing the innermost resulting template
6754 arguments. If any error occurs, return error_mark_node. Error and
6755 warning messages are issued under control of COMPLAIN.
6757 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6758 for arguments not specified in ARGS. Otherwise, if
6759 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6760 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6761 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6765 coerce_template_parms (tree parms
,
6768 tsubst_flags_t complain
,
6769 bool require_all_args
,
6770 bool use_default_args
)
6772 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6773 tree orig_inner_args
;
6776 tree new_inner_args
;
6777 int saved_unevaluated_operand
;
6778 int saved_inhibit_evaluation_warnings
;
6780 /* When used as a boolean value, indicates whether this is a
6781 variadic template parameter list. Since it's an int, we can also
6782 subtract it from nparms to get the number of non-variadic
6785 int variadic_args_p
= 0;
6786 int post_variadic_parms
= 0;
6788 if (args
== error_mark_node
)
6789 return error_mark_node
;
6791 nparms
= TREE_VEC_LENGTH (parms
);
6793 /* Determine if there are any parameter packs. */
6794 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
6796 tree tparm
= TREE_VALUE (TREE_VEC_ELT (parms
, parm_idx
));
6798 ++post_variadic_parms
;
6799 if (template_parameter_pack_p (tparm
))
6803 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
6804 /* If there are no parameters that follow a parameter pack, we need to
6805 expand any argument packs so that we can deduce a parameter pack from
6806 some non-packed args followed by an argument pack, as in variadic85.C.
6807 If there are such parameters, we need to leave argument packs intact
6808 so the arguments are assigned properly. This can happen when dealing
6809 with a nested class inside a partial specialization of a class
6810 template, as in variadic92.C, or when deducing a template parameter pack
6811 from a sub-declarator, as in variadic114.C. */
6812 if (!post_variadic_parms
)
6813 inner_args
= expand_template_argument_pack (inner_args
);
6815 /* Count any pack expansion args. */
6816 variadic_args_p
= pack_expansion_args_count (inner_args
);
6818 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6819 if ((nargs
> nparms
&& !variadic_p
)
6820 || (nargs
< nparms
- variadic_p
6823 && (!use_default_args
6824 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
6825 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
6827 if (complain
& tf_error
)
6831 nparms
-= variadic_p
;
6832 error ("wrong number of template arguments "
6833 "(%d, should be %d or more)", nargs
, nparms
);
6836 error ("wrong number of template arguments "
6837 "(%d, should be %d)", nargs
, nparms
);
6840 error ("provided for %q+D", in_decl
);
6843 return error_mark_node
;
6845 /* We can't pass a pack expansion to a non-pack parameter of an alias
6846 template (DR 1430). */
6847 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
6849 && nargs
- variadic_args_p
< nparms
- variadic_p
)
6851 if (complain
& tf_error
)
6853 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
6855 tree arg
= TREE_VEC_ELT (inner_args
, i
);
6856 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
6858 if (PACK_EXPANSION_P (arg
)
6859 && !template_parameter_pack_p (parm
))
6861 error ("pack expansion argument for non-pack parameter "
6862 "%qD of alias template %qD", parm
, in_decl
);
6863 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
6870 return error_mark_node
;
6873 /* We need to evaluate the template arguments, even though this
6874 template-id may be nested within a "sizeof". */
6875 saved_unevaluated_operand
= cp_unevaluated_operand
;
6876 cp_unevaluated_operand
= 0;
6877 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6878 c_inhibit_evaluation_warnings
= 0;
6879 new_inner_args
= make_tree_vec (nparms
);
6880 new_args
= add_outermost_template_args (args
, new_inner_args
);
6881 int pack_adjust
= 0;
6882 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
6887 /* Get the Ith template parameter. */
6888 parm
= TREE_VEC_ELT (parms
, parm_idx
);
6890 if (parm
== error_mark_node
)
6892 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
6896 /* Calculate the next argument. */
6897 if (arg_idx
< nargs
)
6898 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6902 if (template_parameter_pack_p (TREE_VALUE (parm
))
6903 && !(arg
&& ARGUMENT_PACK_P (arg
)))
6905 /* Some arguments will be placed in the
6906 template parameter pack PARM. */
6907 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
6908 inner_args
, arg_idx
,
6912 if (arg
== NULL_TREE
)
6914 /* We don't know how many args we have yet, just use the
6915 unconverted (and still packed) ones for now. */
6916 new_inner_args
= orig_inner_args
;
6921 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
6923 /* Store this argument. */
6924 if (arg
== error_mark_node
)
6927 /* We are done with all of the arguments. */
6932 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
6933 arg_idx
+= pack_adjust
;
6940 if (PACK_EXPANSION_P (arg
))
6942 /* "If every valid specialization of a variadic template
6943 requires an empty template parameter pack, the template is
6944 ill-formed, no diagnostic required." So check that the
6945 pattern works with this parameter. */
6946 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
6947 tree conv
= convert_template_argument (TREE_VALUE (parm
),
6951 if (conv
== error_mark_node
)
6953 inform (input_location
, "so any instantiation with a "
6954 "non-empty parameter pack would be ill-formed");
6957 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
6958 /* Recover from missing typename. */
6959 TREE_VEC_ELT (inner_args
, arg_idx
)
6960 = make_pack_expansion (conv
);
6962 /* We don't know how many args we have yet, just
6963 use the unconverted ones for now. */
6964 new_inner_args
= inner_args
;
6969 else if (require_all_args
)
6971 /* There must be a default arg in this case. */
6972 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
6974 /* The position of the first default template argument,
6975 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6977 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
6978 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
6979 arg_idx
- pack_adjust
);
6984 if (arg
== error_mark_node
)
6986 if (complain
& tf_error
)
6987 error ("template argument %d is invalid", arg_idx
+ 1);
6990 /* This only occurs if there was an error in the template
6991 parameter list itself (which we would already have
6992 reported) that we are trying to recover from, e.g., a class
6993 template with a parameter list such as
6994 template<typename..., typename>. */
6997 arg
= convert_template_argument (TREE_VALUE (parm
),
6998 arg
, new_args
, complain
,
7001 if (arg
== error_mark_node
)
7003 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7005 cp_unevaluated_operand
= saved_unevaluated_operand
;
7006 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7008 if (variadic_p
&& arg_idx
< nargs
)
7010 if (complain
& tf_error
)
7012 error ("wrong number of template arguments "
7013 "(%d, should be %d)", nargs
, arg_idx
);
7015 error ("provided for %q+D", in_decl
);
7017 return error_mark_node
;
7021 return error_mark_node
;
7023 #ifdef ENABLE_CHECKING
7024 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7025 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7026 TREE_VEC_LENGTH (new_inner_args
));
7029 return new_inner_args
;
7032 /* Like coerce_template_parms. If PARMS represents all template
7033 parameters levels, this function returns a vector of vectors
7034 representing all the resulting argument levels. Note that in this
7035 case, only the innermost arguments are coerced because the
7036 outermost ones are supposed to have been coerced already.
7038 Otherwise, if PARMS represents only (the innermost) vector of
7039 parameters, this function returns a vector containing just the
7040 innermost resulting arguments. */
7043 coerce_innermost_template_parms (tree parms
,
7046 tsubst_flags_t complain
,
7047 bool require_all_args
,
7048 bool use_default_args
)
7050 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7051 int args_depth
= TMPL_ARGS_DEPTH (args
);
7054 if (parms_depth
> 1)
7056 coerced_args
= make_tree_vec (parms_depth
);
7060 for (level
= parms
, cur_depth
= parms_depth
;
7061 parms_depth
> 0 && level
!= NULL_TREE
;
7062 level
= TREE_CHAIN (level
), --cur_depth
)
7065 if (cur_depth
== args_depth
)
7066 l
= coerce_template_parms (TREE_VALUE (level
),
7067 args
, in_decl
, complain
,
7071 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7073 if (l
== error_mark_node
)
7074 return error_mark_node
;
7076 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7080 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7081 args
, in_decl
, complain
,
7084 return coerced_args
;
7087 /* Returns 1 if template args OT and NT are equivalent. */
7090 template_args_equal (tree ot
, tree nt
)
7094 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7097 if (TREE_CODE (nt
) == TREE_VEC
)
7098 /* For member templates */
7099 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7100 else if (PACK_EXPANSION_P (ot
))
7101 return (PACK_EXPANSION_P (nt
)
7102 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7103 PACK_EXPANSION_PATTERN (nt
))
7104 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7105 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7106 else if (ARGUMENT_PACK_P (ot
))
7111 if (!ARGUMENT_PACK_P (nt
))
7114 opack
= ARGUMENT_PACK_ARGS (ot
);
7115 npack
= ARGUMENT_PACK_ARGS (nt
);
7116 len
= TREE_VEC_LENGTH (opack
);
7117 if (TREE_VEC_LENGTH (npack
) != len
)
7119 for (i
= 0; i
< len
; ++i
)
7120 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7121 TREE_VEC_ELT (npack
, i
)))
7125 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7127 /* We get here probably because we are in the middle of substituting
7128 into the pattern of a pack expansion. In that case the
7129 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7130 interested in. So we want to use the initial pack argument for
7132 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7133 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7134 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7135 return template_args_equal (ot
, nt
);
7137 else if (TYPE_P (nt
))
7138 return TYPE_P (ot
) && same_type_p (ot
, nt
);
7139 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7142 return cp_tree_equal (ot
, nt
);
7145 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7146 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7147 NEWARG_PTR with the offending arguments if they are non-NULL. */
7150 comp_template_args_with_info (tree oldargs
, tree newargs
,
7151 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7155 if (oldargs
== newargs
)
7158 if (!oldargs
|| !newargs
)
7161 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7164 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7166 tree nt
= TREE_VEC_ELT (newargs
, i
);
7167 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7169 if (! template_args_equal (ot
, nt
))
7171 if (oldarg_ptr
!= NULL
)
7173 if (newarg_ptr
!= NULL
)
7181 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7182 of template arguments. Returns 0 otherwise. */
7185 comp_template_args (tree oldargs
, tree newargs
)
7187 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7191 add_pending_template (tree d
)
7193 tree ti
= (TYPE_P (d
)
7194 ? CLASSTYPE_TEMPLATE_INFO (d
)
7195 : DECL_TEMPLATE_INFO (d
));
7196 struct pending_template
*pt
;
7199 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7202 /* We are called both from instantiate_decl, where we've already had a
7203 tinst_level pushed, and instantiate_template, where we haven't.
7205 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7208 push_tinst_level (d
);
7210 pt
= ggc_alloc
<pending_template
> ();
7212 pt
->tinst
= current_tinst_level
;
7213 if (last_pending_template
)
7214 last_pending_template
->next
= pt
;
7216 pending_templates
= pt
;
7218 last_pending_template
= pt
;
7220 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7227 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7228 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7229 documentation for TEMPLATE_ID_EXPR. */
7232 lookup_template_function (tree fns
, tree arglist
)
7236 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7237 return error_mark_node
;
7239 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7241 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7243 error ("%q#D is not a function template", fns
);
7244 return error_mark_node
;
7247 if (BASELINK_P (fns
))
7249 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7251 BASELINK_FUNCTIONS (fns
),
7256 type
= TREE_TYPE (fns
);
7257 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7258 type
= unknown_type_node
;
7260 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7263 /* Within the scope of a template class S<T>, the name S gets bound
7264 (in build_self_reference) to a TYPE_DECL for the class, not a
7265 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7266 or one of its enclosing classes, and that type is a template,
7267 return the associated TEMPLATE_DECL. Otherwise, the original
7270 Also handle the case when DECL is a TREE_LIST of ambiguous
7271 injected-class-names from different bases. */
7274 maybe_get_template_decl_from_type_decl (tree decl
)
7276 if (decl
== NULL_TREE
)
7279 /* DR 176: A lookup that finds an injected-class-name (10.2
7280 [class.member.lookup]) can result in an ambiguity in certain cases
7281 (for example, if it is found in more than one base class). If all of
7282 the injected-class-names that are found refer to specializations of
7283 the same class template, and if the name is followed by a
7284 template-argument-list, the reference refers to the class template
7285 itself and not a specialization thereof, and is not ambiguous. */
7286 if (TREE_CODE (decl
) == TREE_LIST
)
7288 tree t
, tmpl
= NULL_TREE
;
7289 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7291 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7294 else if (tmpl
!= elt
)
7297 if (tmpl
&& t
== NULL_TREE
)
7303 return (decl
!= NULL_TREE
7304 && DECL_SELF_REFERENCE_P (decl
)
7305 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7306 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7309 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7310 parameters, find the desired type.
7312 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7314 IN_DECL, if non-NULL, is the template declaration we are trying to
7317 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7318 the class we are looking up.
7320 Issue error and warning messages under control of COMPLAIN.
7322 If the template class is really a local class in a template
7323 function, then the FUNCTION_CONTEXT is the function in which it is
7326 ??? Note that this function is currently called *twice* for each
7327 template-id: the first time from the parser, while creating the
7328 incomplete type (finish_template_type), and the second type during the
7329 real instantiation (instantiate_template_class). This is surely something
7330 that we want to avoid. It also causes some problems with argument
7331 coercion (see convert_nontype_argument for more information on this). */
7334 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7335 int entering_scope
, tsubst_flags_t complain
)
7337 tree templ
= NULL_TREE
, parmlist
;
7344 if (identifier_p (d1
))
7346 tree value
= innermost_non_namespace_value (d1
);
7347 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7352 push_decl_namespace (context
);
7353 templ
= lookup_name (d1
);
7354 templ
= maybe_get_template_decl_from_type_decl (templ
);
7356 pop_decl_namespace ();
7359 context
= DECL_CONTEXT (templ
);
7361 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7363 tree type
= TREE_TYPE (d1
);
7365 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7366 an implicit typename for the second A. Deal with it. */
7367 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7368 type
= TREE_TYPE (type
);
7370 if (CLASSTYPE_TEMPLATE_INFO (type
))
7372 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7373 d1
= DECL_NAME (templ
);
7376 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7377 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7379 templ
= TYPE_TI_TEMPLATE (d1
);
7380 d1
= DECL_NAME (templ
);
7382 else if (TREE_CODE (d1
) == TEMPLATE_DECL
7383 && DECL_TEMPLATE_RESULT (d1
)
7384 && TREE_CODE (DECL_TEMPLATE_RESULT (d1
)) == TYPE_DECL
)
7387 d1
= DECL_NAME (templ
);
7388 context
= DECL_CONTEXT (templ
);
7390 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7393 d1
= DECL_NAME (templ
);
7396 /* Issue an error message if we didn't find a template. */
7399 if (complain
& tf_error
)
7400 error ("%qT is not a template", d1
);
7401 return error_mark_node
;
7404 if (TREE_CODE (templ
) != TEMPLATE_DECL
7405 /* Make sure it's a user visible template, if it was named by
7407 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7408 && !PRIMARY_TEMPLATE_P (templ
)))
7410 if (complain
& tf_error
)
7412 error ("non-template type %qT used as a template", d1
);
7414 error ("for template declaration %q+D", in_decl
);
7416 return error_mark_node
;
7419 complain
&= ~tf_user
;
7421 /* An alias that just changes the name of a template is equivalent to the
7422 other template, so if any of the arguments are pack expansions, strip
7423 the alias to avoid problems with a pack expansion passed to a non-pack
7424 alias template parameter (DR 1430). */
7425 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7426 templ
= get_underlying_template (templ
);
7428 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7430 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7431 template arguments */
7437 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7439 /* Consider an example where a template template parameter declared as
7441 template <class T, class U = std::allocator<T> > class TT
7443 The template parameter level of T and U are one level larger than
7444 of TT. To proper process the default argument of U, say when an
7445 instantiation `TT<int>' is seen, we need to build the full
7446 arguments containing {int} as the innermost level. Outer levels,
7447 available when not appearing as default template argument, can be
7448 obtained from the arguments of the enclosing template.
7450 Suppose that TT is later substituted with std::vector. The above
7451 instantiation is `TT<int, std::allocator<T> >' with TT at
7452 level 1, and T at level 2, while the template arguments at level 1
7453 becomes {std::vector} and the inner level 2 is {int}. */
7455 outer
= DECL_CONTEXT (templ
);
7457 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7458 else if (current_template_parms
)
7459 /* This is an argument of the current template, so we haven't set
7460 DECL_CONTEXT yet. */
7461 outer
= current_template_args ();
7464 arglist
= add_to_template_args (outer
, arglist
);
7466 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7468 /*require_all_args=*/true,
7469 /*use_default_args=*/true);
7470 if (arglist2
== error_mark_node
7471 || (!uses_template_parms (arglist2
)
7472 && check_instantiated_args (templ
, arglist2
, complain
)))
7473 return error_mark_node
;
7475 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7480 tree template_type
= TREE_TYPE (templ
);
7483 tree found
= NULL_TREE
;
7486 int is_dependent_type
;
7487 int use_partial_inst_tmpl
= false;
7489 if (template_type
== error_mark_node
)
7490 /* An error occurred while building the template TEMPL, and a
7491 diagnostic has most certainly been emitted for that
7492 already. Let's propagate that error. */
7493 return error_mark_node
;
7495 gen_tmpl
= most_general_template (templ
);
7496 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7497 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7498 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7500 if (arg_depth
== 1 && parm_depth
> 1)
7502 /* We've been given an incomplete set of template arguments.
7505 template <class T> struct S1 {
7506 template <class U> struct S2 {};
7507 template <class U> struct S2<U*> {};
7510 we will be called with an ARGLIST of `U*', but the
7511 TEMPLATE will be `template <class T> template
7512 <class U> struct S1<T>::S2'. We must fill in the missing
7515 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7517 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7520 /* Now we should have enough arguments. */
7521 gcc_assert (parm_depth
== arg_depth
);
7523 /* From here on, we're only interested in the most general
7526 /* Calculate the BOUND_ARGS. These will be the args that are
7527 actually tsubst'd into the definition to create the
7531 /* We have multiple levels of arguments to coerce, at once. */
7533 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
7535 tree bound_args
= make_tree_vec (parm_depth
);
7537 for (i
= saved_depth
,
7538 t
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7539 i
> 0 && t
!= NULL_TREE
;
7540 --i
, t
= TREE_CHAIN (t
))
7543 if (i
== saved_depth
)
7544 a
= coerce_template_parms (TREE_VALUE (t
),
7547 /*require_all_args=*/true,
7548 /*use_default_args=*/true);
7550 /* Outer levels should have already been coerced. */
7551 a
= TMPL_ARGS_LEVEL (arglist
, i
);
7553 /* Don't process further if one of the levels fails. */
7554 if (a
== error_mark_node
)
7556 /* Restore the ARGLIST to its full size. */
7557 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7558 return error_mark_node
;
7561 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
7563 /* We temporarily reduce the length of the ARGLIST so
7564 that coerce_template_parms will see only the arguments
7565 corresponding to the template parameters it is
7567 TREE_VEC_LENGTH (arglist
)--;
7570 /* Restore the ARGLIST to its full size. */
7571 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7573 arglist
= bound_args
;
7577 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
7578 INNERMOST_TEMPLATE_ARGS (arglist
),
7581 /*require_all_args=*/true,
7582 /*use_default_args=*/true);
7584 if (arglist
== error_mark_node
)
7585 /* We were unable to bind the arguments. */
7586 return error_mark_node
;
7588 /* In the scope of a template class, explicit references to the
7589 template class refer to the type of the template, not any
7590 instantiation of it. For example, in:
7592 template <class T> class C { void f(C<T>); }
7594 the `C<T>' is just the same as `C'. Outside of the
7595 class, however, such a reference is an instantiation. */
7597 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7598 || currently_open_class (template_type
))
7599 /* comp_template_args is expensive, check it last. */
7600 && comp_template_args (TYPE_TI_ARGS (template_type
),
7602 return template_type
;
7604 /* If we already have this specialization, return it. */
7605 elt
.tmpl
= gen_tmpl
;
7607 hash
= hash_specialization (&elt
);
7608 entry
= (spec_entry
*) htab_find_with_hash (type_specializations
,
7614 is_dependent_type
= uses_template_parms (arglist
);
7616 /* If the deduced arguments are invalid, then the binding
7618 if (!is_dependent_type
7619 && check_instantiated_args (gen_tmpl
,
7620 INNERMOST_TEMPLATE_ARGS (arglist
),
7622 return error_mark_node
;
7624 if (!is_dependent_type
7625 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7626 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7627 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7629 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7630 DECL_NAME (gen_tmpl
),
7631 /*tag_scope=*/ts_global
);
7635 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7637 if (context
== error_mark_node
)
7638 return error_mark_node
;
7641 context
= global_namespace
;
7643 /* Create the type. */
7644 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7646 /* The user referred to a specialization of an alias
7647 template represented by GEN_TMPL.
7649 [temp.alias]/2 says:
7651 When a template-id refers to the specialization of an
7652 alias template, it is equivalent to the associated
7653 type obtained by substitution of its
7654 template-arguments for the template-parameters in the
7655 type-id of the alias template. */
7657 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7658 /* Note that the call above (by indirectly calling
7659 register_specialization in tsubst_decl) registers the
7660 TYPE_DECL representing the specialization of the alias
7661 template. So next time someone substitutes ARGLIST for
7662 the template parms into the alias template (GEN_TMPL),
7663 she'll get that TYPE_DECL back. */
7665 if (t
== error_mark_node
)
7668 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7670 if (!is_dependent_type
)
7672 set_current_access_from_decl (TYPE_NAME (template_type
));
7673 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7674 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7675 arglist
, complain
, in_decl
),
7676 SCOPED_ENUM_P (template_type
), NULL
);
7678 if (t
== error_mark_node
)
7683 /* We don't want to call start_enum for this type, since
7684 the values for the enumeration constants may involve
7685 template parameters. And, no one should be interested
7686 in the enumeration constants for such a type. */
7687 t
= cxx_make_type (ENUMERAL_TYPE
);
7688 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7690 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7691 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7692 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7694 else if (CLASS_TYPE_P (template_type
))
7696 t
= make_class_type (TREE_CODE (template_type
));
7697 CLASSTYPE_DECLARED_CLASS (t
)
7698 = CLASSTYPE_DECLARED_CLASS (template_type
);
7699 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7700 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7702 /* A local class. Make sure the decl gets registered properly. */
7703 if (context
== current_function_decl
)
7704 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7706 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7707 /* This instantiation is another name for the primary
7708 template type. Set the TYPE_CANONICAL field
7710 TYPE_CANONICAL (t
) = template_type
;
7711 else if (any_template_arguments_need_structural_equality_p (arglist
))
7712 /* Some of the template arguments require structural
7713 equality testing, so this template class requires
7714 structural equality testing. */
7715 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7720 /* If we called start_enum or pushtag above, this information
7721 will already be set up. */
7724 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7726 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7727 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7728 DECL_SOURCE_LOCATION (type_decl
)
7729 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7732 type_decl
= TYPE_NAME (t
);
7734 if (CLASS_TYPE_P (template_type
))
7736 TREE_PRIVATE (type_decl
)
7737 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7738 TREE_PROTECTED (type_decl
)
7739 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7740 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7742 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7743 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7747 /* Let's consider the explicit specialization of a member
7748 of a class template specialization that is implicitly instantiated,
7753 template<class U> struct M {}; //#0
7758 struct S<int>::M<char> //#1
7762 [temp.expl.spec]/4 says this is valid.
7764 In this case, when we write:
7767 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7770 When we encounter #1, we want to store the partial instantiation
7771 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7773 For all cases other than this "explicit specialization of member of a
7774 class template", we just want to store the most general template into
7775 the CLASSTYPE_TI_TEMPLATE of M.
7777 This case of "explicit specialization of member of a class template"
7779 1/ the enclosing class is an instantiation of, and therefore not
7780 the same as, the context of the most general template, and
7781 2/ we aren't looking at the partial instantiation itself, i.e.
7782 the innermost arguments are not the same as the innermost parms of
7783 the most general template.
7785 So it's only when 1/ and 2/ happens that we want to use the partial
7786 instantiation of the member template in lieu of its most general
7789 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
7790 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
7791 /* the enclosing class must be an instantiation... */
7792 && CLASS_TYPE_P (context
)
7793 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
7795 tree partial_inst_args
;
7796 TREE_VEC_LENGTH (arglist
)--;
7797 ++processing_template_decl
;
7799 tsubst (INNERMOST_TEMPLATE_ARGS
7800 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
7801 arglist
, complain
, NULL_TREE
);
7802 --processing_template_decl
;
7803 TREE_VEC_LENGTH (arglist
)++;
7804 use_partial_inst_tmpl
=
7805 /*...and we must not be looking at the partial instantiation
7807 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
7811 if (!use_partial_inst_tmpl
)
7812 /* This case is easy; there are no member templates involved. */
7816 /* This is a full instantiation of a member template. Find
7817 the partial instantiation of which this is an instance. */
7819 /* Temporarily reduce by one the number of levels in the ARGLIST
7820 so as to avoid comparing the last set of arguments. */
7821 TREE_VEC_LENGTH (arglist
)--;
7822 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
7823 TREE_VEC_LENGTH (arglist
)++;
7824 /* FOUND is either a proper class type, or an alias
7825 template specialization. In the later case, it's a
7826 TYPE_DECL, resulting from the substituting of arguments
7827 for parameters in the TYPE_DECL of the alias template
7828 done earlier. So be careful while getting the template
7830 found
= TREE_CODE (found
) == TYPE_DECL
7831 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
7832 : CLASSTYPE_TI_TEMPLATE (found
);
7835 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
7838 slot
= htab_find_slot_with_hash (type_specializations
,
7839 &elt
, hash
, INSERT
);
7840 entry
= ggc_alloc
<spec_entry
> ();
7844 /* Note this use of the partial instantiation so we can check it
7845 later in maybe_process_partial_specialization. */
7846 DECL_TEMPLATE_INSTANTIATIONS (found
)
7847 = tree_cons (arglist
, t
,
7848 DECL_TEMPLATE_INSTANTIATIONS (found
));
7850 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
7851 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7852 /* Now that the type has been registered on the instantiations
7853 list, we set up the enumerators. Because the enumeration
7854 constants may involve the enumeration type itself, we make
7855 sure to register the type first, and then create the
7856 constants. That way, doing tsubst_expr for the enumeration
7857 constants won't result in recursive calls here; we'll find
7858 the instantiation and exit above. */
7859 tsubst_enum (template_type
, t
, arglist
);
7861 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
7862 /* If the type makes use of template parameters, the
7863 code that generates debugging information will crash. */
7864 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
7866 /* Possibly limit visibility based on template args. */
7867 TREE_PUBLIC (type_decl
) = 1;
7868 determine_visibility (type_decl
);
7874 /* Wrapper for lookup_template_class_1. */
7877 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
7878 int entering_scope
, tsubst_flags_t complain
)
7881 timevar_push (TV_TEMPLATE_INST
);
7882 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
7883 entering_scope
, complain
);
7884 timevar_pop (TV_TEMPLATE_INST
);
7892 /* True when we should also visit template parameters that occur in
7893 non-deduced contexts. */
7894 bool include_nondeduced_p
;
7895 struct pointer_set_t
*visited
;
7898 /* Called from for_each_template_parm via walk_tree. */
7901 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
7904 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
7905 tree_fn_t fn
= pfd
->fn
;
7906 void *data
= pfd
->data
;
7909 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
7910 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
7911 pfd
->include_nondeduced_p
))
7912 return error_mark_node
;
7914 switch (TREE_CODE (t
))
7917 if (TYPE_PTRMEMFUNC_P (t
))
7923 if (!TYPE_TEMPLATE_INFO (t
))
7925 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
7926 fn
, data
, pfd
->visited
,
7927 pfd
->include_nondeduced_p
))
7928 return error_mark_node
;
7932 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
7933 fn
, data
, pfd
->visited
,
7934 pfd
->include_nondeduced_p
)
7935 || for_each_template_parm (TYPE_MAX_VALUE (t
),
7936 fn
, data
, pfd
->visited
,
7937 pfd
->include_nondeduced_p
))
7938 return error_mark_node
;
7942 /* Since we're not going to walk subtrees, we have to do this
7944 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
7945 pfd
->visited
, pfd
->include_nondeduced_p
))
7946 return error_mark_node
;
7950 /* Check the return type. */
7951 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
7952 pfd
->include_nondeduced_p
))
7953 return error_mark_node
;
7955 /* Check the parameter types. Since default arguments are not
7956 instantiated until they are needed, the TYPE_ARG_TYPES may
7957 contain expressions that involve template parameters. But,
7958 no-one should be looking at them yet. And, once they're
7959 instantiated, they don't contain template parameters, so
7960 there's no point in looking at them then, either. */
7964 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
7965 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
7966 pfd
->visited
, pfd
->include_nondeduced_p
))
7967 return error_mark_node
;
7969 /* Since we've already handled the TYPE_ARG_TYPES, we don't
7970 want walk_tree walking into them itself. */
7976 case UNDERLYING_TYPE
:
7977 if (pfd
->include_nondeduced_p
7978 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
7980 pfd
->include_nondeduced_p
))
7981 return error_mark_node
;
7986 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
7987 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
7988 pfd
->visited
, pfd
->include_nondeduced_p
))
7989 return error_mark_node
;
7994 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
7995 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
7996 pfd
->visited
, pfd
->include_nondeduced_p
))
7997 return error_mark_node
;
7998 if (DECL_CONTEXT (t
)
7999 && pfd
->include_nondeduced_p
8000 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
8001 pfd
->visited
, pfd
->include_nondeduced_p
))
8002 return error_mark_node
;
8005 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8006 /* Record template parameters such as `T' inside `TT<T>'. */
8007 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
8008 pfd
->include_nondeduced_p
))
8009 return error_mark_node
;
8012 case TEMPLATE_TEMPLATE_PARM
:
8013 case TEMPLATE_TYPE_PARM
:
8014 case TEMPLATE_PARM_INDEX
:
8015 if (fn
&& (*fn
)(t
, data
))
8016 return error_mark_node
;
8018 return error_mark_node
;
8022 /* A template template parameter is encountered. */
8023 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
8024 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8025 pfd
->include_nondeduced_p
))
8026 return error_mark_node
;
8028 /* Already substituted template template parameter */
8034 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8036 pfd
->include_nondeduced_p
))
8037 return error_mark_node
;
8041 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8042 && pfd
->include_nondeduced_p
8043 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8044 (TREE_TYPE (t
)), fn
, data
,
8045 pfd
->visited
, pfd
->include_nondeduced_p
))
8046 return error_mark_node
;
8051 /* If there's no type, then this thing must be some expression
8052 involving template parameters. */
8053 if (!fn
&& !TREE_TYPE (t
))
8054 return error_mark_node
;
8059 case IMPLICIT_CONV_EXPR
:
8060 case REINTERPRET_CAST_EXPR
:
8061 case CONST_CAST_EXPR
:
8062 case STATIC_CAST_EXPR
:
8063 case DYNAMIC_CAST_EXPR
:
8067 case PSEUDO_DTOR_EXPR
:
8069 return error_mark_node
;
8076 /* We didn't find any template parameters we liked. */
8080 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8081 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8082 call FN with the parameter and the DATA.
8083 If FN returns nonzero, the iteration is terminated, and
8084 for_each_template_parm returns 1. Otherwise, the iteration
8085 continues. If FN never returns a nonzero value, the value
8086 returned by for_each_template_parm is 0. If FN is NULL, it is
8087 considered to be the function which always returns 1.
8089 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8090 parameters that occur in non-deduced contexts. When false, only
8091 visits those template parameters that can be deduced. */
8094 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8095 struct pointer_set_t
*visited
,
8096 bool include_nondeduced_p
)
8098 struct pair_fn_data pfd
;
8104 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8106 /* Walk the tree. (Conceptually, we would like to walk without
8107 duplicates, but for_each_template_parm_r recursively calls
8108 for_each_template_parm, so we would need to reorganize a fair
8109 bit to use walk_tree_without_duplicates, so we keep our own
8112 pfd
.visited
= visited
;
8114 pfd
.visited
= pointer_set_create ();
8115 result
= cp_walk_tree (&t
,
8116 for_each_template_parm_r
,
8118 pfd
.visited
) != NULL_TREE
;
8123 pointer_set_destroy (pfd
.visited
);
8130 /* Returns true if T depends on any template parameter. */
8133 uses_template_parms (tree t
)
8136 int saved_processing_template_decl
;
8138 saved_processing_template_decl
= processing_template_decl
;
8139 if (!saved_processing_template_decl
)
8140 processing_template_decl
= 1;
8142 dependent_p
= dependent_type_p (t
);
8143 else if (TREE_CODE (t
) == TREE_VEC
)
8144 dependent_p
= any_dependent_template_arguments_p (t
);
8145 else if (TREE_CODE (t
) == TREE_LIST
)
8146 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8147 || uses_template_parms (TREE_CHAIN (t
)));
8148 else if (TREE_CODE (t
) == TYPE_DECL
)
8149 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8152 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8153 || TREE_CODE (t
) == OVERLOAD
8156 || TREE_CODE (t
) == TRAIT_EXPR
8157 || TREE_CODE (t
) == CONSTRUCTOR
8158 || CONSTANT_CLASS_P (t
))
8159 dependent_p
= (type_dependent_expression_p (t
)
8160 || value_dependent_expression_p (t
));
8163 gcc_assert (t
== error_mark_node
);
8164 dependent_p
= false;
8167 processing_template_decl
= saved_processing_template_decl
;
8172 /* Returns true iff current_function_decl is an incompletely instantiated
8173 template. Useful instead of processing_template_decl because the latter
8174 is set to 0 during fold_non_dependent_expr. */
8177 in_template_function (void)
8179 tree fn
= current_function_decl
;
8181 ++processing_template_decl
;
8182 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8183 && DECL_TEMPLATE_INFO (fn
)
8184 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8185 --processing_template_decl
;
8189 /* Returns true if T depends on any template parameter with level LEVEL. */
8192 uses_template_parms_level (tree t
, int level
)
8194 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8195 /*include_nondeduced_p=*/true);
8198 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8199 ill-formed translation unit, i.e. a variable or function that isn't
8200 usable in a constant expression. */
8203 neglectable_inst_p (tree d
)
8206 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8207 : decl_maybe_constant_var_p (d
)));
8210 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8211 neglectable and instantiated from within an erroneous instantiation. */
8214 limit_bad_template_recursion (tree decl
)
8216 struct tinst_level
*lev
= current_tinst_level
;
8217 int errs
= errorcount
+ sorrycount
;
8218 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8221 for (; lev
; lev
= lev
->next
)
8222 if (neglectable_inst_p (lev
->decl
))
8225 return (lev
&& errs
> lev
->errors
);
8228 static int tinst_depth
;
8229 extern int max_tinst_depth
;
8232 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8234 /* We're starting to instantiate D; record the template instantiation context
8235 for diagnostics and to restore it later. */
8238 push_tinst_level (tree d
)
8240 struct tinst_level
*new_level
;
8242 if (tinst_depth
>= max_tinst_depth
)
8244 last_error_tinst_level
= current_tinst_level
;
8245 if (TREE_CODE (d
) == TREE_LIST
)
8246 error ("template instantiation depth exceeds maximum of %d (use "
8247 "-ftemplate-depth= to increase the maximum) substituting %qS",
8248 max_tinst_depth
, d
);
8250 error ("template instantiation depth exceeds maximum of %d (use "
8251 "-ftemplate-depth= to increase the maximum) instantiating %qD",
8252 max_tinst_depth
, d
);
8254 print_instantiation_context ();
8259 /* If the current instantiation caused problems, don't let it instantiate
8260 anything else. Do allow deduction substitution and decls usable in
8261 constant expressions. */
8262 if (limit_bad_template_recursion (d
))
8265 new_level
= ggc_alloc
<tinst_level
> ();
8266 new_level
->decl
= d
;
8267 new_level
->locus
= input_location
;
8268 new_level
->errors
= errorcount
+sorrycount
;
8269 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8270 new_level
->next
= current_tinst_level
;
8271 current_tinst_level
= new_level
;
8274 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8275 depth_reached
= tinst_depth
;
8280 /* We're done instantiating this template; return to the instantiation
8284 pop_tinst_level (void)
8286 /* Restore the filename and line number stashed away when we started
8287 this instantiation. */
8288 input_location
= current_tinst_level
->locus
;
8289 current_tinst_level
= current_tinst_level
->next
;
8293 /* We're instantiating a deferred template; restore the template
8294 instantiation context in which the instantiation was requested, which
8295 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8298 reopen_tinst_level (struct tinst_level
*level
)
8300 struct tinst_level
*t
;
8303 for (t
= level
; t
; t
= t
->next
)
8306 current_tinst_level
= level
;
8308 if (current_tinst_level
)
8309 current_tinst_level
->errors
= errorcount
+sorrycount
;
8313 /* Returns the TINST_LEVEL which gives the original instantiation
8316 struct tinst_level
*
8317 outermost_tinst_level (void)
8319 struct tinst_level
*level
= current_tinst_level
;
8322 level
= level
->next
;
8326 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8327 vector of template arguments, as for tsubst.
8329 Returns an appropriate tsubst'd friend declaration. */
8332 tsubst_friend_function (tree decl
, tree args
)
8336 if (TREE_CODE (decl
) == FUNCTION_DECL
8337 && DECL_TEMPLATE_INSTANTIATION (decl
)
8338 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8339 /* This was a friend declared with an explicit template
8340 argument list, e.g.:
8344 to indicate that f was a template instantiation, not a new
8345 function declaration. Now, we have to figure out what
8346 instantiation of what template. */
8348 tree template_id
, arglist
, fns
;
8351 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8353 /* Friend functions are looked up in the containing namespace scope.
8354 We must enter that scope, to avoid finding member functions of the
8355 current class with same name. */
8356 push_nested_namespace (ns
);
8357 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8358 tf_warning_or_error
, NULL_TREE
,
8359 /*integral_constant_expression_p=*/false);
8360 pop_nested_namespace (ns
);
8361 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8362 tf_warning_or_error
, NULL_TREE
);
8363 template_id
= lookup_template_function (fns
, arglist
);
8365 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8366 tmpl
= determine_specialization (template_id
, new_friend
,
8368 /*need_member_template=*/0,
8369 TREE_VEC_LENGTH (args
),
8371 return instantiate_template (tmpl
, new_args
, tf_error
);
8374 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8376 /* The NEW_FRIEND will look like an instantiation, to the
8377 compiler, but is not an instantiation from the point of view of
8378 the language. For example, we might have had:
8380 template <class T> struct S {
8381 template <class U> friend void f(T, U);
8384 Then, in S<int>, template <class U> void f(int, U) is not an
8385 instantiation of anything. */
8386 if (new_friend
== error_mark_node
)
8387 return error_mark_node
;
8389 DECL_USE_TEMPLATE (new_friend
) = 0;
8390 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8392 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8393 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8394 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8397 /* The mangled name for the NEW_FRIEND is incorrect. The function
8398 is not a template instantiation and should not be mangled like
8399 one. Therefore, we forget the mangling here; we'll recompute it
8400 later if we need it. */
8401 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8403 SET_DECL_RTL (new_friend
, NULL
);
8404 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8407 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8410 tree new_friend_template_info
;
8411 tree new_friend_result_template_info
;
8413 int new_friend_is_defn
;
8415 /* We must save some information from NEW_FRIEND before calling
8416 duplicate decls since that function will free NEW_FRIEND if
8418 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8419 new_friend_is_defn
=
8420 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8421 (template_for_substitution (new_friend
)))
8423 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8425 /* This declaration is a `primary' template. */
8426 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8428 new_friend_result_template_info
8429 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8432 new_friend_result_template_info
= NULL_TREE
;
8434 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8435 if (new_friend_is_defn
)
8436 DECL_INITIAL (new_friend
) = error_mark_node
;
8438 /* Inside pushdecl_namespace_level, we will push into the
8439 current namespace. However, the friend function should go
8440 into the namespace of the template. */
8441 ns
= decl_namespace_context (new_friend
);
8442 push_nested_namespace (ns
);
8443 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8444 pop_nested_namespace (ns
);
8446 if (old_decl
== error_mark_node
)
8447 return error_mark_node
;
8449 if (old_decl
!= new_friend
)
8451 /* This new friend declaration matched an existing
8452 declaration. For example, given:
8454 template <class T> void f(T);
8455 template <class U> class C {
8456 template <class T> friend void f(T) {}
8459 the friend declaration actually provides the definition
8460 of `f', once C has been instantiated for some type. So,
8461 old_decl will be the out-of-class template declaration,
8462 while new_friend is the in-class definition.
8464 But, if `f' was called before this point, the
8465 instantiation of `f' will have DECL_TI_ARGS corresponding
8466 to `T' but not to `U', references to which might appear
8467 in the definition of `f'. Previously, the most general
8468 template for an instantiation of `f' was the out-of-class
8469 version; now it is the in-class version. Therefore, we
8470 run through all specialization of `f', adding to their
8471 DECL_TI_ARGS appropriately. In particular, they need a
8472 new set of outer arguments, corresponding to the
8473 arguments for this class instantiation.
8475 The same situation can arise with something like this:
8478 template <class T> class C {
8482 when `C<int>' is instantiated. Now, `f(int)' is defined
8485 if (!new_friend_is_defn
)
8486 /* On the other hand, if the in-class declaration does
8487 *not* provide a definition, then we don't want to alter
8488 existing definitions. We can just leave everything
8493 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8494 tree new_args
= TI_ARGS (new_friend_template_info
);
8496 /* Overwrite whatever template info was there before, if
8497 any, with the new template information pertaining to
8499 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8501 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8503 /* We should have called reregister_specialization in
8505 gcc_assert (retrieve_specialization (new_template
,
8509 /* Instantiate it if the global has already been used. */
8510 if (DECL_ODR_USED (old_decl
))
8511 instantiate_decl (old_decl
, /*defer_ok=*/true,
8512 /*expl_inst_class_mem_p=*/false);
8518 /* Indicate that the old function template is a partial
8520 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8521 = new_friend_result_template_info
;
8523 gcc_assert (new_template
8524 == most_general_template (new_template
));
8525 gcc_assert (new_template
!= old_decl
);
8527 /* Reassign any specializations already in the hash table
8528 to the new more general template, and add the
8529 additional template args. */
8530 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8534 tree spec
= TREE_VALUE (t
);
8537 elt
.tmpl
= old_decl
;
8538 elt
.args
= DECL_TI_ARGS (spec
);
8539 elt
.spec
= NULL_TREE
;
8541 htab_remove_elt (decl_specializations
, &elt
);
8544 = add_outermost_template_args (new_args
,
8545 DECL_TI_ARGS (spec
));
8547 register_specialization
8548 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8551 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8555 /* The information from NEW_FRIEND has been merged into OLD_DECL
8556 by duplicate_decls. */
8557 new_friend
= old_decl
;
8562 tree context
= DECL_CONTEXT (new_friend
);
8566 template <class T> class C {
8567 template <class U> friend void C1<U>::f (); // case 1
8568 friend void C2<T>::f (); // case 2
8570 we only need to make sure CONTEXT is a complete type for
8571 case 2. To distinguish between the two cases, we note that
8572 CONTEXT of case 1 remains dependent type after tsubst while
8573 this isn't true for case 2. */
8574 ++processing_template_decl
;
8575 dependent_p
= dependent_type_p (context
);
8576 --processing_template_decl
;
8579 && !complete_type_or_else (context
, NULL_TREE
))
8580 return error_mark_node
;
8582 if (COMPLETE_TYPE_P (context
))
8584 tree fn
= new_friend
;
8585 /* do_friend adds the TEMPLATE_DECL for any member friend
8586 template even if it isn't a member template, i.e.
8587 template <class T> friend A<T>::f();
8588 Look through it in that case. */
8589 if (TREE_CODE (fn
) == TEMPLATE_DECL
8590 && !PRIMARY_TEMPLATE_P (fn
))
8591 fn
= DECL_TEMPLATE_RESULT (fn
);
8592 /* Check to see that the declaration is really present, and,
8593 possibly obtain an improved declaration. */
8594 fn
= check_classfn (context
, fn
, NULL_TREE
);
8604 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8605 template arguments, as for tsubst.
8607 Returns an appropriate tsubst'd friend type or error_mark_node on
8611 tsubst_friend_class (tree friend_tmpl
, tree args
)
8617 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8619 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8620 return TREE_TYPE (t
);
8623 context
= CP_DECL_CONTEXT (friend_tmpl
);
8625 if (context
!= global_namespace
)
8627 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8628 push_nested_namespace (context
);
8630 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8633 /* Look for a class template declaration. We look for hidden names
8634 because two friend declarations of the same template are the
8635 same. For example, in:
8638 template <typename> friend class F;
8640 template <typename> struct B {
8641 template <typename> friend class F;
8644 both F templates are the same. */
8645 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8646 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8648 /* But, if we don't find one, it might be because we're in a
8649 situation like this:
8657 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8658 for `S<int>', not the TEMPLATE_DECL. */
8659 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8661 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8662 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8665 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8667 /* The friend template has already been declared. Just
8668 check to see that the declarations match, and install any new
8669 default parameters. We must tsubst the default parameters,
8670 of course. We only need the innermost template parameters
8671 because that is all that redeclare_class_template will look
8673 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8674 > TMPL_ARGS_DEPTH (args
))
8677 location_t saved_input_location
;
8678 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8679 args
, tf_warning_or_error
);
8681 saved_input_location
= input_location
;
8682 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8683 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8684 input_location
= saved_input_location
;
8688 friend_type
= TREE_TYPE (tmpl
);
8692 /* The friend template has not already been declared. In this
8693 case, the instantiation of the template class will cause the
8694 injection of this template into the global scope. */
8695 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8696 if (tmpl
== error_mark_node
)
8697 return error_mark_node
;
8699 /* The new TMPL is not an instantiation of anything, so we
8700 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8701 the new type because that is supposed to be the corresponding
8702 template decl, i.e., TMPL. */
8703 DECL_USE_TEMPLATE (tmpl
) = 0;
8704 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8705 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8706 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8707 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8709 /* Inject this template into the global scope. */
8710 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8713 if (context
!= global_namespace
)
8715 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8716 pop_nested_namespace (context
);
8718 pop_nested_class ();
8724 /* Returns zero if TYPE cannot be completed later due to circularity.
8725 Otherwise returns one. */
8728 can_complete_type_without_circularity (tree type
)
8730 if (type
== NULL_TREE
|| type
== error_mark_node
)
8732 else if (COMPLETE_TYPE_P (type
))
8734 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8735 return can_complete_type_without_circularity (TREE_TYPE (type
));
8736 else if (CLASS_TYPE_P (type
)
8737 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
8743 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
8745 /* Apply any attributes which had to be deferred until instantiation
8746 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8747 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8750 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
8751 tree args
, tsubst_flags_t complain
, tree in_decl
)
8753 tree last_dep
= NULL_TREE
;
8757 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
8758 if (ATTR_IS_DEPENDENT (t
))
8761 attributes
= copy_list (attributes
);
8765 if (DECL_P (*decl_p
))
8767 if (TREE_TYPE (*decl_p
) == error_mark_node
)
8769 p
= &DECL_ATTRIBUTES (*decl_p
);
8772 p
= &TYPE_ATTRIBUTES (*decl_p
);
8776 tree late_attrs
= NULL_TREE
;
8777 tree
*q
= &late_attrs
;
8779 for (*p
= attributes
; *p
; )
8782 if (ATTR_IS_DEPENDENT (t
))
8784 *p
= TREE_CHAIN (t
);
8785 TREE_CHAIN (t
) = NULL_TREE
;
8786 if ((flag_openmp
|| flag_cilkplus
)
8787 && is_attribute_p ("omp declare simd",
8788 get_attribute_name (t
))
8791 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
8792 clauses
= tsubst_omp_clauses (clauses
, true, args
,
8794 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
8795 clauses
= finish_omp_clauses (clauses
);
8796 tree parms
= DECL_ARGUMENTS (*decl_p
);
8798 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
8800 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
8802 TREE_VALUE (t
) = NULL_TREE
;
8804 /* If the first attribute argument is an identifier, don't
8805 pass it through tsubst. Attributes like mode, format,
8806 cleanup and several target specific attributes expect it
8808 else if (attribute_takes_identifier_p (get_attribute_name (t
))
8812 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
8814 /*integral_constant_expression_p=*/false);
8815 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
8817 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
8822 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
8823 /*integral_constant_expression_p=*/false);
8825 q
= &TREE_CHAIN (t
);
8828 p
= &TREE_CHAIN (t
);
8831 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
8835 /* Perform (or defer) access check for typedefs that were referenced
8836 from within the template TMPL code.
8837 This is a subroutine of instantiate_decl and instantiate_class_template.
8838 TMPL is the template to consider and TARGS is the list of arguments of
8842 perform_typedefs_access_check (tree tmpl
, tree targs
)
8844 location_t saved_location
;
8846 qualified_typedef_usage_t
*iter
;
8849 || (!CLASS_TYPE_P (tmpl
)
8850 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
8853 saved_location
= input_location
;
8854 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
8856 tree type_decl
= iter
->typedef_decl
;
8857 tree type_scope
= iter
->context
;
8859 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
8862 if (uses_template_parms (type_decl
))
8863 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
8864 if (uses_template_parms (type_scope
))
8865 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
8867 /* Make access check error messages point to the location
8868 of the use of the typedef. */
8869 input_location
= iter
->locus
;
8870 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
8871 type_decl
, type_decl
,
8872 tf_warning_or_error
);
8874 input_location
= saved_location
;
8878 instantiate_class_template_1 (tree type
)
8880 tree templ
, args
, pattern
, t
, member
;
8884 unsigned int saved_maximum_field_alignment
;
8887 if (type
== error_mark_node
)
8888 return error_mark_node
;
8890 if (COMPLETE_OR_OPEN_TYPE_P (type
)
8891 || uses_template_parms (type
))
8894 /* Figure out which template is being instantiated. */
8895 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
8896 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
8898 /* Determine what specialization of the original template to
8900 t
= most_specialized_class (type
, tf_warning_or_error
);
8901 if (t
== error_mark_node
)
8903 TYPE_BEING_DEFINED (type
) = 1;
8904 return error_mark_node
;
8908 /* This TYPE is actually an instantiation of a partial
8909 specialization. We replace the innermost set of ARGS with
8910 the arguments appropriate for substitution. For example,
8913 template <class T> struct S {};
8914 template <class T> struct S<T*> {};
8916 and supposing that we are instantiating S<int*>, ARGS will
8917 presently be {int*} -- but we need {int}. */
8918 pattern
= TREE_TYPE (t
);
8919 args
= TREE_PURPOSE (t
);
8923 pattern
= TREE_TYPE (templ
);
8924 args
= CLASSTYPE_TI_ARGS (type
);
8927 /* If the template we're instantiating is incomplete, then clearly
8928 there's nothing we can do. */
8929 if (!COMPLETE_TYPE_P (pattern
))
8932 /* If we've recursively instantiated too many templates, stop. */
8933 if (! push_tinst_level (type
))
8936 /* Now we're really doing the instantiation. Mark the type as in
8937 the process of being defined. */
8938 TYPE_BEING_DEFINED (type
) = 1;
8940 /* We may be in the middle of deferred access check. Disable
8942 push_deferring_access_checks (dk_no_deferred
);
8944 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
8946 push_to_top_level ();
8947 /* Use #pragma pack from the template context. */
8948 saved_maximum_field_alignment
= maximum_field_alignment
;
8949 maximum_field_alignment
= TYPE_PRECISION (pattern
);
8951 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
8953 /* Set the input location to the most specialized template definition.
8954 This is needed if tsubsting causes an error. */
8955 typedecl
= TYPE_MAIN_DECL (pattern
);
8956 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
8957 DECL_SOURCE_LOCATION (typedecl
);
8959 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
8960 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
8961 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
8962 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
8963 if (ANON_AGGR_TYPE_P (pattern
))
8964 SET_ANON_AGGR_TYPE_P (type
);
8965 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
8967 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
8968 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
8969 /* Adjust visibility for template arguments. */
8970 determine_visibility (TYPE_MAIN_DECL (type
));
8972 if (CLASS_TYPE_P (type
))
8973 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
8975 pbinfo
= TYPE_BINFO (pattern
);
8977 /* We should never instantiate a nested class before its enclosing
8978 class; we need to look up the nested class by name before we can
8979 instantiate it, and that lookup should instantiate the enclosing
8981 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
8982 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
8984 base_list
= NULL_TREE
;
8985 if (BINFO_N_BASE_BINFOS (pbinfo
))
8991 /* We must enter the scope containing the type, as that is where
8992 the accessibility of types named in dependent bases are
8994 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
8996 /* Substitute into each of the bases to determine the actual
8998 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9001 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9002 tree expanded_bases
= NULL_TREE
;
9005 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9008 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9009 args
, tf_error
, NULL_TREE
);
9010 if (expanded_bases
== error_mark_node
)
9013 len
= TREE_VEC_LENGTH (expanded_bases
);
9016 for (idx
= 0; idx
< len
; idx
++)
9019 /* Extract the already-expanded base class. */
9020 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9022 /* Substitute to figure out the base class. */
9023 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9026 if (base
== error_mark_node
)
9029 base_list
= tree_cons (access
, base
, base_list
);
9030 if (BINFO_VIRTUAL_P (pbase_binfo
))
9031 TREE_TYPE (base_list
) = integer_type_node
;
9035 /* The list is now in reverse order; correct that. */
9036 base_list
= nreverse (base_list
);
9039 pop_scope (pushed_scope
);
9041 /* Now call xref_basetypes to set up all the base-class
9043 xref_basetypes (type
, base_list
);
9045 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9046 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9047 args
, tf_error
, NULL_TREE
);
9048 fixup_attribute_variants (type
);
9050 /* Now that our base classes are set up, enter the scope of the
9051 class, so that name lookups into base classes, etc. will work
9052 correctly. This is precisely analogous to what we do in
9053 begin_class_definition when defining an ordinary non-template
9054 class, except we also need to push the enclosing classes. */
9055 push_nested_class (type
);
9057 /* Now members are processed in the order of declaration. */
9058 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9059 member
; member
= TREE_CHAIN (member
))
9061 tree t
= TREE_VALUE (member
);
9063 if (TREE_PURPOSE (member
))
9067 /* Build new CLASSTYPE_NESTED_UTDS. */
9070 bool class_template_p
;
9072 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9073 && TYPE_LANG_SPECIFIC (t
)
9074 && CLASSTYPE_IS_TEMPLATE (t
));
9075 /* If the member is a class template, then -- even after
9076 substitution -- there may be dependent types in the
9077 template argument list for the class. We increment
9078 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9079 that function will assume that no types are dependent
9080 when outside of a template. */
9081 if (class_template_p
)
9082 ++processing_template_decl
;
9083 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9084 if (class_template_p
)
9085 --processing_template_decl
;
9086 if (newtag
== error_mark_node
)
9089 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9091 tree name
= TYPE_IDENTIFIER (t
);
9093 if (class_template_p
)
9094 /* Unfortunately, lookup_template_class sets
9095 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9096 instantiation (i.e., for the type of a member
9097 template class nested within a template class.)
9098 This behavior is required for
9099 maybe_process_partial_specialization to work
9100 correctly, but is not accurate in this case;
9101 the TAG is not an instantiation of anything.
9102 (The corresponding TEMPLATE_DECL is an
9103 instantiation, but the TYPE is not.) */
9104 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9106 /* Now, we call pushtag to put this NEWTAG into the scope of
9107 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9108 pushtag calling push_template_decl. We don't have to do
9109 this for enums because it will already have been done in
9112 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9113 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9116 else if (DECL_DECLARES_FUNCTION_P (t
))
9118 /* Build new TYPE_METHODS. */
9121 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9122 ++processing_template_decl
;
9123 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9124 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9125 --processing_template_decl
;
9126 set_current_access_from_decl (r
);
9127 finish_member_declaration (r
);
9128 /* Instantiate members marked with attribute used. */
9129 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9131 if (TREE_CODE (r
) == FUNCTION_DECL
9132 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9133 cp_check_omp_declare_reduction (r
);
9137 /* Build new TYPE_FIELDS. */
9138 if (TREE_CODE (t
) == STATIC_ASSERT
)
9142 ++c_inhibit_evaluation_warnings
;
9144 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9145 tf_warning_or_error
, NULL_TREE
,
9146 /*integral_constant_expression_p=*/true);
9147 --c_inhibit_evaluation_warnings
;
9149 finish_static_assert (condition
,
9150 STATIC_ASSERT_MESSAGE (t
),
9151 STATIC_ASSERT_SOURCE_LOCATION (t
),
9154 else if (TREE_CODE (t
) != CONST_DECL
)
9157 tree vec
= NULL_TREE
;
9160 /* The file and line for this declaration, to
9161 assist in error message reporting. Since we
9162 called push_tinst_level above, we don't need to
9164 input_location
= DECL_SOURCE_LOCATION (t
);
9166 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9167 ++processing_template_decl
;
9168 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9169 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9170 --processing_template_decl
;
9172 if (TREE_CODE (r
) == TREE_VEC
)
9174 /* A capture pack became multiple fields. */
9176 len
= TREE_VEC_LENGTH (vec
);
9179 for (int i
= 0; i
< len
; ++i
)
9182 r
= TREE_VEC_ELT (vec
, i
);
9187 [t]he initialization (and any associated
9188 side-effects) of a static data member does
9189 not occur unless the static data member is
9190 itself used in a way that requires the
9191 definition of the static data member to
9194 Therefore, we do not substitute into the
9195 initialized for the static data member here. */
9196 finish_static_data_member_decl
9199 /*init_const_expr_p=*/false,
9200 /*asmspec_tree=*/NULL_TREE
,
9202 /* Instantiate members marked with attribute used. */
9203 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9206 else if (TREE_CODE (r
) == FIELD_DECL
)
9208 /* Determine whether R has a valid type and can be
9209 completed later. If R is invalid, then its type
9210 is replaced by error_mark_node. */
9211 tree rtype
= TREE_TYPE (r
);
9212 if (can_complete_type_without_circularity (rtype
))
9213 complete_type (rtype
);
9215 if (!COMPLETE_TYPE_P (rtype
))
9217 cxx_incomplete_type_error (r
, rtype
);
9218 TREE_TYPE (r
) = error_mark_node
;
9222 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9223 such a thing will already have been added to the field
9224 list by tsubst_enum in finish_member_declaration in the
9225 CLASSTYPE_NESTED_UTDS case above. */
9226 if (!(TREE_CODE (r
) == TYPE_DECL
9227 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9228 && DECL_ARTIFICIAL (r
)))
9230 set_current_access_from_decl (r
);
9231 finish_member_declaration (r
);
9239 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9240 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9242 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9244 tree friend_type
= t
;
9245 bool adjust_processing_template_decl
= false;
9247 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9249 /* template <class T> friend class C; */
9250 friend_type
= tsubst_friend_class (friend_type
, args
);
9251 adjust_processing_template_decl
= true;
9253 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9255 /* template <class T> friend class C::D; */
9256 friend_type
= tsubst (friend_type
, args
,
9257 tf_warning_or_error
, NULL_TREE
);
9258 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9259 friend_type
= TREE_TYPE (friend_type
);
9260 adjust_processing_template_decl
= true;
9262 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9263 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9265 /* This could be either
9269 when dependent_type_p is false or
9271 template <class U> friend class T::C;
9274 friend_type
= tsubst (friend_type
, args
,
9275 tf_warning_or_error
, NULL_TREE
);
9276 /* Bump processing_template_decl for correct
9277 dependent_type_p calculation. */
9278 ++processing_template_decl
;
9279 if (dependent_type_p (friend_type
))
9280 adjust_processing_template_decl
= true;
9281 --processing_template_decl
;
9283 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9284 && hidden_name_p (TYPE_NAME (friend_type
)))
9288 where C hasn't been declared yet. Let's lookup name
9289 from namespace scope directly, bypassing any name that
9290 come from dependent base class. */
9291 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9293 /* The call to xref_tag_from_type does injection for friend
9295 push_nested_namespace (ns
);
9297 xref_tag_from_type (friend_type
, NULL_TREE
,
9298 /*tag_scope=*/ts_current
);
9299 pop_nested_namespace (ns
);
9301 else if (uses_template_parms (friend_type
))
9302 /* friend class C<T>; */
9303 friend_type
= tsubst (friend_type
, args
,
9304 tf_warning_or_error
, NULL_TREE
);
9309 where C is already declared or
9311 friend class C<int>;
9313 We don't have to do anything in these cases. */
9315 if (adjust_processing_template_decl
)
9316 /* Trick make_friend_class into realizing that the friend
9317 we're adding is a template, not an ordinary class. It's
9318 important that we use make_friend_class since it will
9319 perform some error-checking and output cross-reference
9321 ++processing_template_decl
;
9323 if (friend_type
!= error_mark_node
)
9324 make_friend_class (type
, friend_type
, /*complain=*/false);
9326 if (adjust_processing_template_decl
)
9327 --processing_template_decl
;
9331 /* Build new DECL_FRIENDLIST. */
9334 /* The file and line for this declaration, to
9335 assist in error message reporting. Since we
9336 called push_tinst_level above, we don't need to
9338 input_location
= DECL_SOURCE_LOCATION (t
);
9340 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9342 ++processing_template_decl
;
9343 push_deferring_access_checks (dk_no_check
);
9346 r
= tsubst_friend_function (t
, args
);
9347 add_friend (type
, r
, /*complain=*/false);
9348 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9350 pop_deferring_access_checks ();
9351 --processing_template_decl
;
9357 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9359 tree decl
= lambda_function (type
);
9362 if (!DECL_TEMPLATE_INFO (decl
)
9363 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9364 instantiate_decl (decl
, false, false);
9366 /* We need to instantiate the capture list from the template
9367 after we've instantiated the closure members, but before we
9368 consider adding the conversion op. Also keep any captures
9369 that may have been added during instantiation of the op(). */
9370 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9372 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9373 args
, tf_warning_or_error
, NULL_TREE
,
9376 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9377 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9379 maybe_add_lambda_conv_op (type
);
9382 gcc_assert (errorcount
);
9385 /* Set the file and line number information to whatever is given for
9386 the class itself. This puts error messages involving generated
9387 implicit functions at a predictable point, and the same point
9388 that would be used for non-template classes. */
9389 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9391 unreverse_member_declarations (type
);
9392 finish_struct_1 (type
);
9393 TYPE_BEING_DEFINED (type
) = 0;
9395 /* We don't instantiate default arguments for member functions. 14.7.1:
9397 The implicit instantiation of a class template specialization causes
9398 the implicit instantiation of the declarations, but not of the
9399 definitions or default arguments, of the class member functions,
9400 member classes, static data members and member templates.... */
9402 /* Some typedefs referenced from within the template code need to be access
9403 checked at template instantiation time, i.e now. These types were
9404 added to the template at parsing time. Let's get those and perform
9405 the access checks then. */
9406 perform_typedefs_access_check (pattern
, args
);
9407 perform_deferred_access_checks (tf_warning_or_error
);
9408 pop_nested_class ();
9409 maximum_field_alignment
= saved_maximum_field_alignment
;
9411 pop_from_top_level ();
9412 pop_deferring_access_checks ();
9415 /* The vtable for a template class can be emitted in any translation
9416 unit in which the class is instantiated. When there is no key
9417 method, however, finish_struct_1 will already have added TYPE to
9418 the keyed_classes list. */
9419 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9420 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9425 /* Wrapper for instantiate_class_template_1. */
9428 instantiate_class_template (tree type
)
9431 timevar_push (TV_TEMPLATE_INST
);
9432 ret
= instantiate_class_template_1 (type
);
9433 timevar_pop (TV_TEMPLATE_INST
);
9438 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9444 else if (TYPE_P (t
))
9445 r
= tsubst (t
, args
, complain
, in_decl
);
9448 if (!(complain
& tf_warning
))
9449 ++c_inhibit_evaluation_warnings
;
9450 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9451 /*integral_constant_expression_p=*/true);
9452 if (!(complain
& tf_warning
))
9453 --c_inhibit_evaluation_warnings
;
9458 /* Given a function parameter pack TMPL_PARM and some function parameters
9459 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9460 and set *SPEC_P to point at the next point in the list. */
9463 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9465 /* Collect all of the extra "packed" parameters into an
9469 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9470 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9471 tree spec_parm
= *spec_p
;
9474 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9476 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9479 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9480 parmvec
= make_tree_vec (len
);
9481 parmtypevec
= make_tree_vec (len
);
9482 spec_parm
= *spec_p
;
9483 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9485 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9486 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9489 /* Build the argument packs. */
9490 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9491 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9492 TREE_TYPE (argpack
) = argtypepack
;
9493 *spec_p
= spec_parm
;
9498 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9499 NONTYPE_ARGUMENT_PACK. */
9502 make_fnparm_pack (tree spec_parm
)
9504 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9507 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9511 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9513 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9514 if (i
>= TREE_VEC_LENGTH (vec
))
9516 return PACK_EXPANSION_P (TREE_VEC_ELT (vec
, i
));
9520 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9523 make_argument_pack_select (tree arg_pack
, unsigned index
)
9525 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9527 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9528 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9533 /* This is a subroutine of tsubst_pack_expansion.
9535 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9536 mechanism to store the (non complete list of) arguments of the
9537 substitution and return a non substituted pack expansion, in order
9538 to wait for when we have enough arguments to really perform the
9542 use_pack_expansion_extra_args_p (tree parm_packs
,
9546 /* If one pack has an expansion and another pack has a normal
9547 argument or if one pack has an empty argument and an another
9548 one hasn't then tsubst_pack_expansion cannot perform the
9549 substitution and need to fall back on the
9550 PACK_EXPANSION_EXTRA mechanism. */
9551 if (parm_packs
== NULL_TREE
)
9553 else if (has_empty_arg
)
9556 bool has_expansion_arg
= false;
9557 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9559 bool has_non_expansion_arg
= false;
9560 for (tree parm_pack
= parm_packs
;
9562 parm_pack
= TREE_CHAIN (parm_pack
))
9564 tree arg
= TREE_VALUE (parm_pack
);
9566 if (argument_pack_element_is_expansion_p (arg
, i
))
9567 has_expansion_arg
= true;
9569 has_non_expansion_arg
= true;
9572 if (has_expansion_arg
&& has_non_expansion_arg
)
9578 /* [temp.variadic]/6 says that:
9580 The instantiation of a pack expansion [...]
9581 produces a list E1,E2, ..., En, where N is the number of elements
9582 in the pack expansion parameters.
9584 This subroutine of tsubst_pack_expansion produces one of these Ei.
9586 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9587 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9588 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9589 INDEX is the index 'i' of the element Ei to produce. ARGS,
9590 COMPLAIN, and IN_DECL are the same parameters as for the
9591 tsubst_pack_expansion function.
9593 The function returns the resulting Ei upon successful completion,
9596 Note that this function possibly modifies the ARGS parameter, so
9597 it's the responsibility of the caller to restore it. */
9600 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9603 tree args
/* This parm gets
9605 tsubst_flags_t complain
,
9609 bool ith_elem_is_expansion
= false;
9611 /* For each parameter pack, change the substitution of the parameter
9612 pack to the ith argument in its argument pack, then expand the
9614 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9616 tree parm
= TREE_PURPOSE (pack
);
9617 tree arg_pack
= TREE_VALUE (pack
);
9618 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9620 ith_elem_is_expansion
|=
9621 argument_pack_element_is_expansion_p (arg_pack
, index
);
9623 /* Select the Ith argument from the pack. */
9624 if (TREE_CODE (parm
) == PARM_DECL
9625 || TREE_CODE (parm
) == FIELD_DECL
)
9629 aps
= make_argument_pack_select (arg_pack
, index
);
9631 register_local_specialization (aps
, parm
);
9634 aps
= retrieve_local_specialization (parm
);
9639 template_parm_level_and_index (parm
, &level
, &idx
);
9643 aps
= make_argument_pack_select (arg_pack
, index
);
9644 /* Update the corresponding argument. */
9645 TMPL_ARG (args
, level
, idx
) = aps
;
9648 /* Re-use the ARGUMENT_PACK_SELECT. */
9649 aps
= TMPL_ARG (args
, level
, idx
);
9651 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9654 /* Substitute into the PATTERN with the (possibly altered)
9656 if (pattern
== in_decl
)
9657 /* Expanding a fixed parameter pack from
9658 coerce_template_parameter_pack. */
9659 t
= tsubst_decl (pattern
, args
, complain
);
9660 else if (!TYPE_P (pattern
))
9661 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9662 /*integral_constant_expression_p=*/false);
9664 t
= tsubst (pattern
, args
, complain
, in_decl
);
9666 /* If the Ith argument pack element is a pack expansion, then
9667 the Ith element resulting from the substituting is going to
9668 be a pack expansion as well. */
9669 if (ith_elem_is_expansion
)
9670 t
= make_pack_expansion (t
);
9675 /* Substitute ARGS into T, which is an pack expansion
9676 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9677 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9678 (if only a partial substitution could be performed) or
9679 ERROR_MARK_NODE if there was an error. */
9681 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9685 tree pack
, packs
= NULL_TREE
;
9686 bool unsubstituted_packs
= false;
9689 struct pointer_map_t
*saved_local_specializations
= NULL
;
9690 bool need_local_specializations
= false;
9693 gcc_assert (PACK_EXPANSION_P (t
));
9694 pattern
= PACK_EXPANSION_PATTERN (t
);
9696 /* Add in any args remembered from an earlier partial instantiation. */
9697 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9699 levels
= TMPL_ARGS_DEPTH (args
);
9701 /* Determine the argument packs that will instantiate the parameter
9702 packs used in the expansion expression. While we're at it,
9703 compute the number of arguments to be expanded and make sure it
9705 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
9706 pack
= TREE_CHAIN (pack
))
9708 tree parm_pack
= TREE_VALUE (pack
);
9709 tree arg_pack
= NULL_TREE
;
9710 tree orig_arg
= NULL_TREE
;
9713 if (TREE_CODE (parm_pack
) == BASES
)
9715 if (BASES_DIRECT (parm_pack
))
9716 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9717 args
, complain
, in_decl
, false));
9719 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9720 args
, complain
, in_decl
, false));
9722 if (TREE_CODE (parm_pack
) == PARM_DECL
)
9724 if (PACK_EXPANSION_LOCAL_P (t
))
9725 arg_pack
= retrieve_local_specialization (parm_pack
);
9728 /* We can't rely on local_specializations for a parameter
9729 name used later in a function declaration (such as in a
9730 late-specified return type). Even if it exists, it might
9731 have the wrong value for a recursive call. Just make a
9732 dummy decl, since it's only used for its type. */
9733 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
9734 if (arg_pack
&& DECL_PACK_P (arg_pack
))
9735 /* Partial instantiation of the parm_pack, we can't build
9736 up an argument pack yet. */
9737 arg_pack
= NULL_TREE
;
9739 arg_pack
= make_fnparm_pack (arg_pack
);
9740 need_local_specializations
= true;
9743 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
9744 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
9748 template_parm_level_and_index (parm_pack
, &level
, &idx
);
9750 if (level
<= levels
)
9751 arg_pack
= TMPL_ARG (args
, level
, idx
);
9754 orig_arg
= arg_pack
;
9755 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
9756 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
9758 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
9759 /* This can only happen if we forget to expand an argument
9760 pack somewhere else. Just return an error, silently. */
9762 result
= make_tree_vec (1);
9763 TREE_VEC_ELT (result
, 0) = error_mark_node
;
9770 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
9772 /* Don't bother trying to do a partial substitution with
9773 incomplete packs; we'll try again after deduction. */
9774 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
9779 else if (len
!= my_len
)
9781 if (!(complain
& tf_error
))
9782 /* Fail quietly. */;
9783 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
9784 error ("mismatched argument pack lengths while expanding "
9788 error ("mismatched argument pack lengths while expanding "
9791 return error_mark_node
;
9794 /* Keep track of the parameter packs and their corresponding
9796 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
9797 TREE_TYPE (packs
) = orig_arg
;
9801 /* We can't substitute for this parameter pack. We use a flag as
9802 well as the missing_level counter because function parameter
9803 packs don't have a level. */
9804 unsubstituted_packs
= true;
9808 /* We cannot expand this expansion expression, because we don't have
9809 all of the argument packs we need. */
9810 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
9812 /* We got some full packs, but we can't substitute them in until we
9813 have values for all the packs. So remember these until then. */
9815 t
= make_pack_expansion (pattern
);
9816 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
9819 else if (unsubstituted_packs
)
9821 /* There were no real arguments, we're just replacing a parameter
9822 pack with another version of itself. Substitute into the
9823 pattern and return a PACK_EXPANSION_*. The caller will need to
9825 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
9826 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9827 /*integral_constant_expression_p=*/false);
9829 t
= tsubst (pattern
, args
, complain
, in_decl
);
9830 t
= make_pack_expansion (t
);
9834 gcc_assert (len
>= 0);
9836 if (need_local_specializations
)
9838 /* We're in a late-specified return type, so create our own local
9839 specializations map; the current map is either NULL or (in the
9840 case of recursive unification) might have bindings that we don't
9841 want to use or alter. */
9842 saved_local_specializations
= local_specializations
;
9843 local_specializations
= pointer_map_create ();
9846 /* For each argument in each argument pack, substitute into the
9848 result
= make_tree_vec (len
);
9849 for (i
= 0; i
< len
; ++i
)
9851 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
9855 TREE_VEC_ELT (result
, i
) = t
;
9856 if (t
== error_mark_node
)
9858 result
= error_mark_node
;
9863 /* Update ARGS to restore the substitution from parameter packs to
9864 their argument packs. */
9865 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
9867 tree parm
= TREE_PURPOSE (pack
);
9869 if (TREE_CODE (parm
) == PARM_DECL
9870 || TREE_CODE (parm
) == FIELD_DECL
)
9871 register_local_specialization (TREE_TYPE (pack
), parm
);
9876 if (TREE_VALUE (pack
) == NULL_TREE
)
9879 template_parm_level_and_index (parm
, &level
, &idx
);
9881 /* Update the corresponding argument. */
9882 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
9883 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
9886 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
9890 if (need_local_specializations
)
9892 pointer_map_destroy (local_specializations
);
9893 local_specializations
= saved_local_specializations
;
9899 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
9900 TMPL. We do this using DECL_PARM_INDEX, which should work even with
9901 parameter packs; all parms generated from a function parameter pack will
9902 have the same DECL_PARM_INDEX. */
9905 get_pattern_parm (tree parm
, tree tmpl
)
9907 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
9910 if (DECL_ARTIFICIAL (parm
))
9912 for (patparm
= DECL_ARGUMENTS (pattern
);
9913 patparm
; patparm
= DECL_CHAIN (patparm
))
9914 if (DECL_ARTIFICIAL (patparm
)
9915 && DECL_NAME (parm
) == DECL_NAME (patparm
))
9920 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
9921 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
9922 gcc_assert (DECL_PARM_INDEX (patparm
)
9923 == DECL_PARM_INDEX (parm
));
9929 /* Substitute ARGS into the vector or list of template arguments T. */
9932 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9935 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
9938 if (t
== error_mark_node
)
9939 return error_mark_node
;
9941 len
= TREE_VEC_LENGTH (t
);
9942 elts
= XALLOCAVEC (tree
, len
);
9944 for (i
= 0; i
< len
; i
++)
9946 tree orig_arg
= TREE_VEC_ELT (t
, i
);
9949 if (TREE_CODE (orig_arg
) == TREE_VEC
)
9950 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
9951 else if (PACK_EXPANSION_P (orig_arg
))
9953 /* Substitute into an expansion expression. */
9954 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
9956 if (TREE_CODE (new_arg
) == TREE_VEC
)
9957 /* Add to the expanded length adjustment the number of
9958 expanded arguments. We subtract one from this
9959 measurement, because the argument pack expression
9960 itself is already counted as 1 in
9961 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
9962 the argument pack is empty. */
9963 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
9965 else if (ARGUMENT_PACK_P (orig_arg
))
9967 /* Substitute into each of the arguments. */
9968 new_arg
= TYPE_P (orig_arg
)
9969 ? cxx_make_type (TREE_CODE (orig_arg
))
9970 : make_node (TREE_CODE (orig_arg
));
9972 SET_ARGUMENT_PACK_ARGS (
9974 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
9975 args
, complain
, in_decl
));
9977 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
9978 new_arg
= error_mark_node
;
9980 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
9981 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
9983 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
9985 if (TREE_TYPE (new_arg
) == error_mark_node
)
9986 new_arg
= error_mark_node
;
9990 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
9992 if (new_arg
== error_mark_node
)
9993 return error_mark_node
;
9996 if (new_arg
!= orig_arg
)
10003 /* Make space for the expanded arguments coming from template
10005 t
= make_tree_vec (len
+ expanded_len_adjust
);
10006 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10007 arguments for a member template.
10008 In that case each TREE_VEC in ORIG_T represents a level of template
10009 arguments, and ORIG_T won't carry any non defaulted argument count.
10010 It will rather be the nested TREE_VECs that will carry one.
10011 In other words, ORIG_T carries a non defaulted argument count only
10012 if it doesn't contain any nested TREE_VEC. */
10013 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
10015 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
10016 count
+= expanded_len_adjust
;
10017 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
10019 for (i
= 0, out
= 0; i
< len
; i
++)
10021 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
10022 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
10023 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10027 /* Now expand the template argument pack "in place". */
10028 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10029 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10033 TREE_VEC_ELT (t
, out
) = elts
[i
];
10041 /* Return the result of substituting ARGS into the template parameters
10042 given by PARMS. If there are m levels of ARGS and m + n levels of
10043 PARMS, then the result will contain n levels of PARMS. For
10044 example, if PARMS is `template <class T> template <class U>
10045 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10046 result will be `template <int*, double, class V>'. */
10049 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10051 tree r
= NULL_TREE
;
10054 /* When substituting into a template, we must set
10055 PROCESSING_TEMPLATE_DECL as the template parameters may be
10056 dependent if they are based on one-another, and the dependency
10057 predicates are short-circuit outside of templates. */
10058 ++processing_template_decl
;
10060 for (new_parms
= &r
;
10061 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10062 new_parms
= &(TREE_CHAIN (*new_parms
)),
10063 parms
= TREE_CHAIN (parms
))
10066 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10069 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10073 if (parms
== error_mark_node
)
10076 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10078 if (tuple
== error_mark_node
)
10081 TREE_VEC_ELT (new_vec
, i
) =
10082 tsubst_template_parm (tuple
, args
, complain
);
10086 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10087 - TMPL_ARGS_DEPTH (args
)),
10088 new_vec
, NULL_TREE
);
10091 --processing_template_decl
;
10096 /* Return the result of substituting ARGS into one template parameter
10097 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10098 parameter and which TREE_PURPOSE is the default argument of the
10099 template parameter. */
10102 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10104 tree default_value
, parm_decl
;
10106 if (args
== NULL_TREE
10108 || t
== error_mark_node
)
10111 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10113 default_value
= TREE_PURPOSE (t
);
10114 parm_decl
= TREE_VALUE (t
);
10116 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10117 if (TREE_CODE (parm_decl
) == PARM_DECL
10118 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10119 parm_decl
= error_mark_node
;
10120 default_value
= tsubst_template_arg (default_value
, args
,
10121 complain
, NULL_TREE
);
10123 return build_tree_list (default_value
, parm_decl
);
10126 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10127 type T. If T is not an aggregate or enumeration type, it is
10128 handled as if by tsubst. IN_DECL is as for tsubst. If
10129 ENTERING_SCOPE is nonzero, T is the context for a template which
10130 we are presently tsubst'ing. Return the substituted value. */
10133 tsubst_aggr_type (tree t
,
10135 tsubst_flags_t complain
,
10137 int entering_scope
)
10139 if (t
== NULL_TREE
)
10142 switch (TREE_CODE (t
))
10145 if (TYPE_PTRMEMFUNC_P (t
))
10146 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10148 /* Else fall through. */
10149 case ENUMERAL_TYPE
:
10151 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10156 int saved_unevaluated_operand
;
10157 int saved_inhibit_evaluation_warnings
;
10159 /* In "sizeof(X<I>)" we need to evaluate "I". */
10160 saved_unevaluated_operand
= cp_unevaluated_operand
;
10161 cp_unevaluated_operand
= 0;
10162 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10163 c_inhibit_evaluation_warnings
= 0;
10165 /* First, determine the context for the type we are looking
10167 context
= TYPE_CONTEXT (t
);
10168 if (context
&& TYPE_P (context
))
10170 context
= tsubst_aggr_type (context
, args
, complain
,
10171 in_decl
, /*entering_scope=*/1);
10172 /* If context is a nested class inside a class template,
10173 it may still need to be instantiated (c++/33959). */
10174 context
= complete_type (context
);
10177 /* Then, figure out what arguments are appropriate for the
10178 type we are trying to find. For example, given:
10180 template <class T> struct S;
10181 template <class T, class U> void f(T, U) { S<U> su; }
10183 and supposing that we are instantiating f<int, double>,
10184 then our ARGS will be {int, double}, but, when looking up
10185 S we only want {double}. */
10186 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10187 complain
, in_decl
);
10188 if (argvec
== error_mark_node
)
10189 r
= error_mark_node
;
10192 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10193 entering_scope
, complain
);
10194 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10197 cp_unevaluated_operand
= saved_unevaluated_operand
;
10198 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10203 /* This is not a template type, so there's nothing to do. */
10207 return tsubst (t
, args
, complain
, in_decl
);
10211 /* Substitute into the default argument ARG (a default argument for
10212 FN), which has the indicated TYPE. */
10215 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10217 tree saved_class_ptr
= NULL_TREE
;
10218 tree saved_class_ref
= NULL_TREE
;
10219 int errs
= errorcount
+ sorrycount
;
10221 /* This can happen in invalid code. */
10222 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10225 /* This default argument came from a template. Instantiate the
10226 default argument here, not in tsubst. In the case of
10235 we must be careful to do name lookup in the scope of S<T>,
10236 rather than in the current class. */
10237 push_access_scope (fn
);
10238 /* The "this" pointer is not valid in a default argument. */
10241 saved_class_ptr
= current_class_ptr
;
10242 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10243 saved_class_ref
= current_class_ref
;
10244 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10247 push_deferring_access_checks(dk_no_deferred
);
10248 /* The default argument expression may cause implicitly defined
10249 member functions to be synthesized, which will result in garbage
10250 collection. We must treat this situation as if we were within
10251 the body of function so as to avoid collecting live data on the
10254 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10255 complain
, NULL_TREE
,
10256 /*integral_constant_expression_p=*/false);
10258 pop_deferring_access_checks();
10260 /* Restore the "this" pointer. */
10263 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10264 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10267 if (errorcount
+sorrycount
> errs
10268 && (complain
& tf_warning_or_error
))
10269 inform (input_location
,
10270 " when instantiating default argument for call to %D", fn
);
10272 /* Make sure the default argument is reasonable. */
10273 arg
= check_default_argument (type
, arg
, complain
);
10275 pop_access_scope (fn
);
10280 /* Substitute into all the default arguments for FN. */
10283 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10288 tmpl_args
= DECL_TI_ARGS (fn
);
10290 /* If this function is not yet instantiated, we certainly don't need
10291 its default arguments. */
10292 if (uses_template_parms (tmpl_args
))
10294 /* Don't do this again for clones. */
10295 if (DECL_CLONED_FUNCTION_P (fn
))
10298 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10300 arg
= TREE_CHAIN (arg
))
10301 if (TREE_PURPOSE (arg
))
10302 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10304 TREE_PURPOSE (arg
),
10308 /* Substitute the ARGS into the T, which is a _DECL. Return the
10309 result of the substitution. Issue error and warning messages under
10310 control of COMPLAIN. */
10313 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10315 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10316 location_t saved_loc
;
10317 tree r
= NULL_TREE
;
10319 hashval_t hash
= 0;
10321 /* Set the filename and linenumber to improve error-reporting. */
10322 saved_loc
= input_location
;
10323 input_location
= DECL_SOURCE_LOCATION (t
);
10325 switch (TREE_CODE (t
))
10327 case TEMPLATE_DECL
:
10329 /* We can get here when processing a member function template,
10330 member class template, or template template parameter. */
10331 tree decl
= DECL_TEMPLATE_RESULT (t
);
10336 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10338 /* Template template parameter is treated here. */
10339 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10340 if (new_type
== error_mark_node
)
10341 RETURN (error_mark_node
);
10342 /* If we get a real template back, return it. This can happen in
10343 the context of most_specialized_class. */
10344 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10348 DECL_CHAIN (r
) = NULL_TREE
;
10349 TREE_TYPE (r
) = new_type
;
10350 DECL_TEMPLATE_RESULT (r
)
10351 = build_decl (DECL_SOURCE_LOCATION (decl
),
10352 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10353 DECL_TEMPLATE_PARMS (r
)
10354 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10356 TYPE_NAME (new_type
) = r
;
10360 /* We might already have an instance of this template.
10361 The ARGS are for the surrounding class type, so the
10362 full args contain the tsubst'd args for the context,
10363 plus the innermost args from the template decl. */
10364 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10365 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10366 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10367 /* Because this is a template, the arguments will still be
10368 dependent, even after substitution. If
10369 PROCESSING_TEMPLATE_DECL is not set, the dependency
10370 predicates will short-circuit. */
10371 ++processing_template_decl
;
10372 full_args
= tsubst_template_args (tmpl_args
, args
,
10373 complain
, in_decl
);
10374 --processing_template_decl
;
10375 if (full_args
== error_mark_node
)
10376 RETURN (error_mark_node
);
10378 /* If this is a default template template argument,
10379 tsubst might not have changed anything. */
10380 if (full_args
== tmpl_args
)
10383 hash
= hash_tmpl_and_args (t
, full_args
);
10384 spec
= retrieve_specialization (t
, full_args
, hash
);
10385 if (spec
!= NULL_TREE
)
10391 /* Make a new template decl. It will be similar to the
10392 original, but will record the current template arguments.
10393 We also create a new function declaration, which is just
10394 like the old one, but points to this new template, rather
10395 than the old one. */
10397 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10398 DECL_CHAIN (r
) = NULL_TREE
;
10400 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10402 if (TREE_CODE (decl
) == TYPE_DECL
10403 && !TYPE_DECL_ALIAS_P (decl
))
10406 ++processing_template_decl
;
10407 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10408 --processing_template_decl
;
10409 if (new_type
== error_mark_node
)
10410 RETURN (error_mark_node
);
10412 TREE_TYPE (r
) = new_type
;
10413 /* For a partial specialization, we need to keep pointing to
10414 the primary template. */
10415 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10416 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10417 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10418 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10419 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10424 ++processing_template_decl
;
10425 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10426 --processing_template_decl
;
10427 if (new_decl
== error_mark_node
)
10428 RETURN (error_mark_node
);
10430 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10431 DECL_TI_TEMPLATE (new_decl
) = r
;
10432 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10433 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10434 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10437 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10438 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10439 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10441 /* The template parameters for this new template are all the
10442 template parameters for the old template, except the
10443 outermost level of parameters. */
10444 DECL_TEMPLATE_PARMS (r
)
10445 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10448 if (PRIMARY_TEMPLATE_P (t
))
10449 DECL_PRIMARY_TEMPLATE (r
) = r
;
10451 if (TREE_CODE (decl
) != TYPE_DECL
)
10452 /* Record this non-type partial instantiation. */
10453 register_specialization (r
, t
,
10454 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10459 case FUNCTION_DECL
:
10462 tree argvec
= NULL_TREE
;
10470 /* Nobody should be tsubst'ing into non-template functions. */
10471 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10473 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10478 /* If T is not dependent, just return it. We have to
10479 increment PROCESSING_TEMPLATE_DECL because
10480 value_dependent_expression_p assumes that nothing is
10481 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10482 ++processing_template_decl
;
10483 dependent_p
= value_dependent_expression_p (t
);
10484 --processing_template_decl
;
10488 /* Calculate the most general template of which R is a
10489 specialization, and the complete set of arguments used to
10491 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10492 argvec
= tsubst_template_args (DECL_TI_ARGS
10493 (DECL_TEMPLATE_RESULT
10494 (DECL_TI_TEMPLATE (t
))),
10495 args
, complain
, in_decl
);
10496 if (argvec
== error_mark_node
)
10497 RETURN (error_mark_node
);
10499 /* Check to see if we already have this specialization. */
10500 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10501 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10509 /* We can see more levels of arguments than parameters if
10510 there was a specialization of a member template, like
10513 template <class T> struct S { template <class U> void f(); }
10514 template <> template <class U> void S<int>::f(U);
10516 Here, we'll be substituting into the specialization,
10517 because that's where we can find the code we actually
10518 want to generate, but we'll have enough arguments for
10519 the most general template.
10521 We also deal with the peculiar case:
10523 template <class T> struct S {
10524 template <class U> friend void f();
10526 template <class U> void f() {}
10528 template void f<double>();
10530 Here, the ARGS for the instantiation of will be {int,
10531 double}. But, we only need as many ARGS as there are
10532 levels of template parameters in CODE_PATTERN. We are
10533 careful not to get fooled into reducing the ARGS in
10536 template <class T> struct S { template <class U> void f(U); }
10537 template <class T> template <> void S<T>::f(int) {}
10539 which we can spot because the pattern will be a
10540 specialization in this case. */
10541 args_depth
= TMPL_ARGS_DEPTH (args
);
10543 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10544 if (args_depth
> parms_depth
10545 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10546 args
= get_innermost_template_args (args
, parms_depth
);
10550 /* This special case arises when we have something like this:
10552 template <class T> struct S {
10553 friend void f<int>(int, double);
10556 Here, the DECL_TI_TEMPLATE for the friend declaration
10557 will be an IDENTIFIER_NODE. We are being called from
10558 tsubst_friend_function, and we want only to create a
10559 new decl (R) with appropriate types so that we can call
10560 determine_specialization. */
10561 gen_tmpl
= NULL_TREE
;
10564 if (DECL_CLASS_SCOPE_P (t
))
10566 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10570 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10571 complain
, t
, /*entering_scope=*/1);
10576 ctx
= DECL_CONTEXT (t
);
10578 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10579 if (type
== error_mark_node
)
10580 RETURN (error_mark_node
);
10582 /* If we hit excessive deduction depth, the type is bogus even if
10583 it isn't error_mark_node, so don't build a decl. */
10584 if (excessive_deduction_depth
)
10585 RETURN (error_mark_node
);
10587 /* We do NOT check for matching decls pushed separately at this
10588 point, as they may not represent instantiations of this
10589 template, and in any case are considered separate under the
10592 DECL_USE_TEMPLATE (r
) = 0;
10593 TREE_TYPE (r
) = type
;
10594 /* Clear out the mangled name and RTL for the instantiation. */
10595 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10596 SET_DECL_RTL (r
, NULL
);
10597 /* Leave DECL_INITIAL set on deleted instantiations. */
10598 if (!DECL_DELETED_FN (r
))
10599 DECL_INITIAL (r
) = NULL_TREE
;
10600 DECL_CONTEXT (r
) = ctx
;
10602 /* OpenMP UDRs have the only argument a reference to the declared
10603 type. We want to diagnose if the declared type is a reference,
10604 which is invalid, but as references to references are usually
10605 quietly merged, diagnose it here. */
10606 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10609 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10610 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10611 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10612 error_at (DECL_SOURCE_LOCATION (t
),
10613 "reference type %qT in "
10614 "%<#pragma omp declare reduction%>", argtype
);
10615 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10616 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10620 if (member
&& DECL_CONV_FN_P (r
))
10621 /* Type-conversion operator. Reconstruct the name, in
10622 case it's the name of one of the template's parameters. */
10623 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10625 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10627 DECL_RESULT (r
) = NULL_TREE
;
10629 TREE_STATIC (r
) = 0;
10630 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10631 DECL_EXTERNAL (r
) = 1;
10632 /* If this is an instantiation of a function with internal
10633 linkage, we already know what object file linkage will be
10634 assigned to the instantiation. */
10635 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10636 DECL_DEFER_OUTPUT (r
) = 0;
10637 DECL_CHAIN (r
) = NULL_TREE
;
10638 DECL_PENDING_INLINE_INFO (r
) = 0;
10639 DECL_PENDING_INLINE_P (r
) = 0;
10640 DECL_SAVED_TREE (r
) = NULL_TREE
;
10641 DECL_STRUCT_FUNCTION (r
) = NULL
;
10643 /* We'll re-clone as appropriate in instantiate_template. */
10644 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10646 /* If we aren't complaining now, return on error before we register
10647 the specialization so that we'll complain eventually. */
10648 if ((complain
& tf_error
) == 0
10649 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10650 && !grok_op_properties (r
, /*complain=*/false))
10651 RETURN (error_mark_node
);
10653 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10654 this in the special friend case mentioned above where
10655 GEN_TMPL is NULL. */
10658 DECL_TEMPLATE_INFO (r
)
10659 = build_template_info (gen_tmpl
, argvec
);
10660 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10663 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10665 /* We instantiated this while substituting into
10666 the type earlier (template/friend54.C). */
10669 /* We're not supposed to instantiate default arguments
10670 until they are called, for a template. But, for a
10673 template <class T> void f ()
10674 { extern void g(int i = T()); }
10676 we should do the substitution when the template is
10677 instantiated. We handle the member function case in
10678 instantiate_class_template since the default arguments
10679 might refer to other members of the class. */
10681 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10682 && !uses_template_parms (argvec
))
10683 tsubst_default_arguments (r
, complain
);
10686 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10688 /* Copy the list of befriending classes. */
10689 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10691 friends
= &TREE_CHAIN (*friends
))
10693 *friends
= copy_node (*friends
);
10694 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
10699 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
10701 maybe_retrofit_in_chrg (r
);
10702 if (DECL_CONSTRUCTOR_P (r
))
10703 grok_ctor_properties (ctx
, r
);
10704 if (DECL_INHERITED_CTOR_BASE (r
))
10705 deduce_inheriting_ctor (r
);
10706 /* If this is an instantiation of a member template, clone it.
10707 If it isn't, that'll be handled by
10708 clone_constructors_and_destructors. */
10709 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
10710 clone_function_decl (r
, /*update_method_vec_p=*/0);
10712 else if ((complain
& tf_error
) != 0
10713 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10714 && !grok_op_properties (r
, /*complain=*/true))
10715 RETURN (error_mark_node
);
10717 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
10718 SET_DECL_FRIEND_CONTEXT (r
,
10719 tsubst (DECL_FRIEND_CONTEXT (t
),
10720 args
, complain
, in_decl
));
10722 /* Possibly limit visibility based on template args. */
10723 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10724 if (DECL_VISIBILITY_SPECIFIED (t
))
10726 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10727 DECL_ATTRIBUTES (r
)
10728 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10730 determine_visibility (r
);
10731 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
10732 && !processing_template_decl
)
10733 defaulted_late_check (r
);
10735 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10736 args
, complain
, in_decl
);
10742 tree type
= NULL_TREE
;
10744 tree expanded_types
= NULL_TREE
;
10745 tree prev_r
= NULL_TREE
;
10746 tree first_r
= NULL_TREE
;
10748 if (DECL_PACK_P (t
))
10750 /* If there is a local specialization that isn't a
10751 parameter pack, it means that we're doing a "simple"
10752 substitution from inside tsubst_pack_expansion. Just
10753 return the local specialization (which will be a single
10755 tree spec
= retrieve_local_specialization (t
);
10757 && TREE_CODE (spec
) == PARM_DECL
10758 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
10761 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10762 the parameters in this function parameter pack. */
10763 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10764 complain
, in_decl
);
10765 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10767 len
= TREE_VEC_LENGTH (expanded_types
);
10769 /* Zero-length parameter packs are boring. Just substitute
10772 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
10777 /* All we did was update the type. Make a note of that. */
10778 type
= expanded_types
;
10779 expanded_types
= NULL_TREE
;
10783 /* Loop through all of the parameters we'll build. When T is
10784 a function parameter pack, LEN is the number of expanded
10785 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10787 for (i
= 0; i
< len
; ++i
)
10791 if (DECL_TEMPLATE_PARM_P (t
))
10792 SET_DECL_TEMPLATE_PARM_P (r
);
10794 if (expanded_types
)
10795 /* We're on the Ith parameter of the function parameter
10798 /* Get the Ith type. */
10799 type
= TREE_VEC_ELT (expanded_types
, i
);
10801 /* Rename the parameter to include the index. */
10803 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10806 /* We're dealing with a normal parameter. */
10807 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10809 type
= type_decays_to (type
);
10810 TREE_TYPE (r
) = type
;
10811 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10813 if (DECL_INITIAL (r
))
10815 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
10816 DECL_INITIAL (r
) = TREE_TYPE (r
);
10818 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
10819 complain
, in_decl
);
10822 DECL_CONTEXT (r
) = NULL_TREE
;
10824 if (!DECL_TEMPLATE_PARM_P (r
))
10825 DECL_ARG_TYPE (r
) = type_passed_as (type
);
10827 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10828 args
, complain
, in_decl
);
10830 /* Keep track of the first new parameter we
10831 generate. That's what will be returned to the
10836 /* Build a proper chain of parameters when substituting
10837 into a function parameter pack. */
10839 DECL_CHAIN (prev_r
) = r
;
10842 /* If cp_unevaluated_operand is set, we're just looking for a
10843 single dummy parameter, so don't keep going. */
10844 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
10845 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
10846 complain
, DECL_CHAIN (t
));
10848 /* FIRST_R contains the start of the chain we've built. */
10855 tree type
= NULL_TREE
;
10856 tree vec
= NULL_TREE
;
10857 tree expanded_types
= NULL_TREE
;
10860 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
10862 /* This field is a lambda capture pack. Return a TREE_VEC of
10863 the expanded fields to instantiate_class_template_1 and
10864 store them in the specializations hash table as a
10865 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
10866 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10867 complain
, in_decl
);
10868 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10870 len
= TREE_VEC_LENGTH (expanded_types
);
10871 vec
= make_tree_vec (len
);
10875 /* All we did was update the type. Make a note of that. */
10876 type
= expanded_types
;
10877 expanded_types
= NULL_TREE
;
10881 for (int i
= 0; i
< len
; ++i
)
10884 if (expanded_types
)
10886 type
= TREE_VEC_ELT (expanded_types
, i
);
10888 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10891 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10893 if (type
== error_mark_node
)
10894 RETURN (error_mark_node
);
10895 TREE_TYPE (r
) = type
;
10896 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10898 if (DECL_C_BIT_FIELD (r
))
10899 /* For bit-fields, DECL_INITIAL gives the number of bits. For
10900 non-bit-fields DECL_INITIAL is a non-static data member
10901 initializer, which gets deferred instantiation. */
10903 = tsubst_expr (DECL_INITIAL (t
), args
,
10905 /*integral_constant_expression_p=*/true);
10906 else if (DECL_INITIAL (t
))
10908 /* Set up DECL_TEMPLATE_INFO so that we can get at the
10909 NSDMI in perform_member_init. Still set DECL_INITIAL
10910 so that we know there is one. */
10911 DECL_INITIAL (r
) = void_zero_node
;
10912 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
10913 retrofit_lang_decl (r
);
10914 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10916 /* We don't have to set DECL_CONTEXT here; it is set by
10917 finish_member_declaration. */
10918 DECL_CHAIN (r
) = NULL_TREE
;
10920 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10921 args
, complain
, in_decl
);
10924 TREE_VEC_ELT (vec
, i
) = r
;
10930 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
10931 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
10932 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
10933 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
10934 TREE_TYPE (pack
) = tpack
;
10935 register_specialization (pack
, t
, args
, false, 0);
10941 /* We reach here only for member using decls. We also need to check
10942 uses_template_parms because DECL_DEPENDENT_P is not set for a
10943 using-declaration that designates a member of the current
10944 instantiation (c++/53549). */
10945 if (DECL_DEPENDENT_P (t
)
10946 || uses_template_parms (USING_DECL_SCOPE (t
)))
10948 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
10949 complain
, in_decl
);
10950 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
10951 r
= do_class_using_decl (inst_scope
, name
);
10953 r
= error_mark_node
;
10956 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
10957 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
10963 DECL_CHAIN (r
) = NULL_TREE
;
10970 tree argvec
= NULL_TREE
;
10971 tree gen_tmpl
= NULL_TREE
;
10973 tree tmpl
= NULL_TREE
;
10975 tree type
= NULL_TREE
;
10978 if (TREE_TYPE (t
) == error_mark_node
)
10979 RETURN (error_mark_node
);
10981 if (TREE_CODE (t
) == TYPE_DECL
10982 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
10984 /* If this is the canonical decl, we don't have to
10985 mess with instantiations, and often we can't (for
10986 typename, template type parms and such). Note that
10987 TYPE_NAME is not correct for the above test if
10988 we've copied the type for a typedef. */
10989 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10990 if (type
== error_mark_node
)
10991 RETURN (error_mark_node
);
10992 r
= TYPE_NAME (type
);
10996 /* Check to see if we already have the specialization we
10999 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
11001 /* T is a static data member or namespace-scope entity.
11002 We have to substitute into namespace-scope variables
11003 (even though such entities are never templates) because
11006 template <class T> void f() { extern T t; }
11008 where the entity referenced is not known until
11009 instantiation time. */
11011 ctx
= DECL_CONTEXT (t
);
11012 if (DECL_CLASS_SCOPE_P (t
))
11014 ctx
= tsubst_aggr_type (ctx
, args
,
11016 in_decl
, /*entering_scope=*/1);
11017 /* If CTX is unchanged, then T is in fact the
11018 specialization we want. That situation occurs when
11019 referencing a static data member within in its own
11020 class. We can use pointer equality, rather than
11021 same_type_p, because DECL_CONTEXT is always
11023 if (ctx
== DECL_CONTEXT (t
)
11024 && (TREE_CODE (t
) != TYPE_DECL
11025 /* ... unless T is a member template; in which
11026 case our caller can be willing to create a
11027 specialization of that template represented
11029 || !(DECL_TI_TEMPLATE (t
)
11030 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))))
11036 tmpl
= DECL_TI_TEMPLATE (t
);
11037 gen_tmpl
= most_general_template (tmpl
);
11038 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11039 if (argvec
== error_mark_node
)
11040 RETURN (error_mark_node
);
11041 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11042 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11047 /* A local variable. */
11049 /* Subsequent calls to pushdecl will fill this in. */
11051 spec
= retrieve_local_specialization (t
);
11053 /* If we already have the specialization we need, there is
11054 nothing more to do. */
11061 /* Create a new node for the specialization we need. */
11063 if (type
== NULL_TREE
)
11065 if (is_typedef_decl (t
))
11066 type
= DECL_ORIGINAL_TYPE (t
);
11068 type
= TREE_TYPE (t
);
11070 && VAR_HAD_UNKNOWN_BOUND (t
)
11071 && type
!= error_mark_node
)
11072 type
= strip_array_domain (type
);
11073 type
= tsubst (type
, args
, complain
, in_decl
);
11077 /* Even if the original location is out of scope, the
11078 newly substituted one is not. */
11079 DECL_DEAD_FOR_LOCAL (r
) = 0;
11080 DECL_INITIALIZED_P (r
) = 0;
11081 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11082 if (type
== error_mark_node
)
11083 RETURN (error_mark_node
);
11084 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11086 /* It may seem that this case cannot occur, since:
11091 declares a function, not a variable. However:
11094 template <typename T> void g() { T t; }
11095 template void g<f>();
11097 is an attempt to declare a variable with function
11099 error ("variable %qD has function type",
11100 /* R is not yet sufficiently initialized, so we
11101 just use its name. */
11103 RETURN (error_mark_node
);
11105 type
= complete_type (type
);
11106 /* Wait until cp_finish_decl to set this again, to handle
11107 circular dependency (template/instantiate6.C). */
11108 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11109 type
= check_var_type (DECL_NAME (r
), type
);
11111 if (DECL_HAS_VALUE_EXPR_P (t
))
11113 tree ve
= DECL_VALUE_EXPR (t
);
11114 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11115 /*constant_expression_p=*/false);
11116 if (REFERENCE_REF_P (ve
))
11118 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11119 ve
= TREE_OPERAND (ve
, 0);
11121 SET_DECL_VALUE_EXPR (r
, ve
);
11124 else if (DECL_SELF_REFERENCE_P (t
))
11125 SET_DECL_SELF_REFERENCE_P (r
);
11126 TREE_TYPE (r
) = type
;
11127 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11128 DECL_CONTEXT (r
) = ctx
;
11129 /* Clear out the mangled name and RTL for the instantiation. */
11130 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11131 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11132 SET_DECL_RTL (r
, NULL
);
11133 /* The initializer must not be expanded until it is required;
11134 see [temp.inst]. */
11135 DECL_INITIAL (r
) = NULL_TREE
;
11136 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11137 SET_DECL_RTL (r
, NULL
);
11138 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11141 /* Possibly limit visibility based on template args. */
11142 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11143 if (DECL_VISIBILITY_SPECIFIED (t
))
11145 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11146 DECL_ATTRIBUTES (r
)
11147 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11149 determine_visibility (r
);
11154 /* A static data member declaration is always marked
11155 external when it is declared in-class, even if an
11156 initializer is present. We mimic the non-template
11157 processing here. */
11158 DECL_EXTERNAL (r
) = 1;
11160 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11161 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11162 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11164 else if (!cp_unevaluated_operand
)
11165 register_local_specialization (r
, t
);
11167 DECL_CHAIN (r
) = NULL_TREE
;
11169 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11171 args
, complain
, in_decl
);
11173 /* Preserve a typedef that names a type. */
11174 if (is_typedef_decl (r
))
11176 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11177 set_underlying_type (r
);
11180 layout_decl (r
, 0);
11185 gcc_unreachable ();
11190 /* Restore the file and line information. */
11191 input_location
= saved_loc
;
11196 /* Substitute into the ARG_TYPES of a function type.
11197 If END is a TREE_CHAIN, leave it and any following types
11201 tsubst_arg_types (tree arg_types
,
11204 tsubst_flags_t complain
,
11207 tree remaining_arg_types
;
11208 tree type
= NULL_TREE
;
11210 tree expanded_args
= NULL_TREE
;
11213 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11216 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11217 args
, end
, complain
, in_decl
);
11218 if (remaining_arg_types
== error_mark_node
)
11219 return error_mark_node
;
11221 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11223 /* For a pack expansion, perform substitution on the
11224 entire expression. Later on, we'll handle the arguments
11226 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11227 args
, complain
, in_decl
);
11229 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11230 /* So that we'll spin through the parameters, one by one. */
11231 i
= TREE_VEC_LENGTH (expanded_args
);
11234 /* We only partially substituted into the parameter
11235 pack. Our type is TYPE_PACK_EXPANSION. */
11236 type
= expanded_args
;
11237 expanded_args
= NULL_TREE
;
11245 type
= TREE_VEC_ELT (expanded_args
, i
);
11247 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11249 if (type
== error_mark_node
)
11250 return error_mark_node
;
11251 if (VOID_TYPE_P (type
))
11253 if (complain
& tf_error
)
11255 error ("invalid parameter type %qT", type
);
11257 error ("in declaration %q+D", in_decl
);
11259 return error_mark_node
;
11262 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11263 return error_mark_node
;
11265 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11266 top-level qualifiers as required. */
11267 type
= cv_unqualified (type_decays_to (type
));
11269 /* We do not substitute into default arguments here. The standard
11270 mandates that they be instantiated only when needed, which is
11271 done in build_over_call. */
11272 default_arg
= TREE_PURPOSE (arg_types
);
11274 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11276 /* We've instantiated a template before its default arguments
11277 have been parsed. This can happen for a nested template
11278 class, and is not an error unless we require the default
11279 argument in a call of this function. */
11280 remaining_arg_types
=
11281 tree_cons (default_arg
, type
, remaining_arg_types
);
11282 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11285 remaining_arg_types
=
11286 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11289 return remaining_arg_types
;
11292 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11293 *not* handle the exception-specification for FNTYPE, because the
11294 initial substitution of explicitly provided template parameters
11295 during argument deduction forbids substitution into the
11296 exception-specification:
11300 All references in the function type of the function template to the
11301 corresponding template parameters are replaced by the specified tem-
11302 plate argument values. If a substitution in a template parameter or
11303 in the function type of the function template results in an invalid
11304 type, type deduction fails. [Note: The equivalent substitution in
11305 exception specifications is done only when the function is instanti-
11306 ated, at which point a program is ill-formed if the substitution
11307 results in an invalid type.] */
11310 tsubst_function_type (tree t
,
11312 tsubst_flags_t complain
,
11319 /* The TYPE_CONTEXT is not used for function/method types. */
11320 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11322 /* Substitute the return type. */
11323 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11324 if (return_type
== error_mark_node
)
11325 return error_mark_node
;
11326 /* DR 486 clarifies that creation of a function type with an
11327 invalid return type is a deduction failure. */
11328 if (TREE_CODE (return_type
) == ARRAY_TYPE
11329 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11331 if (complain
& tf_error
)
11333 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11334 error ("function returning an array");
11336 error ("function returning a function");
11338 return error_mark_node
;
11341 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11342 return error_mark_node
;
11344 /* Substitute the argument types. */
11345 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11346 complain
, in_decl
);
11347 if (arg_types
== error_mark_node
)
11348 return error_mark_node
;
11350 /* Construct a new type node and return it. */
11351 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11353 fntype
= build_function_type (return_type
, arg_types
);
11354 fntype
= apply_memfn_quals (fntype
,
11355 type_memfn_quals (t
),
11356 type_memfn_rqual (t
));
11360 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11361 /* Don't pick up extra function qualifiers from the basetype. */
11362 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11363 if (! MAYBE_CLASS_TYPE_P (r
))
11367 Type deduction may fail for any of the following
11370 -- Attempting to create "pointer to member of T" when T
11371 is not a class type. */
11372 if (complain
& tf_error
)
11373 error ("creating pointer to member function of non-class type %qT",
11375 return error_mark_node
;
11378 fntype
= build_method_type_directly (r
, return_type
,
11379 TREE_CHAIN (arg_types
));
11380 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11382 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11387 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11388 ARGS into that specification, and return the substituted
11389 specification. If there is no specification, return NULL_TREE. */
11392 tsubst_exception_specification (tree fntype
,
11394 tsubst_flags_t complain
,
11401 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11402 new_specs
= NULL_TREE
;
11403 if (specs
&& TREE_PURPOSE (specs
))
11405 /* A noexcept-specifier. */
11406 tree expr
= TREE_PURPOSE (specs
);
11407 if (TREE_CODE (expr
) == INTEGER_CST
)
11411 /* Defer instantiation of noexcept-specifiers to avoid
11412 excessive instantiations (c++/49107). */
11413 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11414 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11416 /* We already partially instantiated this member template,
11417 so combine the new args with the old. */
11418 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11419 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11420 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11421 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11425 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11426 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11430 new_specs
= tsubst_copy_and_build
11431 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11432 /*integral_constant_expression_p=*/true);
11433 new_specs
= build_noexcept_spec (new_specs
, complain
);
11437 if (! TREE_VALUE (specs
))
11444 tree expanded_specs
= NULL_TREE
;
11446 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11448 /* Expand the pack expansion type. */
11449 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11453 if (expanded_specs
== error_mark_node
)
11454 return error_mark_node
;
11455 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11456 len
= TREE_VEC_LENGTH (expanded_specs
);
11459 /* We're substituting into a member template, so
11460 we got a TYPE_PACK_EXPANSION back. Add that
11461 expansion and move on. */
11462 gcc_assert (TREE_CODE (expanded_specs
)
11463 == TYPE_PACK_EXPANSION
);
11464 new_specs
= add_exception_specifier (new_specs
,
11467 specs
= TREE_CHAIN (specs
);
11472 for (i
= 0; i
< len
; ++i
)
11474 if (expanded_specs
)
11475 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11477 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11478 if (spec
== error_mark_node
)
11480 new_specs
= add_exception_specifier (new_specs
, spec
,
11484 specs
= TREE_CHAIN (specs
);
11490 /* Take the tree structure T and replace template parameters used
11491 therein with the argument vector ARGS. IN_DECL is an associated
11492 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11493 Issue error and warning messages under control of COMPLAIN. Note
11494 that we must be relatively non-tolerant of extensions here, in
11495 order to preserve conformance; if we allow substitutions that
11496 should not be allowed, we may allow argument deductions that should
11497 not succeed, and therefore report ambiguous overload situations
11498 where there are none. In theory, we could allow the substitution,
11499 but indicate that it should have failed, and allow our caller to
11500 make sure that the right thing happens, but we don't try to do this
11503 This function is used for dealing with types, decls and the like;
11504 for expressions, use tsubst_expr or tsubst_copy. */
11507 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11509 enum tree_code code
;
11510 tree type
, r
= NULL_TREE
;
11512 if (t
== NULL_TREE
|| t
== error_mark_node
11513 || t
== integer_type_node
11514 || t
== void_type_node
11515 || t
== char_type_node
11516 || t
== unknown_type_node
11517 || TREE_CODE (t
) == NAMESPACE_DECL
11518 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11522 return tsubst_decl (t
, args
, complain
);
11524 if (args
== NULL_TREE
)
11527 code
= TREE_CODE (t
);
11529 if (code
== IDENTIFIER_NODE
)
11530 type
= IDENTIFIER_TYPE_VALUE (t
);
11532 type
= TREE_TYPE (t
);
11534 gcc_assert (type
!= unknown_type_node
);
11536 /* Reuse typedefs. We need to do this to handle dependent attributes,
11537 such as attribute aligned. */
11539 && typedef_variant_p (t
))
11541 tree decl
= TYPE_NAME (t
);
11543 if (alias_template_specialization_p (t
))
11545 /* DECL represents an alias template and we want to
11547 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11548 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11549 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11551 else if (DECL_CLASS_SCOPE_P (decl
)
11552 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11553 && uses_template_parms (DECL_CONTEXT (decl
)))
11555 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11556 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11557 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11559 else if (DECL_FUNCTION_SCOPE_P (decl
)
11560 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11561 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11562 r
= retrieve_local_specialization (decl
);
11564 /* The typedef is from a non-template context. */
11570 r
= cp_build_qualified_type_real
11571 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11572 complain
| tf_ignore_bad_quals
);
11577 /* We don't have an instantiation yet, so drop the typedef. */
11578 int quals
= cp_type_quals (t
);
11579 t
= DECL_ORIGINAL_TYPE (decl
);
11580 t
= cp_build_qualified_type_real (t
, quals
,
11581 complain
| tf_ignore_bad_quals
);
11586 && code
!= TYPENAME_TYPE
11587 && code
!= TEMPLATE_TYPE_PARM
11588 && code
!= IDENTIFIER_NODE
11589 && code
!= FUNCTION_TYPE
11590 && code
!= METHOD_TYPE
)
11591 type
= tsubst (type
, args
, complain
, in_decl
);
11592 if (type
== error_mark_node
)
11593 return error_mark_node
;
11599 case ENUMERAL_TYPE
:
11600 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11601 /*entering_scope=*/0);
11604 case IDENTIFIER_NODE
:
11615 if (t
== integer_type_node
)
11618 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11619 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11623 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11625 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11626 /*integral_constant_expression_p=*/false);
11628 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11630 if (TREE_CODE (max
) == NOP_EXPR
11631 && TREE_SIDE_EFFECTS (omax
)
11632 && !TREE_TYPE (max
))
11633 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11635 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11636 with TREE_SIDE_EFFECTS that indicates this is not an integral
11637 constant expression. */
11638 if (processing_template_decl
11639 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11641 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11642 TREE_SIDE_EFFECTS (max
) = 1;
11645 return compute_array_index_type (NULL_TREE
, max
, complain
);
11648 case TEMPLATE_TYPE_PARM
:
11649 case TEMPLATE_TEMPLATE_PARM
:
11650 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11651 case TEMPLATE_PARM_INDEX
:
11656 tree arg
= NULL_TREE
;
11660 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
11661 template_parm_level_and_index (t
, &level
, &idx
);
11663 levels
= TMPL_ARGS_DEPTH (args
);
11664 if (level
<= levels
)
11666 arg
= TMPL_ARG (args
, level
, idx
);
11668 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
11670 /* See through ARGUMENT_PACK_SELECT arguments. */
11671 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
11672 /* If the selected argument is an expansion E, that most
11673 likely means we were called from
11674 gen_elem_of_pack_expansion_instantiation during the
11675 substituting of pack an argument pack (which Ith
11676 element is a pack expansion, where I is
11677 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11678 In this case, the Ith element resulting from this
11679 substituting is going to be a pack expansion, which
11680 pattern is the pattern of E. Let's return the
11682 gen_elem_of_pack_expansion_instantiation will
11683 build the resulting pack expansion from it. */
11684 if (PACK_EXPANSION_P (arg
))
11685 arg
= PACK_EXPANSION_PATTERN (arg
);
11689 if (arg
== error_mark_node
)
11690 return error_mark_node
;
11691 else if (arg
!= NULL_TREE
)
11693 if (ARGUMENT_PACK_P (arg
))
11694 /* If ARG is an argument pack, we don't actually want to
11695 perform a substitution here, because substitutions
11696 for argument packs are only done
11697 element-by-element. We can get to this point when
11698 substituting the type of a non-type template
11699 parameter pack, when that type actually contains
11700 template parameter packs from an outer template, e.g.,
11702 template<typename... Types> struct A {
11703 template<Types... Values> struct B { };
11707 if (code
== TEMPLATE_TYPE_PARM
)
11710 gcc_assert (TYPE_P (arg
));
11712 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
11714 return cp_build_qualified_type_real
11715 (arg
, quals
, complain
| tf_ignore_bad_quals
);
11717 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11719 /* We are processing a type constructed from a
11720 template template parameter. */
11721 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
11722 args
, complain
, in_decl
);
11723 if (argvec
== error_mark_node
)
11724 return error_mark_node
;
11726 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
11727 || TREE_CODE (arg
) == TEMPLATE_DECL
11728 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
11730 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
11731 /* Consider this code:
11733 template <template <class> class Template>
11735 template <class Arg> using Bind = Template<Arg>;
11738 template <template <class> class Template, class Arg>
11739 using Instantiate = Template<Arg>; //#0
11741 template <template <class> class Template,
11744 Instantiate<Internal<Template>::template Bind,
11747 When #1 is parsed, the
11748 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11749 parameter `Template' in #0 matches the
11750 UNBOUND_CLASS_TEMPLATE representing the argument
11751 `Internal<Template>::template Bind'; We then want
11752 to assemble the type `Bind<Argument>' that can't
11753 be fully created right now, because
11754 `Internal<Template>' not being complete, the Bind
11755 template cannot be looked up in that context. So
11756 we need to "store" `Bind<Argument>' for later
11757 when the context of Bind becomes complete. Let's
11758 store that in a TYPENAME_TYPE. */
11759 return make_typename_type (TYPE_CONTEXT (arg
),
11760 build_nt (TEMPLATE_ID_EXPR
,
11761 TYPE_IDENTIFIER (arg
),
11766 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11767 are resolving nested-types in the signature of a
11768 member function templates. Otherwise ARG is a
11769 TEMPLATE_DECL and is the real template to be
11771 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11772 arg
= TYPE_NAME (arg
);
11774 r
= lookup_template_class (arg
,
11776 DECL_CONTEXT (arg
),
11777 /*entering_scope=*/0,
11779 return cp_build_qualified_type_real
11780 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
11783 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11784 return convert_from_reference (unshare_expr (arg
));
11788 /* This can happen during the attempted tsubst'ing in
11789 unify. This means that we don't yet have any information
11790 about the template parameter in question. */
11793 /* Early in template argument deduction substitution, we don't
11794 want to reduce the level of 'auto', or it will be confused
11795 with a normal template parm in subsequent deduction. */
11796 if (is_auto (t
) && (complain
& tf_partial
))
11799 /* If we get here, we must have been looking at a parm for a
11800 more deeply nested template. Make a new version of this
11801 template parameter, but with a lower level. */
11804 case TEMPLATE_TYPE_PARM
:
11805 case TEMPLATE_TEMPLATE_PARM
:
11806 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11807 if (cp_type_quals (t
))
11809 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
11810 r
= cp_build_qualified_type_real
11811 (r
, cp_type_quals (t
),
11812 complain
| (code
== TEMPLATE_TYPE_PARM
11813 ? tf_ignore_bad_quals
: 0));
11818 TEMPLATE_TYPE_PARM_INDEX (r
)
11819 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
11820 r
, levels
, args
, complain
);
11821 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
11822 TYPE_MAIN_VARIANT (r
) = r
;
11823 TYPE_POINTER_TO (r
) = NULL_TREE
;
11824 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
11826 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
11827 /* We have reduced the level of the template
11828 template parameter, but not the levels of its
11829 template parameters, so canonical_type_parameter
11830 will not be able to find the canonical template
11831 template parameter for this level. Thus, we
11832 require structural equality checking to compare
11833 TEMPLATE_TEMPLATE_PARMs. */
11834 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11835 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
11836 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11838 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
11840 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11842 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
11843 complain
, in_decl
);
11844 if (argvec
== error_mark_node
)
11845 return error_mark_node
;
11847 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
11848 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
11853 case TEMPLATE_PARM_INDEX
:
11854 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
11858 gcc_unreachable ();
11866 tree purpose
, value
, chain
;
11868 if (t
== void_list_node
)
11871 purpose
= TREE_PURPOSE (t
);
11874 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
11875 if (purpose
== error_mark_node
)
11876 return error_mark_node
;
11878 value
= TREE_VALUE (t
);
11881 value
= tsubst (value
, args
, complain
, in_decl
);
11882 if (value
== error_mark_node
)
11883 return error_mark_node
;
11885 chain
= TREE_CHAIN (t
);
11886 if (chain
&& chain
!= void_type_node
)
11888 chain
= tsubst (chain
, args
, complain
, in_decl
);
11889 if (chain
== error_mark_node
)
11890 return error_mark_node
;
11892 if (purpose
== TREE_PURPOSE (t
)
11893 && value
== TREE_VALUE (t
)
11894 && chain
== TREE_CHAIN (t
))
11896 return hash_tree_cons (purpose
, value
, chain
);
11900 /* We should never be tsubsting a binfo. */
11901 gcc_unreachable ();
11904 /* A vector of template arguments. */
11905 gcc_assert (!type
);
11906 return tsubst_template_args (t
, args
, complain
, in_decl
);
11909 case REFERENCE_TYPE
:
11911 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
11916 Type deduction may fail for any of the following
11919 -- Attempting to create a pointer to reference type.
11920 -- Attempting to create a reference to a reference type or
11921 a reference to void.
11923 Core issue 106 says that creating a reference to a reference
11924 during instantiation is no longer a cause for failure. We
11925 only enforce this check in strict C++98 mode. */
11926 if ((TREE_CODE (type
) == REFERENCE_TYPE
11927 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
11928 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
11930 static location_t last_loc
;
11932 /* We keep track of the last time we issued this error
11933 message to avoid spewing a ton of messages during a
11934 single bad template instantiation. */
11935 if (complain
& tf_error
11936 && last_loc
!= input_location
)
11938 if (VOID_TYPE_P (type
))
11939 error ("forming reference to void");
11940 else if (code
== POINTER_TYPE
)
11941 error ("forming pointer to reference type %qT", type
);
11943 error ("forming reference to reference type %qT", type
);
11944 last_loc
= input_location
;
11947 return error_mark_node
;
11949 else if (TREE_CODE (type
) == FUNCTION_TYPE
11950 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
11951 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
11953 if (complain
& tf_error
)
11955 if (code
== POINTER_TYPE
)
11956 error ("forming pointer to qualified function type %qT",
11959 error ("forming reference to qualified function type %qT",
11962 return error_mark_node
;
11964 else if (code
== POINTER_TYPE
)
11966 r
= build_pointer_type (type
);
11967 if (TREE_CODE (type
) == METHOD_TYPE
)
11968 r
= build_ptrmemfunc_type (r
);
11970 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
11971 /* In C++0x, during template argument substitution, when there is an
11972 attempt to create a reference to a reference type, reference
11973 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
11975 "If a template-argument for a template-parameter T names a type
11976 that is a reference to a type A, an attempt to create the type
11977 'lvalue reference to cv T' creates the type 'lvalue reference to
11978 A,' while an attempt to create the type type rvalue reference to
11979 cv T' creates the type T"
11981 r
= cp_build_reference_type
11983 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
11985 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
11986 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
11988 if (cxx_dialect
>= cxx1y
11989 && !(TREE_CODE (t
) == REFERENCE_TYPE
&& REFERENCE_VLA_OK (t
))
11990 && array_of_runtime_bound_p (type
)
11991 && (flag_iso
|| warn_vla
> 0))
11993 if (complain
& tf_warning_or_error
)
11995 (input_location
, OPT_Wvla
,
11996 code
== REFERENCE_TYPE
11997 ? G_("cannot declare reference to array of runtime bound")
11998 : G_("cannot declare pointer to array of runtime bound"));
12000 r
= error_mark_node
;
12003 if (r
!= error_mark_node
)
12004 /* Will this ever be needed for TYPE_..._TO values? */
12011 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12012 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12016 Type deduction may fail for any of the following
12019 -- Attempting to create "pointer to member of T" when T
12020 is not a class type. */
12021 if (complain
& tf_error
)
12022 error ("creating pointer to member of non-class type %qT", r
);
12023 return error_mark_node
;
12025 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12027 if (complain
& tf_error
)
12028 error ("creating pointer to member reference type %qT", type
);
12029 return error_mark_node
;
12031 if (VOID_TYPE_P (type
))
12033 if (complain
& tf_error
)
12034 error ("creating pointer to member of type void");
12035 return error_mark_node
;
12037 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12038 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12040 /* The type of the implicit object parameter gets its
12041 cv-qualifiers from the FUNCTION_TYPE. */
12044 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12045 type_memfn_rqual (type
));
12046 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12047 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12051 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12055 case FUNCTION_TYPE
:
12060 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12061 if (fntype
== error_mark_node
)
12062 return error_mark_node
;
12064 /* Substitute the exception specification. */
12065 specs
= tsubst_exception_specification (t
, args
, complain
,
12066 in_decl
, /*defer_ok*/true);
12067 if (specs
== error_mark_node
)
12068 return error_mark_node
;
12070 fntype
= build_exception_variant (fntype
, specs
);
12075 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12076 if (domain
== error_mark_node
)
12077 return error_mark_node
;
12079 /* As an optimization, we avoid regenerating the array type if
12080 it will obviously be the same as T. */
12081 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12084 /* These checks should match the ones in grokdeclarator.
12088 The deduction may fail for any of the following reasons:
12090 -- Attempting to create an array with an element type that
12091 is void, a function type, or a reference type, or [DR337]
12092 an abstract class type. */
12093 if (VOID_TYPE_P (type
)
12094 || TREE_CODE (type
) == FUNCTION_TYPE
12095 || TREE_CODE (type
) == REFERENCE_TYPE
)
12097 if (complain
& tf_error
)
12098 error ("creating array of %qT", type
);
12099 return error_mark_node
;
12102 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12103 return error_mark_node
;
12105 r
= build_cplus_array_type (type
, domain
);
12107 if (TYPE_USER_ALIGN (t
))
12109 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12110 TYPE_USER_ALIGN (r
) = 1;
12116 case TYPENAME_TYPE
:
12118 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12119 in_decl
, /*entering_scope=*/1);
12120 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12121 complain
, in_decl
);
12123 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12124 return error_mark_node
;
12126 if (!MAYBE_CLASS_TYPE_P (ctx
))
12128 if (complain
& tf_error
)
12129 error ("%qT is not a class, struct, or union type", ctx
);
12130 return error_mark_node
;
12132 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12134 /* Normally, make_typename_type does not require that the CTX
12135 have complete type in order to allow things like:
12137 template <class T> struct S { typename S<T>::X Y; };
12139 But, such constructs have already been resolved by this
12140 point, so here CTX really should have complete type, unless
12141 it's a partial instantiation. */
12142 ctx
= complete_type (ctx
);
12143 if (!COMPLETE_TYPE_P (ctx
))
12145 if (complain
& tf_error
)
12146 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12147 return error_mark_node
;
12151 f
= make_typename_type (ctx
, f
, typename_type
,
12152 complain
| tf_keep_type_decl
);
12153 if (f
== error_mark_node
)
12155 if (TREE_CODE (f
) == TYPE_DECL
)
12157 complain
|= tf_ignore_bad_quals
;
12161 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12163 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12165 if (complain
& tf_error
)
12166 error ("%qT resolves to %qT, which is not an enumeration type",
12169 return error_mark_node
;
12171 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12173 if (complain
& tf_error
)
12174 error ("%qT resolves to %qT, which is is not a class type",
12177 return error_mark_node
;
12181 return cp_build_qualified_type_real
12182 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12185 case UNBOUND_CLASS_TEMPLATE
:
12187 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12188 in_decl
, /*entering_scope=*/1);
12189 tree name
= TYPE_IDENTIFIER (t
);
12190 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12192 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12193 return error_mark_node
;
12196 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12197 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12204 ++cp_unevaluated_operand
;
12205 ++c_inhibit_evaluation_warnings
;
12207 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12209 /*integral_constant_expression_p=*/false);
12211 --cp_unevaluated_operand
;
12212 --c_inhibit_evaluation_warnings
;
12214 type
= finish_typeof (type
);
12215 return cp_build_qualified_type_real (type
,
12217 | cp_type_quals (type
),
12221 case DECLTYPE_TYPE
:
12225 ++cp_unevaluated_operand
;
12226 ++c_inhibit_evaluation_warnings
;
12228 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12229 complain
|tf_decltype
, in_decl
,
12230 /*function_p*/false,
12231 /*integral_constant_expression*/false);
12233 --cp_unevaluated_operand
;
12234 --c_inhibit_evaluation_warnings
;
12236 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12237 type
= lambda_capture_field_type (type
,
12238 DECLTYPE_FOR_INIT_CAPTURE (t
));
12239 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12240 type
= lambda_proxy_type (type
);
12243 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12244 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12246 /* In a template ~id could be either a complement expression
12247 or an unqualified-id naming a destructor; if instantiating
12248 it produces an expression, it's not an id-expression or
12251 type
= finish_decltype_type (type
, id
, complain
);
12253 return cp_build_qualified_type_real (type
,
12255 | cp_type_quals (type
),
12259 case UNDERLYING_TYPE
:
12261 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12262 complain
, in_decl
);
12263 return finish_underlying_type (type
);
12266 case TYPE_ARGUMENT_PACK
:
12267 case NONTYPE_ARGUMENT_PACK
:
12269 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12271 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12275 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12277 /* For template nontype argument packs, also substitute into
12279 if (code
== NONTYPE_ARGUMENT_PACK
)
12280 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12298 /* We should use one of the expression tsubsts for these codes. */
12299 gcc_unreachable ();
12302 sorry ("use of %qs in template", get_tree_code_name (code
));
12303 return error_mark_node
;
12307 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12308 type of the expression on the left-hand side of the "." or "->"
12312 tsubst_baselink (tree baselink
, tree object_type
,
12313 tree args
, tsubst_flags_t complain
, tree in_decl
)
12316 tree qualifying_scope
;
12319 tree template_args
= 0;
12320 bool template_id_p
= false;
12321 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12323 /* A baselink indicates a function from a base class. Both the
12324 BASELINK_ACCESS_BINFO and the base class referenced may
12325 indicate bases of the template class, rather than the
12326 instantiated class. In addition, lookups that were not
12327 ambiguous before may be ambiguous now. Therefore, we perform
12328 the lookup again. */
12329 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12330 qualifying_scope
= tsubst (qualifying_scope
, args
,
12331 complain
, in_decl
);
12332 fns
= BASELINK_FUNCTIONS (baselink
);
12333 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12334 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12336 template_id_p
= true;
12337 template_args
= TREE_OPERAND (fns
, 1);
12338 fns
= TREE_OPERAND (fns
, 0);
12340 template_args
= tsubst_template_args (template_args
, args
,
12341 complain
, in_decl
);
12343 name
= DECL_NAME (get_first_fn (fns
));
12344 if (IDENTIFIER_TYPENAME_P (name
))
12345 name
= mangle_conv_op_name_for_type (optype
);
12346 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12348 return error_mark_node
;
12350 /* If lookup found a single function, mark it as used at this
12351 point. (If it lookup found multiple functions the one selected
12352 later by overload resolution will be marked as used at that
12354 if (BASELINK_P (baselink
))
12355 fns
= BASELINK_FUNCTIONS (baselink
);
12356 if (!template_id_p
&& !really_overloaded_fn (fns
))
12357 mark_used (OVL_CURRENT (fns
));
12359 /* Add back the template arguments, if present. */
12360 if (BASELINK_P (baselink
) && template_id_p
)
12361 BASELINK_FUNCTIONS (baselink
)
12362 = build_nt (TEMPLATE_ID_EXPR
,
12363 BASELINK_FUNCTIONS (baselink
),
12365 /* Update the conversion operator type. */
12366 BASELINK_OPTYPE (baselink
) = optype
;
12369 object_type
= current_class_type
;
12372 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12378 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12379 true if the qualified-id will be a postfix-expression in-and-of
12380 itself; false if more of the postfix-expression follows the
12381 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12385 tsubst_qualified_id (tree qualified_id
, tree args
,
12386 tsubst_flags_t complain
, tree in_decl
,
12387 bool done
, bool address_p
)
12393 tree template_args
;
12394 location_t loc
= UNKNOWN_LOCATION
;
12396 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12398 /* Figure out what name to look up. */
12399 name
= TREE_OPERAND (qualified_id
, 1);
12400 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12402 is_template
= true;
12403 loc
= EXPR_LOCATION (name
);
12404 template_args
= TREE_OPERAND (name
, 1);
12406 template_args
= tsubst_template_args (template_args
, args
,
12407 complain
, in_decl
);
12408 name
= TREE_OPERAND (name
, 0);
12412 is_template
= false;
12413 template_args
= NULL_TREE
;
12416 /* Substitute into the qualifying scope. When there are no ARGS, we
12417 are just trying to simplify a non-dependent expression. In that
12418 case the qualifying scope may be dependent, and, in any case,
12419 substituting will not help. */
12420 scope
= TREE_OPERAND (qualified_id
, 0);
12423 scope
= tsubst (scope
, args
, complain
, in_decl
);
12424 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12429 if (dependent_scope_p (scope
))
12432 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12433 return build_qualified_name (NULL_TREE
, scope
, expr
,
12434 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12437 if (!BASELINK_P (name
) && !DECL_P (expr
))
12439 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12441 /* A BIT_NOT_EXPR is used to represent a destructor. */
12442 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12444 error ("qualifying type %qT does not match destructor name ~%qT",
12445 scope
, TREE_OPERAND (expr
, 0));
12446 expr
= error_mark_node
;
12449 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12450 /*is_type_p=*/0, false);
12453 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12454 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12455 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12457 if (complain
& tf_error
)
12459 error ("dependent-name %qE is parsed as a non-type, but "
12460 "instantiation yields a type", qualified_id
);
12461 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12463 return error_mark_node
;
12469 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12471 /* Remember that there was a reference to this entity. */
12475 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12477 if (complain
& tf_error
)
12478 qualified_name_lookup_error (scope
,
12479 TREE_OPERAND (qualified_id
, 1),
12480 expr
, input_location
);
12481 return error_mark_node
;
12485 expr
= lookup_template_function (expr
, template_args
);
12487 if (expr
== error_mark_node
&& complain
& tf_error
)
12488 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12489 expr
, input_location
);
12490 else if (TYPE_P (scope
))
12492 expr
= (adjust_result_of_qualified_name_lookup
12493 (expr
, scope
, current_nonlambda_class_type ()));
12494 expr
= (finish_qualified_id_expr
12495 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12496 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12497 /*template_arg_p=*/false, complain
));
12500 /* Expressions do not generally have reference type. */
12501 if (TREE_CODE (expr
) != SCOPE_REF
12502 /* However, if we're about to form a pointer-to-member, we just
12503 want the referenced member referenced. */
12504 && TREE_CODE (expr
) != OFFSET_REF
)
12505 expr
= convert_from_reference (expr
);
12510 /* Like tsubst, but deals with expressions. This function just replaces
12511 template parms; to finish processing the resultant expression, use
12512 tsubst_copy_and_build or tsubst_expr. */
12515 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12517 enum tree_code code
;
12520 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12523 code
= TREE_CODE (t
);
12528 r
= retrieve_local_specialization (t
);
12530 if (r
== NULL_TREE
)
12532 /* We get here for a use of 'this' in an NSDMI. */
12533 if (DECL_NAME (t
) == this_identifier
12534 && at_function_scope_p ()
12535 && DECL_CONSTRUCTOR_P (current_function_decl
))
12536 return current_class_ptr
;
12538 /* This can happen for a parameter name used later in a function
12539 declaration (such as in a late-specified return type). Just
12540 make a dummy decl, since it's only used for its type. */
12541 gcc_assert (cp_unevaluated_operand
!= 0);
12542 r
= tsubst_decl (t
, args
, complain
);
12543 /* Give it the template pattern as its context; its true context
12544 hasn't been instantiated yet and this is good enough for
12546 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12549 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12550 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12559 if (DECL_TEMPLATE_PARM_P (t
))
12560 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12561 /* There is no need to substitute into namespace-scope
12563 if (DECL_NAMESPACE_SCOPE_P (t
))
12565 /* If ARGS is NULL, then T is known to be non-dependent. */
12566 if (args
== NULL_TREE
)
12567 return integral_constant_value (t
);
12569 /* Unfortunately, we cannot just call lookup_name here.
12572 template <int I> int f() {
12574 struct S { void g() { E e = a; } };
12577 When we instantiate f<7>::S::g(), say, lookup_name is not
12578 clever enough to find f<7>::a. */
12580 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12581 /*entering_scope=*/0);
12583 for (v
= TYPE_VALUES (enum_type
);
12585 v
= TREE_CHAIN (v
))
12586 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12587 return TREE_VALUE (v
);
12589 /* We didn't find the name. That should never happen; if
12590 name-lookup found it during preliminary parsing, we
12591 should find it again here during instantiation. */
12592 gcc_unreachable ();
12597 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12599 /* Check for a local specialization set up by
12600 tsubst_pack_expansion. */
12601 if (tree r
= retrieve_local_specialization (t
))
12603 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12604 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12608 /* When retrieving a capture pack from a generic lambda, remove the
12609 lambda call op's own template argument list from ARGS. Only the
12610 template arguments active for the closure type should be used to
12611 retrieve the pack specialization. */
12612 if (LAMBDA_FUNCTION_P (current_function_decl
)
12613 && (template_class_depth (DECL_CONTEXT (t
))
12614 != TMPL_ARGS_DEPTH (args
)))
12615 args
= strip_innermost_template_args (args
, 1);
12617 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12618 tsubst_decl put in the hash table. */
12619 return retrieve_specialization (t
, args
, 0);
12622 if (DECL_CONTEXT (t
))
12626 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12627 /*entering_scope=*/1);
12628 if (ctx
!= DECL_CONTEXT (t
))
12630 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
12633 if (complain
& tf_error
)
12634 error ("using invalid field %qD", t
);
12635 return error_mark_node
;
12644 case FUNCTION_DECL
:
12645 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
12646 r
= tsubst (t
, args
, complain
, in_decl
);
12647 else if (local_variable_p (t
))
12649 r
= retrieve_local_specialization (t
);
12650 if (r
== NULL_TREE
)
12652 if (DECL_ANON_UNION_VAR_P (t
))
12654 /* Just use name lookup to find a member alias for an
12655 anonymous union, but then add it to the hash table. */
12656 r
= lookup_name (DECL_NAME (t
));
12657 gcc_assert (DECL_ANON_UNION_VAR_P (r
));
12658 register_local_specialization (r
, t
);
12662 /* This can happen for a variable used in a
12663 late-specified return type of a local lambda, or for a
12664 local static or constant. Building a new VAR_DECL
12665 should be OK in all those cases. */
12666 r
= tsubst_decl (t
, args
, complain
);
12667 if (decl_constant_var_p (r
))
12668 /* A use of a local constant must decay to its value. */
12669 return integral_constant_value (r
);
12670 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
12671 || errorcount
|| sorrycount
);
12681 case NAMESPACE_DECL
:
12685 /* An OVERLOAD will always be a non-dependent overload set; an
12686 overload set from function scope will just be represented with an
12687 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12688 gcc_assert (!uses_template_parms (t
));
12692 return tsubst_baselink (t
, current_nonlambda_class_type (),
12693 args
, complain
, in_decl
);
12695 case TEMPLATE_DECL
:
12696 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12697 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
12698 args
, complain
, in_decl
);
12699 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
12700 return tsubst (t
, args
, complain
, in_decl
);
12701 else if (DECL_CLASS_SCOPE_P (t
)
12702 && uses_template_parms (DECL_CONTEXT (t
)))
12704 /* Template template argument like the following example need
12707 template <template <class> class TT> struct C {};
12708 template <class T> struct D {
12709 template <class U> struct E {};
12714 We are processing the template argument `E' in #1 for
12715 the template instantiation #2. Originally, `E' is a
12716 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12717 have to substitute this with one having context `D<int>'. */
12719 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
12720 return lookup_field (context
, DECL_NAME(t
), 0, false);
12723 /* Ordinary template template argument. */
12727 case REINTERPRET_CAST_EXPR
:
12728 case CONST_CAST_EXPR
:
12729 case STATIC_CAST_EXPR
:
12730 case DYNAMIC_CAST_EXPR
:
12731 case IMPLICIT_CONV_EXPR
:
12735 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
12736 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
12739 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
12742 tree expanded
, op
= TREE_OPERAND (t
, 0);
12745 if (SIZEOF_EXPR_TYPE_P (t
))
12746 op
= TREE_TYPE (op
);
12748 ++cp_unevaluated_operand
;
12749 ++c_inhibit_evaluation_warnings
;
12750 /* We only want to compute the number of arguments. */
12751 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
12752 --cp_unevaluated_operand
;
12753 --c_inhibit_evaluation_warnings
;
12755 if (TREE_CODE (expanded
) == TREE_VEC
)
12756 len
= TREE_VEC_LENGTH (expanded
);
12758 if (expanded
== error_mark_node
)
12759 return error_mark_node
;
12760 else if (PACK_EXPANSION_P (expanded
)
12761 || (TREE_CODE (expanded
) == TREE_VEC
12763 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
12765 if (TREE_CODE (expanded
) == TREE_VEC
)
12766 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
12768 if (TYPE_P (expanded
))
12769 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
12770 complain
& tf_error
);
12772 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
12773 complain
& tf_error
);
12776 return build_int_cst (size_type_node
, len
);
12778 if (SIZEOF_EXPR_TYPE_P (t
))
12780 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
12781 args
, complain
, in_decl
);
12782 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
12783 r
= build1 (SIZEOF_EXPR
,
12784 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
12785 SIZEOF_EXPR_TYPE_P (r
) = 1;
12792 case TRUTH_NOT_EXPR
:
12795 case UNARY_PLUS_EXPR
: /* Unary + */
12797 case AT_ENCODE_EXPR
:
12801 case REALPART_EXPR
:
12802 case IMAGPART_EXPR
:
12805 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
12806 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
12808 case COMPONENT_REF
:
12813 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12814 name
= TREE_OPERAND (t
, 1);
12815 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
12817 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12818 complain
, in_decl
);
12819 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12821 else if (TREE_CODE (name
) == SCOPE_REF
12822 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
12824 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12825 complain
, in_decl
);
12826 name
= TREE_OPERAND (name
, 1);
12827 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12828 complain
, in_decl
);
12829 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12830 name
= build_qualified_name (/*type=*/NULL_TREE
,
12832 /*template_p=*/false);
12834 else if (BASELINK_P (name
))
12835 name
= tsubst_baselink (name
,
12836 non_reference (TREE_TYPE (object
)),
12840 name
= tsubst_copy (name
, args
, complain
, in_decl
);
12841 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
12847 case TRUNC_DIV_EXPR
:
12848 case CEIL_DIV_EXPR
:
12849 case FLOOR_DIV_EXPR
:
12850 case ROUND_DIV_EXPR
:
12851 case EXACT_DIV_EXPR
:
12855 case TRUNC_MOD_EXPR
:
12856 case FLOOR_MOD_EXPR
:
12857 case TRUTH_ANDIF_EXPR
:
12858 case TRUTH_ORIF_EXPR
:
12859 case TRUTH_AND_EXPR
:
12860 case TRUTH_OR_EXPR
:
12873 case COMPOUND_EXPR
:
12876 case PREDECREMENT_EXPR
:
12877 case PREINCREMENT_EXPR
:
12878 case POSTDECREMENT_EXPR
:
12879 case POSTINCREMENT_EXPR
:
12881 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12882 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
12885 return build_qualified_name (/*type=*/NULL_TREE
,
12886 tsubst_copy (TREE_OPERAND (t
, 0),
12887 args
, complain
, in_decl
),
12888 tsubst_copy (TREE_OPERAND (t
, 1),
12889 args
, complain
, in_decl
),
12890 QUALIFIED_NAME_IS_TEMPLATE (t
));
12895 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12896 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12897 NULL_TREE
, NULL_TREE
);
12901 int n
= VL_EXP_OPERAND_LENGTH (t
);
12902 tree result
= build_vl_exp (CALL_EXPR
, n
);
12904 for (i
= 0; i
< n
; i
++)
12905 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
12906 complain
, in_decl
);
12912 case PSEUDO_DTOR_EXPR
:
12913 case VEC_PERM_EXPR
:
12916 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12917 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12918 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
12919 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
12926 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12927 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12928 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
12929 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
12936 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12937 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
12938 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
12939 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
12943 case TEMPLATE_ID_EXPR
:
12945 /* Substituted template arguments */
12946 tree fn
= TREE_OPERAND (t
, 0);
12947 tree targs
= TREE_OPERAND (t
, 1);
12949 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
12951 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
12953 return lookup_template_function (fn
, targs
);
12958 tree purpose
, value
, chain
;
12960 if (t
== void_list_node
)
12963 purpose
= TREE_PURPOSE (t
);
12965 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
12966 value
= TREE_VALUE (t
);
12968 value
= tsubst_copy (value
, args
, complain
, in_decl
);
12969 chain
= TREE_CHAIN (t
);
12970 if (chain
&& chain
!= void_type_node
)
12971 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
12972 if (purpose
== TREE_PURPOSE (t
)
12973 && value
== TREE_VALUE (t
)
12974 && chain
== TREE_CHAIN (t
))
12976 return tree_cons (purpose
, value
, chain
);
12981 case ENUMERAL_TYPE
:
12983 case TEMPLATE_TYPE_PARM
:
12984 case TEMPLATE_TEMPLATE_PARM
:
12985 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12986 case TEMPLATE_PARM_INDEX
:
12988 case REFERENCE_TYPE
:
12990 case FUNCTION_TYPE
:
12993 case TYPENAME_TYPE
:
12994 case UNBOUND_CLASS_TEMPLATE
:
12996 case DECLTYPE_TYPE
:
12998 return tsubst (t
, args
, complain
, in_decl
);
13002 /* Fall through. */
13003 case IDENTIFIER_NODE
:
13004 if (IDENTIFIER_TYPENAME_P (t
))
13006 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13007 return mangle_conv_op_name_for_type (new_type
);
13013 /* This is handled by tsubst_copy_and_build. */
13014 gcc_unreachable ();
13017 return build_x_va_arg (EXPR_LOCATION (t
),
13018 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
,
13020 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
13022 case CLEANUP_POINT_EXPR
:
13023 /* We shouldn't have built any of these during initial template
13024 generation. Instead, they should be built during instantiation
13025 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13026 gcc_unreachable ();
13030 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
13031 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
13032 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
13033 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13034 mark_used (TREE_OPERAND (r
, 1));
13037 case EXPR_PACK_EXPANSION
:
13038 error ("invalid use of pack expansion expression");
13039 return error_mark_node
;
13041 case NONTYPE_ARGUMENT_PACK
:
13042 error ("use %<...%> to expand argument pack");
13043 return error_mark_node
;
13050 /* Instantiate any typedefs in the type. */
13051 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13052 r
= fold_convert (type
, t
);
13053 gcc_assert (TREE_CODE (r
) == code
);
13058 /* These can sometimes show up in a partial instantiation, but never
13059 involve template parms. */
13060 gcc_assert (!uses_template_parms (t
));
13064 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13065 gcc_checking_assert (false);
13070 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13073 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13074 tree args
, tsubst_flags_t complain
, tree in_decl
)
13076 tree new_clauses
= NULL
, nc
, oc
;
13078 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13080 nc
= copy_node (oc
);
13081 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13084 switch (OMP_CLAUSE_CODE (nc
))
13086 case OMP_CLAUSE_LASTPRIVATE
:
13087 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13089 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13090 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13091 in_decl
, /*integral_constant_expression_p=*/false);
13092 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13093 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13096 case OMP_CLAUSE_PRIVATE
:
13097 case OMP_CLAUSE_SHARED
:
13098 case OMP_CLAUSE_FIRSTPRIVATE
:
13099 case OMP_CLAUSE_COPYIN
:
13100 case OMP_CLAUSE_COPYPRIVATE
:
13101 case OMP_CLAUSE_IF
:
13102 case OMP_CLAUSE_NUM_THREADS
:
13103 case OMP_CLAUSE_SCHEDULE
:
13104 case OMP_CLAUSE_COLLAPSE
:
13105 case OMP_CLAUSE_FINAL
:
13106 case OMP_CLAUSE_DEPEND
:
13107 case OMP_CLAUSE_FROM
:
13108 case OMP_CLAUSE_TO
:
13109 case OMP_CLAUSE_UNIFORM
:
13110 case OMP_CLAUSE_MAP
:
13111 case OMP_CLAUSE_DEVICE
:
13112 case OMP_CLAUSE_DIST_SCHEDULE
:
13113 case OMP_CLAUSE_NUM_TEAMS
:
13114 case OMP_CLAUSE_THREAD_LIMIT
:
13115 case OMP_CLAUSE_SAFELEN
:
13116 case OMP_CLAUSE_SIMDLEN
:
13117 OMP_CLAUSE_OPERAND (nc
, 0)
13118 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13119 in_decl
, /*integral_constant_expression_p=*/false);
13121 case OMP_CLAUSE_REDUCTION
:
13122 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13124 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13125 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13127 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13128 complain
, in_decl
);
13129 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13130 = build_qualified_name (NULL_TREE
, scope
,
13131 TREE_OPERAND (placeholder
, 1),
13135 gcc_assert (identifier_p (placeholder
));
13137 OMP_CLAUSE_OPERAND (nc
, 0)
13138 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13139 in_decl
, /*integral_constant_expression_p=*/false);
13141 case OMP_CLAUSE_LINEAR
:
13142 case OMP_CLAUSE_ALIGNED
:
13143 OMP_CLAUSE_OPERAND (nc
, 0)
13144 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13145 in_decl
, /*integral_constant_expression_p=*/false);
13146 OMP_CLAUSE_OPERAND (nc
, 1)
13147 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13148 in_decl
, /*integral_constant_expression_p=*/false);
13151 case OMP_CLAUSE_NOWAIT
:
13152 case OMP_CLAUSE_ORDERED
:
13153 case OMP_CLAUSE_DEFAULT
:
13154 case OMP_CLAUSE_UNTIED
:
13155 case OMP_CLAUSE_MERGEABLE
:
13156 case OMP_CLAUSE_INBRANCH
:
13157 case OMP_CLAUSE_NOTINBRANCH
:
13158 case OMP_CLAUSE_PROC_BIND
:
13159 case OMP_CLAUSE_FOR
:
13160 case OMP_CLAUSE_PARALLEL
:
13161 case OMP_CLAUSE_SECTIONS
:
13162 case OMP_CLAUSE_TASKGROUP
:
13165 gcc_unreachable ();
13169 new_clauses
= nreverse (new_clauses
);
13171 new_clauses
= finish_omp_clauses (new_clauses
);
13172 return new_clauses
;
13175 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13178 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13181 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13183 tree purpose
, value
, chain
;
13188 if (TREE_CODE (t
) != TREE_LIST
)
13189 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13190 /*function_p=*/false,
13191 /*integral_constant_expression_p=*/false);
13193 if (t
== void_list_node
)
13196 purpose
= TREE_PURPOSE (t
);
13198 purpose
= RECUR (purpose
);
13199 value
= TREE_VALUE (t
);
13202 if (TREE_CODE (value
) != LABEL_DECL
)
13203 value
= RECUR (value
);
13206 value
= lookup_label (DECL_NAME (value
));
13207 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13208 TREE_USED (value
) = 1;
13211 chain
= TREE_CHAIN (t
);
13212 if (chain
&& chain
!= void_type_node
)
13213 chain
= RECUR (chain
);
13214 return tree_cons (purpose
, value
, chain
);
13218 /* Substitute one OMP_FOR iterator. */
13221 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13222 tree condv
, tree incrv
, tree
*clauses
,
13223 tree args
, tsubst_flags_t complain
, tree in_decl
,
13224 bool integral_constant_expression_p
)
13226 #define RECUR(NODE) \
13227 tsubst_expr ((NODE), args, complain, in_decl, \
13228 integral_constant_expression_p)
13229 tree decl
, init
, cond
, incr
;
13231 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13232 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13233 decl
= TREE_OPERAND (init
, 0);
13234 init
= TREE_OPERAND (init
, 1);
13235 tree decl_expr
= NULL_TREE
;
13236 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13238 /* We need to jump through some hoops to handle declarations in the
13239 for-init-statement, since we might need to handle auto deduction,
13240 but we need to keep control of initialization. */
13242 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13243 decl
= tsubst_decl (decl
, args
, complain
);
13246 decl
= RECUR (decl
);
13247 init
= RECUR (init
);
13249 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13250 if (auto_node
&& init
)
13252 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13254 gcc_assert (!type_dependent_expression_p (decl
));
13256 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13260 /* Declare the variable, but don't let that initialize it. */
13261 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13262 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13264 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13267 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13268 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13269 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13270 incr
= build_x_modify_expr (EXPR_LOCATION (incr
),
13271 RECUR (TREE_OPERAND (incr
, 0)), NOP_EXPR
,
13272 RECUR (TREE_OPERAND (incr
, 1)),
13275 incr
= RECUR (incr
);
13276 TREE_VEC_ELT (declv
, i
) = decl
;
13277 TREE_VEC_ELT (initv
, i
) = init
;
13278 TREE_VEC_ELT (condv
, i
) = cond
;
13279 TREE_VEC_ELT (incrv
, i
) = incr
;
13285 /* Declare and initialize the variable. */
13292 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13294 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13295 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13296 && OMP_CLAUSE_DECL (c
) == decl
)
13298 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13299 && OMP_CLAUSE_DECL (c
) == decl
)
13300 error ("iteration variable %qD should not be firstprivate", decl
);
13301 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13302 && OMP_CLAUSE_DECL (c
) == decl
)
13303 error ("iteration variable %qD should not be reduction", decl
);
13307 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13308 OMP_CLAUSE_DECL (c
) = decl
;
13309 c
= finish_omp_clauses (c
);
13312 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13317 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13318 if (COMPARISON_CLASS_P (cond
))
13319 cond
= build2 (TREE_CODE (cond
), boolean_type_node
,
13320 RECUR (TREE_OPERAND (cond
, 0)),
13321 RECUR (TREE_OPERAND (cond
, 1)));
13323 cond
= RECUR (cond
);
13324 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13325 switch (TREE_CODE (incr
))
13327 case PREINCREMENT_EXPR
:
13328 case PREDECREMENT_EXPR
:
13329 case POSTINCREMENT_EXPR
:
13330 case POSTDECREMENT_EXPR
:
13331 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13332 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13335 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13336 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13338 tree rhs
= TREE_OPERAND (incr
, 1);
13339 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
),
13340 RECUR (TREE_OPERAND (incr
, 0)),
13341 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13342 RECUR (TREE_OPERAND (rhs
, 0)),
13343 RECUR (TREE_OPERAND (rhs
, 1))));
13346 incr
= RECUR (incr
);
13349 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13350 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13352 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13353 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13354 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13355 TREE_TYPE (decl
), lhs
,
13356 RECUR (TREE_OPERAND (incr
, 2))));
13358 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13359 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13360 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13362 tree rhs
= TREE_OPERAND (incr
, 2);
13363 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
),
13364 RECUR (TREE_OPERAND (incr
, 0)),
13365 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13366 RECUR (TREE_OPERAND (rhs
, 0)),
13367 RECUR (TREE_OPERAND (rhs
, 1))));
13370 incr
= RECUR (incr
);
13373 incr
= RECUR (incr
);
13377 TREE_VEC_ELT (declv
, i
) = decl
;
13378 TREE_VEC_ELT (initv
, i
) = init
;
13379 TREE_VEC_ELT (condv
, i
) = cond
;
13380 TREE_VEC_ELT (incrv
, i
) = incr
;
13384 /* Like tsubst_copy for expressions, etc. but also does semantic
13388 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13389 bool integral_constant_expression_p
)
13391 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13392 #define RECUR(NODE) \
13393 tsubst_expr ((NODE), args, complain, in_decl, \
13394 integral_constant_expression_p)
13400 if (t
== NULL_TREE
|| t
== error_mark_node
)
13403 loc
= input_location
;
13404 if (EXPR_HAS_LOCATION (t
))
13405 input_location
= EXPR_LOCATION (t
);
13406 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13407 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13409 switch (TREE_CODE (t
))
13411 case STATEMENT_LIST
:
13413 tree_stmt_iterator i
;
13414 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13415 RECUR (tsi_stmt (i
));
13419 case CTOR_INITIALIZER
:
13420 finish_mem_initializers (tsubst_initializer_list
13421 (TREE_OPERAND (t
, 0), args
));
13425 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13429 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13430 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13431 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13433 finish_expr_stmt (tmp
);
13437 do_using_directive (USING_STMT_NAMESPACE (t
));
13442 tree decl
, pattern_decl
;
13445 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13446 if (TREE_CODE (decl
) == LABEL_DECL
)
13447 finish_label_decl (DECL_NAME (decl
));
13448 else if (TREE_CODE (decl
) == USING_DECL
)
13450 tree scope
= USING_DECL_SCOPE (decl
);
13451 tree name
= DECL_NAME (decl
);
13454 scope
= tsubst (scope
, args
, complain
, in_decl
);
13455 decl
= lookup_qualified_name (scope
, name
,
13456 /*is_type_p=*/false,
13457 /*complain=*/false);
13458 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13459 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13461 do_local_using_decl (decl
, scope
, name
);
13463 else if (DECL_PACK_P (decl
))
13465 /* Don't build up decls for a variadic capture proxy, we'll
13466 instantiate the elements directly as needed. */
13471 init
= DECL_INITIAL (decl
);
13472 decl
= tsubst (decl
, args
, complain
, in_decl
);
13473 if (decl
!= error_mark_node
)
13475 /* By marking the declaration as instantiated, we avoid
13476 trying to instantiate it. Since instantiate_decl can't
13477 handle local variables, and since we've already done
13478 all that needs to be done, that's the right thing to
13481 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13483 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13484 /* Anonymous aggregates are a special case. */
13485 finish_anon_union (decl
);
13486 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13488 DECL_CONTEXT (decl
) = current_function_decl
;
13489 if (DECL_NAME (decl
) == this_identifier
)
13491 tree lam
= DECL_CONTEXT (current_function_decl
);
13492 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13493 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13495 insert_capture_proxy (decl
);
13497 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13498 /* We already did a pushtag. */;
13499 else if (TREE_CODE (decl
) == FUNCTION_DECL
13500 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13501 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13503 DECL_CONTEXT (decl
) = NULL_TREE
;
13505 DECL_CONTEXT (decl
) = current_function_decl
;
13506 cp_check_omp_declare_reduction (decl
);
13510 int const_init
= false;
13511 maybe_push_decl (decl
);
13513 && DECL_PRETTY_FUNCTION_P (decl
))
13515 /* For __PRETTY_FUNCTION__ we have to adjust the
13517 const char *const name
13518 = cxx_printable_name (current_function_decl
, 2);
13519 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13523 tree t
= RECUR (init
);
13527 /* If we had an initializer but it
13528 instantiated to nothing,
13529 value-initialize the object. This will
13530 only occur when the initializer was a
13531 pack expansion where the parameter packs
13532 used in that expansion were of length
13534 init
= build_value_init (TREE_TYPE (decl
),
13536 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
13537 init
= get_target_expr_sfinae (init
, complain
);
13544 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13546 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13555 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13556 RECUR (FOR_INIT_STMT (t
));
13557 finish_for_init_stmt (stmt
);
13558 tmp
= RECUR (FOR_COND (t
));
13559 finish_for_cond (tmp
, stmt
, false);
13560 tmp
= RECUR (FOR_EXPR (t
));
13561 finish_for_expr (tmp
, stmt
);
13562 RECUR (FOR_BODY (t
));
13563 finish_for_stmt (stmt
);
13566 case RANGE_FOR_STMT
:
13569 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13570 decl
= RANGE_FOR_DECL (t
);
13571 decl
= tsubst (decl
, args
, complain
, in_decl
);
13572 maybe_push_decl (decl
);
13573 expr
= RECUR (RANGE_FOR_EXPR (t
));
13574 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13575 RECUR (RANGE_FOR_BODY (t
));
13576 finish_for_stmt (stmt
);
13581 stmt
= begin_while_stmt ();
13582 tmp
= RECUR (WHILE_COND (t
));
13583 finish_while_stmt_cond (tmp
, stmt
, false);
13584 RECUR (WHILE_BODY (t
));
13585 finish_while_stmt (stmt
);
13589 stmt
= begin_do_stmt ();
13590 RECUR (DO_BODY (t
));
13591 finish_do_body (stmt
);
13592 tmp
= RECUR (DO_COND (t
));
13593 finish_do_stmt (tmp
, stmt
, false);
13597 stmt
= begin_if_stmt ();
13598 tmp
= RECUR (IF_COND (t
));
13599 finish_if_stmt_cond (tmp
, stmt
);
13600 RECUR (THEN_CLAUSE (t
));
13601 finish_then_clause (stmt
);
13603 if (ELSE_CLAUSE (t
))
13605 begin_else_clause (stmt
);
13606 RECUR (ELSE_CLAUSE (t
));
13607 finish_else_clause (stmt
);
13610 finish_if_stmt (stmt
);
13614 if (BIND_EXPR_BODY_BLOCK (t
))
13615 stmt
= begin_function_body ();
13617 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
13618 ? BCS_TRY_BLOCK
: 0);
13620 RECUR (BIND_EXPR_BODY (t
));
13622 if (BIND_EXPR_BODY_BLOCK (t
))
13623 finish_function_body (stmt
);
13625 finish_compound_stmt (stmt
);
13629 finish_break_stmt ();
13632 case CONTINUE_STMT
:
13633 finish_continue_stmt ();
13637 stmt
= begin_switch_stmt ();
13638 tmp
= RECUR (SWITCH_STMT_COND (t
));
13639 finish_switch_cond (tmp
, stmt
);
13640 RECUR (SWITCH_STMT_BODY (t
));
13641 finish_switch_stmt (stmt
);
13644 case CASE_LABEL_EXPR
:
13645 finish_case_label (EXPR_LOCATION (t
),
13646 RECUR (CASE_LOW (t
)),
13647 RECUR (CASE_HIGH (t
)));
13652 tree decl
= LABEL_EXPR_LABEL (t
);
13655 label
= finish_label_stmt (DECL_NAME (decl
));
13656 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13657 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13662 tmp
= GOTO_DESTINATION (t
);
13663 if (TREE_CODE (tmp
) != LABEL_DECL
)
13664 /* Computed goto's must be tsubst'd into. On the other hand,
13665 non-computed gotos must not be; the identifier in question
13666 will have no binding. */
13669 tmp
= DECL_NAME (tmp
);
13670 finish_goto_stmt (tmp
);
13674 tmp
= finish_asm_stmt
13675 (ASM_VOLATILE_P (t
),
13676 RECUR (ASM_STRING (t
)),
13677 tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
, complain
, in_decl
),
13678 tsubst_copy_asm_operands (ASM_INPUTS (t
), args
, complain
, in_decl
),
13679 tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
, complain
, in_decl
),
13680 tsubst_copy_asm_operands (ASM_LABELS (t
), args
, complain
, in_decl
));
13682 tree asm_expr
= tmp
;
13683 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
13684 asm_expr
= TREE_OPERAND (asm_expr
, 0);
13685 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
13692 stmt
= begin_try_block ();
13693 RECUR (TRY_STMTS (t
));
13694 finish_cleanup_try_block (stmt
);
13695 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
13699 tree compound_stmt
= NULL_TREE
;
13701 if (FN_TRY_BLOCK_P (t
))
13702 stmt
= begin_function_try_block (&compound_stmt
);
13704 stmt
= begin_try_block ();
13706 RECUR (TRY_STMTS (t
));
13708 if (FN_TRY_BLOCK_P (t
))
13709 finish_function_try_block (stmt
);
13711 finish_try_block (stmt
);
13713 RECUR (TRY_HANDLERS (t
));
13714 if (FN_TRY_BLOCK_P (t
))
13715 finish_function_handler_sequence (stmt
, compound_stmt
);
13717 finish_handler_sequence (stmt
);
13723 tree decl
= HANDLER_PARMS (t
);
13727 decl
= tsubst (decl
, args
, complain
, in_decl
);
13728 /* Prevent instantiate_decl from trying to instantiate
13729 this variable. We've already done all that needs to be
13731 if (decl
!= error_mark_node
)
13732 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13734 stmt
= begin_handler ();
13735 finish_handler_parms (decl
, stmt
);
13736 RECUR (HANDLER_BODY (t
));
13737 finish_handler (stmt
);
13742 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
13743 if (CLASS_TYPE_P (tmp
))
13745 /* Local classes are not independent templates; they are
13746 instantiated along with their containing function. And this
13747 way we don't have to deal with pushing out of one local class
13748 to instantiate a member of another local class. */
13750 /* Closures are handled by the LAMBDA_EXPR. */
13751 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
13752 complete_type (tmp
);
13753 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
13754 if (!DECL_ARTIFICIAL (fn
))
13755 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
13759 case STATIC_ASSERT
:
13763 ++c_inhibit_evaluation_warnings
;
13765 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
13768 /*integral_constant_expression_p=*/true);
13769 --c_inhibit_evaluation_warnings
;
13771 finish_static_assert (condition
,
13772 STATIC_ASSERT_MESSAGE (t
),
13773 STATIC_ASSERT_SOURCE_LOCATION (t
),
13774 /*member_p=*/false);
13779 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
13780 args
, complain
, in_decl
);
13781 stmt
= begin_omp_parallel ();
13782 RECUR (OMP_PARALLEL_BODY (t
));
13783 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
13784 = OMP_PARALLEL_COMBINED (t
);
13788 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
13789 args
, complain
, in_decl
);
13790 stmt
= begin_omp_task ();
13791 RECUR (OMP_TASK_BODY (t
));
13792 finish_omp_task (tmp
, stmt
);
13798 case OMP_DISTRIBUTE
:
13800 tree clauses
, body
, pre_body
;
13801 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
13802 tree incrv
= NULL_TREE
;
13805 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
13806 args
, complain
, in_decl
);
13807 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13809 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13810 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13811 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13812 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13815 stmt
= begin_omp_structured_block ();
13817 pre_body
= push_stmt_list ();
13818 RECUR (OMP_FOR_PRE_BODY (t
));
13819 pre_body
= pop_stmt_list (pre_body
);
13821 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13822 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
13823 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
13824 &clauses
, args
, complain
, in_decl
,
13825 integral_constant_expression_p
);
13827 body
= push_stmt_list ();
13828 RECUR (OMP_FOR_BODY (t
));
13829 body
= pop_stmt_list (body
);
13831 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13832 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
13833 condv
, incrv
, body
, pre_body
, clauses
);
13836 t
= make_node (TREE_CODE (t
));
13837 TREE_TYPE (t
) = void_type_node
;
13838 OMP_FOR_BODY (t
) = body
;
13839 OMP_FOR_PRE_BODY (t
) = pre_body
;
13840 OMP_FOR_CLAUSES (t
) = clauses
;
13841 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
13845 add_stmt (finish_omp_structured_block (stmt
));
13852 case OMP_TARGET_DATA
:
13854 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
13855 args
, complain
, in_decl
);
13856 stmt
= push_stmt_list ();
13857 RECUR (OMP_BODY (t
));
13858 stmt
= pop_stmt_list (stmt
);
13861 OMP_BODY (t
) = stmt
;
13862 OMP_CLAUSES (t
) = tmp
;
13866 case OMP_TARGET_UPDATE
:
13867 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
13868 args
, complain
, in_decl
);
13870 OMP_CLAUSES (t
) = tmp
;
13877 case OMP_TASKGROUP
:
13879 stmt
= push_stmt_list ();
13880 RECUR (OMP_BODY (t
));
13881 stmt
= pop_stmt_list (stmt
);
13884 OMP_BODY (t
) = stmt
;
13889 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
13890 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
13892 tree op1
= TREE_OPERAND (t
, 1);
13893 tree rhs1
= NULL_TREE
;
13895 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
13897 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
13898 op1
= TREE_OPERAND (op1
, 1);
13900 lhs
= RECUR (TREE_OPERAND (op1
, 0));
13901 rhs
= RECUR (TREE_OPERAND (op1
, 1));
13902 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
13903 NULL_TREE
, NULL_TREE
, rhs1
,
13904 OMP_ATOMIC_SEQ_CST (t
));
13908 tree op1
= TREE_OPERAND (t
, 1);
13909 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
13910 tree rhs1
= NULL_TREE
;
13911 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
13912 enum tree_code opcode
= NOP_EXPR
;
13913 if (code
== OMP_ATOMIC_READ
)
13915 v
= RECUR (TREE_OPERAND (op1
, 0));
13916 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
13918 else if (code
== OMP_ATOMIC_CAPTURE_OLD
13919 || code
== OMP_ATOMIC_CAPTURE_NEW
)
13921 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
13922 v
= RECUR (TREE_OPERAND (op1
, 0));
13923 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
13924 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
13926 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
13927 op11
= TREE_OPERAND (op11
, 1);
13929 lhs
= RECUR (TREE_OPERAND (op11
, 0));
13930 rhs
= RECUR (TREE_OPERAND (op11
, 1));
13931 opcode
= TREE_CODE (op11
);
13932 if (opcode
== MODIFY_EXPR
)
13938 lhs
= RECUR (TREE_OPERAND (op1
, 0));
13939 rhs
= RECUR (TREE_OPERAND (op1
, 1));
13941 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
13942 OMP_ATOMIC_SEQ_CST (t
));
13946 case TRANSACTION_EXPR
:
13949 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
13950 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
13952 if (TRANSACTION_EXPR_IS_STMT (t
))
13954 tree body
= TRANSACTION_EXPR_BODY (t
);
13955 tree noex
= NULL_TREE
;
13956 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
13958 noex
= MUST_NOT_THROW_COND (body
);
13959 if (noex
== NULL_TREE
)
13960 noex
= boolean_true_node
;
13961 body
= TREE_OPERAND (body
, 0);
13963 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
13965 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
13969 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
13970 RECUR (TRANSACTION_EXPR_BODY (t
)),
13977 case MUST_NOT_THROW_EXPR
:
13978 RETURN (build_must_not_throw_expr (RECUR (TREE_OPERAND (t
, 0)),
13979 RECUR (MUST_NOT_THROW_COND (t
))));
13981 case EXPR_PACK_EXPANSION
:
13982 error ("invalid use of pack expansion expression");
13983 RETURN (error_mark_node
);
13985 case NONTYPE_ARGUMENT_PACK
:
13986 error ("use %<...%> to expand argument pack");
13987 RETURN (error_mark_node
);
13989 case CILK_SPAWN_STMT
:
13990 cfun
->calls_cilk_spawn
= 1;
13991 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
13993 case CILK_SYNC_STMT
:
13994 RETURN (build_cilk_sync ());
13996 case COMPOUND_EXPR
:
13997 tmp
= RECUR (TREE_OPERAND (t
, 0));
13998 if (tmp
== NULL_TREE
)
13999 /* If the first operand was a statement, we're done with it. */
14000 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14001 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14002 RECUR (TREE_OPERAND (t
, 1)),
14005 case ANNOTATE_EXPR
:
14006 tmp
= RECUR (TREE_OPERAND (t
, 0));
14007 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14008 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14011 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14013 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14014 /*function_p=*/false,
14015 integral_constant_expression_p
));
14018 RETURN (NULL_TREE
);
14020 input_location
= loc
;
14026 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14027 function. For description of the body see comment above
14028 cp_parser_omp_declare_reduction_exprs. */
14031 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14033 if (t
== NULL_TREE
|| t
== error_mark_node
)
14036 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14038 tree_stmt_iterator tsi
;
14041 memset (stmts
, 0, sizeof stmts
);
14042 for (i
= 0, tsi
= tsi_start (t
);
14043 i
< 7 && !tsi_end_p (tsi
);
14044 i
++, tsi_next (&tsi
))
14045 stmts
[i
] = tsi_stmt (tsi
);
14046 gcc_assert (tsi_end_p (tsi
));
14050 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14051 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14052 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14053 args
, complain
, in_decl
);
14054 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14055 args
, complain
, in_decl
);
14056 DECL_CONTEXT (omp_out
) = current_function_decl
;
14057 DECL_CONTEXT (omp_in
) = current_function_decl
;
14058 keep_next_level (true);
14059 tree block
= begin_omp_structured_block ();
14060 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14061 block
= finish_omp_structured_block (block
);
14062 block
= maybe_cleanup_point_expr_void (block
);
14063 add_decl_expr (omp_out
);
14064 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14065 TREE_NO_WARNING (omp_out
) = 1;
14066 add_decl_expr (omp_in
);
14067 finish_expr_stmt (block
);
14071 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14072 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14073 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14074 args
, complain
, in_decl
);
14075 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14076 args
, complain
, in_decl
);
14077 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14078 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14079 keep_next_level (true);
14080 tree block
= begin_omp_structured_block ();
14081 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14082 block
= finish_omp_structured_block (block
);
14083 block
= maybe_cleanup_point_expr_void (block
);
14084 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14085 add_decl_expr (omp_priv
);
14086 add_decl_expr (omp_orig
);
14087 finish_expr_stmt (block
);
14089 add_decl_expr (omp_orig
);
14093 /* T is a postfix-expression that is not being used in a function
14094 call. Return the substituted version of T. */
14097 tsubst_non_call_postfix_expression (tree t
, tree args
,
14098 tsubst_flags_t complain
,
14101 if (TREE_CODE (t
) == SCOPE_REF
)
14102 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14103 /*done=*/false, /*address_p=*/false);
14105 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14106 /*function_p=*/false,
14107 /*integral_constant_expression_p=*/false);
14112 /* Sentinel to disable certain warnings during template substitution. */
14114 struct warning_sentinel
{
14117 warning_sentinel(int& flag
, bool suppress
=true)
14118 : flag(flag
), val(flag
) { if (suppress
) flag
= 0; }
14119 ~warning_sentinel() { flag
= val
; }
14122 /* Like tsubst but deals with expressions and performs semantic
14123 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14126 tsubst_copy_and_build (tree t
,
14128 tsubst_flags_t complain
,
14131 bool integral_constant_expression_p
)
14133 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14134 #define RECUR(NODE) \
14135 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14136 /*function_p=*/false, \
14137 integral_constant_expression_p)
14142 if (t
== NULL_TREE
|| t
== error_mark_node
)
14145 loc
= input_location
;
14146 if (EXPR_HAS_LOCATION (t
))
14147 input_location
= EXPR_LOCATION (t
);
14149 /* N3276 decltype magic only applies to calls at the top level or on the
14150 right side of a comma. */
14151 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14152 complain
&= ~tf_decltype
;
14154 switch (TREE_CODE (t
))
14158 /* Fall through. */
14159 case IDENTIFIER_NODE
:
14163 bool non_integral_constant_expression_p
;
14164 const char *error_msg
;
14166 if (IDENTIFIER_TYPENAME_P (t
))
14168 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14169 t
= mangle_conv_op_name_for_type (new_type
);
14172 /* Look up the name. */
14173 decl
= lookup_name (t
);
14175 /* By convention, expressions use ERROR_MARK_NODE to indicate
14176 failure, not NULL_TREE. */
14177 if (decl
== NULL_TREE
)
14178 decl
= error_mark_node
;
14180 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14182 integral_constant_expression_p
,
14183 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14184 &non_integral_constant_expression_p
,
14185 /*template_p=*/false,
14187 /*address_p=*/false,
14188 /*template_arg_p=*/false,
14193 if (!function_p
&& identifier_p (decl
))
14195 if (complain
& tf_error
)
14196 unqualified_name_lookup_error (decl
);
14197 decl
= error_mark_node
;
14202 case TEMPLATE_ID_EXPR
:
14205 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14206 tree targs
= TREE_OPERAND (t
, 1);
14209 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14211 if (TREE_CODE (templ
) == COMPONENT_REF
)
14213 object
= TREE_OPERAND (templ
, 0);
14214 templ
= TREE_OPERAND (templ
, 1);
14217 object
= NULL_TREE
;
14218 templ
= lookup_template_function (templ
, targs
);
14221 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14222 object
, templ
, NULL_TREE
));
14224 RETURN (baselink_for_fns (templ
));
14229 tree r
= RECUR (TREE_OPERAND (t
, 0));
14231 if (REFERENCE_REF_P (t
))
14233 /* A type conversion to reference type will be enclosed in
14234 such an indirect ref, but the substitution of the cast
14235 will have also added such an indirect ref. */
14236 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14237 r
= convert_from_reference (r
);
14240 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14241 complain
|decltype_flag
);
14247 (tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
14248 RECUR (TREE_OPERAND (t
, 0))));
14250 case IMPLICIT_CONV_EXPR
:
14252 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14253 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14254 int flags
= LOOKUP_IMPLICIT
;
14255 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14256 flags
= LOOKUP_NORMAL
;
14257 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14264 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
14265 RECUR (TREE_OPERAND (t
, 0))));
14268 case REINTERPRET_CAST_EXPR
:
14269 case CONST_CAST_EXPR
:
14270 case DYNAMIC_CAST_EXPR
:
14271 case STATIC_CAST_EXPR
:
14274 tree op
, r
= NULL_TREE
;
14276 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14277 if (integral_constant_expression_p
14278 && !cast_valid_in_integral_constant_expression_p (type
))
14280 if (complain
& tf_error
)
14281 error ("a cast to a type other than an integral or "
14282 "enumeration type cannot appear in a constant-expression");
14283 RETURN (error_mark_node
);
14286 op
= RECUR (TREE_OPERAND (t
, 0));
14288 warning_sentinel
s(warn_useless_cast
);
14289 switch (TREE_CODE (t
))
14292 r
= build_functional_cast (type
, op
, complain
);
14294 case REINTERPRET_CAST_EXPR
:
14295 r
= build_reinterpret_cast (type
, op
, complain
);
14297 case CONST_CAST_EXPR
:
14298 r
= build_const_cast (type
, op
, complain
);
14300 case DYNAMIC_CAST_EXPR
:
14301 r
= build_dynamic_cast (type
, op
, complain
);
14303 case STATIC_CAST_EXPR
:
14304 r
= build_static_cast (type
, op
, complain
);
14307 gcc_unreachable ();
14313 case POSTDECREMENT_EXPR
:
14314 case POSTINCREMENT_EXPR
:
14315 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14316 args
, complain
, in_decl
);
14317 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14318 complain
|decltype_flag
));
14320 case PREDECREMENT_EXPR
:
14321 case PREINCREMENT_EXPR
:
14325 case TRUTH_NOT_EXPR
:
14326 case UNARY_PLUS_EXPR
: /* Unary + */
14327 case REALPART_EXPR
:
14328 case IMAGPART_EXPR
:
14329 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14330 RECUR (TREE_OPERAND (t
, 0)),
14331 complain
|decltype_flag
));
14333 case FIX_TRUNC_EXPR
:
14334 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14338 op1
= TREE_OPERAND (t
, 0);
14339 if (TREE_CODE (op1
) == LABEL_DECL
)
14340 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14341 EXPR_LOCATION (op1
)));
14342 if (TREE_CODE (op1
) == SCOPE_REF
)
14343 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14344 /*done=*/true, /*address_p=*/true);
14346 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14348 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14349 complain
|decltype_flag
));
14354 case TRUNC_DIV_EXPR
:
14355 case CEIL_DIV_EXPR
:
14356 case FLOOR_DIV_EXPR
:
14357 case ROUND_DIV_EXPR
:
14358 case EXACT_DIV_EXPR
:
14362 case TRUNC_MOD_EXPR
:
14363 case FLOOR_MOD_EXPR
:
14364 case TRUTH_ANDIF_EXPR
:
14365 case TRUTH_ORIF_EXPR
:
14366 case TRUTH_AND_EXPR
:
14367 case TRUTH_OR_EXPR
:
14383 warning_sentinel
s1(warn_type_limits
);
14384 warning_sentinel
s2(warn_div_by_zero
);
14385 tree r
= build_x_binary_op
14386 (input_location
, TREE_CODE (t
),
14387 RECUR (TREE_OPERAND (t
, 0)),
14388 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14390 : TREE_CODE (TREE_OPERAND (t
, 0))),
14391 RECUR (TREE_OPERAND (t
, 1)),
14392 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14394 : TREE_CODE (TREE_OPERAND (t
, 1))),
14396 complain
|decltype_flag
);
14397 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14398 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14403 case POINTER_PLUS_EXPR
:
14404 return fold_build_pointer_plus (RECUR (TREE_OPERAND (t
, 0)),
14405 RECUR (TREE_OPERAND (t
, 1)));
14408 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14409 /*address_p=*/false));
14411 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14412 args
, complain
, in_decl
);
14413 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14414 RECUR (TREE_OPERAND (t
, 1)),
14415 complain
|decltype_flag
));
14417 case ARRAY_NOTATION_REF
:
14419 tree start_index
, length
, stride
;
14420 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14421 args
, complain
, in_decl
);
14422 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14423 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14424 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14425 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14426 length
, stride
, TREE_TYPE (op1
)));
14429 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14430 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14437 op1
= TREE_OPERAND (t
, 0);
14438 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14439 op1
= TREE_TYPE (op1
);
14442 /* When there are no ARGS, we are trying to evaluate a
14443 non-dependent expression from the parser. Trying to do
14444 the substitutions may not work. */
14446 op1
= TREE_TYPE (op1
);
14450 ++cp_unevaluated_operand
;
14451 ++c_inhibit_evaluation_warnings
;
14453 op1
= tsubst (op1
, args
, complain
, in_decl
);
14455 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14456 /*function_p=*/false,
14457 /*integral_constant_expression_p=*/
14459 --cp_unevaluated_operand
;
14460 --c_inhibit_evaluation_warnings
;
14463 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14464 complain
& tf_error
);
14466 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14467 complain
& tf_error
);
14468 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14470 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14472 if (!processing_template_decl
&& TYPE_P (op1
))
14474 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14475 build1 (NOP_EXPR
, op1
, error_mark_node
));
14476 SIZEOF_EXPR_TYPE_P (r
) = 1;
14479 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14480 TREE_SIDE_EFFECTS (r
) = 0;
14481 TREE_READONLY (r
) = 1;
14483 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14488 case AT_ENCODE_EXPR
:
14490 op1
= TREE_OPERAND (t
, 0);
14491 ++cp_unevaluated_operand
;
14492 ++c_inhibit_evaluation_warnings
;
14493 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14494 /*function_p=*/false,
14495 /*integral_constant_expression_p=*/false);
14496 --cp_unevaluated_operand
;
14497 --c_inhibit_evaluation_warnings
;
14498 RETURN (objc_build_encode_expr (op1
));
14501 case NOEXCEPT_EXPR
:
14502 op1
= TREE_OPERAND (t
, 0);
14503 ++cp_unevaluated_operand
;
14504 ++c_inhibit_evaluation_warnings
;
14505 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14506 /*function_p=*/false,
14507 /*integral_constant_expression_p=*/false);
14508 --cp_unevaluated_operand
;
14509 --c_inhibit_evaluation_warnings
;
14510 RETURN (finish_noexcept_expr (op1
, complain
));
14514 warning_sentinel
s(warn_div_by_zero
);
14515 tree r
= build_x_modify_expr
14516 (EXPR_LOCATION (t
),
14517 RECUR (TREE_OPERAND (t
, 0)),
14518 TREE_CODE (TREE_OPERAND (t
, 1)),
14519 RECUR (TREE_OPERAND (t
, 2)),
14520 complain
|decltype_flag
);
14521 /* TREE_NO_WARNING must be set if either the expression was
14522 parenthesized or it uses an operator such as >>= rather
14523 than plain assignment. In the former case, it was already
14524 set and must be copied. In the latter case,
14525 build_x_modify_expr sets it and it must not be reset
14527 if (TREE_NO_WARNING (t
))
14528 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14534 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14535 args
, complain
, in_decl
);
14536 /* Remember that there was a reference to this entity. */
14539 RETURN (build_x_arrow (input_location
, op1
, complain
));
14543 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14544 tree init
= RECUR (TREE_OPERAND (t
, 3));
14545 vec
<tree
, va_gc
> *placement_vec
;
14546 vec
<tree
, va_gc
> *init_vec
;
14549 if (placement
== NULL_TREE
)
14550 placement_vec
= NULL
;
14553 placement_vec
= make_tree_vector ();
14554 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14555 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14558 /* If there was an initializer in the original tree, but it
14559 instantiated to an empty list, then we should pass a
14560 non-NULL empty vector to tell build_new that it was an
14561 empty initializer() rather than no initializer. This can
14562 only happen when the initializer is a pack expansion whose
14563 parameter packs are of length zero. */
14564 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
14568 init_vec
= make_tree_vector ();
14569 if (init
== void_zero_node
)
14570 gcc_assert (init_vec
!= NULL
);
14573 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
14574 vec_safe_push (init_vec
, TREE_VALUE (init
));
14578 ret
= build_new (&placement_vec
,
14579 tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
14580 RECUR (TREE_OPERAND (t
, 2)),
14582 NEW_EXPR_USE_GLOBAL (t
),
14585 if (placement_vec
!= NULL
)
14586 release_tree_vector (placement_vec
);
14587 if (init_vec
!= NULL
)
14588 release_tree_vector (init_vec
);
14594 RETURN (delete_sanity
14595 (RECUR (TREE_OPERAND (t
, 0)),
14596 RECUR (TREE_OPERAND (t
, 1)),
14597 DELETE_EXPR_USE_VEC (t
),
14598 DELETE_EXPR_USE_GLOBAL (t
),
14601 case COMPOUND_EXPR
:
14603 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
14604 complain
& ~tf_decltype
, in_decl
,
14605 /*function_p=*/false,
14606 integral_constant_expression_p
);
14607 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
14609 RECUR (TREE_OPERAND (t
, 1)),
14610 complain
|decltype_flag
));
14616 vec
<tree
, va_gc
> *call_args
;
14617 unsigned int nargs
, i
;
14622 function
= CALL_EXPR_FN (t
);
14623 /* When we parsed the expression, we determined whether or
14624 not Koenig lookup should be performed. */
14625 koenig_p
= KOENIG_LOOKUP_P (t
);
14626 if (TREE_CODE (function
) == SCOPE_REF
)
14628 qualified_p
= true;
14629 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
14631 /*address_p=*/false);
14633 else if (koenig_p
&& identifier_p (function
))
14635 /* Do nothing; calling tsubst_copy_and_build on an identifier
14636 would incorrectly perform unqualified lookup again.
14638 Note that we can also have an IDENTIFIER_NODE if the earlier
14639 unqualified lookup found a member function; in that case
14640 koenig_p will be false and we do want to do the lookup
14641 again to find the instantiated member function.
14643 FIXME but doing that causes c++/15272, so we need to stop
14644 using IDENTIFIER_NODE in that situation. */
14645 qualified_p
= false;
14649 if (TREE_CODE (function
) == COMPONENT_REF
)
14651 tree op
= TREE_OPERAND (function
, 1);
14653 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
14654 || (BASELINK_P (op
)
14655 && BASELINK_QUALIFIED_P (op
)));
14658 qualified_p
= false;
14660 if (TREE_CODE (function
) == ADDR_EXPR
14661 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
14662 /* Avoid error about taking the address of a constructor. */
14663 function
= TREE_OPERAND (function
, 0);
14665 function
= tsubst_copy_and_build (function
, args
, complain
,
14668 integral_constant_expression_p
);
14670 if (BASELINK_P (function
))
14671 qualified_p
= true;
14674 nargs
= call_expr_nargs (t
);
14675 call_args
= make_tree_vector ();
14676 for (i
= 0; i
< nargs
; ++i
)
14678 tree arg
= CALL_EXPR_ARG (t
, i
);
14680 if (!PACK_EXPANSION_P (arg
))
14681 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
14684 /* Expand the pack expansion and push each entry onto
14686 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
14687 if (TREE_CODE (arg
) == TREE_VEC
)
14689 unsigned int len
, j
;
14691 len
= TREE_VEC_LENGTH (arg
);
14692 for (j
= 0; j
< len
; ++j
)
14694 tree value
= TREE_VEC_ELT (arg
, j
);
14695 if (value
!= NULL_TREE
)
14696 value
= convert_from_reference (value
);
14697 vec_safe_push (call_args
, value
);
14702 /* A partial substitution. Add one entry. */
14703 vec_safe_push (call_args
, arg
);
14708 /* We do not perform argument-dependent lookup if normal
14709 lookup finds a non-function, in accordance with the
14710 expected resolution of DR 218. */
14712 && ((is_overloaded_fn (function
)
14713 /* If lookup found a member function, the Koenig lookup is
14714 not appropriate, even if an unqualified-name was used
14715 to denote the function. */
14716 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
14717 || identifier_p (function
))
14718 /* Only do this when substitution turns a dependent call
14719 into a non-dependent call. */
14720 && type_dependent_expression_p_push (t
)
14721 && !any_type_dependent_arguments_p (call_args
))
14722 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
14724 if (identifier_p (function
)
14725 && !any_type_dependent_arguments_p (call_args
))
14727 if (koenig_p
&& (complain
& tf_warning_or_error
))
14729 /* For backwards compatibility and good diagnostics, try
14730 the unqualified lookup again if we aren't in SFINAE
14732 tree unq
= (tsubst_copy_and_build
14733 (function
, args
, complain
, in_decl
, true,
14734 integral_constant_expression_p
));
14735 if (unq
== error_mark_node
)
14736 RETURN (error_mark_node
);
14738 if (unq
!= function
)
14741 if (INDIRECT_REF_P (fn
))
14742 fn
= TREE_OPERAND (fn
, 0);
14743 if (TREE_CODE (fn
) == COMPONENT_REF
)
14744 fn
= TREE_OPERAND (fn
, 1);
14745 if (is_overloaded_fn (fn
))
14746 fn
= get_first_fn (fn
);
14747 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
14748 "%qD was not declared in this scope, "
14749 "and no declarations were found by "
14750 "argument-dependent lookup at the point "
14751 "of instantiation", function
))
14754 /* Can't say anything more. */;
14755 else if (DECL_CLASS_SCOPE_P (fn
))
14757 location_t loc
= EXPR_LOC_OR_LOC (t
,
14760 "declarations in dependent base %qT are "
14761 "not found by unqualified lookup",
14762 DECL_CLASS_CONTEXT (fn
));
14763 if (current_class_ptr
)
14765 "use %<this->%D%> instead", function
);
14768 "use %<%T::%D%> instead",
14769 current_class_name
, function
);
14772 inform (0, "%q+D declared here, later in the "
14773 "translation unit", fn
);
14778 if (identifier_p (function
))
14780 if (complain
& tf_error
)
14781 unqualified_name_lookup_error (function
);
14782 release_tree_vector (call_args
);
14783 RETURN (error_mark_node
);
14787 /* Remember that there was a reference to this entity. */
14788 if (DECL_P (function
))
14789 mark_used (function
);
14791 /* Put back tf_decltype for the actual call. */
14792 complain
|= decltype_flag
;
14794 if (TREE_CODE (function
) == OFFSET_REF
)
14795 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
14797 else if (TREE_CODE (function
) == COMPONENT_REF
)
14799 tree instance
= TREE_OPERAND (function
, 0);
14800 tree fn
= TREE_OPERAND (function
, 1);
14802 if (processing_template_decl
14803 && (type_dependent_expression_p (instance
)
14804 || (!BASELINK_P (fn
)
14805 && TREE_CODE (fn
) != FIELD_DECL
)
14806 || type_dependent_expression_p (fn
)
14807 || any_type_dependent_arguments_p (call_args
)))
14808 ret
= build_nt_call_vec (function
, call_args
);
14809 else if (!BASELINK_P (fn
))
14810 ret
= finish_call_expr (function
, &call_args
,
14811 /*disallow_virtual=*/false,
14812 /*koenig_p=*/false,
14815 ret
= (build_new_method_call
14817 &call_args
, NULL_TREE
,
14818 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
14823 ret
= finish_call_expr (function
, &call_args
,
14824 /*disallow_virtual=*/qualified_p
,
14828 release_tree_vector (call_args
);
14835 tree cond
= RECUR (TREE_OPERAND (t
, 0));
14838 if (TREE_CODE (cond
) == INTEGER_CST
)
14840 if (integer_zerop (cond
))
14842 ++c_inhibit_evaluation_warnings
;
14843 exp1
= RECUR (TREE_OPERAND (t
, 1));
14844 --c_inhibit_evaluation_warnings
;
14845 exp2
= RECUR (TREE_OPERAND (t
, 2));
14849 exp1
= RECUR (TREE_OPERAND (t
, 1));
14850 ++c_inhibit_evaluation_warnings
;
14851 exp2
= RECUR (TREE_OPERAND (t
, 2));
14852 --c_inhibit_evaluation_warnings
;
14857 exp1
= RECUR (TREE_OPERAND (t
, 1));
14858 exp2
= RECUR (TREE_OPERAND (t
, 2));
14861 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
14862 cond
, exp1
, exp2
, complain
));
14865 case PSEUDO_DTOR_EXPR
:
14866 RETURN (finish_pseudo_destructor_expr
14867 (RECUR (TREE_OPERAND (t
, 0)),
14868 RECUR (TREE_OPERAND (t
, 1)),
14869 tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
),
14874 tree purpose
, value
, chain
;
14876 if (t
== void_list_node
)
14879 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
14880 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
14882 /* We have pack expansions, so expand those and
14883 create a new list out of it. */
14884 tree purposevec
= NULL_TREE
;
14885 tree valuevec
= NULL_TREE
;
14889 /* Expand the argument expressions. */
14890 if (TREE_PURPOSE (t
))
14891 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
14892 complain
, in_decl
);
14893 if (TREE_VALUE (t
))
14894 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
14895 complain
, in_decl
);
14897 /* Build the rest of the list. */
14898 chain
= TREE_CHAIN (t
);
14899 if (chain
&& chain
!= void_type_node
)
14900 chain
= RECUR (chain
);
14902 /* Determine the number of arguments. */
14903 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
14905 len
= TREE_VEC_LENGTH (purposevec
);
14906 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
14908 else if (TREE_CODE (valuevec
) == TREE_VEC
)
14909 len
= TREE_VEC_LENGTH (valuevec
);
14912 /* Since we only performed a partial substitution into
14913 the argument pack, we only RETURN (a single list
14915 if (purposevec
== TREE_PURPOSE (t
)
14916 && valuevec
== TREE_VALUE (t
)
14917 && chain
== TREE_CHAIN (t
))
14920 RETURN (tree_cons (purposevec
, valuevec
, chain
));
14923 /* Convert the argument vectors into a TREE_LIST */
14927 /* Grab the Ith values. */
14929 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
14932 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
14935 /* Build the list (backwards). */
14936 chain
= tree_cons (purpose
, value
, chain
);
14942 purpose
= TREE_PURPOSE (t
);
14944 purpose
= RECUR (purpose
);
14945 value
= TREE_VALUE (t
);
14947 value
= RECUR (value
);
14948 chain
= TREE_CHAIN (t
);
14949 if (chain
&& chain
!= void_type_node
)
14950 chain
= RECUR (chain
);
14951 if (purpose
== TREE_PURPOSE (t
)
14952 && value
== TREE_VALUE (t
)
14953 && chain
== TREE_CHAIN (t
))
14955 RETURN (tree_cons (purpose
, value
, chain
));
14958 case COMPONENT_REF
:
14965 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14966 args
, complain
, in_decl
);
14967 /* Remember that there was a reference to this entity. */
14968 if (DECL_P (object
))
14969 mark_used (object
);
14970 object_type
= TREE_TYPE (object
);
14972 member
= TREE_OPERAND (t
, 1);
14973 if (BASELINK_P (member
))
14974 member
= tsubst_baselink (member
,
14975 non_reference (TREE_TYPE (object
)),
14976 args
, complain
, in_decl
);
14978 member
= tsubst_copy (member
, args
, complain
, in_decl
);
14979 if (member
== error_mark_node
)
14980 RETURN (error_mark_node
);
14982 if (type_dependent_expression_p (object
))
14983 /* We can't do much here. */;
14984 else if (!CLASS_TYPE_P (object_type
))
14986 if (scalarish_type_p (object_type
))
14988 tree s
= NULL_TREE
;
14989 tree dtor
= member
;
14991 if (TREE_CODE (dtor
) == SCOPE_REF
)
14993 s
= TREE_OPERAND (dtor
, 0);
14994 dtor
= TREE_OPERAND (dtor
, 1);
14996 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
14998 dtor
= TREE_OPERAND (dtor
, 0);
15000 RETURN (finish_pseudo_destructor_expr
15001 (object
, s
, dtor
, input_location
));
15005 else if (TREE_CODE (member
) == SCOPE_REF
15006 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15008 /* Lookup the template functions now that we know what the
15010 tree scope
= TREE_OPERAND (member
, 0);
15011 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15012 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15013 member
= lookup_qualified_name (scope
, tmpl
,
15014 /*is_type_p=*/false,
15015 /*complain=*/false);
15016 if (BASELINK_P (member
))
15018 BASELINK_FUNCTIONS (member
)
15019 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15021 member
= (adjust_result_of_qualified_name_lookup
15022 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15027 qualified_name_lookup_error (scope
, tmpl
, member
,
15029 RETURN (error_mark_node
);
15032 else if (TREE_CODE (member
) == SCOPE_REF
15033 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15034 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15036 if (complain
& tf_error
)
15038 if (TYPE_P (TREE_OPERAND (member
, 0)))
15039 error ("%qT is not a class or namespace",
15040 TREE_OPERAND (member
, 0));
15042 error ("%qD is not a class or namespace",
15043 TREE_OPERAND (member
, 0));
15045 RETURN (error_mark_node
);
15047 else if (TREE_CODE (member
) == FIELD_DECL
)
15049 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15050 if (TREE_CODE (r
) == COMPONENT_REF
)
15051 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15055 r
= finish_class_member_access_expr (object
, member
,
15056 /*template_p=*/false,
15058 if (TREE_CODE (r
) == COMPONENT_REF
)
15059 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15064 RETURN (build_throw
15065 (RECUR (TREE_OPERAND (t
, 0))));
15069 vec
<constructor_elt
, va_gc
> *n
;
15070 constructor_elt
*ce
;
15071 unsigned HOST_WIDE_INT idx
;
15072 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15073 bool process_index_p
;
15075 bool need_copy_p
= false;
15078 if (type
== error_mark_node
)
15079 RETURN (error_mark_node
);
15081 /* digest_init will do the wrong thing if we let it. */
15082 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15085 /* We do not want to process the index of aggregate
15086 initializers as they are identifier nodes which will be
15087 looked up by digest_init. */
15088 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15090 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15091 newlen
= vec_safe_length (n
);
15092 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15094 if (ce
->index
&& process_index_p
15095 /* An identifier index is looked up in the type
15096 being initialized, not the current scope. */
15097 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15098 ce
->index
= RECUR (ce
->index
);
15100 if (PACK_EXPANSION_P (ce
->value
))
15102 /* Substitute into the pack expansion. */
15103 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15106 if (ce
->value
== error_mark_node
15107 || PACK_EXPANSION_P (ce
->value
))
15109 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15110 /* Just move the argument into place. */
15111 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15114 /* Update the length of the final CONSTRUCTOR
15115 arguments vector, and note that we will need to
15117 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15118 need_copy_p
= true;
15122 ce
->value
= RECUR (ce
->value
);
15127 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15129 vec_alloc (n
, newlen
);
15130 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15132 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15134 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15135 for (i
= 0; i
< len
; ++i
)
15136 CONSTRUCTOR_APPEND_ELT (n
, 0,
15137 TREE_VEC_ELT (ce
->value
, i
));
15140 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15144 r
= build_constructor (init_list_type_node
, n
);
15145 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15147 if (TREE_HAS_CONSTRUCTOR (t
))
15148 RETURN (finish_compound_literal (type
, r
, complain
));
15150 TREE_TYPE (r
) = type
;
15156 tree operand_0
= TREE_OPERAND (t
, 0);
15157 if (TYPE_P (operand_0
))
15159 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15160 RETURN (get_typeid (operand_0
, complain
));
15164 operand_0
= RECUR (operand_0
);
15165 RETURN (build_typeid (operand_0
, complain
));
15172 else if (DECL_PACK_P (t
))
15174 /* We don't build decls for an instantiation of a
15175 variadic capture proxy, we instantiate the elements
15177 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15178 return RECUR (DECL_VALUE_EXPR (t
));
15184 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15186 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15187 /* If the original type was a reference, we'll be wrapped in
15188 the appropriate INDIRECT_REF. */
15189 r
= convert_from_reference (r
);
15194 RETURN (build_x_va_arg (EXPR_LOCATION (t
),
15195 RECUR (TREE_OPERAND (t
, 0)),
15196 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
)));
15198 case OFFSETOF_EXPR
:
15199 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0))));
15203 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15204 complain
, in_decl
);
15206 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15208 type2
= tsubst (type2
, args
, complain
, in_decl
);
15210 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15215 tree old_stmt_expr
= cur_stmt_expr
;
15216 tree stmt_expr
= begin_stmt_expr ();
15218 cur_stmt_expr
= stmt_expr
;
15219 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15220 integral_constant_expression_p
);
15221 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15222 cur_stmt_expr
= old_stmt_expr
;
15224 /* If the resulting list of expression statement is empty,
15225 fold it further into void_zero_node. */
15226 if (empty_expr_stmt_p (stmt_expr
))
15227 stmt_expr
= void_zero_node
;
15229 RETURN (stmt_expr
);
15234 tree r
= build_lambda_expr ();
15236 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15237 LAMBDA_EXPR_CLOSURE (r
) = type
;
15238 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15240 LAMBDA_EXPR_LOCATION (r
)
15241 = LAMBDA_EXPR_LOCATION (t
);
15242 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15243 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15244 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15245 LAMBDA_EXPR_DISCRIMINATOR (r
)
15246 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15247 /* For a function scope, we want to use tsubst so that we don't
15248 complain about referring to an auto function before its return
15249 type has been deduced. Otherwise, we want to use tsubst_copy so
15250 that we look up the existing field/parameter/variable rather
15251 than build a new one. */
15252 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15253 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15254 scope
= tsubst (scope
, args
, complain
, in_decl
);
15255 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15257 /* Look up the parameter we want directly, as tsubst_copy
15258 doesn't do what we need. */
15259 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15260 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15261 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15262 parm
= DECL_CHAIN (parm
);
15264 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15265 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15266 DECL_CONTEXT (scope
) = fn
;
15269 scope
= RECUR (scope
);
15270 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15271 LAMBDA_EXPR_RETURN_TYPE (r
)
15272 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15274 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15275 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15277 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15278 determine_visibility (TYPE_NAME (type
));
15279 /* Now that we know visibility, instantiate the type so we have a
15280 declaration of the op() for later calls to lambda_function. */
15281 complete_type (type
);
15283 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15285 RETURN (build_lambda_object (r
));
15289 /* We can get here for a constant initializer of non-dependent type.
15290 FIXME stop folding in cp_parser_initializer_clause. */
15292 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15297 case TRANSACTION_EXPR
:
15298 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15299 integral_constant_expression_p
));
15302 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15304 case VEC_PERM_EXPR
:
15305 RETURN (build_x_vec_perm_expr (input_location
,
15306 RECUR (TREE_OPERAND (t
, 0)),
15307 RECUR (TREE_OPERAND (t
, 1)),
15308 RECUR (TREE_OPERAND (t
, 2)),
15312 /* Handle Objective-C++ constructs, if appropriate. */
15315 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15316 in_decl
, /*function_p=*/false);
15320 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15326 input_location
= loc
;
15330 /* Verify that the instantiated ARGS are valid. For type arguments,
15331 make sure that the type's linkage is ok. For non-type arguments,
15332 make sure they are constants if they are integral or enumerations.
15333 Emit an error under control of COMPLAIN, and return TRUE on error. */
15336 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15338 if (dependent_template_arg_p (t
))
15340 if (ARGUMENT_PACK_P (t
))
15342 tree vec
= ARGUMENT_PACK_ARGS (t
);
15343 int len
= TREE_VEC_LENGTH (vec
);
15344 bool result
= false;
15347 for (i
= 0; i
< len
; ++i
)
15348 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15352 else if (TYPE_P (t
))
15354 /* [basic.link]: A name with no linkage (notably, the name
15355 of a class or enumeration declared in a local scope)
15356 shall not be used to declare an entity with linkage.
15357 This implies that names with no linkage cannot be used as
15360 DR 757 relaxes this restriction for C++0x. */
15361 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15362 : no_linkage_check (t
, /*relaxed_p=*/false));
15366 /* DR 488 makes use of a type with no linkage cause
15367 type deduction to fail. */
15368 if (complain
& tf_error
)
15370 if (TYPE_ANONYMOUS_P (nt
))
15371 error ("%qT is/uses anonymous type", t
);
15373 error ("template argument for %qD uses local type %qT",
15378 /* In order to avoid all sorts of complications, we do not
15379 allow variably-modified types as template arguments. */
15380 else if (variably_modified_type_p (t
, NULL_TREE
))
15382 if (complain
& tf_error
)
15383 error ("%qT is a variably modified type", t
);
15387 /* Class template and alias template arguments should be OK. */
15388 else if (DECL_TYPE_TEMPLATE_P (t
))
15390 /* A non-type argument of integral or enumerated type must be a
15392 else if (TREE_TYPE (t
)
15393 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15394 && !TREE_CONSTANT (t
))
15396 if (complain
& tf_error
)
15397 error ("integral expression %qE is not constant", t
);
15404 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15406 int ix
, len
= DECL_NTPARMS (tmpl
);
15407 bool result
= false;
15409 for (ix
= 0; ix
!= len
; ix
++)
15411 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15414 if (result
&& (complain
& tf_error
))
15415 error (" trying to instantiate %qD", tmpl
);
15419 /* We're out of SFINAE context now, so generate diagnostics for the access
15420 errors we saw earlier when instantiating D from TMPL and ARGS. */
15423 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15425 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15426 tree type
= TREE_TYPE (pattern
);
15427 location_t loc
= input_location
;
15429 push_access_scope (d
);
15430 push_deferring_access_checks (dk_no_deferred
);
15431 input_location
= DECL_SOURCE_LOCATION (pattern
);
15432 tsubst (type
, args
, tf_warning_or_error
, d
);
15433 input_location
= loc
;
15434 pop_deferring_access_checks ();
15435 pop_access_scope (d
);
15438 /* Instantiate the indicated variable, function, or alias template TMPL with
15439 the template arguments in TARG_PTR. */
15442 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15444 tree targ_ptr
= orig_args
;
15448 bool access_ok
= true;
15450 if (tmpl
== error_mark_node
)
15451 return error_mark_node
;
15453 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15455 /* If this function is a clone, handle it specially. */
15456 if (DECL_CLONED_FUNCTION_P (tmpl
))
15461 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15462 DECL_CLONED_FUNCTION. */
15463 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15464 targ_ptr
, complain
);
15465 if (spec
== error_mark_node
)
15466 return error_mark_node
;
15468 /* Look for the clone. */
15469 FOR_EACH_CLONE (clone
, spec
)
15470 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15472 /* We should always have found the clone by now. */
15473 gcc_unreachable ();
15477 if (targ_ptr
== error_mark_node
)
15478 return error_mark_node
;
15480 /* Check to see if we already have this specialization. */
15481 gen_tmpl
= most_general_template (tmpl
);
15482 if (tmpl
!= gen_tmpl
)
15483 /* The TMPL is a partial instantiation. To get a full set of
15484 arguments we must add the arguments used to perform the
15485 partial instantiation. */
15486 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15489 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15490 but it doesn't seem to be on the hot path. */
15491 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15493 gcc_assert (tmpl
== gen_tmpl
15494 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15496 || fndecl
== NULL_TREE
);
15498 if (spec
!= NULL_TREE
)
15500 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15502 if (complain
& tf_error
)
15503 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15504 return error_mark_node
;
15509 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15511 return error_mark_node
;
15513 /* We are building a FUNCTION_DECL, during which the access of its
15514 parameters and return types have to be checked. However this
15515 FUNCTION_DECL which is the desired context for access checking
15516 is not built yet. We solve this chicken-and-egg problem by
15517 deferring all checks until we have the FUNCTION_DECL. */
15518 push_deferring_access_checks (dk_deferred
);
15520 /* Instantiation of the function happens in the context of the function
15521 template, not the context of the overload resolution we're doing. */
15522 push_to_top_level ();
15523 /* If there are dependent arguments, e.g. because we're doing partial
15524 ordering, make sure processing_template_decl stays set. */
15525 if (uses_template_parms (targ_ptr
))
15526 ++processing_template_decl
;
15527 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15529 tree ctx
= tsubst (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15530 complain
, gen_tmpl
);
15531 push_nested_class (ctx
);
15533 /* Substitute template parameters to obtain the specialization. */
15534 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
15535 targ_ptr
, complain
, gen_tmpl
);
15536 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15537 pop_nested_class ();
15538 pop_from_top_level ();
15540 if (fndecl
== error_mark_node
)
15542 pop_deferring_access_checks ();
15543 return error_mark_node
;
15546 /* The DECL_TI_TEMPLATE should always be the immediate parent
15547 template, not the most general template. */
15548 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
15550 /* Now we know the specialization, compute access previously
15552 push_access_scope (fndecl
);
15553 if (!perform_deferred_access_checks (complain
))
15555 pop_access_scope (fndecl
);
15556 pop_deferring_access_checks ();
15558 /* If we've just instantiated the main entry point for a function,
15559 instantiate all the alternate entry points as well. We do this
15560 by cloning the instantiation of the main entry point, not by
15561 instantiating the template clones. */
15562 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
15563 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
15567 if (!(complain
& tf_error
))
15569 /* Remember to reinstantiate when we're out of SFINAE so the user
15570 can see the errors. */
15571 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
15573 return error_mark_node
;
15578 /* Wrapper for instantiate_template_1. */
15581 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15584 timevar_push (TV_TEMPLATE_INST
);
15585 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
15586 timevar_pop (TV_TEMPLATE_INST
);
15590 /* Instantiate the alias template TMPL with ARGS. Also push a template
15591 instantiation level, which instantiate_template doesn't do because
15592 functions and variables have sufficient context established by the
15596 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
15598 struct pending_template
*old_last_pend
= last_pending_template
;
15599 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15600 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
15601 return error_mark_node
;
15602 tree tinst
= build_tree_list (tmpl
, args
);
15603 if (!push_tinst_level (tinst
))
15606 return error_mark_node
;
15610 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
15611 args
, tmpl
, complain
,
15612 /*require_all_args=*/true,
15613 /*use_default_args=*/true);
15615 tree r
= instantiate_template (tmpl
, args
, complain
);
15616 pop_tinst_level ();
15617 /* We can't free this if a pending_template entry or last_error_tinst_level
15618 is pointing at it. */
15619 if (last_pending_template
== old_last_pend
15620 && last_error_tinst_level
== old_error_tinst
)
15626 /* PARM is a template parameter pack for FN. Returns true iff
15627 PARM is used in a deducible way in the argument list of FN. */
15630 pack_deducible_p (tree parm
, tree fn
)
15632 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
15633 for (; t
; t
= TREE_CHAIN (t
))
15635 tree type
= TREE_VALUE (t
);
15637 if (!PACK_EXPANSION_P (type
))
15639 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
15640 packs
; packs
= TREE_CHAIN (packs
))
15641 if (TREE_VALUE (packs
) == parm
)
15643 /* The template parameter pack is used in a function parameter
15644 pack. If this is the end of the parameter list, the
15645 template parameter pack is deducible. */
15646 if (TREE_CHAIN (t
) == void_list_node
)
15649 /* Otherwise, not. Well, it could be deduced from
15650 a non-pack parameter, but doing so would end up with
15651 a deduction mismatch, so don't bother. */
15655 /* The template parameter pack isn't used in any function parameter
15656 packs, but it might be used deeper, e.g. tuple<Args...>. */
15660 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
15661 NARGS elements of the arguments that are being used when calling
15662 it. TARGS is a vector into which the deduced template arguments
15665 Returns either a FUNCTION_DECL for the matching specialization of FN or
15666 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
15667 true, diagnostics will be printed to explain why it failed.
15669 If FN is a conversion operator, or we are trying to produce a specific
15670 specialization, RETURN_TYPE is the return type desired.
15672 The EXPLICIT_TARGS are explicit template arguments provided via a
15675 The parameter STRICT is one of:
15678 We are deducing arguments for a function call, as in
15679 [temp.deduct.call].
15682 We are deducing arguments for a conversion function, as in
15683 [temp.deduct.conv].
15686 We are deducing arguments when doing an explicit instantiation
15687 as in [temp.explicit], when determining an explicit specialization
15688 as in [temp.expl.spec], or when taking the address of a function
15689 template, as in [temp.deduct.funcaddr]. */
15692 fn_type_unification (tree fn
,
15693 tree explicit_targs
,
15696 unsigned int nargs
,
15698 unification_kind_t strict
,
15705 tree decl
= NULL_TREE
;
15706 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
15708 static int deduction_depth
;
15709 struct pending_template
*old_last_pend
= last_pending_template
;
15710 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15711 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
15713 tree r
= error_mark_node
;
15716 complain
|= tf_decltype
;
15718 /* In C++0x, it's possible to have a function template whose type depends
15719 on itself recursively. This is most obvious with decltype, but can also
15720 occur with enumeration scope (c++/48969). So we need to catch infinite
15721 recursion and reject the substitution at deduction time; this function
15722 will return error_mark_node for any repeated substitution.
15724 This also catches excessive recursion such as when f<N> depends on
15725 f<N-1> across all integers, and returns error_mark_node for all the
15726 substitutions back up to the initial one.
15728 This is, of course, not reentrant. */
15729 if (excessive_deduction_depth
)
15730 return error_mark_node
;
15731 tinst
= build_tree_list (fn
, NULL_TREE
);
15734 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
15736 fntype
= TREE_TYPE (fn
);
15737 if (explicit_targs
)
15741 The specified template arguments must match the template
15742 parameters in kind (i.e., type, nontype, template), and there
15743 must not be more arguments than there are parameters;
15744 otherwise type deduction fails.
15746 Nontype arguments must match the types of the corresponding
15747 nontype template parameters, or must be convertible to the
15748 types of the corresponding nontype parameters as specified in
15749 _temp.arg.nontype_, otherwise type deduction fails.
15751 All references in the function type of the function template
15752 to the corresponding template parameters are replaced by the
15753 specified template argument values. If a substitution in a
15754 template parameter or in the function type of the function
15755 template results in an invalid type, type deduction fails. */
15756 int i
, len
= TREE_VEC_LENGTH (tparms
);
15757 location_t loc
= input_location
;
15758 bool incomplete
= false;
15760 /* Adjust any explicit template arguments before entering the
15761 substitution context. */
15763 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
15765 /*require_all_args=*/false,
15766 /*use_default_args=*/false));
15767 if (explicit_targs
== error_mark_node
)
15770 /* Substitute the explicit args into the function type. This is
15771 necessary so that, for instance, explicitly declared function
15772 arguments can match null pointed constants. If we were given
15773 an incomplete set of explicit args, we must not do semantic
15774 processing during substitution as we could create partial
15776 for (i
= 0; i
< len
; i
++)
15778 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
15779 bool parameter_pack
= false;
15780 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
15782 /* Dig out the actual parm. */
15783 if (TREE_CODE (parm
) == TYPE_DECL
15784 || TREE_CODE (parm
) == TEMPLATE_DECL
)
15786 parm
= TREE_TYPE (parm
);
15787 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
15789 else if (TREE_CODE (parm
) == PARM_DECL
)
15791 parm
= DECL_INITIAL (parm
);
15792 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
15795 if (!parameter_pack
&& targ
== NULL_TREE
)
15796 /* No explicit argument for this template parameter. */
15799 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
15801 /* Mark the argument pack as "incomplete". We could
15802 still deduce more arguments during unification.
15803 We remove this mark in type_unification_real. */
15806 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
15807 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
15808 = ARGUMENT_PACK_ARGS (targ
);
15811 /* We have some incomplete argument packs. */
15816 TREE_VALUE (tinst
) = explicit_targs
;
15817 if (!push_tinst_level (tinst
))
15819 excessive_deduction_depth
= true;
15822 processing_template_decl
+= incomplete
;
15823 input_location
= DECL_SOURCE_LOCATION (fn
);
15824 /* Ignore any access checks; we'll see them again in
15825 instantiate_template and they might have the wrong
15826 access path at this point. */
15827 push_deferring_access_checks (dk_deferred
);
15828 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
15829 complain
| tf_partial
, NULL_TREE
);
15830 pop_deferring_access_checks ();
15831 input_location
= loc
;
15832 processing_template_decl
-= incomplete
;
15833 pop_tinst_level ();
15835 if (fntype
== error_mark_node
)
15838 /* Place the explicitly specified arguments in TARGS. */
15839 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
15840 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
15843 /* Never do unification on the 'this' parameter. */
15844 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
15850 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
15851 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
15852 new_args
[0] = return_type
;
15853 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
15858 /* We allow incomplete unification without an error message here
15859 because the standard doesn't seem to explicitly prohibit it. Our
15860 callers must be ready to deal with unification failures in any
15863 TREE_VALUE (tinst
) = targs
;
15864 /* If we aren't explaining yet, push tinst context so we can see where
15865 any errors (e.g. from class instantiations triggered by instantiation
15866 of default template arguments) come from. If we are explaining, this
15867 context is redundant. */
15868 if (!explain_p
&& !push_tinst_level (tinst
))
15870 excessive_deduction_depth
= true;
15874 /* type_unification_real will pass back any access checks from default
15875 template argument substitution. */
15876 vec
<deferred_access_check
, va_gc
> *checks
;
15879 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
15880 targs
, parms
, args
, nargs
, /*subr=*/0,
15881 strict
, flags
, &checks
, explain_p
);
15883 pop_tinst_level ();
15887 /* Now that we have bindings for all of the template arguments,
15888 ensure that the arguments deduced for the template template
15889 parameters have compatible template parameter lists. We cannot
15890 check this property before we have deduced all template
15891 arguments, because the template parameter types of a template
15892 template parameter might depend on prior template parameters
15893 deduced after the template template parameter. The following
15894 ill-formed example illustrates this issue:
15896 template<typename T, template<T> class C> void f(C<5>, T);
15898 template<int N> struct X {};
15901 f(X<5>(), 5l); // error: template argument deduction fails
15904 The template parameter list of 'C' depends on the template type
15905 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
15906 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
15907 time that we deduce 'C'. */
15908 if (!template_template_parm_bindings_ok_p
15909 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
15911 unify_inconsistent_template_template_parameters (explain_p
);
15915 /* All is well so far. Now, check:
15919 When all template arguments have been deduced, all uses of
15920 template parameters in nondeduced contexts are replaced with
15921 the corresponding deduced argument values. If the
15922 substitution results in an invalid type, as described above,
15923 type deduction fails. */
15924 TREE_VALUE (tinst
) = targs
;
15925 if (!push_tinst_level (tinst
))
15927 excessive_deduction_depth
= true;
15931 /* Also collect access checks from the instantiation. */
15932 reopen_deferring_access_checks (checks
);
15934 decl
= instantiate_template (fn
, targs
, complain
);
15936 checks
= get_deferred_access_checks ();
15937 pop_deferring_access_checks ();
15939 pop_tinst_level ();
15941 if (decl
== error_mark_node
)
15944 /* Now perform any access checks encountered during substitution. */
15945 push_access_scope (decl
);
15946 ok
= perform_access_checks (checks
, complain
);
15947 pop_access_scope (decl
);
15951 /* If we're looking for an exact match, check that what we got
15952 is indeed an exact match. It might not be if some template
15953 parameters are used in non-deduced contexts. But don't check
15954 for an exact match if we have dependent template arguments;
15955 in that case we're doing partial ordering, and we already know
15956 that we have two candidates that will provide the actual type. */
15957 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
15959 tree substed
= TREE_TYPE (decl
);
15963 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
15965 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
15966 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
15967 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
15969 unify_type_mismatch (explain_p
, args
[i
],
15970 TREE_VALUE (sarg
));
15979 if (excessive_deduction_depth
)
15981 if (deduction_depth
== 0)
15982 /* Reset once we're all the way out. */
15983 excessive_deduction_depth
= false;
15986 /* We can't free this if a pending_template entry or last_error_tinst_level
15987 is pointing at it. */
15988 if (last_pending_template
== old_last_pend
15989 && last_error_tinst_level
== old_error_tinst
)
15995 /* Adjust types before performing type deduction, as described in
15996 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
15997 sections are symmetric. PARM is the type of a function parameter
15998 or the return type of the conversion function. ARG is the type of
15999 the argument passed to the call, or the type of the value
16000 initialized with the result of the conversion function.
16001 ARG_EXPR is the original argument expression, which may be null. */
16004 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16018 /* Swap PARM and ARG throughout the remainder of this
16019 function; the handling is precisely symmetric since PARM
16020 will initialize ARG rather than vice versa. */
16028 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16029 too, but here handle it by stripping the reference from PARM
16030 rather than by adding it to ARG. */
16031 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16032 && TYPE_REF_IS_RVALUE (*parm
)
16033 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16034 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16035 && TREE_CODE (*arg
) == REFERENCE_TYPE
16036 && !TYPE_REF_IS_RVALUE (*arg
))
16037 *parm
= TREE_TYPE (*parm
);
16038 /* Nothing else to do in this case. */
16042 gcc_unreachable ();
16045 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16047 /* [temp.deduct.call]
16049 If P is not a reference type:
16051 --If A is an array type, the pointer type produced by the
16052 array-to-pointer standard conversion (_conv.array_) is
16053 used in place of A for type deduction; otherwise,
16055 --If A is a function type, the pointer type produced by
16056 the function-to-pointer standard conversion
16057 (_conv.func_) is used in place of A for type deduction;
16060 --If A is a cv-qualified type, the top level
16061 cv-qualifiers of A's type are ignored for type
16063 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16064 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16065 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16066 *arg
= build_pointer_type (*arg
);
16068 *arg
= TYPE_MAIN_VARIANT (*arg
);
16071 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16072 of the form T&&, where T is a template parameter, and the argument
16073 is an lvalue, T is deduced as A& */
16074 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16075 && TYPE_REF_IS_RVALUE (*parm
)
16076 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16077 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16078 && (arg_expr
? real_lvalue_p (arg_expr
)
16079 /* try_one_overload doesn't provide an arg_expr, but
16080 functions are always lvalues. */
16081 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16082 *arg
= build_reference_type (*arg
);
16084 /* [temp.deduct.call]
16086 If P is a cv-qualified type, the top level cv-qualifiers
16087 of P's type are ignored for type deduction. If P is a
16088 reference type, the type referred to by P is used for
16090 *parm
= TYPE_MAIN_VARIANT (*parm
);
16091 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16093 *parm
= TREE_TYPE (*parm
);
16094 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16097 /* DR 322. For conversion deduction, remove a reference type on parm
16098 too (which has been swapped into ARG). */
16099 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16100 *arg
= TREE_TYPE (*arg
);
16105 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16106 template which does contain any deducible template parameters; check if
16107 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16108 unify_one_argument. */
16111 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16112 int flags
, bool explain_p
)
16117 type
= TREE_TYPE (arg
);
16121 if (same_type_p (parm
, type
))
16122 return unify_success (explain_p
);
16124 if (strict
== DEDUCE_CONV
)
16126 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16127 explain_p
? tf_warning_or_error
: tf_none
))
16128 return unify_success (explain_p
);
16130 else if (strict
!= DEDUCE_EXACT
)
16132 if (can_convert_arg (parm
, type
,
16133 TYPE_P (arg
) ? NULL_TREE
: arg
,
16134 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16135 return unify_success (explain_p
);
16138 if (strict
== DEDUCE_EXACT
)
16139 return unify_type_mismatch (explain_p
, parm
, arg
);
16141 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16144 static bool uses_deducible_template_parms (tree type
);
16146 /* Returns true iff the expression EXPR is one from which a template
16147 argument can be deduced. In other words, if it's an undecorated
16148 use of a template non-type parameter. */
16151 deducible_expression (tree expr
)
16153 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16156 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16157 deducible way; that is, if it has a max value of <PARM> - 1. */
16160 deducible_array_bound (tree domain
)
16162 if (domain
== NULL_TREE
)
16165 tree max
= TYPE_MAX_VALUE (domain
);
16166 if (TREE_CODE (max
) != MINUS_EXPR
)
16169 return deducible_expression (TREE_OPERAND (max
, 0));
16172 /* Returns true iff the template arguments ARGS use a template parameter
16173 in a deducible way. */
16176 deducible_template_args (tree args
)
16178 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16181 tree elt
= TREE_VEC_ELT (args
, i
);
16182 if (ARGUMENT_PACK_P (elt
))
16183 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16186 if (PACK_EXPANSION_P (elt
))
16187 elt
= PACK_EXPANSION_PATTERN (elt
);
16188 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16190 else if (TYPE_P (elt
))
16191 deducible
= uses_deducible_template_parms (elt
);
16193 deducible
= deducible_expression (elt
);
16201 /* Returns true iff TYPE contains any deducible references to template
16202 parameters, as per 14.8.2.5. */
16205 uses_deducible_template_parms (tree type
)
16207 if (PACK_EXPANSION_P (type
))
16208 type
= PACK_EXPANSION_PATTERN (type
);
16215 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16216 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16222 if (POINTER_TYPE_P (type
))
16223 return uses_deducible_template_parms (TREE_TYPE (type
));
16225 /* T[integer-constant ]
16227 if (TREE_CODE (type
) == ARRAY_TYPE
)
16228 return (uses_deducible_template_parms (TREE_TYPE (type
))
16229 || deducible_array_bound (TYPE_DOMAIN (type
)));
16241 if (TYPE_PTRMEM_P (type
))
16242 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16243 || (uses_deducible_template_parms
16244 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16246 /* template-name <T> (where template-name refers to a class template)
16247 template-name <i> (where template-name refers to a class template) */
16248 if (CLASS_TYPE_P (type
)
16249 && CLASSTYPE_TEMPLATE_INFO (type
)
16250 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16251 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16252 (CLASSTYPE_TI_ARGS (type
)));
16257 if (TREE_CODE (type
) == FUNCTION_TYPE
16258 || TREE_CODE (type
) == METHOD_TYPE
)
16260 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16262 tree parm
= TYPE_ARG_TYPES (type
);
16263 if (TREE_CODE (type
) == METHOD_TYPE
)
16264 parm
= TREE_CHAIN (parm
);
16265 for (; parm
; parm
= TREE_CHAIN (parm
))
16266 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16273 /* Subroutine of type_unification_real and unify_pack_expansion to
16274 handle unification of a single P/A pair. Parameters are as
16275 for those functions. */
16278 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16279 int subr
, unification_kind_t strict
, int flags
,
16282 tree arg_expr
= NULL_TREE
;
16285 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16286 return unify_invalid (explain_p
);
16287 if (arg
== unknown_type_node
)
16288 /* We can't deduce anything from this, but we might get all the
16289 template args from other function args. */
16290 return unify_success (explain_p
);
16292 /* Implicit conversions (Clause 4) will be performed on a function
16293 argument to convert it to the type of the corresponding function
16294 parameter if the parameter type contains no template-parameters that
16295 participate in template argument deduction. */
16296 if (TYPE_P (parm
) && !uses_template_parms (parm
))
16297 /* For function parameters that contain no template-parameters at all,
16298 we have historically checked for convertibility in order to shortcut
16299 consideration of this candidate. */
16300 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
16302 else if (strict
== DEDUCE_CALL
16303 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16304 /* For function parameters with only non-deducible template parameters,
16306 return unify_success (explain_p
);
16311 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16312 | UNIFY_ALLOW_MORE_CV_QUAL
16313 | UNIFY_ALLOW_DERIVED
);
16317 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16321 arg_strict
= UNIFY_ALLOW_NONE
;
16325 gcc_unreachable ();
16328 /* We only do these transformations if this is the top-level
16329 parameter_type_list in a call or declaration matching; in other
16330 situations (nested function declarators, template argument lists) we
16331 won't be comparing a type to an expression, and we don't do any type
16337 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16338 if (type_unknown_p (arg
))
16340 /* [temp.deduct.type] A template-argument can be
16341 deduced from a pointer to function or pointer
16342 to member function argument if the set of
16343 overloaded functions does not contain function
16344 templates and at most one of a set of
16345 overloaded functions provides a unique
16348 if (resolve_overloaded_unification
16349 (tparms
, targs
, parm
, arg
, strict
,
16350 arg_strict
, explain_p
))
16351 return unify_success (explain_p
);
16352 return unify_overload_resolution_failure (explain_p
, arg
);
16356 arg
= unlowered_expr_type (arg
);
16357 if (arg
== error_mark_node
)
16358 return unify_invalid (explain_p
);
16362 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16365 gcc_assert ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16366 == (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
));
16368 /* For deduction from an init-list we need the actual list. */
16369 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16371 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16374 /* Most parms like fn_type_unification.
16376 If SUBR is 1, we're being called recursively (to unify the
16377 arguments of a function or method parameter of a function
16380 CHECKS is a pointer to a vector of access checks encountered while
16381 substituting default template arguments. */
16384 type_unification_real (tree tparms
,
16388 unsigned int xnargs
,
16390 unification_kind_t strict
,
16392 vec
<deferred_access_check
, va_gc
> **checks
,
16397 int ntparms
= TREE_VEC_LENGTH (tparms
);
16398 int saw_undeduced
= 0;
16401 unsigned int nargs
;
16404 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16405 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16406 gcc_assert (ntparms
> 0);
16408 /* Reset the number of non-defaulted template arguments contained
16410 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16418 while (parms
&& parms
!= void_list_node
16421 parm
= TREE_VALUE (parms
);
16423 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16424 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16425 /* For a function parameter pack that occurs at the end of the
16426 parameter-declaration-list, the type A of each remaining
16427 argument of the call is compared with the type P of the
16428 declarator-id of the function parameter pack. */
16431 parms
= TREE_CHAIN (parms
);
16433 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16434 /* For a function parameter pack that does not occur at the
16435 end of the parameter-declaration-list, the type of the
16436 parameter pack is a non-deduced context. */
16442 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16448 && parms
!= void_list_node
16449 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16451 /* Unify the remaining arguments with the pack expansion type. */
16453 tree parmvec
= make_tree_vec (1);
16455 /* Allocate a TREE_VEC and copy in all of the arguments */
16456 argvec
= make_tree_vec (nargs
- ia
);
16457 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16458 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16460 /* Copy the parameter into parmvec. */
16461 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16462 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16463 /*subr=*/subr
, explain_p
))
16466 /* Advance to the end of the list of parameters. */
16467 parms
= TREE_CHAIN (parms
);
16470 /* Fail if we've reached the end of the parm list, and more args
16471 are present, and the parm list isn't variadic. */
16472 if (ia
< nargs
&& parms
== void_list_node
)
16473 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16474 /* Fail if parms are left and they don't have default values. */
16475 if (parms
&& parms
!= void_list_node
16476 && TREE_PURPOSE (parms
) == NULL_TREE
)
16478 unsigned int count
= nargs
;
16480 while (p
&& p
!= void_list_node
)
16483 p
= TREE_CHAIN (p
);
16485 return unify_too_few_arguments (explain_p
, ia
, count
);
16490 tsubst_flags_t complain
= (explain_p
16491 ? tf_warning_or_error
16494 for (i
= 0; i
< ntparms
; i
++)
16496 tree targ
= TREE_VEC_ELT (targs
, i
);
16497 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16499 /* Clear the "incomplete" flags on all argument packs now so that
16500 substituting them into later default arguments works. */
16501 if (targ
&& ARGUMENT_PACK_P (targ
))
16503 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16504 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16507 if (targ
|| tparm
== error_mark_node
)
16509 tparm
= TREE_VALUE (tparm
);
16511 /* If this is an undeduced nontype parameter that depends on
16512 a type parameter, try another pass; its type may have been
16513 deduced from a later argument than the one from which
16514 this parameter can be deduced. */
16515 if (TREE_CODE (tparm
) == PARM_DECL
16516 && uses_template_parms (TREE_TYPE (tparm
))
16517 && !saw_undeduced
++)
16520 /* Core issue #226 (C++0x) [temp.deduct]:
16522 If a template argument has not been deduced, its
16523 default template argument, if any, is used.
16525 When we are in C++98 mode, TREE_PURPOSE will either
16526 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16527 to explicitly check cxx_dialect here. */
16528 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
16530 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16531 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
16532 reopen_deferring_access_checks (*checks
);
16533 location_t save_loc
= input_location
;
16535 input_location
= DECL_SOURCE_LOCATION (parm
);
16536 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
16537 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
16539 input_location
= save_loc
;
16540 *checks
= get_deferred_access_checks ();
16541 pop_deferring_access_checks ();
16542 if (arg
== error_mark_node
)
16546 TREE_VEC_ELT (targs
, i
) = arg
;
16547 /* The position of the first default template argument,
16548 is also the number of non-defaulted arguments in TARGS.
16550 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16551 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
16556 /* If the type parameter is a parameter pack, then it will
16557 be deduced to an empty parameter pack. */
16558 if (template_parameter_pack_p (tparm
))
16562 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
16564 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
16565 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
16566 TREE_CONSTANT (arg
) = 1;
16569 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16571 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
16573 TREE_VEC_ELT (targs
, i
) = arg
;
16577 return unify_parameter_deduction_failure (explain_p
, tparm
);
16580 #ifdef ENABLE_CHECKING
16581 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16582 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
16585 return unify_success (explain_p
);
16588 /* Subroutine of type_unification_real. Args are like the variables
16589 at the call site. ARG is an overloaded function (or template-id);
16590 we try deducing template args from each of the overloads, and if
16591 only one succeeds, we go with that. Modifies TARGS and returns
16592 true on success. */
16595 resolve_overloaded_unification (tree tparms
,
16599 unification_kind_t strict
,
16603 tree tempargs
= copy_node (targs
);
16605 tree goodfn
= NULL_TREE
;
16608 if (TREE_CODE (arg
) == ADDR_EXPR
)
16610 arg
= TREE_OPERAND (arg
, 0);
16616 if (TREE_CODE (arg
) == COMPONENT_REF
)
16617 /* Handle `&x' where `x' is some static or non-static member
16619 arg
= TREE_OPERAND (arg
, 1);
16621 if (TREE_CODE (arg
) == OFFSET_REF
)
16622 arg
= TREE_OPERAND (arg
, 1);
16624 /* Strip baselink information. */
16625 if (BASELINK_P (arg
))
16626 arg
= BASELINK_FUNCTIONS (arg
);
16628 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
16630 /* If we got some explicit template args, we need to plug them into
16631 the affected templates before we try to unify, in case the
16632 explicit args will completely resolve the templates in question. */
16635 tree expl_subargs
= TREE_OPERAND (arg
, 1);
16636 arg
= TREE_OPERAND (arg
, 0);
16638 for (; arg
; arg
= OVL_NEXT (arg
))
16640 tree fn
= OVL_CURRENT (arg
);
16641 tree subargs
, elem
;
16643 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16646 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16647 expl_subargs
, NULL_TREE
, tf_none
,
16648 /*require_all_args=*/true,
16649 /*use_default_args=*/true);
16650 if (subargs
!= error_mark_node
16651 && !any_dependent_template_arguments_p (subargs
))
16653 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
16654 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16655 elem
, strict
, sub_strict
, addr_p
, explain_p
)
16656 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
16665 /* If no templates (or more than one) are fully resolved by the
16666 explicit arguments, this template-id is a non-deduced context; it
16667 could still be OK if we deduce all template arguments for the
16668 enclosing call through other arguments. */
16672 else if (TREE_CODE (arg
) != OVERLOAD
16673 && TREE_CODE (arg
) != FUNCTION_DECL
)
16674 /* If ARG is, for example, "(0, &f)" then its type will be unknown
16675 -- but the deduction does not succeed because the expression is
16676 not just the function on its own. */
16679 for (; arg
; arg
= OVL_NEXT (arg
))
16680 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16681 TREE_TYPE (OVL_CURRENT (arg
)),
16682 strict
, sub_strict
, addr_p
, explain_p
)
16683 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
16685 goodfn
= OVL_CURRENT (arg
);
16689 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16690 to function or pointer to member function argument if the set of
16691 overloaded functions does not contain function templates and at most
16692 one of a set of overloaded functions provides a unique match.
16694 So if we found multiple possibilities, we return success but don't
16695 deduce anything. */
16699 int i
= TREE_VEC_LENGTH (targs
);
16701 if (TREE_VEC_ELT (tempargs
, i
))
16702 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
16710 /* Core DR 115: In contexts where deduction is done and fails, or in
16711 contexts where deduction is not done, if a template argument list is
16712 specified and it, along with any default template arguments, identifies
16713 a single function template specialization, then the template-id is an
16714 lvalue for the function template specialization. */
16717 resolve_nondeduced_context (tree orig_expr
)
16719 tree expr
, offset
, baselink
;
16722 if (!type_unknown_p (orig_expr
))
16727 offset
= NULL_TREE
;
16728 baselink
= NULL_TREE
;
16730 if (TREE_CODE (expr
) == ADDR_EXPR
)
16732 expr
= TREE_OPERAND (expr
, 0);
16735 if (TREE_CODE (expr
) == OFFSET_REF
)
16738 expr
= TREE_OPERAND (expr
, 1);
16740 if (BASELINK_P (expr
))
16743 expr
= BASELINK_FUNCTIONS (expr
);
16746 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
16749 tree goodfn
= NULL_TREE
;
16751 /* If we got some explicit template args, we need to plug them into
16752 the affected templates before we try to unify, in case the
16753 explicit args will completely resolve the templates in question. */
16755 tree expl_subargs
= TREE_OPERAND (expr
, 1);
16756 tree arg
= TREE_OPERAND (expr
, 0);
16757 tree badfn
= NULL_TREE
;
16758 tree badargs
= NULL_TREE
;
16760 for (; arg
; arg
= OVL_NEXT (arg
))
16762 tree fn
= OVL_CURRENT (arg
);
16763 tree subargs
, elem
;
16765 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16768 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16769 expl_subargs
, NULL_TREE
, tf_none
,
16770 /*require_all_args=*/true,
16771 /*use_default_args=*/true);
16772 if (subargs
!= error_mark_node
16773 && !any_dependent_template_arguments_p (subargs
))
16775 elem
= instantiate_template (fn
, subargs
, tf_none
);
16776 if (elem
== error_mark_node
)
16781 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
16790 mark_used (goodfn
);
16793 expr
= build_baselink (BASELINK_BINFO (baselink
),
16794 BASELINK_ACCESS_BINFO (baselink
),
16795 expr
, BASELINK_OPTYPE (baselink
));
16799 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
16800 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
16803 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
16806 else if (good
== 0 && badargs
)
16807 /* There were no good options and at least one bad one, so let the
16808 user know what the problem is. */
16809 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
16814 /* Subroutine of resolve_overloaded_unification; does deduction for a single
16815 overload. Fills TARGS with any deduced arguments, or error_mark_node if
16816 different overloads deduce different arguments for a given parm.
16817 ADDR_P is true if the expression for which deduction is being
16818 performed was of the form "& fn" rather than simply "fn".
16820 Returns 1 on success. */
16823 try_one_overload (tree tparms
,
16828 unification_kind_t strict
,
16837 if (arg
== error_mark_node
)
16840 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16841 to function or pointer to member function argument if the set of
16842 overloaded functions does not contain function templates and at most
16843 one of a set of overloaded functions provides a unique match.
16845 So if this is a template, just return success. */
16847 if (uses_template_parms (arg
))
16850 if (TREE_CODE (arg
) == METHOD_TYPE
)
16851 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
16853 arg
= build_pointer_type (arg
);
16855 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
16857 /* We don't copy orig_targs for this because if we have already deduced
16858 some template args from previous args, unify would complain when we
16859 try to deduce a template parameter for the same argument, even though
16860 there isn't really a conflict. */
16861 nargs
= TREE_VEC_LENGTH (targs
);
16862 tempargs
= make_tree_vec (nargs
);
16864 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
16867 /* First make sure we didn't deduce anything that conflicts with
16868 explicitly specified args. */
16869 for (i
= nargs
; i
--; )
16871 tree elt
= TREE_VEC_ELT (tempargs
, i
);
16872 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
16876 else if (uses_template_parms (elt
))
16877 /* Since we're unifying against ourselves, we will fill in
16878 template args used in the function parm list with our own
16879 template parms. Discard them. */
16880 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
16881 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
16885 for (i
= nargs
; i
--; )
16887 tree elt
= TREE_VEC_ELT (tempargs
, i
);
16890 TREE_VEC_ELT (targs
, i
) = elt
;
16896 /* PARM is a template class (perhaps with unbound template
16897 parameters). ARG is a fully instantiated type. If ARG can be
16898 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
16899 TARGS are as for unify. */
16902 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
16905 tree copy_of_targs
;
16907 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
16908 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
16909 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
16912 /* We need to make a new template argument vector for the call to
16913 unify. If we used TARGS, we'd clutter it up with the result of
16914 the attempted unification, even if this class didn't work out.
16915 We also don't want to commit ourselves to all the unifications
16916 we've already done, since unification is supposed to be done on
16917 an argument-by-argument basis. In other words, consider the
16918 following pathological case:
16920 template <int I, int J, int K>
16923 template <int I, int J>
16924 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
16926 template <int I, int J, int K>
16927 void f(S<I, J, K>, S<I, I, I>);
16936 Now, by the time we consider the unification involving `s2', we
16937 already know that we must have `f<0, 0, 0>'. But, even though
16938 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
16939 because there are two ways to unify base classes of S<0, 1, 2>
16940 with S<I, I, I>. If we kept the already deduced knowledge, we
16941 would reject the possibility I=1. */
16942 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
16944 /* If unification failed, we're done. */
16945 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
16946 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
16952 /* Given a template type PARM and a class type ARG, find the unique
16953 base type in ARG that is an instance of PARM. We do not examine
16954 ARG itself; only its base-classes. If there is not exactly one
16955 appropriate base class, return NULL_TREE. PARM may be the type of
16956 a partial specialization, as well as a plain template type. Used
16959 static enum template_base_result
16960 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
16961 bool explain_p
, tree
*result
)
16963 tree rval
= NULL_TREE
;
16966 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
16968 binfo
= TYPE_BINFO (complete_type (arg
));
16971 /* The type could not be completed. */
16972 *result
= NULL_TREE
;
16973 return tbr_incomplete_type
;
16976 /* Walk in inheritance graph order. The search order is not
16977 important, and this avoids multiple walks of virtual bases. */
16978 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
16980 tree r
= try_class_unification (tparms
, targs
, parm
,
16981 BINFO_TYPE (binfo
), explain_p
);
16985 /* If there is more than one satisfactory baseclass, then:
16989 If they yield more than one possible deduced A, the type
16993 if (rval
&& !same_type_p (r
, rval
))
16995 *result
= NULL_TREE
;
16996 return tbr_ambiguous_baseclass
;
17004 return tbr_success
;
17007 /* Returns the level of DECL, which declares a template parameter. */
17010 template_decl_level (tree decl
)
17012 switch (TREE_CODE (decl
))
17015 case TEMPLATE_DECL
:
17016 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17019 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17022 gcc_unreachable ();
17027 /* Decide whether ARG can be unified with PARM, considering only the
17028 cv-qualifiers of each type, given STRICT as documented for unify.
17029 Returns nonzero iff the unification is OK on that basis. */
17032 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17034 int arg_quals
= cp_type_quals (arg
);
17035 int parm_quals
= cp_type_quals (parm
);
17037 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17038 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17040 /* Although a CVR qualifier is ignored when being applied to a
17041 substituted template parameter ([8.3.2]/1 for example), that
17042 does not allow us to unify "const T" with "int&" because both
17043 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17044 It is ok when we're allowing additional CV qualifiers
17045 at the outer level [14.8.2.1]/3,1st bullet. */
17046 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17047 || TREE_CODE (arg
) == FUNCTION_TYPE
17048 || TREE_CODE (arg
) == METHOD_TYPE
)
17049 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17052 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17053 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17057 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17058 && (arg_quals
& parm_quals
) != parm_quals
)
17061 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17062 && (parm_quals
& arg_quals
) != arg_quals
)
17068 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17070 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17072 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17073 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17074 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17076 *index
= TEMPLATE_TYPE_IDX (parm
);
17077 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17081 *index
= TEMPLATE_PARM_IDX (parm
);
17082 *level
= TEMPLATE_PARM_LEVEL (parm
);
17086 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17088 if (unify (TP, TA, P, A, S, EP)) \
17092 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17093 expansion at the end of PACKED_PARMS. Returns 0 if the type
17094 deduction succeeds, 1 otherwise. STRICT is the same as in
17095 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17096 call argument list. We'll need to adjust the arguments to make them
17097 types. SUBR tells us if this is from a recursive call to
17098 type_unification_real, or for comparing two template argument
17102 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17103 tree packed_args
, unification_kind_t strict
,
17104 bool subr
, bool explain_p
)
17107 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17108 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17109 tree pack
, packs
= NULL_TREE
;
17110 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17112 packed_args
= expand_template_argument_pack (packed_args
);
17114 int len
= TREE_VEC_LENGTH (packed_args
);
17116 /* Determine the parameter packs we will be deducing from the
17117 pattern, and record their current deductions. */
17118 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17119 pack
; pack
= TREE_CHAIN (pack
))
17121 tree parm_pack
= TREE_VALUE (pack
);
17124 /* Determine the index and level of this parameter pack. */
17125 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17127 /* Keep track of the parameter packs and their corresponding
17129 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17130 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17133 /* Loop through all of the arguments that have not yet been
17134 unified and unify each with the pattern. */
17135 for (i
= start
; i
< len
; i
++)
17138 bool any_explicit
= false;
17139 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17141 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17142 or the element of its argument pack at the current index if
17143 this argument was explicitly specified. */
17144 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17148 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17151 if (TREE_VALUE (pack
)
17152 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17153 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17155 any_explicit
= true;
17156 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17158 TMPL_ARG (targs
, level
, idx
) = arg
;
17161 /* If we had explicit template arguments, substitute them into the
17162 pattern before deduction. */
17165 /* Some arguments might still be unspecified or dependent. */
17167 ++processing_template_decl
;
17168 dependent
= any_dependent_template_arguments_p (targs
);
17170 --processing_template_decl
;
17171 parm
= tsubst (pattern
, targs
,
17172 explain_p
? tf_warning_or_error
: tf_none
,
17175 --processing_template_decl
;
17176 if (parm
== error_mark_node
)
17182 /* Unify the pattern with the current argument. */
17183 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17184 LOOKUP_IMPLICIT
, explain_p
))
17187 /* For each parameter pack, collect the deduced value. */
17188 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17191 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17193 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17194 TMPL_ARG (targs
, level
, idx
);
17198 /* Verify that the results of unification with the parameter packs
17199 produce results consistent with what we've seen before, and make
17200 the deduced argument packs available. */
17201 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17203 tree old_pack
= TREE_VALUE (pack
);
17204 tree new_args
= TREE_TYPE (pack
);
17205 int i
, len
= TREE_VEC_LENGTH (new_args
);
17207 bool nondeduced_p
= false;
17209 /* By default keep the original deduced argument pack.
17210 If necessary, more specific code is going to update the
17211 resulting deduced argument later down in this function. */
17212 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17213 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17215 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17216 actually deduce anything. */
17217 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17218 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17219 nondeduced_p
= true;
17223 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17225 /* If we had fewer function args than explicit template args,
17226 just use the explicits. */
17227 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17228 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17229 if (len
< explicit_len
)
17230 new_args
= explicit_args
;
17236 /* Build the deduced *_ARGUMENT_PACK. */
17237 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17239 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17240 TREE_TYPE (result
) =
17241 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17242 TREE_CONSTANT (result
) = 1;
17245 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17247 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17249 /* Note the deduced argument packs for this parameter
17251 TMPL_ARG (targs
, level
, idx
) = result
;
17253 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17254 && (ARGUMENT_PACK_ARGS (old_pack
)
17255 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17257 /* We only had the explicitly-provided arguments before, but
17258 now we have a complete set of arguments. */
17259 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17261 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17262 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17263 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17267 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17268 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17270 if (!comp_template_args_with_info (old_args
, new_args
,
17271 &bad_old_arg
, &bad_new_arg
))
17272 /* Inconsistent unification of this parameter pack. */
17273 return unify_parameter_pack_inconsistent (explain_p
,
17279 return unify_success (explain_p
);
17282 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17283 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17284 parameters and return value are as for unify. */
17287 unify_array_domain (tree tparms
, tree targs
,
17288 tree parm_dom
, tree arg_dom
,
17296 /* Our representation of array types uses "N - 1" as the
17297 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17298 not an integer constant. We cannot unify arbitrarily
17299 complex expressions, so we eliminate the MINUS_EXPRs
17301 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17302 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17305 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17306 parm_max
= TREE_OPERAND (parm_max
, 0);
17308 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17309 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17312 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17313 trying to unify the type of a variable with the type
17314 of a template parameter. For example:
17316 template <unsigned int N>
17317 void f (char (&) [N]);
17324 Here, the type of the ARG will be "int [g(i)]", and
17325 may be a SAVE_EXPR, etc. */
17326 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17327 return unify_vla_arg (explain_p
, arg_dom
);
17328 arg_max
= TREE_OPERAND (arg_max
, 0);
17331 /* If only one of the bounds used a MINUS_EXPR, compensate
17332 by adding one to the other bound. */
17333 if (parm_cst
&& !arg_cst
)
17334 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17338 else if (arg_cst
&& !parm_cst
)
17339 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17344 return unify (tparms
, targs
, parm_max
, arg_max
,
17345 UNIFY_ALLOW_INTEGER
, explain_p
);
17348 /* Deduce the value of template parameters. TPARMS is the (innermost)
17349 set of template parameters to a template. TARGS is the bindings
17350 for those template parameters, as determined thus far; TARGS may
17351 include template arguments for outer levels of template parameters
17352 as well. PARM is a parameter to a template function, or a
17353 subcomponent of that parameter; ARG is the corresponding argument.
17354 This function attempts to match PARM with ARG in a manner
17355 consistent with the existing assignments in TARGS. If more values
17356 are deduced, then TARGS is updated.
17358 Returns 0 if the type deduction succeeds, 1 otherwise. The
17359 parameter STRICT is a bitwise or of the following flags:
17362 Require an exact match between PARM and ARG.
17363 UNIFY_ALLOW_MORE_CV_QUAL:
17364 Allow the deduced ARG to be more cv-qualified (by qualification
17365 conversion) than ARG.
17366 UNIFY_ALLOW_LESS_CV_QUAL:
17367 Allow the deduced ARG to be less cv-qualified than ARG.
17368 UNIFY_ALLOW_DERIVED:
17369 Allow the deduced ARG to be a template base class of ARG,
17370 or a pointer to a template base class of the type pointed to by
17372 UNIFY_ALLOW_INTEGER:
17373 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17374 case for more information.
17375 UNIFY_ALLOW_OUTER_LEVEL:
17376 This is the outermost level of a deduction. Used to determine validity
17377 of qualification conversions. A valid qualification conversion must
17378 have const qualified pointers leading up to the inner type which
17379 requires additional CV quals, except at the outer level, where const
17380 is not required [conv.qual]. It would be normal to set this flag in
17381 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17382 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17383 This is the outermost level of a deduction, and PARM can be more CV
17384 qualified at this point.
17385 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17386 This is the outermost level of a deduction, and PARM can be less CV
17387 qualified at this point. */
17390 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17396 int strict_in
= strict
;
17398 /* I don't think this will do the right thing with respect to types.
17399 But the only case I've seen it in so far has been array bounds, where
17400 signedness is the only information lost, and I think that will be
17402 while (TREE_CODE (parm
) == NOP_EXPR
)
17403 parm
= TREE_OPERAND (parm
, 0);
17405 if (arg
== error_mark_node
)
17406 return unify_invalid (explain_p
);
17407 if (arg
== unknown_type_node
17408 || arg
== init_list_type_node
)
17409 /* We can't deduce anything from this, but we might get all the
17410 template args from other function args. */
17411 return unify_success (explain_p
);
17413 /* If PARM uses template parameters, then we can't bail out here,
17414 even if ARG == PARM, since we won't record unifications for the
17415 template parameters. We might need them if we're trying to
17416 figure out which of two things is more specialized. */
17417 if (arg
== parm
&& !uses_template_parms (parm
))
17418 return unify_success (explain_p
);
17420 /* Handle init lists early, so the rest of the function can assume
17421 we're dealing with a type. */
17422 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17426 tree orig_parm
= parm
;
17428 /* Replace T with std::initializer_list<T> for deduction. */
17429 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17430 && flag_deduce_init_list
)
17431 parm
= listify (parm
);
17433 if (!is_std_init_list (parm
)
17434 && TREE_CODE (parm
) != ARRAY_TYPE
)
17435 /* We can only deduce from an initializer list argument if the
17436 parameter is std::initializer_list or an array; otherwise this
17437 is a non-deduced context. */
17438 return unify_success (explain_p
);
17440 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17441 elttype
= TREE_TYPE (parm
);
17443 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17445 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
17447 int elt_strict
= strict
;
17449 if (elt
== error_mark_node
)
17450 return unify_invalid (explain_p
);
17452 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
17454 tree type
= TREE_TYPE (elt
);
17455 /* It should only be possible to get here for a call. */
17456 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
17457 elt_strict
|= maybe_adjust_types_for_deduction
17458 (DEDUCE_CALL
, &elttype
, &type
, elt
);
17462 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
17466 if (TREE_CODE (parm
) == ARRAY_TYPE
17467 && deducible_array_bound (TYPE_DOMAIN (parm
)))
17469 /* Also deduce from the length of the initializer list. */
17470 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
17471 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
17472 if (idx
== error_mark_node
)
17473 return unify_invalid (explain_p
);
17474 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17478 /* If the std::initializer_list<T> deduction worked, replace the
17479 deduced A with std::initializer_list<A>. */
17480 if (orig_parm
!= parm
)
17482 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
17483 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17484 targ
= listify (targ
);
17485 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
17487 return unify_success (explain_p
);
17490 /* Immediately reject some pairs that won't unify because of
17491 cv-qualification mismatches. */
17492 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17494 /* It is the elements of the array which hold the cv quals of an array
17495 type, and the elements might be template type parms. We'll check
17496 when we recurse. */
17497 && TREE_CODE (arg
) != ARRAY_TYPE
17498 /* We check the cv-qualifiers when unifying with template type
17499 parameters below. We want to allow ARG `const T' to unify with
17500 PARM `T' for example, when computing which of two templates
17501 is more specialized, for example. */
17502 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
17503 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
17504 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17506 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
17507 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
17508 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
17509 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
17510 strict
&= ~UNIFY_ALLOW_DERIVED
;
17511 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17512 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
17514 switch (TREE_CODE (parm
))
17516 case TYPENAME_TYPE
:
17518 case UNBOUND_CLASS_TEMPLATE
:
17519 /* In a type which contains a nested-name-specifier, template
17520 argument values cannot be deduced for template parameters used
17521 within the nested-name-specifier. */
17522 return unify_success (explain_p
);
17524 case TEMPLATE_TYPE_PARM
:
17525 case TEMPLATE_TEMPLATE_PARM
:
17526 case BOUND_TEMPLATE_TEMPLATE_PARM
:
17527 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17528 if (error_operand_p (tparm
))
17529 return unify_invalid (explain_p
);
17531 if (TEMPLATE_TYPE_LEVEL (parm
)
17532 != template_decl_level (tparm
))
17533 /* The PARM is not one we're trying to unify. Just check
17534 to see if it matches ARG. */
17536 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17537 && (is_auto (parm
) ? is_auto (arg
)
17538 : same_type_p (parm
, arg
)))
17539 return unify_success (explain_p
);
17541 return unify_type_mismatch (explain_p
, parm
, arg
);
17543 idx
= TEMPLATE_TYPE_IDX (parm
);
17544 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17545 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
17546 if (error_operand_p (tparm
))
17547 return unify_invalid (explain_p
);
17549 /* Check for mixed types and values. */
17550 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17551 && TREE_CODE (tparm
) != TYPE_DECL
)
17552 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17553 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
17554 gcc_unreachable ();
17556 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17558 /* ARG must be constructed from a template class or a template
17559 template parameter. */
17560 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
17561 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
17562 return unify_template_deduction_failure (explain_p
, parm
, arg
);
17564 tree parmvec
= TYPE_TI_ARGS (parm
);
17565 /* An alias template name is never deduced. */
17566 if (TYPE_ALIAS_P (arg
))
17567 arg
= strip_typedefs (arg
);
17568 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
17569 tree full_argvec
= add_to_template_args (targs
, argvec
);
17571 = DECL_INNERMOST_TEMPLATE_PARMS
17572 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
17574 int parm_variadic_p
= 0;
17576 /* The resolution to DR150 makes clear that default
17577 arguments for an N-argument may not be used to bind T
17578 to a template template parameter with fewer than N
17579 parameters. It is not safe to permit the binding of
17580 default arguments as an extension, as that may change
17581 the meaning of a conforming program. Consider:
17583 struct Dense { static const unsigned int dim = 1; };
17585 template <template <typename> class View,
17587 void operator+(float, View<Block> const&);
17589 template <typename Block,
17590 unsigned int Dim = Block::dim>
17591 struct Lvalue_proxy { operator float() const; };
17595 Lvalue_proxy<Dense> p;
17600 Here, if Lvalue_proxy is permitted to bind to View, then
17601 the global operator+ will be used; if they are not, the
17602 Lvalue_proxy will be converted to float. */
17603 if (coerce_template_parms (parm_parms
,
17605 TYPE_TI_TEMPLATE (parm
),
17607 ? tf_warning_or_error
17609 /*require_all_args=*/true,
17610 /*use_default_args=*/false)
17611 == error_mark_node
)
17614 /* Deduce arguments T, i from TT<T> or TT<i>.
17615 We check each element of PARMVEC and ARGVEC individually
17616 rather than the whole TREE_VEC since they can have
17617 different number of elements. */
17619 parmvec
= expand_template_argument_pack (parmvec
);
17620 argvec
= expand_template_argument_pack (argvec
);
17622 len
= TREE_VEC_LENGTH (parmvec
);
17624 /* Check if the parameters end in a pack, making them
17627 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
17628 parm_variadic_p
= 1;
17630 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17631 /* If the template argument list of P contains a pack
17632 expansion that is not the last template argument, the
17633 entire template argument list is a non-deduced
17635 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
17636 return unify_success (explain_p
);
17638 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
17639 return unify_too_few_arguments (explain_p
,
17640 TREE_VEC_LENGTH (argvec
), len
);
17642 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17644 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17645 TREE_VEC_ELT (parmvec
, i
),
17646 TREE_VEC_ELT (argvec
, i
),
17647 UNIFY_ALLOW_NONE
, explain_p
);
17650 if (parm_variadic_p
17651 && unify_pack_expansion (tparms
, targs
,
17654 /*subr=*/true, explain_p
))
17657 arg
= TYPE_TI_TEMPLATE (arg
);
17659 /* Fall through to deduce template name. */
17662 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17663 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17665 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
17667 /* Simple cases: Value already set, does match or doesn't. */
17668 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
17669 return unify_success (explain_p
);
17671 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17675 /* If PARM is `const T' and ARG is only `int', we don't have
17676 a match unless we are allowing additional qualification.
17677 If ARG is `const int' and PARM is just `T' that's OK;
17678 that binds `const int' to `T'. */
17679 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
17681 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17683 /* Consider the case where ARG is `const volatile int' and
17684 PARM is `const T'. Then, T should be `volatile int'. */
17685 arg
= cp_build_qualified_type_real
17686 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
17687 if (arg
== error_mark_node
)
17688 return unify_invalid (explain_p
);
17690 /* Simple cases: Value already set, does match or doesn't. */
17691 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
17692 return unify_success (explain_p
);
17694 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17696 /* Make sure that ARG is not a variable-sized array. (Note
17697 that were talking about variable-sized arrays (like
17698 `int[n]'), rather than arrays of unknown size (like
17699 `int[]').) We'll get very confused by such a type since
17700 the bound of the array is not constant, and therefore
17701 not mangleable. Besides, such types are not allowed in
17702 ISO C++, so we can do as we please here. We do allow
17703 them for 'auto' deduction, since that isn't ABI-exposed. */
17704 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
17705 return unify_vla_arg (explain_p
, arg
);
17707 /* Strip typedefs as in convert_template_argument. */
17708 arg
= canonicalize_type_argument (arg
, tf_none
);
17711 /* If ARG is a parameter pack or an expansion, we cannot unify
17712 against it unless PARM is also a parameter pack. */
17713 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17714 && !template_parameter_pack_p (parm
))
17715 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17717 /* If the argument deduction results is a METHOD_TYPE,
17718 then there is a problem.
17719 METHOD_TYPE doesn't map to any real C++ type the result of
17720 the deduction can not be of that type. */
17721 if (TREE_CODE (arg
) == METHOD_TYPE
)
17722 return unify_method_type_error (explain_p
, arg
);
17724 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17725 return unify_success (explain_p
);
17727 case TEMPLATE_PARM_INDEX
:
17728 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17729 if (error_operand_p (tparm
))
17730 return unify_invalid (explain_p
);
17732 if (TEMPLATE_PARM_LEVEL (parm
)
17733 != template_decl_level (tparm
))
17735 /* The PARM is not one we're trying to unify. Just check
17736 to see if it matches ARG. */
17737 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
17738 && cp_tree_equal (parm
, arg
));
17740 unify_expression_unequal (explain_p
, parm
, arg
);
17744 idx
= TEMPLATE_PARM_IDX (parm
);
17745 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17749 int x
= !cp_tree_equal (targ
, arg
);
17751 unify_inconsistency (explain_p
, parm
, targ
, arg
);
17755 /* [temp.deduct.type] If, in the declaration of a function template
17756 with a non-type template-parameter, the non-type
17757 template-parameter is used in an expression in the function
17758 parameter-list and, if the corresponding template-argument is
17759 deduced, the template-argument type shall match the type of the
17760 template-parameter exactly, except that a template-argument
17761 deduced from an array bound may be of any integral type.
17762 The non-type parameter might use already deduced type parameters. */
17763 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
17764 if (!TREE_TYPE (arg
))
17765 /* Template-parameter dependent expression. Just accept it for now.
17766 It will later be processed in convert_template_argument. */
17768 else if (same_type_p (TREE_TYPE (arg
), tparm
))
17770 else if ((strict
& UNIFY_ALLOW_INTEGER
)
17771 && CP_INTEGRAL_TYPE_P (tparm
))
17772 /* Convert the ARG to the type of PARM; the deduced non-type
17773 template argument must exactly match the types of the
17774 corresponding parameter. */
17775 arg
= fold (build_nop (tparm
, arg
));
17776 else if (uses_template_parms (tparm
))
17777 /* We haven't deduced the type of this parameter yet. Try again
17779 return unify_success (explain_p
);
17781 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
17783 /* If ARG is a parameter pack or an expansion, we cannot unify
17784 against it unless PARM is also a parameter pack. */
17785 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17786 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
17787 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17789 arg
= strip_typedefs_expr (arg
);
17790 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17791 return unify_success (explain_p
);
17795 /* A pointer-to-member constant can be unified only with
17796 another constant. */
17797 if (TREE_CODE (arg
) != PTRMEM_CST
)
17798 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
17800 /* Just unify the class member. It would be useless (and possibly
17801 wrong, depending on the strict flags) to unify also
17802 PTRMEM_CST_CLASS, because we want to be sure that both parm and
17803 arg refer to the same variable, even if through different
17804 classes. For instance:
17806 struct A { int x; };
17809 Unification of &A::x and &B::x must succeed. */
17810 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
17811 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
17816 if (!TYPE_PTR_P (arg
))
17817 return unify_type_mismatch (explain_p
, parm
, arg
);
17819 /* [temp.deduct.call]
17821 A can be another pointer or pointer to member type that can
17822 be converted to the deduced A via a qualification
17823 conversion (_conv.qual_).
17825 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
17826 This will allow for additional cv-qualification of the
17827 pointed-to types if appropriate. */
17829 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
17830 /* The derived-to-base conversion only persists through one
17831 level of pointers. */
17832 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
17834 return unify (tparms
, targs
, TREE_TYPE (parm
),
17835 TREE_TYPE (arg
), strict
, explain_p
);
17838 case REFERENCE_TYPE
:
17839 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
17840 return unify_type_mismatch (explain_p
, parm
, arg
);
17841 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
17842 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
17845 if (TREE_CODE (arg
) != ARRAY_TYPE
)
17846 return unify_type_mismatch (explain_p
, parm
, arg
);
17847 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
17848 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
17849 return unify_type_mismatch (explain_p
, parm
, arg
);
17850 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
17851 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
17852 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
17853 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17854 TYPE_DOMAIN (arg
), explain_p
);
17855 return unify_success (explain_p
);
17862 case ENUMERAL_TYPE
:
17865 if (TREE_CODE (arg
) != TREE_CODE (parm
))
17866 return unify_type_mismatch (explain_p
, parm
, arg
);
17868 /* We have already checked cv-qualification at the top of the
17870 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
17871 return unify_type_mismatch (explain_p
, parm
, arg
);
17873 /* As far as unification is concerned, this wins. Later checks
17874 will invalidate it if necessary. */
17875 return unify_success (explain_p
);
17877 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
17878 /* Type INTEGER_CST can come from ordinary constant template args. */
17880 while (TREE_CODE (arg
) == NOP_EXPR
)
17881 arg
= TREE_OPERAND (arg
, 0);
17883 if (TREE_CODE (arg
) != INTEGER_CST
)
17884 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
17885 return (tree_int_cst_equal (parm
, arg
)
17886 ? unify_success (explain_p
)
17887 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
17891 int i
, len
, argslen
;
17892 int parm_variadic_p
= 0;
17894 if (TREE_CODE (arg
) != TREE_VEC
)
17895 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
17897 len
= TREE_VEC_LENGTH (parm
);
17898 argslen
= TREE_VEC_LENGTH (arg
);
17900 /* Check for pack expansions in the parameters. */
17901 for (i
= 0; i
< len
; ++i
)
17903 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
17906 /* We can unify against something with a trailing
17908 parm_variadic_p
= 1;
17910 /* [temp.deduct.type]/9: If the template argument list of
17911 P contains a pack expansion that is not the last
17912 template argument, the entire template argument list
17913 is a non-deduced context. */
17914 return unify_success (explain_p
);
17918 /* If we don't have enough arguments to satisfy the parameters
17919 (not counting the pack expression at the end), or we have
17920 too many arguments for a parameter list that doesn't end in
17921 a pack expression, we can't unify. */
17922 if (parm_variadic_p
17923 ? argslen
< len
- parm_variadic_p
17925 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
17927 /* Unify all of the parameters that precede the (optional)
17928 pack expression. */
17929 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17931 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17932 TREE_VEC_ELT (parm
, i
),
17933 TREE_VEC_ELT (arg
, i
),
17934 UNIFY_ALLOW_NONE
, explain_p
);
17936 if (parm_variadic_p
)
17937 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
17939 /*subr=*/true, explain_p
);
17940 return unify_success (explain_p
);
17945 if (TREE_CODE (arg
) != TREE_CODE (parm
))
17946 return unify_type_mismatch (explain_p
, parm
, arg
);
17948 if (TYPE_PTRMEMFUNC_P (parm
))
17950 if (!TYPE_PTRMEMFUNC_P (arg
))
17951 return unify_type_mismatch (explain_p
, parm
, arg
);
17953 return unify (tparms
, targs
,
17954 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
17955 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
17956 strict
, explain_p
);
17959 if (CLASSTYPE_TEMPLATE_INFO (parm
))
17961 tree t
= NULL_TREE
;
17963 if (strict_in
& UNIFY_ALLOW_DERIVED
)
17965 /* First, we try to unify the PARM and ARG directly. */
17966 t
= try_class_unification (tparms
, targs
,
17967 parm
, arg
, explain_p
);
17971 /* Fallback to the special case allowed in
17972 [temp.deduct.call]:
17974 If P is a class, and P has the form
17975 template-id, then A can be a derived class of
17976 the deduced A. Likewise, if P is a pointer to
17977 a class of the form template-id, A can be a
17978 pointer to a derived class pointed to by the
17980 enum template_base_result r
;
17981 r
= get_template_base (tparms
, targs
, parm
, arg
,
17985 return unify_no_common_base (explain_p
, r
, parm
, arg
);
17988 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
17989 && (CLASSTYPE_TI_TEMPLATE (parm
)
17990 == CLASSTYPE_TI_TEMPLATE (arg
)))
17991 /* Perhaps PARM is something like S<U> and ARG is S<int>.
17992 Then, we should unify `int' and `U'. */
17995 /* There's no chance of unification succeeding. */
17996 return unify_type_mismatch (explain_p
, parm
, arg
);
17998 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
17999 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18001 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18002 return unify_type_mismatch (explain_p
, parm
, arg
);
18003 return unify_success (explain_p
);
18006 case FUNCTION_TYPE
:
18008 unsigned int nargs
;
18013 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18014 return unify_type_mismatch (explain_p
, parm
, arg
);
18016 /* CV qualifications for methods can never be deduced, they must
18017 match exactly. We need to check them explicitly here,
18018 because type_unification_real treats them as any other
18019 cv-qualified parameter. */
18020 if (TREE_CODE (parm
) == METHOD_TYPE
18021 && (!check_cv_quals_for_unify
18023 class_of_this_parm (arg
),
18024 class_of_this_parm (parm
))))
18025 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18027 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18028 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18030 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18031 args
= XALLOCAVEC (tree
, nargs
);
18032 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18033 a
!= NULL_TREE
&& a
!= void_list_node
;
18034 a
= TREE_CHAIN (a
), ++i
)
18035 args
[i
] = TREE_VALUE (a
);
18038 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18039 args
, nargs
, 1, DEDUCE_EXACT
,
18040 LOOKUP_NORMAL
, NULL
, explain_p
);
18044 /* Unify a pointer to member with a pointer to member function, which
18045 deduces the type of the member as a function type. */
18046 if (TYPE_PTRMEMFUNC_P (arg
))
18048 /* Check top-level cv qualifiers */
18049 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18050 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18052 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18053 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18054 UNIFY_ALLOW_NONE
, explain_p
);
18056 /* Determine the type of the function we are unifying against. */
18057 tree fntype
= static_fn_type (arg
);
18059 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18062 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18063 return unify_type_mismatch (explain_p
, parm
, arg
);
18064 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18065 TYPE_OFFSET_BASETYPE (arg
),
18066 UNIFY_ALLOW_NONE
, explain_p
);
18067 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18068 strict
, explain_p
);
18071 if (DECL_TEMPLATE_PARM_P (parm
))
18072 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18073 if (arg
!= integral_constant_value (parm
))
18074 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18075 return unify_success (explain_p
);
18078 case TEMPLATE_DECL
:
18079 /* Matched cases are handled by the ARG == PARM test above. */
18080 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18083 /* A non-type template parameter that is a variable should be a
18084 an integral constant, in which case, it whould have been
18085 folded into its (constant) value. So we should not be getting
18086 a variable here. */
18087 gcc_unreachable ();
18089 case TYPE_ARGUMENT_PACK
:
18090 case NONTYPE_ARGUMENT_PACK
:
18091 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18092 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18095 case DECLTYPE_TYPE
:
18096 case UNDERLYING_TYPE
:
18097 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18098 or UNDERLYING_TYPE nodes. */
18099 return unify_success (explain_p
);
18102 /* Unification fails if we hit an error node. */
18103 return unify_invalid (explain_p
);
18106 if (REFERENCE_REF_P (parm
))
18107 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18108 strict
, explain_p
);
18112 /* An unresolved overload is a nondeduced context. */
18113 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18114 return unify_success (explain_p
);
18115 gcc_assert (EXPR_P (parm
));
18117 /* We must be looking at an expression. This can happen with
18121 void foo(S<I>, S<I + 2>);
18123 This is a "nondeduced context":
18127 The nondeduced contexts are:
18129 --A type that is a template-id in which one or more of
18130 the template-arguments is an expression that references
18131 a template-parameter.
18133 In these cases, we assume deduction succeeded, but don't
18134 actually infer any unifications. */
18136 if (!uses_template_parms (parm
)
18137 && !template_args_equal (parm
, arg
))
18138 return unify_expression_unequal (explain_p
, parm
, arg
);
18140 return unify_success (explain_p
);
18143 #undef RECUR_AND_CHECK_FAILURE
18145 /* Note that DECL can be defined in this translation unit, if
18149 mark_definable (tree decl
)
18152 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18153 FOR_EACH_CLONE (clone
, decl
)
18154 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18157 /* Called if RESULT is explicitly instantiated, or is a member of an
18158 explicitly instantiated class. */
18161 mark_decl_instantiated (tree result
, int extern_p
)
18163 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18165 /* If this entity has already been written out, it's too late to
18166 make any modifications. */
18167 if (TREE_ASM_WRITTEN (result
))
18170 /* For anonymous namespace we don't need to do anything. */
18171 if (decl_anon_ns_mem_p (result
))
18173 gcc_assert (!TREE_PUBLIC (result
));
18177 if (TREE_CODE (result
) != FUNCTION_DECL
)
18178 /* The TREE_PUBLIC flag for function declarations will have been
18179 set correctly by tsubst. */
18180 TREE_PUBLIC (result
) = 1;
18182 /* This might have been set by an earlier implicit instantiation. */
18183 DECL_COMDAT (result
) = 0;
18186 DECL_NOT_REALLY_EXTERN (result
) = 0;
18189 mark_definable (result
);
18190 mark_needed (result
);
18191 /* Always make artificials weak. */
18192 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18193 comdat_linkage (result
);
18194 /* For WIN32 we also want to put explicit instantiations in
18195 linkonce sections. */
18196 else if (TREE_PUBLIC (result
))
18197 maybe_make_one_only (result
);
18200 /* If EXTERN_P, then this function will not be emitted -- unless
18201 followed by an explicit instantiation, at which point its linkage
18202 will be adjusted. If !EXTERN_P, then this function will be
18203 emitted here. In neither circumstance do we want
18204 import_export_decl to adjust the linkage. */
18205 DECL_INTERFACE_KNOWN (result
) = 1;
18208 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18209 important template arguments. If any are missing, we check whether
18210 they're important by using error_mark_node for substituting into any
18211 args that were used for partial ordering (the ones between ARGS and END)
18212 and seeing if it bubbles up. */
18215 check_undeduced_parms (tree targs
, tree args
, tree end
)
18217 bool found
= false;
18219 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18220 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18223 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18227 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18228 if (substed
== error_mark_node
)
18234 /* Given two function templates PAT1 and PAT2, return:
18236 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18237 -1 if PAT2 is more specialized than PAT1.
18238 0 if neither is more specialized.
18240 LEN indicates the number of parameters we should consider
18241 (defaulted parameters should not be considered).
18243 The 1998 std underspecified function template partial ordering, and
18244 DR214 addresses the issue. We take pairs of arguments, one from
18245 each of the templates, and deduce them against each other. One of
18246 the templates will be more specialized if all the *other*
18247 template's arguments deduce against its arguments and at least one
18248 of its arguments *does* *not* deduce against the other template's
18249 corresponding argument. Deduction is done as for class templates.
18250 The arguments used in deduction have reference and top level cv
18251 qualifiers removed. Iff both arguments were originally reference
18252 types *and* deduction succeeds in both directions, an lvalue reference
18253 wins against an rvalue reference and otherwise the template
18254 with the more cv-qualified argument wins for that pairing (if
18255 neither is more cv-qualified, they both are equal). Unlike regular
18256 deduction, after all the arguments have been deduced in this way,
18257 we do *not* verify the deduced template argument values can be
18258 substituted into non-deduced contexts.
18260 The logic can be a bit confusing here, because we look at deduce1 and
18261 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18262 can find template arguments for pat1 to make arg1 look like arg2, that
18263 means that arg2 is at least as specialized as arg1. */
18266 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18268 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18269 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18270 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18271 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18272 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18273 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18274 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18275 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18276 tree origs1
, origs2
;
18277 bool lose1
= false;
18278 bool lose2
= false;
18280 /* Remove the this parameter from non-static member functions. If
18281 one is a non-static member function and the other is not a static
18282 member function, remove the first parameter from that function
18283 also. This situation occurs for operator functions where we
18284 locate both a member function (with this pointer) and non-member
18285 operator (with explicit first operand). */
18286 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18288 len
--; /* LEN is the number of significant arguments for DECL1 */
18289 args1
= TREE_CHAIN (args1
);
18290 if (!DECL_STATIC_FUNCTION_P (decl2
))
18291 args2
= TREE_CHAIN (args2
);
18293 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18295 args2
= TREE_CHAIN (args2
);
18296 if (!DECL_STATIC_FUNCTION_P (decl1
))
18299 args1
= TREE_CHAIN (args1
);
18303 /* If only one is a conversion operator, they are unordered. */
18304 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18307 /* Consider the return type for a conversion function */
18308 if (DECL_CONV_FN_P (decl1
))
18310 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18311 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18315 processing_template_decl
++;
18321 /* Stop when an ellipsis is seen. */
18322 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18324 tree arg1
= TREE_VALUE (args1
);
18325 tree arg2
= TREE_VALUE (args2
);
18326 int deduce1
, deduce2
;
18332 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18333 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18335 /* When both arguments are pack expansions, we need only
18336 unify the patterns themselves. */
18337 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18338 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18340 /* This is the last comparison we need to do. */
18344 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18346 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18347 arg1
= TREE_TYPE (arg1
);
18348 quals1
= cp_type_quals (arg1
);
18351 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18353 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18354 arg2
= TREE_TYPE (arg2
);
18355 quals2
= cp_type_quals (arg2
);
18358 arg1
= TYPE_MAIN_VARIANT (arg1
);
18359 arg2
= TYPE_MAIN_VARIANT (arg2
);
18361 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18363 int i
, len2
= list_length (args2
);
18364 tree parmvec
= make_tree_vec (1);
18365 tree argvec
= make_tree_vec (len2
);
18368 /* Setup the parameter vector, which contains only ARG1. */
18369 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18371 /* Setup the argument vector, which contains the remaining
18373 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18374 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18376 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18377 argvec
, DEDUCE_EXACT
,
18378 /*subr=*/true, /*explain_p=*/false)
18381 /* We cannot deduce in the other direction, because ARG1 is
18382 a pack expansion but ARG2 is not. */
18385 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18387 int i
, len1
= list_length (args1
);
18388 tree parmvec
= make_tree_vec (1);
18389 tree argvec
= make_tree_vec (len1
);
18392 /* Setup the parameter vector, which contains only ARG1. */
18393 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18395 /* Setup the argument vector, which contains the remaining
18397 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18398 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18400 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18401 argvec
, DEDUCE_EXACT
,
18402 /*subr=*/true, /*explain_p=*/false)
18405 /* We cannot deduce in the other direction, because ARG2 is
18406 a pack expansion but ARG1 is not.*/
18412 /* The normal case, where neither argument is a pack
18414 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18415 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18417 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18418 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18422 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18423 arg2, then arg2 is not as specialized as arg1. */
18429 /* "If, for a given type, deduction succeeds in both directions
18430 (i.e., the types are identical after the transformations above)
18431 and both P and A were reference types (before being replaced with
18432 the type referred to above):
18433 - if the type from the argument template was an lvalue reference and
18434 the type from the parameter template was not, the argument type is
18435 considered to be more specialized than the other; otherwise,
18436 - if the type from the argument template is more cv-qualified
18437 than the type from the parameter template (as described above),
18438 the argument type is considered to be more specialized than the other;
18440 - neither type is more specialized than the other." */
18442 if (deduce1
&& deduce2
)
18444 if (ref1
&& ref2
&& ref1
!= ref2
)
18451 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
18453 if ((quals1
& quals2
) == quals2
)
18455 if ((quals1
& quals2
) == quals1
)
18460 if (lose1
&& lose2
)
18461 /* We've failed to deduce something in either direction.
18462 These must be unordered. */
18465 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18466 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18467 /* We have already processed all of the arguments in our
18468 handing of the pack expansion type. */
18471 args1
= TREE_CHAIN (args1
);
18472 args2
= TREE_CHAIN (args2
);
18475 /* "In most cases, all template parameters must have values in order for
18476 deduction to succeed, but for partial ordering purposes a template
18477 parameter may remain without a value provided it is not used in the
18478 types being used for partial ordering."
18480 Thus, if we are missing any of the targs1 we need to substitute into
18481 origs1, then pat2 is not as specialized as pat1. This can happen when
18482 there is a nondeduced context. */
18483 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
18485 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
18488 processing_template_decl
--;
18490 /* All things being equal, if the next argument is a pack expansion
18491 for one function but not for the other, prefer the
18492 non-variadic function. FIXME this is bogus; see c++/41958. */
18494 && args1
&& TREE_VALUE (args1
)
18495 && args2
&& TREE_VALUE (args2
))
18497 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
18498 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
18501 if (lose1
== lose2
)
18509 /* Determine which of two partial specializations of TMPL is more
18512 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18513 to the first partial specialization. The TREE_VALUE is the
18514 innermost set of template parameters for the partial
18515 specialization. PAT2 is similar, but for the second template.
18517 Return 1 if the first partial specialization is more specialized;
18518 -1 if the second is more specialized; 0 if neither is more
18521 See [temp.class.order] for information about determining which of
18522 two templates is more specialized. */
18525 more_specialized_class (tree tmpl
, tree pat1
, tree pat2
)
18530 bool any_deductions
= false;
18532 tmpl1
= TREE_TYPE (pat1
);
18533 tmpl2
= TREE_TYPE (pat2
);
18535 /* Just like what happens for functions, if we are ordering between
18536 different class template specializations, we may encounter dependent
18537 types in the arguments, and we need our dependency check functions
18538 to behave correctly. */
18539 ++processing_template_decl
;
18540 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat1
),
18541 CLASSTYPE_TI_ARGS (tmpl1
),
18542 CLASSTYPE_TI_ARGS (tmpl2
));
18546 any_deductions
= true;
18549 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat2
),
18550 CLASSTYPE_TI_ARGS (tmpl2
),
18551 CLASSTYPE_TI_ARGS (tmpl1
));
18555 any_deductions
= true;
18557 --processing_template_decl
;
18559 /* In the case of a tie where at least one of the class templates
18560 has a parameter pack at the end, the template with the most
18561 non-packed parameters wins. */
18564 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
18565 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
18567 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
18568 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
18569 int len1
= TREE_VEC_LENGTH (args1
);
18570 int len2
= TREE_VEC_LENGTH (args2
);
18572 /* We don't count the pack expansion at the end. */
18573 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
18575 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
18580 else if (len1
< len2
)
18587 /* Return the template arguments that will produce the function signature
18588 DECL from the function template FN, with the explicit template
18589 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18590 also match. Return NULL_TREE if no satisfactory arguments could be
18594 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
18596 int ntparms
= DECL_NTPARMS (fn
);
18597 tree targs
= make_tree_vec (ntparms
);
18598 tree decl_type
= TREE_TYPE (decl
);
18599 tree decl_arg_types
;
18601 unsigned int nargs
, ix
;
18604 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
18606 /* Never do unification on the 'this' parameter. */
18607 decl_arg_types
= skip_artificial_parms_for (decl
,
18608 TYPE_ARG_TYPES (decl_type
));
18610 nargs
= list_length (decl_arg_types
);
18611 args
= XALLOCAVEC (tree
, nargs
);
18612 for (arg
= decl_arg_types
, ix
= 0;
18613 arg
!= NULL_TREE
&& arg
!= void_list_node
;
18614 arg
= TREE_CHAIN (arg
), ++ix
)
18615 args
[ix
] = TREE_VALUE (arg
);
18617 if (fn_type_unification (fn
, explicit_args
, targs
,
18619 (check_rettype
|| DECL_CONV_FN_P (fn
)
18620 ? TREE_TYPE (decl_type
) : NULL_TREE
),
18621 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
18623 == error_mark_node
)
18629 /* Return the innermost template arguments that, when applied to a partial
18630 specialization of TMPL whose innermost template parameters are
18631 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
18634 For example, suppose we have:
18636 template <class T, class U> struct S {};
18637 template <class T> struct S<T*, int> {};
18639 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
18640 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
18641 int}. The resulting vector will be {double}, indicating that `T'
18642 is bound to `double'. */
18645 get_class_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
18647 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
18649 tree innermost_deduced_args
;
18651 innermost_deduced_args
= make_tree_vec (ntparms
);
18652 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18654 deduced_args
= copy_node (args
);
18655 SET_TMPL_ARGS_LEVEL (deduced_args
,
18656 TMPL_ARGS_DEPTH (deduced_args
),
18657 innermost_deduced_args
);
18660 deduced_args
= innermost_deduced_args
;
18662 if (unify (tparms
, deduced_args
,
18663 INNERMOST_TEMPLATE_ARGS (spec_args
),
18664 INNERMOST_TEMPLATE_ARGS (args
),
18665 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
18668 for (i
= 0; i
< ntparms
; ++i
)
18669 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
18672 /* Verify that nondeduced template arguments agree with the type
18673 obtained from argument deduction.
18677 struct A { typedef int X; };
18678 template <class T, class U> struct C {};
18679 template <class T> struct C<T, typename T::X> {};
18681 Then with the instantiation `C<A, int>', we can deduce that
18682 `T' is `A' but unify () does not check whether `typename T::X'
18684 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
18685 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
18687 tf_none
, false, false);
18688 if (spec_args
== error_mark_node
18689 /* We only need to check the innermost arguments; the other
18690 arguments will always agree. */
18691 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
18692 INNERMOST_TEMPLATE_ARGS (args
)))
18695 /* Now that we have bindings for all of the template arguments,
18696 ensure that the arguments deduced for the template template
18697 parameters have compatible template parameter lists. See the use
18698 of template_template_parm_bindings_ok_p in fn_type_unification
18699 for more information. */
18700 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
18703 return deduced_args
;
18706 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
18707 Return the TREE_LIST node with the most specialized template, if
18708 any. If there is no most specialized template, the error_mark_node
18711 Note that this function does not look at, or modify, the
18712 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
18713 returned is one of the elements of INSTANTIATIONS, callers may
18714 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
18715 and retrieve it from the value returned. */
18718 most_specialized_instantiation (tree templates
)
18722 ++processing_template_decl
;
18725 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
18729 if (get_bindings (TREE_VALUE (champ
),
18730 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18731 NULL_TREE
, /*check_ret=*/true))
18734 if (get_bindings (TREE_VALUE (fn
),
18735 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18736 NULL_TREE
, /*check_ret=*/true))
18743 /* Equally specialized, move to next function. If there
18744 is no next function, nothing's most specialized. */
18745 fn
= TREE_CHAIN (fn
);
18753 /* Now verify that champ is better than everything earlier in the
18754 instantiation list. */
18755 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
18756 if (get_bindings (TREE_VALUE (champ
),
18757 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18758 NULL_TREE
, /*check_ret=*/true)
18759 || !get_bindings (TREE_VALUE (fn
),
18760 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18761 NULL_TREE
, /*check_ret=*/true))
18767 processing_template_decl
--;
18770 return error_mark_node
;
18775 /* If DECL is a specialization of some template, return the most
18776 general such template. Otherwise, returns NULL_TREE.
18778 For example, given:
18780 template <class T> struct S { template <class U> void f(U); };
18782 if TMPL is `template <class U> void S<int>::f(U)' this will return
18783 the full template. This function will not trace past partial
18784 specializations, however. For example, given in addition:
18786 template <class T> struct S<T*> { template <class U> void f(U); };
18788 if TMPL is `template <class U> void S<int*>::f(U)' this will return
18789 `template <class T> template <class U> S<T*>::f(U)'. */
18792 most_general_template (tree decl
)
18794 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18796 if (tree tinfo
= get_template_info (decl
))
18797 decl
= TI_TEMPLATE (tinfo
);
18798 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
18799 template friend, or a FIELD_DECL for a capture pack. */
18800 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18804 /* Look for more and more general templates. */
18805 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
18807 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
18808 (See cp-tree.h for details.) */
18809 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
18812 if (CLASS_TYPE_P (TREE_TYPE (decl
))
18813 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
18816 /* Stop if we run into an explicitly specialized class template. */
18817 if (!DECL_NAMESPACE_SCOPE_P (decl
)
18818 && DECL_CONTEXT (decl
)
18819 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
18822 decl
= DECL_TI_TEMPLATE (decl
);
18828 /* Return the most specialized of the class template partial
18829 specializations which can produce TYPE, a specialization of some class
18830 template. The value returned is actually a TREE_LIST; the TREE_TYPE is
18831 a _TYPE node corresponding to the partial specialization, while the
18832 TREE_PURPOSE is the set of template arguments that must be
18833 substituted into the TREE_TYPE in order to generate TYPE.
18835 If the choice of partial specialization is ambiguous, a diagnostic
18836 is issued, and the error_mark_node is returned. If there are no
18837 partial specializations matching TYPE, then NULL_TREE is
18838 returned, indicating that the primary template should be used. */
18841 most_specialized_class (tree type
, tsubst_flags_t complain
)
18843 tree list
= NULL_TREE
;
18848 tree outer_args
= NULL_TREE
;
18850 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
18851 tree main_tmpl
= most_general_template (tmpl
);
18852 tree args
= CLASSTYPE_TI_ARGS (type
);
18854 /* For determining which partial specialization to use, only the
18855 innermost args are interesting. */
18856 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18858 outer_args
= strip_innermost_template_args (args
, 1);
18859 args
= INNERMOST_TEMPLATE_ARGS (args
);
18862 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
18864 tree partial_spec_args
;
18866 tree spec_tmpl
= TREE_VALUE (t
);
18867 tree orig_parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
18869 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
18871 ++processing_template_decl
;
18875 /* Discard the outer levels of args, and then substitute in the
18876 template args from the enclosing class. */
18877 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
18878 partial_spec_args
= tsubst_template_args
18879 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
18881 /* And the same for the partial specialization TEMPLATE_DECL. */
18882 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
18885 partial_spec_args
=
18886 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
18889 /*require_all_args=*/true,
18890 /*use_default_args=*/true);
18892 --processing_template_decl
;
18894 if (partial_spec_args
== error_mark_node
)
18895 return error_mark_node
;
18896 if (spec_tmpl
== error_mark_node
)
18897 return error_mark_node
;
18899 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
18900 spec_args
= get_class_bindings (tmpl
, parms
,
18906 spec_args
= add_to_template_args (outer_args
, spec_args
);
18907 list
= tree_cons (spec_args
, orig_parms
, list
);
18908 TREE_TYPE (list
) = TREE_TYPE (t
);
18915 ambiguous_p
= false;
18918 t
= TREE_CHAIN (t
);
18919 for (; t
; t
= TREE_CHAIN (t
))
18921 fate
= more_specialized_class (tmpl
, champ
, t
);
18928 t
= TREE_CHAIN (t
);
18931 ambiguous_p
= true;
18940 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
18942 fate
= more_specialized_class (tmpl
, champ
, t
);
18945 ambiguous_p
= true;
18953 char *spaces
= NULL
;
18954 if (!(complain
& tf_error
))
18955 return error_mark_node
;
18956 error ("ambiguous class template instantiation for %q#T", type
);
18957 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
18958 for (t
= list
; t
; t
= TREE_CHAIN (t
))
18960 error ("%s %+#T", spaces
? spaces
: str
, TREE_TYPE (t
));
18961 spaces
= spaces
? spaces
: get_spaces (str
);
18964 return error_mark_node
;
18970 /* Explicitly instantiate DECL. */
18973 do_decl_instantiation (tree decl
, tree storage
)
18975 tree result
= NULL_TREE
;
18978 if (!decl
|| decl
== error_mark_node
)
18979 /* An error occurred, for which grokdeclarator has already issued
18980 an appropriate message. */
18982 else if (! DECL_LANG_SPECIFIC (decl
))
18984 error ("explicit instantiation of non-template %q#D", decl
);
18987 else if (VAR_P (decl
))
18989 /* There is an asymmetry here in the way VAR_DECLs and
18990 FUNCTION_DECLs are handled by grokdeclarator. In the case of
18991 the latter, the DECL we get back will be marked as a
18992 template instantiation, and the appropriate
18993 DECL_TEMPLATE_INFO will be set up. This does not happen for
18994 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
18995 should handle VAR_DECLs as it currently handles
18997 if (!DECL_CLASS_SCOPE_P (decl
))
18999 error ("%qD is not a static data member of a class template", decl
);
19002 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19003 if (!result
|| !VAR_P (result
))
19005 error ("no matching template for %qD found", decl
);
19008 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19010 error ("type %qT for explicit instantiation %qD does not match "
19011 "declared type %qT", TREE_TYPE (result
), decl
,
19016 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
19018 error ("explicit instantiation of %q#D", decl
);
19024 /* Check for various error cases. Note that if the explicit
19025 instantiation is valid the RESULT will currently be marked as an
19026 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19027 until we get here. */
19029 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19031 /* DR 259 [temp.spec].
19033 Both an explicit instantiation and a declaration of an explicit
19034 specialization shall not appear in a program unless the explicit
19035 instantiation follows a declaration of the explicit specialization.
19037 For a given set of template parameters, if an explicit
19038 instantiation of a template appears after a declaration of an
19039 explicit specialization for that template, the explicit
19040 instantiation has no effect. */
19043 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19047 No program shall explicitly instantiate any template more
19050 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19051 the first instantiation was `extern' and the second is not,
19052 and EXTERN_P for the opposite case. */
19053 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19054 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19055 /* If an "extern" explicit instantiation follows an ordinary
19056 explicit instantiation, the template is instantiated. */
19060 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19062 error ("no matching template for %qD found", result
);
19065 else if (!DECL_TEMPLATE_INFO (result
))
19067 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19071 if (storage
== NULL_TREE
)
19073 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19075 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19076 pedwarn (input_location
, OPT_Wpedantic
,
19077 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19082 error ("storage class %qD applied to template instantiation", storage
);
19084 check_explicit_instantiation_namespace (result
);
19085 mark_decl_instantiated (result
, extern_p
);
19087 instantiate_decl (result
, /*defer_ok=*/1,
19088 /*expl_inst_class_mem_p=*/false);
19092 mark_class_instantiated (tree t
, int extern_p
)
19094 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19095 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19096 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19097 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19100 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19101 rest_of_type_compilation (t
, 1);
19105 /* Called from do_type_instantiation through binding_table_foreach to
19106 do recursive instantiation for the type bound in ENTRY. */
19108 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19110 tree storage
= *(tree
*) data
;
19112 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19113 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19114 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19117 /* Called from do_type_instantiation to instantiate a member
19118 (a member function or a static member variable) of an
19119 explicitly instantiated class template. */
19121 instantiate_class_member (tree decl
, int extern_p
)
19123 mark_decl_instantiated (decl
, extern_p
);
19125 instantiate_decl (decl
, /*defer_ok=*/1,
19126 /*expl_inst_class_mem_p=*/true);
19129 /* Perform an explicit instantiation of template class T. STORAGE, if
19130 non-null, is the RID for extern, inline or static. COMPLAIN is
19131 nonzero if this is called from the parser, zero if called recursively,
19132 since the standard is unclear (as detailed below). */
19135 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19140 int previous_instantiation_extern_p
= 0;
19142 if (TREE_CODE (t
) == TYPE_DECL
)
19145 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19148 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19150 error ("explicit instantiation of non-class template %qD", tmpl
);
19152 error ("explicit instantiation of non-template type %qT", t
);
19158 if (!COMPLETE_TYPE_P (t
))
19160 if (complain
& tf_error
)
19161 error ("explicit instantiation of %q#T before definition of template",
19166 if (storage
!= NULL_TREE
)
19168 if (!in_system_header_at (input_location
))
19170 if (storage
== ridpointers
[(int) RID_EXTERN
])
19172 if (cxx_dialect
== cxx98
)
19173 pedwarn (input_location
, OPT_Wpedantic
,
19174 "ISO C++ 1998 forbids the use of %<extern%> on "
19175 "explicit instantiations");
19178 pedwarn (input_location
, OPT_Wpedantic
,
19179 "ISO C++ forbids the use of %qE"
19180 " on explicit instantiations", storage
);
19183 if (storage
== ridpointers
[(int) RID_INLINE
])
19185 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19187 else if (storage
== ridpointers
[(int) RID_STATIC
])
19191 error ("storage class %qD applied to template instantiation",
19197 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19199 /* DR 259 [temp.spec].
19201 Both an explicit instantiation and a declaration of an explicit
19202 specialization shall not appear in a program unless the explicit
19203 instantiation follows a declaration of the explicit specialization.
19205 For a given set of template parameters, if an explicit
19206 instantiation of a template appears after a declaration of an
19207 explicit specialization for that template, the explicit
19208 instantiation has no effect. */
19211 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19215 No program shall explicitly instantiate any template more
19218 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19219 instantiation was `extern'. If EXTERN_P then the second is.
19220 These cases are OK. */
19221 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19223 if (!previous_instantiation_extern_p
&& !extern_p
19224 && (complain
& tf_error
))
19225 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19227 /* If we've already instantiated the template, just return now. */
19228 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19232 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19233 mark_class_instantiated (t
, extern_p
);
19241 /* In contrast to implicit instantiation, where only the
19242 declarations, and not the definitions, of members are
19243 instantiated, we have here:
19247 The explicit instantiation of a class template specialization
19248 implies the instantiation of all of its members not
19249 previously explicitly specialized in the translation unit
19250 containing the explicit instantiation.
19252 Of course, we can't instantiate member template classes, since
19253 we don't have any arguments for them. Note that the standard
19254 is unclear on whether the instantiation of the members are
19255 *explicit* instantiations or not. However, the most natural
19256 interpretation is that it should be an explicit instantiation. */
19259 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19260 if (TREE_CODE (tmp
) == FUNCTION_DECL
19261 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19262 instantiate_class_member (tmp
, extern_p
);
19264 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19265 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19266 instantiate_class_member (tmp
, extern_p
);
19268 if (CLASSTYPE_NESTED_UTDS (t
))
19269 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19270 bt_instantiate_type_proc
, &storage
);
19274 /* Given a function DECL, which is a specialization of TMPL, modify
19275 DECL to be a re-instantiation of TMPL with the same template
19276 arguments. TMPL should be the template into which tsubst'ing
19277 should occur for DECL, not the most general template.
19279 One reason for doing this is a scenario like this:
19282 void f(const T&, int i);
19284 void g() { f(3, 7); }
19287 void f(const T& t, const int i) { }
19289 Note that when the template is first instantiated, with
19290 instantiate_template, the resulting DECL will have no name for the
19291 first parameter, and the wrong type for the second. So, when we go
19292 to instantiate the DECL, we regenerate it. */
19295 regenerate_decl_from_template (tree decl
, tree tmpl
)
19297 /* The arguments used to instantiate DECL, from the most general
19302 args
= DECL_TI_ARGS (decl
);
19303 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19305 /* Make sure that we can see identifiers, and compute access
19307 push_access_scope (decl
);
19309 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19317 args_depth
= TMPL_ARGS_DEPTH (args
);
19318 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19319 if (args_depth
> parms_depth
)
19320 args
= get_innermost_template_args (args
, parms_depth
);
19322 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19323 args
, tf_error
, NULL_TREE
,
19324 /*defer_ok*/false);
19325 if (specs
&& specs
!= error_mark_node
)
19326 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19329 /* Merge parameter declarations. */
19330 decl_parm
= skip_artificial_parms_for (decl
,
19331 DECL_ARGUMENTS (decl
));
19333 = skip_artificial_parms_for (code_pattern
,
19334 DECL_ARGUMENTS (code_pattern
));
19335 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19340 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19341 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19342 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19344 parm_type
= type_decays_to (parm_type
);
19345 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19346 TREE_TYPE (decl_parm
) = parm_type
;
19347 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19348 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19350 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19351 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19353 decl_parm
= DECL_CHAIN (decl_parm
);
19354 pattern_parm
= DECL_CHAIN (pattern_parm
);
19356 /* Merge any parameters that match with the function parameter
19358 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19361 tree expanded_types
;
19362 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19363 the parameters in this function parameter pack. */
19364 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19365 args
, tf_error
, NULL_TREE
);
19366 len
= TREE_VEC_LENGTH (expanded_types
);
19367 for (i
= 0; i
< len
; i
++)
19372 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19373 /* Rename the parameter to include the index. */
19374 DECL_NAME (decl_parm
) =
19375 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19376 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19377 parm_type
= type_decays_to (parm_type
);
19378 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19379 TREE_TYPE (decl_parm
) = parm_type
;
19380 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19381 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19383 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19384 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19386 decl_parm
= DECL_CHAIN (decl_parm
);
19389 /* Merge additional specifiers from the CODE_PATTERN. */
19390 if (DECL_DECLARED_INLINE_P (code_pattern
)
19391 && !DECL_DECLARED_INLINE_P (decl
))
19392 DECL_DECLARED_INLINE_P (decl
) = 1;
19394 else if (VAR_P (decl
))
19396 DECL_INITIAL (decl
) =
19397 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19398 tf_error
, DECL_TI_TEMPLATE (decl
),
19399 /*integral_constant_expression_p=*/false);
19400 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19401 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19402 tf_error
, DECL_TI_TEMPLATE (decl
));
19405 gcc_unreachable ();
19407 pop_access_scope (decl
);
19410 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19411 substituted to get DECL. */
19414 template_for_substitution (tree decl
)
19416 tree tmpl
= DECL_TI_TEMPLATE (decl
);
19418 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19419 for the instantiation. This is not always the most general
19420 template. Consider, for example:
19423 struct S { template <class U> void f();
19424 template <> void f<int>(); };
19426 and an instantiation of S<double>::f<int>. We want TD to be the
19427 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19428 while (/* An instantiation cannot have a definition, so we need a
19429 more general template. */
19430 DECL_TEMPLATE_INSTANTIATION (tmpl
)
19431 /* We must also deal with friend templates. Given:
19433 template <class T> struct S {
19434 template <class U> friend void f() {};
19437 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19438 so far as the language is concerned, but that's still
19439 where we get the pattern for the instantiation from. On
19440 other hand, if the definition comes outside the class, say:
19442 template <class T> struct S {
19443 template <class U> friend void f();
19445 template <class U> friend void f() {}
19447 we don't need to look any further. That's what the check for
19448 DECL_INITIAL is for. */
19449 || (TREE_CODE (decl
) == FUNCTION_DECL
19450 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
19451 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
19453 /* The present template, TD, should not be a definition. If it
19454 were a definition, we should be using it! Note that we
19455 cannot restructure the loop to just keep going until we find
19456 a template with a definition, since that might go too far if
19457 a specialization was declared, but not defined. */
19458 gcc_assert (!VAR_P (decl
)
19459 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl
)));
19461 /* Fetch the more general template. */
19462 tmpl
= DECL_TI_TEMPLATE (tmpl
);
19468 /* Returns true if we need to instantiate this template instance even if we
19469 know we aren't going to emit it.. */
19472 always_instantiate_p (tree decl
)
19474 /* We always instantiate inline functions so that we can inline them. An
19475 explicit instantiation declaration prohibits implicit instantiation of
19476 non-inline functions. With high levels of optimization, we would
19477 normally inline non-inline functions -- but we're not allowed to do
19478 that for "extern template" functions. Therefore, we check
19479 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19480 return ((TREE_CODE (decl
) == FUNCTION_DECL
19481 && (DECL_DECLARED_INLINE_P (decl
)
19482 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
19483 /* And we need to instantiate static data members so that
19484 their initializers are available in integral constant
19487 && decl_maybe_constant_var_p (decl
)));
19490 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19491 instantiate it now, modifying TREE_TYPE (fn). */
19494 maybe_instantiate_noexcept (tree fn
)
19496 tree fntype
, spec
, noex
, clone
;
19498 /* Don't instantiate a noexcept-specification from template context. */
19499 if (processing_template_decl
)
19502 if (DECL_CLONED_FUNCTION_P (fn
))
19503 fn
= DECL_CLONED_FUNCTION (fn
);
19504 fntype
= TREE_TYPE (fn
);
19505 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
19507 if (!spec
|| !TREE_PURPOSE (spec
))
19510 noex
= TREE_PURPOSE (spec
);
19512 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
19514 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
19515 spec
= get_defaulted_eh_spec (fn
);
19516 else if (push_tinst_level (fn
))
19518 push_access_scope (fn
);
19519 push_deferring_access_checks (dk_no_deferred
);
19520 input_location
= DECL_SOURCE_LOCATION (fn
);
19521 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
19522 DEFERRED_NOEXCEPT_ARGS (noex
),
19523 tf_warning_or_error
, fn
,
19524 /*function_p=*/false,
19525 /*integral_constant_expression_p=*/true);
19526 pop_deferring_access_checks ();
19527 pop_access_scope (fn
);
19528 pop_tinst_level ();
19529 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
19530 if (spec
== error_mark_node
)
19531 spec
= noexcept_false_spec
;
19534 spec
= noexcept_false_spec
;
19536 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
19539 FOR_EACH_CLONE (clone
, fn
)
19541 if (TREE_TYPE (clone
) == fntype
)
19542 TREE_TYPE (clone
) = TREE_TYPE (fn
);
19544 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
19548 /* Produce the definition of D, a _DECL generated from a template. If
19549 DEFER_OK is nonzero, then we don't have to actually do the
19550 instantiation now; we just have to do it sometime. Normally it is
19551 an error if this is an explicit instantiation but D is undefined.
19552 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19553 explicitly instantiated class template. */
19556 instantiate_decl (tree d
, int defer_ok
,
19557 bool expl_inst_class_mem_p
)
19559 tree tmpl
= DECL_TI_TEMPLATE (d
);
19566 bool pattern_defined
;
19567 location_t saved_loc
= input_location
;
19568 int saved_unevaluated_operand
= cp_unevaluated_operand
;
19569 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
19575 /* This function should only be used to instantiate templates for
19576 functions and static member variables. */
19577 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
19579 /* Variables are never deferred; if instantiation is required, they
19580 are instantiated right away. That allows for better code in the
19581 case that an expression refers to the value of the variable --
19582 if the variable has a constant value the referring expression can
19583 take advantage of that fact. */
19585 || DECL_DECLARED_CONSTEXPR_P (d
))
19588 /* Don't instantiate cloned functions. Instead, instantiate the
19589 functions they cloned. */
19590 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
19591 d
= DECL_CLONED_FUNCTION (d
);
19593 if (DECL_TEMPLATE_INSTANTIATED (d
)
19594 || (TREE_CODE (d
) == FUNCTION_DECL
19595 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
19596 || DECL_TEMPLATE_SPECIALIZATION (d
))
19597 /* D has already been instantiated or explicitly specialized, so
19598 there's nothing for us to do here.
19600 It might seem reasonable to check whether or not D is an explicit
19601 instantiation, and, if so, stop here. But when an explicit
19602 instantiation is deferred until the end of the compilation,
19603 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
19604 the instantiation. */
19607 /* Check to see whether we know that this template will be
19608 instantiated in some other file, as with "extern template"
19610 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
19612 /* In general, we do not instantiate such templates. */
19613 if (external_p
&& !always_instantiate_p (d
))
19616 gen_tmpl
= most_general_template (tmpl
);
19617 gen_args
= DECL_TI_ARGS (d
);
19619 if (tmpl
!= gen_tmpl
)
19620 /* We should already have the extra args. */
19621 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
19622 == TMPL_ARGS_DEPTH (gen_args
));
19623 /* And what's in the hash table should match D. */
19624 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
19625 || spec
== NULL_TREE
);
19627 /* This needs to happen before any tsubsting. */
19628 if (! push_tinst_level (d
))
19631 timevar_push (TV_TEMPLATE_INST
);
19633 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
19634 for the instantiation. */
19635 td
= template_for_substitution (d
);
19636 code_pattern
= DECL_TEMPLATE_RESULT (td
);
19638 /* We should never be trying to instantiate a member of a class
19639 template or partial specialization. */
19640 gcc_assert (d
!= code_pattern
);
19642 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
19643 || DECL_TEMPLATE_SPECIALIZATION (td
))
19644 /* In the case of a friend template whose definition is provided
19645 outside the class, we may have too many arguments. Drop the
19646 ones we don't need. The same is true for specializations. */
19647 args
= get_innermost_template_args
19648 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
19652 if (TREE_CODE (d
) == FUNCTION_DECL
)
19654 deleted_p
= DECL_DELETED_FN (code_pattern
);
19655 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
19656 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
19662 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
19665 /* We may be in the middle of deferred access check. Disable it now. */
19666 push_deferring_access_checks (dk_no_deferred
);
19668 /* Unless an explicit instantiation directive has already determined
19669 the linkage of D, remember that a definition is available for
19671 if (pattern_defined
19672 && !DECL_INTERFACE_KNOWN (d
)
19673 && !DECL_NOT_REALLY_EXTERN (d
))
19674 mark_definable (d
);
19676 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
19677 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
19678 input_location
= DECL_SOURCE_LOCATION (d
);
19680 /* If D is a member of an explicitly instantiated class template,
19681 and no definition is available, treat it like an implicit
19683 if (!pattern_defined
&& expl_inst_class_mem_p
19684 && DECL_EXPLICIT_INSTANTIATION (d
))
19686 /* Leave linkage flags alone on instantiations with anonymous
19688 if (TREE_PUBLIC (d
))
19690 DECL_NOT_REALLY_EXTERN (d
) = 0;
19691 DECL_INTERFACE_KNOWN (d
) = 0;
19693 SET_DECL_IMPLICIT_INSTANTIATION (d
);
19696 /* Defer all other templates, unless we have been explicitly
19697 forbidden from doing so. */
19698 if (/* If there is no definition, we cannot instantiate the
19701 /* If it's OK to postpone instantiation, do so. */
19703 /* If this is a static data member that will be defined
19704 elsewhere, we don't want to instantiate the entire data
19705 member, but we do want to instantiate the initializer so that
19706 we can substitute that elsewhere. */
19707 || (external_p
&& VAR_P (d
))
19708 /* Handle here a deleted function too, avoid generating
19709 its body (c++/61080). */
19712 /* The definition of the static data member is now required so
19713 we must substitute the initializer. */
19715 && !DECL_INITIAL (d
)
19716 && DECL_INITIAL (code_pattern
))
19720 bool const_init
= false;
19722 ns
= decl_namespace_context (d
);
19723 push_nested_namespace (ns
);
19724 push_nested_class (DECL_CONTEXT (d
));
19725 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
19727 tf_warning_or_error
, NULL_TREE
,
19728 /*integral_constant_expression_p=*/false);
19729 /* Make sure the initializer is still constant, in case of
19730 circular dependency (template/instantiate6.C). */
19732 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19733 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
19734 /*asmspec_tree=*/NULL_TREE
,
19735 LOOKUP_ONLYCONVERTING
);
19736 pop_nested_class ();
19737 pop_nested_namespace (ns
);
19740 /* We restore the source position here because it's used by
19741 add_pending_template. */
19742 input_location
= saved_loc
;
19744 if (at_eof
&& !pattern_defined
19745 && DECL_EXPLICIT_INSTANTIATION (d
)
19746 && DECL_NOT_REALLY_EXTERN (d
))
19749 The definition of a non-exported function template, a
19750 non-exported member function template, or a non-exported
19751 member function or static data member of a class template
19752 shall be present in every translation unit in which it is
19753 explicitly instantiated. */
19754 permerror (input_location
, "explicit instantiation of %qD "
19755 "but no definition available", d
);
19757 /* If we're in unevaluated context, we just wanted to get the
19758 constant value; this isn't an odr use, so don't queue
19759 a full instantiation. */
19760 if (cp_unevaluated_operand
!= 0)
19762 /* ??? Historically, we have instantiated inline functions, even
19763 when marked as "extern template". */
19764 if (!(external_p
&& VAR_P (d
)))
19765 add_pending_template (d
);
19768 /* Tell the repository that D is available in this translation unit
19769 -- and see if it is supposed to be instantiated here. */
19770 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
19772 /* In a PCH file, despite the fact that the repository hasn't
19773 requested instantiation in the PCH it is still possible that
19774 an instantiation will be required in a file that includes the
19777 add_pending_template (d
);
19778 /* Instantiate inline functions so that the inliner can do its
19779 job, even though we'll not be emitting a copy of this
19781 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
19785 fn_context
= decl_function_context (d
);
19786 nested
= (current_function_decl
!= NULL_TREE
);
19788 push_to_top_level ();
19792 push_function_context ();
19793 cp_unevaluated_operand
= 0;
19794 c_inhibit_evaluation_warnings
= 0;
19797 /* Mark D as instantiated so that recursive calls to
19798 instantiate_decl do not try to instantiate it again. */
19799 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
19801 /* Regenerate the declaration in case the template has been modified
19802 by a subsequent redeclaration. */
19803 regenerate_decl_from_template (d
, td
);
19805 /* We already set the file and line above. Reset them now in case
19806 they changed as a result of calling regenerate_decl_from_template. */
19807 input_location
= DECL_SOURCE_LOCATION (d
);
19812 bool const_init
= false;
19814 /* Clear out DECL_RTL; whatever was there before may not be right
19815 since we've reset the type of the declaration. */
19816 SET_DECL_RTL (d
, NULL
);
19817 DECL_IN_AGGR_P (d
) = 0;
19819 /* The initializer is placed in DECL_INITIAL by
19820 regenerate_decl_from_template so we don't need to
19821 push/pop_access_scope again here. Pull it out so that
19822 cp_finish_decl can process it. */
19823 init
= DECL_INITIAL (d
);
19824 DECL_INITIAL (d
) = NULL_TREE
;
19825 DECL_INITIALIZED_P (d
) = 0;
19827 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
19828 initializer. That function will defer actual emission until
19829 we have a chance to determine linkage. */
19830 DECL_EXTERNAL (d
) = 0;
19832 /* Enter the scope of D so that access-checking works correctly. */
19833 push_nested_class (DECL_CONTEXT (d
));
19834 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19835 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
19836 pop_nested_class ();
19838 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
19839 synthesize_method (d
);
19840 else if (TREE_CODE (d
) == FUNCTION_DECL
)
19842 struct pointer_map_t
*saved_local_specializations
;
19846 tree block
= NULL_TREE
;
19848 /* Save away the current list, in case we are instantiating one
19849 template from within the body of another. */
19850 saved_local_specializations
= local_specializations
;
19852 /* Set up the list of local specializations. */
19853 local_specializations
= pointer_map_create ();
19855 /* Set up context. */
19856 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
19857 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
19858 block
= push_stmt_list ();
19860 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
19862 /* Some typedefs referenced from within the template code need to be
19863 access checked at template instantiation time, i.e now. These
19864 types were added to the template at parsing time. Let's get those
19865 and perform the access checks then. */
19866 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
19869 /* Create substitution entries for the parameters. */
19870 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
19871 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
19872 spec_parm
= DECL_ARGUMENTS (d
);
19873 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
19875 register_local_specialization (spec_parm
, tmpl_parm
);
19876 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
19877 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
19879 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
19881 if (!DECL_PACK_P (tmpl_parm
))
19883 register_local_specialization (spec_parm
, tmpl_parm
);
19884 spec_parm
= DECL_CHAIN (spec_parm
);
19888 /* Register the (value) argument pack as a specialization of
19889 TMPL_PARM, then move on. */
19890 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
19891 register_local_specialization (argpack
, tmpl_parm
);
19894 gcc_assert (!spec_parm
);
19896 /* Substitute into the body of the function. */
19897 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
19898 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
19899 tf_warning_or_error
, tmpl
);
19902 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
19903 tf_warning_or_error
, tmpl
,
19904 /*integral_constant_expression_p=*/false);
19906 /* Set the current input_location to the end of the function
19907 so that finish_function knows where we are. */
19909 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
19911 /* Remember if we saw an infinite loop in the template. */
19912 current_function_infinite_loop
19913 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
19916 /* We don't need the local specializations any more. */
19917 pointer_map_destroy (local_specializations
);
19918 local_specializations
= saved_local_specializations
;
19920 /* Finish the function. */
19921 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
19922 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
19923 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
19926 d
= finish_function (0);
19927 expand_or_defer_fn (d
);
19930 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
19931 cp_check_omp_declare_reduction (d
);
19934 /* We're not deferring instantiation any more. */
19935 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
19938 pop_from_top_level ();
19940 pop_function_context ();
19943 input_location
= saved_loc
;
19944 cp_unevaluated_operand
= saved_unevaluated_operand
;
19945 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
19946 pop_deferring_access_checks ();
19947 pop_tinst_level ();
19949 timevar_pop (TV_TEMPLATE_INST
);
19954 /* Run through the list of templates that we wish we could
19955 instantiate, and instantiate any we can. RETRIES is the
19956 number of times we retry pending template instantiation. */
19959 instantiate_pending_templates (int retries
)
19962 location_t saved_loc
= input_location
;
19964 /* Instantiating templates may trigger vtable generation. This in turn
19965 may require further template instantiations. We place a limit here
19966 to avoid infinite loop. */
19967 if (pending_templates
&& retries
>= max_tinst_depth
)
19969 tree decl
= pending_templates
->tinst
->decl
;
19971 error ("template instantiation depth exceeds maximum of %d"
19972 " instantiating %q+D, possibly from virtual table generation"
19973 " (use -ftemplate-depth= to increase the maximum)",
19974 max_tinst_depth
, decl
);
19975 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19976 /* Pretend that we defined it. */
19977 DECL_INITIAL (decl
) = error_mark_node
;
19983 struct pending_template
**t
= &pending_templates
;
19984 struct pending_template
*last
= NULL
;
19988 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
19989 bool complete
= false;
19991 if (TYPE_P (instantiation
))
19995 if (!COMPLETE_TYPE_P (instantiation
))
19997 instantiate_class_template (instantiation
);
19998 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
19999 for (fn
= TYPE_METHODS (instantiation
);
20001 fn
= TREE_CHAIN (fn
))
20002 if (! DECL_ARTIFICIAL (fn
))
20003 instantiate_decl (fn
,
20005 /*expl_inst_class_mem_p=*/false);
20006 if (COMPLETE_TYPE_P (instantiation
))
20010 complete
= COMPLETE_TYPE_P (instantiation
);
20014 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20015 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20018 = instantiate_decl (instantiation
,
20020 /*expl_inst_class_mem_p=*/false);
20021 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20025 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20026 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20030 /* If INSTANTIATION has been instantiated, then we don't
20031 need to consider it again in the future. */
20039 current_tinst_level
= NULL
;
20041 last_pending_template
= last
;
20043 while (reconsider
);
20045 input_location
= saved_loc
;
20048 /* Substitute ARGVEC into T, which is a list of initializers for
20049 either base class or a non-static data member. The TREE_PURPOSEs
20050 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20051 instantiate_decl. */
20054 tsubst_initializer_list (tree t
, tree argvec
)
20056 tree inits
= NULL_TREE
;
20058 for (; t
; t
= TREE_CHAIN (t
))
20062 tree expanded_bases
= NULL_TREE
;
20063 tree expanded_arguments
= NULL_TREE
;
20066 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20071 /* Expand the base class expansion type into separate base
20073 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20074 tf_warning_or_error
,
20076 if (expanded_bases
== error_mark_node
)
20079 /* We'll be building separate TREE_LISTs of arguments for
20081 len
= TREE_VEC_LENGTH (expanded_bases
);
20082 expanded_arguments
= make_tree_vec (len
);
20083 for (i
= 0; i
< len
; i
++)
20084 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20086 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20087 expand each argument in the TREE_VALUE of t. */
20088 expr
= make_node (EXPR_PACK_EXPANSION
);
20089 PACK_EXPANSION_LOCAL_P (expr
) = true;
20090 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20091 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20093 if (TREE_VALUE (t
) == void_type_node
)
20094 /* VOID_TYPE_NODE is used to indicate
20095 value-initialization. */
20097 for (i
= 0; i
< len
; i
++)
20098 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20102 /* Substitute parameter packs into each argument in the
20104 in_base_initializer
= 1;
20105 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20107 tree expanded_exprs
;
20109 /* Expand the argument. */
20110 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20112 = tsubst_pack_expansion (expr
, argvec
,
20113 tf_warning_or_error
,
20115 if (expanded_exprs
== error_mark_node
)
20118 /* Prepend each of the expanded expressions to the
20119 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20120 for (i
= 0; i
< len
; i
++)
20122 TREE_VEC_ELT (expanded_arguments
, i
) =
20123 tree_cons (NULL_TREE
,
20124 TREE_VEC_ELT (expanded_exprs
, i
),
20125 TREE_VEC_ELT (expanded_arguments
, i
));
20128 in_base_initializer
= 0;
20130 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20131 since we built them backwards. */
20132 for (i
= 0; i
< len
; i
++)
20134 TREE_VEC_ELT (expanded_arguments
, i
) =
20135 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20140 for (i
= 0; i
< len
; ++i
)
20142 if (expanded_bases
)
20144 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20145 decl
= expand_member_init (decl
);
20146 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20151 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20152 tf_warning_or_error
, NULL_TREE
);
20154 decl
= expand_member_init (decl
);
20155 if (decl
&& !DECL_P (decl
))
20156 in_base_initializer
= 1;
20158 init
= TREE_VALUE (t
);
20160 if (init
!= void_type_node
)
20161 init
= tsubst_expr (init
, argvec
,
20162 tf_warning_or_error
, NULL_TREE
,
20163 /*integral_constant_expression_p=*/false);
20164 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20165 /* If we had an initializer but it instantiated to nothing,
20166 value-initialize the object. This will only occur when
20167 the initializer was a pack expansion where the parameter
20168 packs used in that expansion were of length zero. */
20169 init
= void_type_node
;
20170 in_base_initializer
= 0;
20175 init
= build_tree_list (decl
, init
);
20176 TREE_CHAIN (init
) = inits
;
20184 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20187 set_current_access_from_decl (tree decl
)
20189 if (TREE_PRIVATE (decl
))
20190 current_access_specifier
= access_private_node
;
20191 else if (TREE_PROTECTED (decl
))
20192 current_access_specifier
= access_protected_node
;
20194 current_access_specifier
= access_public_node
;
20197 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20198 is the instantiation (which should have been created with
20199 start_enum) and ARGS are the template arguments to use. */
20202 tsubst_enum (tree tag
, tree newtag
, tree args
)
20206 if (SCOPED_ENUM_P (newtag
))
20207 begin_scope (sk_scoped_enum
, newtag
);
20209 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20214 decl
= TREE_VALUE (e
);
20215 /* Note that in a template enum, the TREE_VALUE is the
20216 CONST_DECL, not the corresponding INTEGER_CST. */
20217 value
= tsubst_expr (DECL_INITIAL (decl
),
20218 args
, tf_warning_or_error
, NULL_TREE
,
20219 /*integral_constant_expression_p=*/true);
20221 /* Give this enumeration constant the correct access. */
20222 set_current_access_from_decl (decl
);
20224 /* Actually build the enumerator itself. */
20226 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
20229 if (SCOPED_ENUM_P (newtag
))
20232 finish_enum_value_list (newtag
);
20233 finish_enum (newtag
);
20235 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20236 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20239 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20240 its type -- but without substituting the innermost set of template
20241 arguments. So, innermost set of template parameters will appear in
20245 get_mostly_instantiated_function_type (tree decl
)
20253 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
20254 targs
= DECL_TI_ARGS (decl
);
20255 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
20256 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
20258 /* There should be as many levels of arguments as there are levels
20260 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
20262 fn_type
= TREE_TYPE (tmpl
);
20264 if (parm_depth
== 1)
20265 /* No substitution is necessary. */
20272 /* Replace the innermost level of the TARGS with NULL_TREEs to
20273 let tsubst know not to substitute for those parameters. */
20274 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20275 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
20276 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
20277 TMPL_ARGS_LEVEL (targs
, i
));
20278 SET_TMPL_ARGS_LEVEL (partial_args
,
20279 TMPL_ARGS_DEPTH (targs
),
20280 make_tree_vec (DECL_NTPARMS (tmpl
)));
20282 /* Make sure that we can see identifiers, and compute access
20284 push_access_scope (decl
);
20286 ++processing_template_decl
;
20287 /* Now, do the (partial) substitution to figure out the
20288 appropriate function type. */
20289 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
20290 --processing_template_decl
;
20292 /* Substitute into the template parameters to obtain the real
20293 innermost set of parameters. This step is important if the
20294 innermost set of template parameters contains value
20295 parameters whose types depend on outer template parameters. */
20296 TREE_VEC_LENGTH (partial_args
)--;
20297 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
20299 pop_access_scope (decl
);
20305 /* Return truthvalue if we're processing a template different from
20306 the last one involved in diagnostics. */
20308 problematic_instantiation_changed (void)
20310 return current_tinst_level
!= last_error_tinst_level
;
20313 /* Remember current template involved in diagnostics. */
20315 record_last_problematic_instantiation (void)
20317 last_error_tinst_level
= current_tinst_level
;
20320 struct tinst_level
*
20321 current_instantiation (void)
20323 return current_tinst_level
;
20326 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20327 type. Return zero for ok, nonzero for disallowed. Issue error and
20328 warning messages under control of COMPLAIN. */
20331 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20333 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20335 else if (POINTER_TYPE_P (type
))
20337 else if (TYPE_PTRMEM_P (type
))
20339 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20341 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20343 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20345 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20348 if (complain
& tf_error
)
20350 if (type
== error_mark_node
)
20351 inform (input_location
, "invalid template non-type parameter");
20353 error ("%q#T is not a valid type for a template non-type parameter",
20359 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20360 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20363 dependent_type_p_r (tree type
)
20369 A type is dependent if it is:
20371 -- a template parameter. Template template parameters are types
20372 for us (since TYPE_P holds true for them) so we handle
20374 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20375 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20377 /* -- a qualified-id with a nested-name-specifier which contains a
20378 class-name that names a dependent type or whose unqualified-id
20379 names a dependent type. */
20380 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20382 /* -- a cv-qualified type where the cv-unqualified type is
20384 type
= TYPE_MAIN_VARIANT (type
);
20385 /* -- a compound type constructed from any dependent type. */
20386 if (TYPE_PTRMEM_P (type
))
20387 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20388 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20390 else if (TYPE_PTR_P (type
)
20391 || TREE_CODE (type
) == REFERENCE_TYPE
)
20392 return dependent_type_p (TREE_TYPE (type
));
20393 else if (TREE_CODE (type
) == FUNCTION_TYPE
20394 || TREE_CODE (type
) == METHOD_TYPE
)
20398 if (dependent_type_p (TREE_TYPE (type
)))
20400 for (arg_type
= TYPE_ARG_TYPES (type
);
20402 arg_type
= TREE_CHAIN (arg_type
))
20403 if (dependent_type_p (TREE_VALUE (arg_type
)))
20407 /* -- an array type constructed from any dependent type or whose
20408 size is specified by a constant expression that is
20411 We checked for type- and value-dependence of the bounds in
20412 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20413 if (TREE_CODE (type
) == ARRAY_TYPE
)
20415 if (TYPE_DOMAIN (type
)
20416 && dependent_type_p (TYPE_DOMAIN (type
)))
20418 return dependent_type_p (TREE_TYPE (type
));
20421 /* -- a template-id in which either the template name is a template
20423 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20425 /* ... or any of the template arguments is a dependent type or
20426 an expression that is type-dependent or value-dependent. */
20427 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
20428 && (any_dependent_template_arguments_p
20429 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
20432 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20433 dependent; if the argument of the `typeof' expression is not
20434 type-dependent, then it should already been have resolved. */
20435 if (TREE_CODE (type
) == TYPEOF_TYPE
20436 || TREE_CODE (type
) == DECLTYPE_TYPE
20437 || TREE_CODE (type
) == UNDERLYING_TYPE
)
20440 /* A template argument pack is dependent if any of its packed
20442 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
20444 tree args
= ARGUMENT_PACK_ARGS (type
);
20445 int i
, len
= TREE_VEC_LENGTH (args
);
20446 for (i
= 0; i
< len
; ++i
)
20447 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20451 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20452 be template parameters. */
20453 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
20456 /* The standard does not specifically mention types that are local
20457 to template functions or local classes, but they should be
20458 considered dependent too. For example:
20460 template <int I> void f() {
20465 The size of `E' cannot be known until the value of `I' has been
20466 determined. Therefore, `E' must be considered dependent. */
20467 scope
= TYPE_CONTEXT (type
);
20468 if (scope
&& TYPE_P (scope
))
20469 return dependent_type_p (scope
);
20470 /* Don't use type_dependent_expression_p here, as it can lead
20471 to infinite recursion trying to determine whether a lambda
20472 nested in a lambda is dependent (c++/47687). */
20473 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
20474 && DECL_LANG_SPECIFIC (scope
)
20475 && DECL_TEMPLATE_INFO (scope
)
20476 && (any_dependent_template_arguments_p
20477 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
20480 /* Other types are non-dependent. */
20484 /* Returns TRUE if TYPE is dependent, in the sense of
20485 [temp.dep.type]. Note that a NULL type is considered dependent. */
20488 dependent_type_p (tree type
)
20490 /* If there are no template parameters in scope, then there can't be
20491 any dependent types. */
20492 if (!processing_template_decl
)
20494 /* If we are not processing a template, then nobody should be
20495 providing us with a dependent type. */
20497 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
20501 /* If the type is NULL, we have not computed a type for the entity
20502 in question; in that case, the type is dependent. */
20506 /* Erroneous types can be considered non-dependent. */
20507 if (type
== error_mark_node
)
20510 /* If we have not already computed the appropriate value for TYPE,
20512 if (!TYPE_DEPENDENT_P_VALID (type
))
20514 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
20515 TYPE_DEPENDENT_P_VALID (type
) = 1;
20518 return TYPE_DEPENDENT_P (type
);
20521 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20522 lookup. In other words, a dependent type that is not the current
20526 dependent_scope_p (tree scope
)
20528 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
20529 && !currently_open_class (scope
));
20532 /* T is a SCOPE_REF; return whether we need to consider it
20533 instantiation-dependent so that we can check access at instantiation
20534 time even though we know which member it resolves to. */
20537 instantiation_dependent_scope_ref_p (tree t
)
20539 if (DECL_P (TREE_OPERAND (t
, 1))
20540 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
20541 && accessible_in_template_p (TREE_OPERAND (t
, 0),
20542 TREE_OPERAND (t
, 1)))
20548 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20549 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20552 /* Note that this predicate is not appropriate for general expressions;
20553 only constant expressions (that satisfy potential_constant_expression)
20554 can be tested for value dependence. */
20557 value_dependent_expression_p (tree expression
)
20559 if (!processing_template_decl
)
20562 /* A name declared with a dependent type. */
20563 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
20566 switch (TREE_CODE (expression
))
20568 case IDENTIFIER_NODE
:
20569 /* A name that has not been looked up -- must be dependent. */
20572 case TEMPLATE_PARM_INDEX
:
20573 /* A non-type template parm. */
20577 /* A non-type template parm. */
20578 if (DECL_TEMPLATE_PARM_P (expression
))
20580 return value_dependent_expression_p (DECL_INITIAL (expression
));
20583 /* A constant with literal type and is initialized
20584 with an expression that is value-dependent.
20586 Note that a non-dependent parenthesized initializer will have
20587 already been replaced with its constant value, so if we see
20588 a TREE_LIST it must be dependent. */
20589 if (DECL_INITIAL (expression
)
20590 && decl_constant_var_p (expression
)
20591 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
20592 || value_dependent_expression_p (DECL_INITIAL (expression
))))
20596 case DYNAMIC_CAST_EXPR
:
20597 case STATIC_CAST_EXPR
:
20598 case CONST_CAST_EXPR
:
20599 case REINTERPRET_CAST_EXPR
:
20601 /* These expressions are value-dependent if the type to which
20602 the cast occurs is dependent or the expression being casted
20603 is value-dependent. */
20605 tree type
= TREE_TYPE (expression
);
20607 if (dependent_type_p (type
))
20610 /* A functional cast has a list of operands. */
20611 expression
= TREE_OPERAND (expression
, 0);
20614 /* If there are no operands, it must be an expression such
20615 as "int()". This should not happen for aggregate types
20616 because it would form non-constant expressions. */
20617 gcc_assert (cxx_dialect
>= cxx11
20618 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
20623 if (TREE_CODE (expression
) == TREE_LIST
)
20624 return any_value_dependent_elements_p (expression
);
20626 return value_dependent_expression_p (expression
);
20630 if (SIZEOF_EXPR_TYPE_P (expression
))
20631 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
20635 /* A `sizeof' expression is value-dependent if the operand is
20636 type-dependent or is a pack expansion. */
20637 expression
= TREE_OPERAND (expression
, 0);
20638 if (PACK_EXPANSION_P (expression
))
20640 else if (TYPE_P (expression
))
20641 return dependent_type_p (expression
);
20642 return instantiation_dependent_expression_p (expression
);
20644 case AT_ENCODE_EXPR
:
20645 /* An 'encode' expression is value-dependent if the operand is
20647 expression
= TREE_OPERAND (expression
, 0);
20648 return dependent_type_p (expression
);
20650 case NOEXCEPT_EXPR
:
20651 expression
= TREE_OPERAND (expression
, 0);
20652 return instantiation_dependent_expression_p (expression
);
20655 /* All instantiation-dependent expressions should also be considered
20656 value-dependent. */
20657 return instantiation_dependent_scope_ref_p (expression
);
20659 case COMPONENT_REF
:
20660 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
20661 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
20663 case NONTYPE_ARGUMENT_PACK
:
20664 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
20665 is value-dependent. */
20667 tree values
= ARGUMENT_PACK_ARGS (expression
);
20668 int i
, len
= TREE_VEC_LENGTH (values
);
20670 for (i
= 0; i
< len
; ++i
)
20671 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
20679 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
20680 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
20681 || (type2
? dependent_type_p (type2
) : false));
20685 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20686 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
20689 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20690 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
20694 tree op
= TREE_OPERAND (expression
, 0);
20695 return (value_dependent_expression_p (op
)
20696 || has_value_dependent_address (op
));
20701 tree fn
= get_callee_fndecl (expression
);
20703 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
20705 nargs
= call_expr_nargs (expression
);
20706 for (i
= 0; i
< nargs
; ++i
)
20708 tree op
= CALL_EXPR_ARG (expression
, i
);
20709 /* In a call to a constexpr member function, look through the
20710 implicit ADDR_EXPR on the object argument so that it doesn't
20711 cause the call to be considered value-dependent. We also
20712 look through it in potential_constant_expression. */
20713 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
20714 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
20715 && TREE_CODE (op
) == ADDR_EXPR
)
20716 op
= TREE_OPERAND (op
, 0);
20717 if (value_dependent_expression_p (op
))
20723 case TEMPLATE_ID_EXPR
:
20724 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
20726 return type_dependent_expression_p (expression
);
20732 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
20733 if (value_dependent_expression_p (val
))
20739 /* Treat a GNU statement expression as dependent to avoid crashing
20740 under fold_non_dependent_expr; it can't be constant. */
20744 /* A constant expression is value-dependent if any subexpression is
20745 value-dependent. */
20746 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
20748 case tcc_reference
:
20750 case tcc_comparison
:
20752 case tcc_expression
:
20755 int i
, len
= cp_tree_operand_length (expression
);
20757 for (i
= 0; i
< len
; i
++)
20759 tree t
= TREE_OPERAND (expression
, i
);
20761 /* In some cases, some of the operands may be missing.l
20762 (For example, in the case of PREDECREMENT_EXPR, the
20763 amount to increment by may be missing.) That doesn't
20764 make the expression dependent. */
20765 if (t
&& value_dependent_expression_p (t
))
20776 /* The expression is not value-dependent. */
20780 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
20781 [temp.dep.expr]. Note that an expression with no type is
20782 considered dependent. Other parts of the compiler arrange for an
20783 expression with type-dependent subexpressions to have no type, so
20784 this function doesn't have to be fully recursive. */
20787 type_dependent_expression_p (tree expression
)
20789 if (!processing_template_decl
)
20792 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
20795 /* An unresolved name is always dependent. */
20796 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
20799 /* Some expression forms are never type-dependent. */
20800 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
20801 || TREE_CODE (expression
) == SIZEOF_EXPR
20802 || TREE_CODE (expression
) == ALIGNOF_EXPR
20803 || TREE_CODE (expression
) == AT_ENCODE_EXPR
20804 || TREE_CODE (expression
) == NOEXCEPT_EXPR
20805 || TREE_CODE (expression
) == TRAIT_EXPR
20806 || TREE_CODE (expression
) == TYPEID_EXPR
20807 || TREE_CODE (expression
) == DELETE_EXPR
20808 || TREE_CODE (expression
) == VEC_DELETE_EXPR
20809 || TREE_CODE (expression
) == THROW_EXPR
)
20812 /* The types of these expressions depends only on the type to which
20813 the cast occurs. */
20814 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
20815 || TREE_CODE (expression
) == STATIC_CAST_EXPR
20816 || TREE_CODE (expression
) == CONST_CAST_EXPR
20817 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
20818 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
20819 || TREE_CODE (expression
) == CAST_EXPR
)
20820 return dependent_type_p (TREE_TYPE (expression
));
20822 /* The types of these expressions depends only on the type created
20823 by the expression. */
20824 if (TREE_CODE (expression
) == NEW_EXPR
20825 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
20827 /* For NEW_EXPR tree nodes created inside a template, either
20828 the object type itself or a TREE_LIST may appear as the
20830 tree type
= TREE_OPERAND (expression
, 1);
20831 if (TREE_CODE (type
) == TREE_LIST
)
20832 /* This is an array type. We need to check array dimensions
20834 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
20835 || value_dependent_expression_p
20836 (TREE_OPERAND (TREE_VALUE (type
), 1));
20838 return dependent_type_p (type
);
20841 if (TREE_CODE (expression
) == SCOPE_REF
)
20843 tree scope
= TREE_OPERAND (expression
, 0);
20844 tree name
= TREE_OPERAND (expression
, 1);
20846 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
20847 contains an identifier associated by name lookup with one or more
20848 declarations declared with a dependent type, or...a
20849 nested-name-specifier or qualified-id that names a member of an
20850 unknown specialization. */
20851 return (type_dependent_expression_p (name
)
20852 || dependent_scope_p (scope
));
20855 if (TREE_CODE (expression
) == FUNCTION_DECL
20856 && DECL_LANG_SPECIFIC (expression
)
20857 && DECL_TEMPLATE_INFO (expression
)
20858 && (any_dependent_template_arguments_p
20859 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
20862 if (TREE_CODE (expression
) == TEMPLATE_DECL
20863 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
20866 if (TREE_CODE (expression
) == STMT_EXPR
)
20867 expression
= stmt_expr_value_expr (expression
);
20869 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
20874 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
20876 if (type_dependent_expression_p (elt
))
20882 /* A static data member of the current instantiation with incomplete
20883 array type is type-dependent, as the definition and specializations
20884 can have different bounds. */
20885 if (VAR_P (expression
)
20886 && DECL_CLASS_SCOPE_P (expression
)
20887 && dependent_type_p (DECL_CONTEXT (expression
))
20888 && VAR_HAD_UNKNOWN_BOUND (expression
))
20891 /* An array of unknown bound depending on a variadic parameter, eg:
20893 template<typename... Args>
20894 void foo (Args... args)
20896 int arr[] = { args... };
20899 template<int... vals>
20902 int arr[] = { vals... };
20905 If the array has no length and has an initializer, it must be that
20906 we couldn't determine its length in cp_complete_array_type because
20907 it is dependent. */
20908 if (VAR_P (expression
)
20909 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
20910 && !TYPE_DOMAIN (TREE_TYPE (expression
))
20911 && DECL_INITIAL (expression
))
20914 if (TREE_TYPE (expression
) == unknown_type_node
)
20916 if (TREE_CODE (expression
) == ADDR_EXPR
)
20917 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
20918 if (TREE_CODE (expression
) == COMPONENT_REF
20919 || TREE_CODE (expression
) == OFFSET_REF
)
20921 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20923 expression
= TREE_OPERAND (expression
, 1);
20924 if (identifier_p (expression
))
20927 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
20928 if (TREE_CODE (expression
) == SCOPE_REF
)
20931 /* Always dependent, on the number of arguments if nothing else. */
20932 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
20935 if (BASELINK_P (expression
))
20936 expression
= BASELINK_FUNCTIONS (expression
);
20938 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
20940 if (any_dependent_template_arguments_p
20941 (TREE_OPERAND (expression
, 1)))
20943 expression
= TREE_OPERAND (expression
, 0);
20945 gcc_assert (TREE_CODE (expression
) == OVERLOAD
20946 || TREE_CODE (expression
) == FUNCTION_DECL
);
20950 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
20952 expression
= OVL_NEXT (expression
);
20957 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
20959 return (dependent_type_p (TREE_TYPE (expression
)));
20962 /* walk_tree callback function for instantiation_dependent_expression_p,
20963 below. Returns non-zero if a dependent subexpression is found. */
20966 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
20971 /* We don't have to worry about decltype currently because decltype
20972 of an instantiation-dependent expr is a dependent type. This
20973 might change depending on the resolution of DR 1172. */
20974 *walk_subtrees
= false;
20977 enum tree_code code
= TREE_CODE (*tp
);
20980 /* Don't treat an argument list as dependent just because it has no
20988 /* A constant with a dependent initializer is dependent. */
20989 if (value_dependent_expression_p (*tp
))
20993 case TEMPLATE_PARM_INDEX
:
20996 /* Handle expressions with type operands. */
21000 case AT_ENCODE_EXPR
:
21002 tree op
= TREE_OPERAND (*tp
, 0);
21003 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21004 op
= TREE_TYPE (op
);
21007 if (dependent_type_p (op
))
21011 *walk_subtrees
= false;
21019 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21020 || (TRAIT_EXPR_TYPE2 (*tp
)
21021 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21023 *walk_subtrees
= false;
21026 case COMPONENT_REF
:
21027 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21028 /* In a template, finish_class_member_access_expr creates a
21029 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21030 type-dependent, so that we can check access control at
21031 instantiation time (PR 42277). See also Core issue 1273. */
21036 if (instantiation_dependent_scope_ref_p (*tp
))
21041 /* Treat statement-expressions as dependent. */
21049 if (type_dependent_expression_p (*tp
))
21055 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21056 sense defined by the ABI:
21058 "An expression is instantiation-dependent if it is type-dependent
21059 or value-dependent, or it has a subexpression that is type-dependent
21060 or value-dependent." */
21063 instantiation_dependent_expression_p (tree expression
)
21067 if (!processing_template_decl
)
21070 if (expression
== error_mark_node
)
21073 result
= cp_walk_tree_without_duplicates (&expression
,
21074 instantiation_dependent_r
, NULL
);
21075 return result
!= NULL_TREE
;
21078 /* Like type_dependent_expression_p, but it also works while not processing
21079 a template definition, i.e. during substitution or mangling. */
21082 type_dependent_expression_p_push (tree expr
)
21085 ++processing_template_decl
;
21086 b
= type_dependent_expression_p (expr
);
21087 --processing_template_decl
;
21091 /* Returns TRUE if ARGS contains a type-dependent expression. */
21094 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21099 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21101 if (type_dependent_expression_p (arg
))
21107 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21108 expressions) contains any type-dependent expressions. */
21111 any_type_dependent_elements_p (const_tree list
)
21113 for (; list
; list
= TREE_CHAIN (list
))
21114 if (type_dependent_expression_p (TREE_VALUE (list
)))
21120 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21121 expressions) contains any value-dependent expressions. */
21124 any_value_dependent_elements_p (const_tree list
)
21126 for (; list
; list
= TREE_CHAIN (list
))
21127 if (value_dependent_expression_p (TREE_VALUE (list
)))
21133 /* Returns TRUE if the ARG (a template argument) is dependent. */
21136 dependent_template_arg_p (tree arg
)
21138 if (!processing_template_decl
)
21141 /* Assume a template argument that was wrongly written by the user
21142 is dependent. This is consistent with what
21143 any_dependent_template_arguments_p [that calls this function]
21145 if (!arg
|| arg
== error_mark_node
)
21148 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21149 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21151 if (TREE_CODE (arg
) == TEMPLATE_DECL
21152 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21153 return dependent_template_p (arg
);
21154 else if (ARGUMENT_PACK_P (arg
))
21156 tree args
= ARGUMENT_PACK_ARGS (arg
);
21157 int i
, len
= TREE_VEC_LENGTH (args
);
21158 for (i
= 0; i
< len
; ++i
)
21160 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21166 else if (TYPE_P (arg
))
21167 return dependent_type_p (arg
);
21169 return (type_dependent_expression_p (arg
)
21170 || value_dependent_expression_p (arg
));
21173 /* Returns true if ARGS (a collection of template arguments) contains
21174 any types that require structural equality testing. */
21177 any_template_arguments_need_structural_equality_p (tree args
)
21184 if (args
== error_mark_node
)
21187 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21189 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21190 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21192 tree arg
= TREE_VEC_ELT (level
, j
);
21193 tree packed_args
= NULL_TREE
;
21196 if (ARGUMENT_PACK_P (arg
))
21198 /* Look inside the argument pack. */
21199 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21200 len
= TREE_VEC_LENGTH (packed_args
);
21203 for (k
= 0; k
< len
; ++k
)
21206 arg
= TREE_VEC_ELT (packed_args
, k
);
21208 if (error_operand_p (arg
))
21210 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21212 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21214 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21215 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21224 /* Returns true if ARGS (a collection of template arguments) contains
21225 any dependent arguments. */
21228 any_dependent_template_arguments_p (const_tree args
)
21235 if (args
== error_mark_node
)
21238 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21240 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21241 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21242 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21249 /* Returns TRUE if the template TMPL is dependent. */
21252 dependent_template_p (tree tmpl
)
21254 if (TREE_CODE (tmpl
) == OVERLOAD
)
21258 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21260 tmpl
= OVL_NEXT (tmpl
);
21265 /* Template template parameters are dependent. */
21266 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21267 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21269 /* So are names that have not been looked up. */
21270 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21272 /* So are member templates of dependent classes. */
21273 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21274 return dependent_type_p (DECL_CONTEXT (tmpl
));
21278 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21281 dependent_template_id_p (tree tmpl
, tree args
)
21283 return (dependent_template_p (tmpl
)
21284 || any_dependent_template_arguments_p (args
));
21287 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21291 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21295 if (!processing_template_decl
)
21298 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21300 tree decl
= TREE_VEC_ELT (declv
, i
);
21301 tree init
= TREE_VEC_ELT (initv
, i
);
21302 tree cond
= TREE_VEC_ELT (condv
, i
);
21303 tree incr
= TREE_VEC_ELT (incrv
, i
);
21305 if (type_dependent_expression_p (decl
))
21308 if (init
&& type_dependent_expression_p (init
))
21311 if (type_dependent_expression_p (cond
))
21314 if (COMPARISON_CLASS_P (cond
)
21315 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21316 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21319 if (TREE_CODE (incr
) == MODOP_EXPR
)
21321 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21322 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21325 else if (type_dependent_expression_p (incr
))
21327 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21329 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21331 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21333 tree t
= TREE_OPERAND (incr
, 1);
21334 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21335 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21344 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21345 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21346 no such TYPE can be found. Note that this function peers inside
21347 uninstantiated templates and therefore should be used only in
21348 extremely limited situations. ONLY_CURRENT_P restricts this
21349 peering to the currently open classes hierarchy (which is required
21350 when comparing types). */
21353 resolve_typename_type (tree type
, bool only_current_p
)
21362 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21364 scope
= TYPE_CONTEXT (type
);
21365 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21366 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21367 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21368 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21369 identifier of the TYPENAME_TYPE anymore.
21370 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21371 TYPENAME_TYPE instead, we avoid messing up with a possible
21372 typedef variant case. */
21373 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21375 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21376 it first before we can figure out what NAME refers to. */
21377 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21379 if (TYPENAME_IS_RESOLVING_P (scope
))
21380 /* Given a class template A with a dependent base with nested type C,
21381 typedef typename A::C::C C will land us here, as trying to resolve
21382 the initial A::C leads to the local C typedef, which leads back to
21383 A::C::C. So we break the recursion now. */
21386 scope
= resolve_typename_type (scope
, only_current_p
);
21388 /* If we don't know what SCOPE refers to, then we cannot resolve the
21390 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21392 /* If the SCOPE is a template type parameter, we have no way of
21393 resolving the name. */
21394 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21396 /* If the SCOPE is not the current instantiation, there's no reason
21397 to look inside it. */
21398 if (only_current_p
&& !currently_open_class (scope
))
21400 /* If this is a typedef, we don't want to look inside (c++/11987). */
21401 if (typedef_variant_p (type
))
21403 /* If SCOPE isn't the template itself, it will not have a valid
21404 TYPE_FIELDS list. */
21405 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21406 /* scope is either the template itself or a compatible instantiation
21407 like X<T>, so look up the name in the original template. */
21408 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
21410 /* scope is a partial instantiation, so we can't do the lookup or we
21411 will lose the template arguments. */
21413 /* Enter the SCOPE so that name lookup will be resolved as if we
21414 were in the class definition. In particular, SCOPE will no
21415 longer be considered a dependent type. */
21416 pushed_scope
= push_scope (scope
);
21417 /* Look up the declaration. */
21418 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
21419 tf_warning_or_error
);
21421 result
= NULL_TREE
;
21423 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21424 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21427 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
21428 && TREE_CODE (decl
) == TYPE_DECL
)
21430 result
= TREE_TYPE (decl
);
21431 if (result
== error_mark_node
)
21432 result
= NULL_TREE
;
21434 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
21435 && DECL_CLASS_TEMPLATE_P (decl
))
21439 /* Obtain the template and the arguments. */
21440 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
21441 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
21442 /* Instantiate the template. */
21443 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
21444 /*entering_scope=*/0,
21445 tf_error
| tf_user
);
21446 if (result
== error_mark_node
)
21447 result
= NULL_TREE
;
21450 /* Leave the SCOPE. */
21452 pop_scope (pushed_scope
);
21454 /* If we failed to resolve it, return the original typename. */
21458 /* If lookup found a typename type, resolve that too. */
21459 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
21461 /* Ill-formed programs can cause infinite recursion here, so we
21462 must catch that. */
21463 TYPENAME_IS_RESOLVING_P (type
) = 1;
21464 result
= resolve_typename_type (result
, only_current_p
);
21465 TYPENAME_IS_RESOLVING_P (type
) = 0;
21468 /* Qualify the resulting type. */
21469 quals
= cp_type_quals (type
);
21471 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
21476 /* EXPR is an expression which is not type-dependent. Return a proxy
21477 for EXPR that can be used to compute the types of larger
21478 expressions containing EXPR. */
21481 build_non_dependent_expr (tree expr
)
21485 #ifdef ENABLE_CHECKING
21486 /* Try to get a constant value for all non-dependent expressions in
21487 order to expose bugs in *_dependent_expression_p and constexpr. */
21488 if (cxx_dialect
>= cxx11
)
21489 maybe_constant_value (fold_non_dependent_expr_sfinae (expr
, tf_none
));
21492 /* Preserve OVERLOADs; the functions must be available to resolve
21495 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
21496 inner_expr
= stmt_expr_value_expr (inner_expr
);
21497 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
21498 inner_expr
= TREE_OPERAND (inner_expr
, 0);
21499 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
21500 inner_expr
= TREE_OPERAND (inner_expr
, 1);
21501 if (is_overloaded_fn (inner_expr
)
21502 || TREE_CODE (inner_expr
) == OFFSET_REF
)
21504 /* There is no need to return a proxy for a variable. */
21507 /* Preserve string constants; conversions from string constants to
21508 "char *" are allowed, even though normally a "const char *"
21509 cannot be used to initialize a "char *". */
21510 if (TREE_CODE (expr
) == STRING_CST
)
21512 /* Preserve arithmetic constants, as an optimization -- there is no
21513 reason to create a new node. */
21514 if (TREE_CODE (expr
) == INTEGER_CST
|| TREE_CODE (expr
) == REAL_CST
)
21516 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21517 There is at least one place where we want to know that a
21518 particular expression is a throw-expression: when checking a ?:
21519 expression, there are special rules if the second or third
21520 argument is a throw-expression. */
21521 if (TREE_CODE (expr
) == THROW_EXPR
)
21524 /* Don't wrap an initializer list, we need to be able to look inside. */
21525 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
21528 /* Don't wrap a dummy object, we need to be able to test for it. */
21529 if (is_dummy_object (expr
))
21532 if (TREE_CODE (expr
) == COND_EXPR
)
21533 return build3 (COND_EXPR
,
21535 TREE_OPERAND (expr
, 0),
21536 (TREE_OPERAND (expr
, 1)
21537 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
21538 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
21539 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
21540 if (TREE_CODE (expr
) == COMPOUND_EXPR
21541 && !COMPOUND_EXPR_OVERLOADED (expr
))
21542 return build2 (COMPOUND_EXPR
,
21544 TREE_OPERAND (expr
, 0),
21545 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
21547 /* If the type is unknown, it can't really be non-dependent */
21548 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
21550 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21551 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
21554 /* ARGS is a vector of expressions as arguments to a function call.
21555 Replace the arguments with equivalent non-dependent expressions.
21556 This modifies ARGS in place. */
21559 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
21564 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
21566 tree newarg
= build_non_dependent_expr (arg
);
21568 (*args
)[ix
] = newarg
;
21572 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21573 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21577 make_auto_1 (tree name
)
21579 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
21580 TYPE_NAME (au
) = build_decl (input_location
,
21581 TYPE_DECL
, name
, au
);
21582 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
21583 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
21584 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
21585 TYPE_NAME (au
), NULL_TREE
);
21586 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
21587 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
21588 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
21594 make_decltype_auto (void)
21596 return make_auto_1 (get_identifier ("decltype(auto)"));
21602 return make_auto_1 (get_identifier ("auto"));
21605 /* Given type ARG, return std::initializer_list<ARG>. */
21610 tree std_init_list
= namespace_binding
21611 (get_identifier ("initializer_list"), std_node
);
21613 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
21615 error ("deducing from brace-enclosed initializer list requires "
21616 "#include <initializer_list>");
21617 return error_mark_node
;
21619 argvec
= make_tree_vec (1);
21620 TREE_VEC_ELT (argvec
, 0) = arg
;
21621 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
21622 NULL_TREE
, 0, tf_warning_or_error
);
21625 /* Replace auto in TYPE with std::initializer_list<auto>. */
21628 listify_autos (tree type
, tree auto_node
)
21630 tree init_auto
= listify (auto_node
);
21631 tree argvec
= make_tree_vec (1);
21632 TREE_VEC_ELT (argvec
, 0) = init_auto
;
21633 if (processing_template_decl
)
21634 argvec
= add_to_template_args (current_template_args (), argvec
);
21635 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21638 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
21639 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
21642 do_auto_deduction (tree type
, tree init
, tree auto_node
)
21646 if (init
== error_mark_node
)
21647 return error_mark_node
;
21649 if (type_dependent_expression_p (init
))
21650 /* Defining a subset of type-dependent expressions that we can deduce
21651 from ahead of time isn't worth the trouble. */
21654 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
21655 with either a new invented type template parameter U or, if the
21656 initializer is a braced-init-list (8.5.4), with
21657 std::initializer_list<U>. */
21658 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
21659 type
= listify_autos (type
, auto_node
);
21661 init
= resolve_nondeduced_context (init
);
21663 targs
= make_tree_vec (1);
21664 if (AUTO_IS_DECLTYPE (auto_node
))
21666 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
21667 && !REF_PARENTHESIZED_P (init
)));
21668 TREE_VEC_ELT (targs
, 0)
21669 = finish_decltype_type (init
, id
, tf_warning_or_error
);
21670 if (type
!= auto_node
)
21672 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
21673 return error_mark_node
;
21678 tree parms
= build_tree_list (NULL_TREE
, type
);
21679 tree tparms
= make_tree_vec (1);
21682 TREE_VEC_ELT (tparms
, 0)
21683 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
21684 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
21685 DEDUCE_CALL
, LOOKUP_NORMAL
,
21686 NULL
, /*explain_p=*/false);
21689 if (processing_template_decl
)
21690 /* Try again at instantiation time. */
21692 if (type
&& type
!= error_mark_node
)
21693 /* If type is error_mark_node a diagnostic must have been
21694 emitted by now. Also, having a mention to '<type error>'
21695 in the diagnostic is not really useful to the user. */
21697 if (cfun
&& auto_node
== current_function_auto_return_pattern
21698 && LAMBDA_FUNCTION_P (current_function_decl
))
21699 error ("unable to deduce lambda return type from %qE", init
);
21701 error ("unable to deduce %qT from %qE", type
, init
);
21703 return error_mark_node
;
21707 /* If the list of declarators contains more than one declarator, the type
21708 of each declared variable is determined as described above. If the
21709 type deduced for the template parameter U is not the same in each
21710 deduction, the program is ill-formed. */
21711 if (TREE_TYPE (auto_node
)
21712 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
21714 if (cfun
&& auto_node
== current_function_auto_return_pattern
21715 && LAMBDA_FUNCTION_P (current_function_decl
))
21716 error ("inconsistent types %qT and %qT deduced for "
21717 "lambda return type", TREE_TYPE (auto_node
),
21718 TREE_VEC_ELT (targs
, 0));
21720 error ("inconsistent deduction for %qT: %qT and then %qT",
21721 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
21722 return error_mark_node
;
21724 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
21726 if (processing_template_decl
)
21727 targs
= add_to_template_args (current_template_args (), targs
);
21728 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
21731 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
21735 splice_late_return_type (tree type
, tree late_return_type
)
21739 if (late_return_type
== NULL_TREE
)
21741 argvec
= make_tree_vec (1);
21742 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
21743 if (processing_template_parmlist
)
21744 /* For a late-specified return type in a template type-parameter, we
21745 need to add a dummy argument level for its parmlist. */
21746 argvec
= add_to_template_args
21747 (make_tree_vec (processing_template_parmlist
), argvec
);
21748 if (current_template_parms
)
21749 argvec
= add_to_template_args (current_template_args (), argvec
);
21750 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21753 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
21754 'decltype(auto)'. */
21757 is_auto (const_tree type
)
21759 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
21760 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
21761 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
21767 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
21768 a use of `auto'. Returns NULL_TREE otherwise. */
21771 type_uses_auto (tree type
)
21773 return find_type_usage (type
, is_auto
);
21776 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
21777 'decltype(auto)' or a concept. */
21780 is_auto_or_concept (const_tree type
)
21782 return is_auto (type
); // or concept
21785 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
21786 a concept identifier) iff TYPE contains a use of a generic type. Returns
21787 NULL_TREE otherwise. */
21790 type_uses_auto_or_concept (tree type
)
21792 return find_type_usage (type
, is_auto_or_concept
);
21796 /* For a given template T, return the vector of typedefs referenced
21797 in T for which access check is needed at T instantiation time.
21798 T is either a FUNCTION_DECL or a RECORD_TYPE.
21799 Those typedefs were added to T by the function
21800 append_type_to_template_for_access_check. */
21802 vec
<qualified_typedef_usage_t
, va_gc
> *
21803 get_types_needing_access_check (tree t
)
21806 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
21808 if (!t
|| t
== error_mark_node
)
21811 if (!(ti
= get_template_info (t
)))
21814 if (CLASS_TYPE_P (t
)
21815 || TREE_CODE (t
) == FUNCTION_DECL
)
21817 if (!TI_TEMPLATE (ti
))
21820 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
21826 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
21827 tied to T. That list of typedefs will be access checked at
21828 T instantiation time.
21829 T is either a FUNCTION_DECL or a RECORD_TYPE.
21830 TYPE_DECL is a TYPE_DECL node representing a typedef.
21831 SCOPE is the scope through which TYPE_DECL is accessed.
21832 LOCATION is the location of the usage point of TYPE_DECL.
21834 This function is a subroutine of
21835 append_type_to_template_for_access_check. */
21838 append_type_to_template_for_access_check_1 (tree t
,
21841 location_t location
)
21843 qualified_typedef_usage_t typedef_usage
;
21846 if (!t
|| t
== error_mark_node
)
21849 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
21850 || CLASS_TYPE_P (t
))
21852 && TREE_CODE (type_decl
) == TYPE_DECL
21855 if (!(ti
= get_template_info (t
)))
21858 gcc_assert (TI_TEMPLATE (ti
));
21860 typedef_usage
.typedef_decl
= type_decl
;
21861 typedef_usage
.context
= scope
;
21862 typedef_usage
.locus
= location
;
21864 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
21867 /* Append TYPE_DECL to the template TEMPL.
21868 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
21869 At TEMPL instanciation time, TYPE_DECL will be checked to see
21870 if it can be accessed through SCOPE.
21871 LOCATION is the location of the usage point of TYPE_DECL.
21873 e.g. consider the following code snippet:
21880 template<class U> struct S
21882 C::myint mi; // <-- usage point of the typedef C::myint
21887 At S<char> instantiation time, we need to check the access of C::myint
21888 In other words, we need to check the access of the myint typedef through
21889 the C scope. For that purpose, this function will add the myint typedef
21890 and the scope C through which its being accessed to a list of typedefs
21891 tied to the template S. That list will be walked at template instantiation
21892 time and access check performed on each typedefs it contains.
21893 Note that this particular code snippet should yield an error because
21894 myint is private to C. */
21897 append_type_to_template_for_access_check (tree templ
,
21900 location_t location
)
21902 qualified_typedef_usage_t
*iter
;
21905 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
21907 /* Make sure we don't append the type to the template twice. */
21908 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
21909 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
21912 append_type_to_template_for_access_check_1 (templ
, type_decl
,
21916 /* Convert the generic type parameters in PARM that match the types given in the
21917 range [START_IDX, END_IDX) from the current_template_parms into generic type
21921 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
21923 tree current
= current_template_parms
;
21924 int depth
= TMPL_PARMS_DEPTH (current
);
21925 current
= INNERMOST_TEMPLATE_PARMS (current
);
21926 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
21928 for (int i
= 0; i
< start_idx
; ++i
)
21929 TREE_VEC_ELT (replacement
, i
)
21930 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
21932 for (int i
= start_idx
; i
< end_idx
; ++i
)
21934 /* Create a distinct parameter pack type from the current parm and add it
21935 to the replacement args to tsubst below into the generic function
21938 tree o
= TREE_TYPE (TREE_VALUE
21939 (TREE_VEC_ELT (current
, i
)));
21940 tree t
= copy_type (o
);
21941 TEMPLATE_TYPE_PARM_INDEX (t
)
21942 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
21944 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
21945 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
21946 TYPE_MAIN_VARIANT (t
) = t
;
21947 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
21948 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
21949 TREE_VEC_ELT (replacement
, i
) = t
;
21950 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
21953 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
21954 TREE_VEC_ELT (replacement
, i
)
21955 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
21957 /* If there are more levels then build up the replacement with the outer
21960 replacement
= add_to_template_args (template_parms_to_args
21961 (TREE_CHAIN (current_template_parms
)),
21964 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
21968 /* Set up the hash tables for template instantiations. */
21971 init_template_processing (void)
21973 decl_specializations
= htab_create_ggc (37,
21974 hash_specialization
,
21975 eq_specializations
,
21977 type_specializations
= htab_create_ggc (37,
21978 hash_specialization
,
21979 eq_specializations
,
21983 /* Print stats about the template hash tables for -fstats. */
21986 print_template_statistics (void)
21988 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
21989 "%f collisions\n", (long) htab_size (decl_specializations
),
21990 (long) htab_elements (decl_specializations
),
21991 htab_collisions (decl_specializations
));
21992 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
21993 "%f collisions\n", (long) htab_size (type_specializations
),
21994 (long) htab_elements (type_specializations
),
21995 htab_collisions (type_specializations
));
21998 #include "gt-cp-pt.h"