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
);
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
)
5279 linkage_kind linkage
;
5281 fn
= instantiate_type (type
, fns
, tf_none
);
5282 if (fn
== error_mark_node
)
5283 return error_mark_node
;
5286 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5287 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5288 if (BASELINK_P (fn_no_ptr
))
5289 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5291 /* [temp.arg.nontype]/1
5293 A template-argument for a non-type, non-template template-parameter
5296 -- the address of an object or function with external [C++11: or
5297 internal] linkage. */
5299 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5301 error ("%qE is not a valid template argument for type %qT", expr
, type
);
5302 if (TYPE_PTR_P (type
))
5303 error ("it must be the address of a function with external linkage");
5305 error ("it must be the name of a function with external linkage");
5309 linkage
= decl_linkage (fn_no_ptr
);
5310 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5312 if (cxx_dialect
>= cxx11
)
5313 error ("%qE is not a valid template argument for type %qT "
5314 "because %qD has no linkage",
5315 expr
, type
, fn_no_ptr
);
5317 error ("%qE is not a valid template argument for type %qT "
5318 "because %qD does not have external linkage",
5319 expr
, type
, fn_no_ptr
);
5326 /* Subroutine of convert_nontype_argument.
5327 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5328 Emit an error otherwise. */
5331 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5332 tsubst_flags_t complain
)
5335 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5337 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5339 if (complain
& tf_error
)
5341 error ("%qE is not a valid template argument for type %qT",
5343 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5348 /* Returns TRUE iff the address of OP is value-dependent.
5350 14.6.2.4 [temp.dep.temp]:
5351 A non-integral non-type template-argument is dependent if its type is
5352 dependent or it has either of the following forms
5355 and contains a nested-name-specifier which specifies a class-name that
5356 names a dependent type.
5358 We generalize this to just say that the address of a member of a
5359 dependent class is value-dependent; the above doesn't cover the
5360 address of a static data member named with an unqualified-id. */
5363 has_value_dependent_address (tree op
)
5365 /* We could use get_inner_reference here, but there's no need;
5366 this is only relevant for template non-type arguments, which
5367 can only be expressed as &id-expression. */
5370 tree ctx
= CP_DECL_CONTEXT (op
);
5371 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5378 /* The next set of functions are used for providing helpful explanatory
5379 diagnostics for failed overload resolution. Their messages should be
5380 indented by two spaces for consistency with the messages in
5384 unify_success (bool /*explain_p*/)
5390 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5393 inform (input_location
,
5394 " couldn't deduce template parameter %qD", parm
);
5399 unify_invalid (bool /*explain_p*/)
5405 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5408 inform (input_location
,
5409 " types %qT and %qT have incompatible cv-qualifiers",
5415 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5418 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5423 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5426 inform (input_location
,
5427 " template parameter %qD is not a parameter pack, but "
5434 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5437 inform (input_location
,
5438 " template argument %qE does not match "
5439 "pointer-to-member constant %qE",
5445 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5448 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5453 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5456 inform (input_location
,
5457 " inconsistent parameter pack deduction with %qT and %qT",
5463 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5468 inform (input_location
,
5469 " deduced conflicting types for parameter %qT (%qT and %qT)",
5470 parm
, first
, second
);
5472 inform (input_location
,
5473 " deduced conflicting values for non-type parameter "
5474 "%qE (%qE and %qE)", parm
, first
, second
);
5480 unify_vla_arg (bool explain_p
, tree arg
)
5483 inform (input_location
,
5484 " variable-sized array type %qT is not "
5485 "a valid template argument",
5491 unify_method_type_error (bool explain_p
, tree arg
)
5494 inform (input_location
,
5495 " member function type %qT is not a valid template argument",
5501 unify_arity (bool explain_p
, int have
, int wanted
)
5504 inform_n (input_location
, wanted
,
5505 " candidate expects %d argument, %d provided",
5506 " candidate expects %d arguments, %d provided",
5512 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5514 return unify_arity (explain_p
, have
, wanted
);
5518 unify_too_few_arguments (bool explain_p
, int have
, int wanted
)
5520 return unify_arity (explain_p
, have
, wanted
);
5524 unify_arg_conversion (bool explain_p
, tree to_type
,
5525 tree from_type
, tree arg
)
5528 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5529 " cannot convert %qE (type %qT) to type %qT",
5530 arg
, from_type
, to_type
);
5535 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5536 tree parm
, tree arg
)
5541 case tbr_ambiguous_baseclass
:
5542 inform (input_location
, " %qT is an ambiguous base class of %qT",
5546 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5553 unify_inconsistent_template_template_parameters (bool explain_p
)
5556 inform (input_location
,
5557 " template parameters of a template template argument are "
5558 "inconsistent with other deduced template arguments");
5563 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5566 inform (input_location
,
5567 " can't deduce a template for %qT from non-template type %qT",
5573 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5576 inform (input_location
,
5577 " template argument %qE does not match %qD", arg
, parm
);
5582 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5585 inform (input_location
,
5586 " could not resolve address from overloaded function %qE",
5591 /* Attempt to convert the non-type template parameter EXPR to the
5592 indicated TYPE. If the conversion is successful, return the
5593 converted value. If the conversion is unsuccessful, return
5594 NULL_TREE if we issued an error message, or error_mark_node if we
5595 did not. We issue error messages for out-and-out bad template
5596 parameters, but not simply because the conversion failed, since we
5597 might be just trying to do argument deduction. Both TYPE and EXPR
5598 must be non-dependent.
5600 The conversion follows the special rules described in
5601 [temp.arg.nontype], and it is much more strict than an implicit
5604 This function is called twice for each template argument (see
5605 lookup_template_class for a more accurate description of this
5606 problem). This means that we need to handle expressions which
5607 are not valid in a C++ source, but can be created from the
5608 first call (for instance, casts to perform conversions). These
5609 hacks can go away after we fix the double coercion problem. */
5612 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5616 /* Detect immediately string literals as invalid non-type argument.
5617 This special-case is not needed for correctness (we would easily
5618 catch this later), but only to provide better diagnostic for this
5619 common user mistake. As suggested by DR 100, we do not mention
5620 linkage issues in the diagnostic as this is not the point. */
5621 /* FIXME we're making this OK. */
5622 if (TREE_CODE (expr
) == STRING_CST
)
5624 if (complain
& tf_error
)
5625 error ("%qE is not a valid template argument for type %qT "
5626 "because string literals can never be used in this context",
5631 /* Add the ADDR_EXPR now for the benefit of
5632 value_dependent_expression_p. */
5633 if (TYPE_PTROBV_P (type
)
5634 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5636 expr
= decay_conversion (expr
, complain
);
5637 if (expr
== error_mark_node
)
5638 return error_mark_node
;
5641 /* If we are in a template, EXPR may be non-dependent, but still
5642 have a syntactic, rather than semantic, form. For example, EXPR
5643 might be a SCOPE_REF, rather than the VAR_DECL to which the
5644 SCOPE_REF refers. Preserving the qualifying scope is necessary
5645 so that access checking can be performed when the template is
5646 instantiated -- but here we need the resolved form so that we can
5647 convert the argument. */
5648 if (TYPE_REF_OBJ_P (type
)
5649 && has_value_dependent_address (expr
))
5650 /* If we want the address and it's value-dependent, don't fold. */;
5651 else if (!type_unknown_p (expr
))
5652 expr
= fold_non_dependent_expr_sfinae (expr
, complain
);
5653 if (error_operand_p (expr
))
5654 return error_mark_node
;
5655 expr_type
= TREE_TYPE (expr
);
5656 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5657 expr
= mark_lvalue_use (expr
);
5659 expr
= mark_rvalue_use (expr
);
5661 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5662 to a non-type argument of "nullptr". */
5663 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5664 expr
= convert (type
, expr
);
5666 /* In C++11, integral or enumeration non-type template arguments can be
5667 arbitrary constant expressions. Pointer and pointer to
5668 member arguments can be general constant expressions that evaluate
5669 to a null value, but otherwise still need to be of a specific form. */
5670 if (cxx_dialect
>= cxx11
)
5672 if (TREE_CODE (expr
) == PTRMEM_CST
)
5673 /* A PTRMEM_CST is already constant, and a valid template
5674 argument for a parameter of pointer to member type, we just want
5675 to leave it in that form rather than lower it to a
5677 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5678 expr
= maybe_constant_value (expr
);
5679 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5681 tree folded
= maybe_constant_value (expr
);
5682 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5683 : null_member_pointer_value_p (folded
))
5688 /* HACK: Due to double coercion, we can get a
5689 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5690 which is the tree that we built on the first call (see
5691 below when coercing to reference to object or to reference to
5692 function). We just strip everything and get to the arg.
5693 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5695 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5697 tree probe_type
, probe
= expr
;
5698 if (REFERENCE_REF_P (probe
))
5699 probe
= TREE_OPERAND (probe
, 0);
5700 probe_type
= TREE_TYPE (probe
);
5701 if (TREE_CODE (probe
) == NOP_EXPR
)
5703 /* ??? Maybe we could use convert_from_reference here, but we
5704 would need to relax its constraints because the NOP_EXPR
5705 could actually change the type to something more cv-qualified,
5706 and this is not folded by convert_from_reference. */
5707 tree addr
= TREE_OPERAND (probe
, 0);
5708 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5709 && TREE_CODE (addr
) == ADDR_EXPR
5710 && TYPE_PTR_P (TREE_TYPE (addr
))
5711 && (same_type_ignoring_top_level_qualifiers_p
5712 (TREE_TYPE (probe_type
),
5713 TREE_TYPE (TREE_TYPE (addr
)))))
5715 expr
= TREE_OPERAND (addr
, 0);
5716 expr_type
= TREE_TYPE (probe_type
);
5721 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5722 parameter is a pointer to object, through decay and
5723 qualification conversion. Let's strip everything. */
5724 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5728 if (TREE_CODE (probe
) == ADDR_EXPR
5729 && TYPE_PTR_P (TREE_TYPE (probe
)))
5731 /* Skip the ADDR_EXPR only if it is part of the decay for
5732 an array. Otherwise, it is part of the original argument
5733 in the source code. */
5734 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5735 probe
= TREE_OPERAND (probe
, 0);
5737 expr_type
= TREE_TYPE (expr
);
5741 /* [temp.arg.nontype]/5, bullet 1
5743 For a non-type template-parameter of integral or enumeration type,
5744 integral promotions (_conv.prom_) and integral conversions
5745 (_conv.integral_) are applied. */
5746 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5748 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5749 t
= maybe_constant_value (t
);
5750 if (t
!= error_mark_node
)
5753 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5754 return error_mark_node
;
5756 /* Notice that there are constant expressions like '4 % 0' which
5757 do not fold into integer constants. */
5758 if (TREE_CODE (expr
) != INTEGER_CST
)
5760 if (complain
& tf_error
)
5762 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
5763 if (processing_template_decl
5764 && !require_potential_constant_expression (expr
))
5766 expr
= cxx_constant_value (expr
);
5767 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
5768 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
5769 "in template argument for type %qT ", type
);
5770 if (expr
== error_mark_node
)
5772 /* else cxx_constant_value complained but gave us
5773 a real constant, so go ahead. */
5774 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
5780 /* Avoid typedef problems. */
5781 if (TREE_TYPE (expr
) != type
)
5782 expr
= fold_convert (type
, expr
);
5784 /* [temp.arg.nontype]/5, bullet 2
5786 For a non-type template-parameter of type pointer to object,
5787 qualification conversions (_conv.qual_) and the array-to-pointer
5788 conversion (_conv.array_) are applied. */
5789 else if (TYPE_PTROBV_P (type
))
5791 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5793 A template-argument for a non-type, non-template template-parameter
5794 shall be one of: [...]
5796 -- the name of a non-type template-parameter;
5797 -- the address of an object or function with external linkage, [...]
5798 expressed as "& id-expression" where the & is optional if the name
5799 refers to a function or array, or if the corresponding
5800 template-parameter is a reference.
5802 Here, we do not care about functions, as they are invalid anyway
5803 for a parameter of type pointer-to-object. */
5805 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
5806 /* Non-type template parameters are OK. */
5808 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5809 /* Null pointer values are OK in C++11. */;
5810 else if (TREE_CODE (expr
) != ADDR_EXPR
5811 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
5815 error ("%qD is not a valid template argument "
5816 "because %qD is a variable, not the address of "
5821 if (POINTER_TYPE_P (expr_type
))
5823 error ("%qE is not a valid template argument for %qT "
5824 "because it is not the address of a variable",
5828 /* Other values, like integer constants, might be valid
5829 non-type arguments of some other type. */
5830 return error_mark_node
;
5836 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
5837 ? TREE_OPERAND (expr
, 0) : expr
);
5840 error ("%qE is not a valid template argument of type %qT "
5841 "because %qE is not a variable",
5845 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
5847 error ("%qE is not a valid template argument of type %qT "
5848 "because %qD does not have external linkage",
5852 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
5854 error ("%qE is not a valid template argument of type %qT "
5855 "because %qD has no linkage",
5861 expr
= decay_conversion (expr
, complain
);
5862 if (expr
== error_mark_node
)
5863 return error_mark_node
;
5865 expr
= perform_qualification_conversions (type
, expr
);
5866 if (expr
== error_mark_node
)
5867 return error_mark_node
;
5869 /* [temp.arg.nontype]/5, bullet 3
5871 For a non-type template-parameter of type reference to object, no
5872 conversions apply. The type referred to by the reference may be more
5873 cv-qualified than the (otherwise identical) type of the
5874 template-argument. The template-parameter is bound directly to the
5875 template-argument, which must be an lvalue. */
5876 else if (TYPE_REF_OBJ_P (type
))
5878 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
5880 return error_mark_node
;
5882 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
5884 error ("%qE is not a valid template argument for type %qT "
5885 "because of conflicts in cv-qualification", expr
, type
);
5889 if (!real_lvalue_p (expr
))
5891 error ("%qE is not a valid template argument for type %qT "
5892 "because it is not an lvalue", expr
, type
);
5896 /* [temp.arg.nontype]/1
5898 A template-argument for a non-type, non-template template-parameter
5899 shall be one of: [...]
5901 -- the address of an object or function with external linkage. */
5902 if (INDIRECT_REF_P (expr
)
5903 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
5905 expr
= TREE_OPERAND (expr
, 0);
5908 error ("%q#D is not a valid template argument for type %qT "
5909 "because a reference variable does not have a constant "
5910 "address", expr
, type
);
5917 error ("%qE is not a valid template argument for type %qT "
5918 "because it is not an object with external linkage",
5923 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
5925 error ("%qE is not a valid template argument for type %qT "
5926 "because object %qD has not external linkage",
5931 expr
= build_nop (type
, build_address (expr
));
5933 /* [temp.arg.nontype]/5, bullet 4
5935 For a non-type template-parameter of type pointer to function, only
5936 the function-to-pointer conversion (_conv.func_) is applied. If the
5937 template-argument represents a set of overloaded functions (or a
5938 pointer to such), the matching function is selected from the set
5940 else if (TYPE_PTRFN_P (type
))
5942 /* If the argument is a template-id, we might not have enough
5943 context information to decay the pointer. */
5944 if (!type_unknown_p (expr_type
))
5946 expr
= decay_conversion (expr
, complain
);
5947 if (expr
== error_mark_node
)
5948 return error_mark_node
;
5951 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5952 /* Null pointer values are OK in C++11. */
5953 return perform_qualification_conversions (type
, expr
);
5955 expr
= convert_nontype_argument_function (type
, expr
);
5956 if (!expr
|| expr
== error_mark_node
)
5959 /* [temp.arg.nontype]/5, bullet 5
5961 For a non-type template-parameter of type reference to function, no
5962 conversions apply. If the template-argument represents a set of
5963 overloaded functions, the matching function is selected from the set
5965 else if (TYPE_REFFN_P (type
))
5967 if (TREE_CODE (expr
) == ADDR_EXPR
)
5969 error ("%qE is not a valid template argument for type %qT "
5970 "because it is a pointer", expr
, type
);
5971 inform (input_location
, "try using %qE instead", TREE_OPERAND (expr
, 0));
5975 expr
= convert_nontype_argument_function (type
, expr
);
5976 if (!expr
|| expr
== error_mark_node
)
5979 expr
= build_nop (type
, build_address (expr
));
5981 /* [temp.arg.nontype]/5, bullet 6
5983 For a non-type template-parameter of type pointer to member function,
5984 no conversions apply. If the template-argument represents a set of
5985 overloaded member functions, the matching member function is selected
5986 from the set (_over.over_). */
5987 else if (TYPE_PTRMEMFUNC_P (type
))
5989 expr
= instantiate_type (type
, expr
, tf_none
);
5990 if (expr
== error_mark_node
)
5991 return error_mark_node
;
5993 /* [temp.arg.nontype] bullet 1 says the pointer to member
5994 expression must be a pointer-to-member constant. */
5995 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
5996 return error_mark_node
;
5998 /* There is no way to disable standard conversions in
5999 resolve_address_of_overloaded_function (called by
6000 instantiate_type). It is possible that the call succeeded by
6001 converting &B::I to &D::I (where B is a base of D), so we need
6002 to reject this conversion here.
6004 Actually, even if there was a way to disable standard conversions,
6005 it would still be better to reject them here so that we can
6006 provide a superior diagnostic. */
6007 if (!same_type_p (TREE_TYPE (expr
), type
))
6009 error ("%qE is not a valid template argument for type %qT "
6010 "because it is of type %qT", expr
, type
,
6012 /* If we are just one standard conversion off, explain. */
6013 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6014 inform (input_location
,
6015 "standard conversions are not allowed in this context");
6019 /* [temp.arg.nontype]/5, bullet 7
6021 For a non-type template-parameter of type pointer to data member,
6022 qualification conversions (_conv.qual_) are applied. */
6023 else if (TYPE_PTRDATAMEM_P (type
))
6025 /* [temp.arg.nontype] bullet 1 says the pointer to member
6026 expression must be a pointer-to-member constant. */
6027 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6028 return error_mark_node
;
6030 expr
= perform_qualification_conversions (type
, expr
);
6031 if (expr
== error_mark_node
)
6034 else if (NULLPTR_TYPE_P (type
))
6036 if (expr
!= nullptr_node
)
6038 error ("%qE is not a valid template argument for type %qT "
6039 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6044 /* A template non-type parameter must be one of the above. */
6048 /* Sanity check: did we actually convert the argument to the
6050 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6051 (type
, TREE_TYPE (expr
)));
6055 /* Subroutine of coerce_template_template_parms, which returns 1 if
6056 PARM_PARM and ARG_PARM match using the rule for the template
6057 parameters of template template parameters. Both PARM and ARG are
6058 template parameters; the rest of the arguments are the same as for
6059 coerce_template_template_parms.
6062 coerce_template_template_parm (tree parm
,
6064 tsubst_flags_t complain
,
6068 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6069 || parm
== NULL_TREE
|| error_operand_p (parm
))
6072 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6075 switch (TREE_CODE (parm
))
6078 /* We encounter instantiations of templates like
6079 template <template <template <class> class> class TT>
6082 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6083 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6085 if (!coerce_template_template_parms
6086 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6092 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6093 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6094 /* Argument is a parameter pack but parameter is not. */
6099 /* The tsubst call is used to handle cases such as
6101 template <int> class C {};
6102 template <class T, template <T> class TT> class D {};
6105 i.e. the parameter list of TT depends on earlier parameters. */
6106 if (!uses_template_parms (TREE_TYPE (arg
))
6108 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6112 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6113 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6114 /* Argument is a parameter pack but parameter is not. */
6127 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6128 template template parameters. Both PARM_PARMS and ARG_PARMS are
6129 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6132 Consider the example:
6133 template <class T> class A;
6134 template<template <class U> class TT> class B;
6136 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6137 the parameters to A, and OUTER_ARGS contains A. */
6140 coerce_template_template_parms (tree parm_parms
,
6142 tsubst_flags_t complain
,
6146 int nparms
, nargs
, i
;
6150 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6151 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6153 nparms
= TREE_VEC_LENGTH (parm_parms
);
6154 nargs
= TREE_VEC_LENGTH (arg_parms
);
6156 /* Determine whether we have a parameter pack at the end of the
6157 template template parameter's template parameter list. */
6158 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6160 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6162 if (error_operand_p (parm
))
6165 switch (TREE_CODE (parm
))
6169 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6174 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6184 && !(variadic_p
&& nargs
>= nparms
- 1))
6187 /* Check all of the template parameters except the parameter pack at
6188 the end (if any). */
6189 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6191 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6192 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6195 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6196 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6198 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6206 /* Check each of the template parameters in the template
6207 argument against the template parameter pack at the end of
6208 the template template parameter. */
6209 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6212 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6214 for (; i
< nargs
; ++i
)
6216 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6219 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6221 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6230 /* Verifies that the deduced template arguments (in TARGS) for the
6231 template template parameters (in TPARMS) represent valid bindings,
6232 by comparing the template parameter list of each template argument
6233 to the template parameter list of its corresponding template
6234 template parameter, in accordance with DR150. This
6235 routine can only be called after all template arguments have been
6236 deduced. It will return TRUE if all of the template template
6237 parameter bindings are okay, FALSE otherwise. */
6239 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6241 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6244 /* We're dealing with template parms in this process. */
6245 ++processing_template_decl
;
6247 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6249 for (i
= 0; i
< ntparms
; ++i
)
6251 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6252 tree targ
= TREE_VEC_ELT (targs
, i
);
6254 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6256 tree packed_args
= NULL_TREE
;
6259 if (ARGUMENT_PACK_P (targ
))
6261 /* Look inside the argument pack. */
6262 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6263 len
= TREE_VEC_LENGTH (packed_args
);
6266 for (idx
= 0; idx
< len
; ++idx
)
6268 tree targ_parms
= NULL_TREE
;
6271 /* Extract the next argument from the argument
6273 targ
= TREE_VEC_ELT (packed_args
, idx
);
6275 if (PACK_EXPANSION_P (targ
))
6276 /* Look at the pattern of the pack expansion. */
6277 targ
= PACK_EXPANSION_PATTERN (targ
);
6279 /* Extract the template parameters from the template
6281 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6282 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6283 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6284 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6286 /* Verify that we can coerce the template template
6287 parameters from the template argument to the template
6288 parameter. This requires an exact match. */
6290 && !coerce_template_template_parms
6291 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6306 --processing_template_decl
;
6310 /* Since type attributes aren't mangled, we need to strip them from
6311 template type arguments. */
6314 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6317 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6319 mv
= TYPE_MAIN_VARIANT (arg
);
6320 arg
= strip_typedefs (arg
);
6321 if (TYPE_ALIGN (arg
) != TYPE_ALIGN (mv
)
6322 || TYPE_ATTRIBUTES (arg
) != TYPE_ATTRIBUTES (mv
))
6324 if (complain
& tf_warning
)
6325 warning (0, "ignoring attributes on template argument %qT", arg
);
6326 arg
= build_aligned_type (arg
, TYPE_ALIGN (mv
));
6327 arg
= cp_build_type_attribute_variant (arg
, TYPE_ATTRIBUTES (mv
));
6332 /* Convert the indicated template ARG as necessary to match the
6333 indicated template PARM. Returns the converted ARG, or
6334 error_mark_node if the conversion was unsuccessful. Error and
6335 warning messages are issued under control of COMPLAIN. This
6336 conversion is for the Ith parameter in the parameter list. ARGS is
6337 the full set of template arguments deduced so far. */
6340 convert_template_argument (tree parm
,
6343 tsubst_flags_t complain
,
6349 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6351 if (TREE_CODE (arg
) == TREE_LIST
6352 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6354 /* The template argument was the name of some
6355 member function. That's usually
6356 invalid, but static members are OK. In any
6357 case, grab the underlying fields/functions
6358 and issue an error later if required. */
6359 orig_arg
= TREE_VALUE (arg
);
6360 TREE_TYPE (arg
) = unknown_type_node
;
6365 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6366 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6367 || requires_tmpl_type
);
6369 /* When determining whether an argument pack expansion is a template,
6370 look at the pattern. */
6371 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6372 arg
= PACK_EXPANSION_PATTERN (arg
);
6374 /* Deal with an injected-class-name used as a template template arg. */
6375 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6377 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6378 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6380 if (cxx_dialect
>= cxx11
)
6381 /* OK under DR 1004. */;
6382 else if (complain
& tf_warning_or_error
)
6383 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6384 " used as template template argument", TYPE_NAME (arg
));
6385 else if (flag_pedantic_errors
)
6393 ((TREE_CODE (arg
) == TEMPLATE_DECL
6394 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6395 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6396 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6397 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6400 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6401 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6402 arg
= TYPE_STUB_DECL (arg
);
6404 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6406 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6407 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6409 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6411 if (complain
& tf_error
)
6412 error ("invalid use of destructor %qE as a type", orig_arg
);
6413 return error_mark_node
;
6416 permerror (input_location
,
6417 "to refer to a type member of a template parameter, "
6418 "use %<typename %E%>", orig_arg
);
6420 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6421 TREE_OPERAND (arg
, 1),
6427 if (is_type
!= requires_type
)
6431 if (complain
& tf_error
)
6433 error ("type/value mismatch at argument %d in template "
6434 "parameter list for %qD",
6437 error (" expected a constant of type %qT, got %qT",
6439 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6440 else if (requires_tmpl_type
)
6441 error (" expected a class template, got %qE", orig_arg
);
6443 error (" expected a type, got %qE", orig_arg
);
6446 return error_mark_node
;
6448 if (is_tmpl_type
^ requires_tmpl_type
)
6450 if (in_decl
&& (complain
& tf_error
))
6452 error ("type/value mismatch at argument %d in template "
6453 "parameter list for %qD",
6456 error (" expected a type, got %qT", DECL_NAME (arg
));
6458 error (" expected a class template, got %qT", orig_arg
);
6460 return error_mark_node
;
6465 if (requires_tmpl_type
)
6467 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6469 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6470 /* The number of argument required is not known yet.
6471 Just accept it for now. */
6472 val
= TREE_TYPE (arg
);
6475 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6478 /* Strip alias templates that are equivalent to another
6480 arg
= get_underlying_template (arg
);
6481 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6483 if (coerce_template_template_parms (parmparm
, argparm
,
6489 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6491 if (val
!= error_mark_node
)
6493 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6494 val
= TREE_TYPE (val
);
6495 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6496 val
= make_pack_expansion (val
);
6501 if (in_decl
&& (complain
& tf_error
))
6503 error ("type/value mismatch at argument %d in "
6504 "template parameter list for %qD",
6506 error (" expected a template of type %qD, got %qT",
6510 val
= error_mark_node
;
6516 /* We only form one instance of each template specialization.
6517 Therefore, if we use a non-canonical variant (i.e., a
6518 typedef), any future messages referring to the type will use
6519 the typedef, which is confusing if those future uses do not
6520 themselves also use the typedef. */
6522 val
= canonicalize_type_argument (val
, complain
);
6526 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6528 if (invalid_nontype_parm_type_p (t
, complain
))
6529 return error_mark_node
;
6531 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6533 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6537 /* Not sure if this is reachable, but it doesn't hurt
6539 error ("type mismatch in nontype parameter pack");
6540 val
= error_mark_node
;
6543 else if (!dependent_template_arg_p (orig_arg
)
6544 && !uses_template_parms (t
))
6545 /* We used to call digest_init here. However, digest_init
6546 will report errors, which we don't want when complain
6547 is zero. More importantly, digest_init will try too
6548 hard to convert things: for example, `0' should not be
6549 converted to pointer type at this point according to
6550 the standard. Accepting this is not merely an
6551 extension, since deciding whether or not these
6552 conversions can occur is part of determining which
6553 function template to call, or whether a given explicit
6554 argument specification is valid. */
6555 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6557 val
= strip_typedefs_expr (orig_arg
);
6559 if (val
== NULL_TREE
)
6560 val
= error_mark_node
;
6561 else if (val
== error_mark_node
&& (complain
& tf_error
))
6562 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6564 if (TREE_CODE (val
) == SCOPE_REF
)
6566 /* Strip typedefs from the SCOPE_REF. */
6567 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6568 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6570 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6571 QUALIFIED_NAME_IS_TEMPLATE (val
));
6578 /* Coerces the remaining template arguments in INNER_ARGS (from
6579 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6580 Returns the coerced argument pack. PARM_IDX is the position of this
6581 parameter in the template parameter list. ARGS is the original
6582 template argument list. */
6584 coerce_template_parameter_pack (tree parms
,
6592 tsubst_flags_t complain
)
6594 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6595 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6598 tree packed_parms
= NULL_TREE
;
6600 if (arg_idx
> nargs
)
6603 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6605 /* When the template parameter is a non-type template parameter pack
6606 or template template parameter pack whose type or template
6607 parameters use parameter packs, we know exactly how many arguments
6608 we are looking for. Build a vector of the instantiated decls for
6609 these template parameters in PACKED_PARMS. */
6610 /* We can't use make_pack_expansion here because it would interpret a
6611 _DECL as a use rather than a declaration. */
6612 tree decl
= TREE_VALUE (parm
);
6613 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6614 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6615 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6616 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6618 TREE_VEC_LENGTH (args
)--;
6619 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6620 TREE_VEC_LENGTH (args
)++;
6622 if (packed_parms
== error_mark_node
)
6623 return error_mark_node
;
6625 /* If we're doing a partial instantiation of a member template,
6626 verify that all of the types used for the non-type
6627 template parameter pack are, in fact, valid for non-type
6628 template parameters. */
6630 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6632 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6633 for (j
= 0; j
< len
; ++j
)
6635 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6636 if (invalid_nontype_parm_type_p (t
, complain
))
6637 return error_mark_node
;
6641 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6644 packed_args
= make_tree_vec (nargs
- arg_idx
);
6646 /* Convert the remaining arguments, which will be a part of the
6647 parameter pack "parm". */
6648 for (; arg_idx
< nargs
; ++arg_idx
)
6650 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6651 tree actual_parm
= TREE_VALUE (parm
);
6652 int pack_idx
= arg_idx
- parm_idx
;
6656 /* Once we've packed as many args as we have types, stop. */
6657 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6659 else if (PACK_EXPANSION_P (arg
))
6660 /* We don't know how many args we have yet, just
6661 use the unconverted ones for now. */
6664 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6667 if (arg
== error_mark_node
)
6669 if (complain
& tf_error
)
6670 error ("template argument %d is invalid", arg_idx
+ 1);
6673 arg
= convert_template_argument (actual_parm
,
6674 arg
, new_args
, complain
, parm_idx
,
6676 if (arg
== error_mark_node
)
6678 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6681 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6682 && TREE_VEC_LENGTH (packed_args
) > 0)
6684 error ("wrong number of template arguments (%d, should be %d)",
6685 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6686 return error_mark_node
;
6689 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6690 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6691 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6694 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6695 TREE_TYPE (argument_pack
)
6696 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6697 TREE_CONSTANT (argument_pack
) = 1;
6700 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6701 #ifdef ENABLE_CHECKING
6702 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6703 TREE_VEC_LENGTH (packed_args
));
6705 return argument_pack
;
6708 /* Returns the number of pack expansions in the template argument vector
6712 pack_expansion_args_count (tree args
)
6717 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6719 tree elt
= TREE_VEC_ELT (args
, i
);
6720 if (elt
&& PACK_EXPANSION_P (elt
))
6726 /* Convert all template arguments to their appropriate types, and
6727 return a vector containing the innermost resulting template
6728 arguments. If any error occurs, return error_mark_node. Error and
6729 warning messages are issued under control of COMPLAIN.
6731 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6732 for arguments not specified in ARGS. Otherwise, if
6733 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6734 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6735 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6739 coerce_template_parms (tree parms
,
6742 tsubst_flags_t complain
,
6743 bool require_all_args
,
6744 bool use_default_args
)
6746 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6747 tree orig_inner_args
;
6750 tree new_inner_args
;
6751 int saved_unevaluated_operand
;
6752 int saved_inhibit_evaluation_warnings
;
6754 /* When used as a boolean value, indicates whether this is a
6755 variadic template parameter list. Since it's an int, we can also
6756 subtract it from nparms to get the number of non-variadic
6759 int variadic_args_p
= 0;
6760 int post_variadic_parms
= 0;
6762 if (args
== error_mark_node
)
6763 return error_mark_node
;
6765 nparms
= TREE_VEC_LENGTH (parms
);
6767 /* Determine if there are any parameter packs. */
6768 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
6770 tree tparm
= TREE_VALUE (TREE_VEC_ELT (parms
, parm_idx
));
6772 ++post_variadic_parms
;
6773 if (template_parameter_pack_p (tparm
))
6777 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
6778 /* If there are no parameters that follow a parameter pack, we need to
6779 expand any argument packs so that we can deduce a parameter pack from
6780 some non-packed args followed by an argument pack, as in variadic85.C.
6781 If there are such parameters, we need to leave argument packs intact
6782 so the arguments are assigned properly. This can happen when dealing
6783 with a nested class inside a partial specialization of a class
6784 template, as in variadic92.C, or when deducing a template parameter pack
6785 from a sub-declarator, as in variadic114.C. */
6786 if (!post_variadic_parms
)
6787 inner_args
= expand_template_argument_pack (inner_args
);
6789 /* Count any pack expansion args. */
6790 variadic_args_p
= pack_expansion_args_count (inner_args
);
6792 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6793 if ((nargs
> nparms
&& !variadic_p
)
6794 || (nargs
< nparms
- variadic_p
6797 && (!use_default_args
6798 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
6799 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
6801 if (complain
& tf_error
)
6805 nparms
-= variadic_p
;
6806 error ("wrong number of template arguments "
6807 "(%d, should be %d or more)", nargs
, nparms
);
6810 error ("wrong number of template arguments "
6811 "(%d, should be %d)", nargs
, nparms
);
6814 error ("provided for %q+D", in_decl
);
6817 return error_mark_node
;
6819 /* We can't pass a pack expansion to a non-pack parameter of an alias
6820 template (DR 1430). */
6821 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
6823 && nargs
- variadic_args_p
< nparms
- variadic_p
)
6825 if (complain
& tf_error
)
6827 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
6829 tree arg
= TREE_VEC_ELT (inner_args
, i
);
6830 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
6832 if (PACK_EXPANSION_P (arg
)
6833 && !template_parameter_pack_p (parm
))
6835 error ("pack expansion argument for non-pack parameter "
6836 "%qD of alias template %qD", parm
, in_decl
);
6837 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
6844 return error_mark_node
;
6847 /* We need to evaluate the template arguments, even though this
6848 template-id may be nested within a "sizeof". */
6849 saved_unevaluated_operand
= cp_unevaluated_operand
;
6850 cp_unevaluated_operand
= 0;
6851 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6852 c_inhibit_evaluation_warnings
= 0;
6853 new_inner_args
= make_tree_vec (nparms
);
6854 new_args
= add_outermost_template_args (args
, new_inner_args
);
6855 int pack_adjust
= 0;
6856 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
6861 /* Get the Ith template parameter. */
6862 parm
= TREE_VEC_ELT (parms
, parm_idx
);
6864 if (parm
== error_mark_node
)
6866 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
6870 /* Calculate the next argument. */
6871 if (arg_idx
< nargs
)
6872 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6876 if (template_parameter_pack_p (TREE_VALUE (parm
))
6877 && !(arg
&& ARGUMENT_PACK_P (arg
)))
6879 /* Some arguments will be placed in the
6880 template parameter pack PARM. */
6881 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
6882 inner_args
, arg_idx
,
6886 if (arg
== NULL_TREE
)
6888 /* We don't know how many args we have yet, just use the
6889 unconverted (and still packed) ones for now. */
6890 new_inner_args
= orig_inner_args
;
6895 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
6897 /* Store this argument. */
6898 if (arg
== error_mark_node
)
6901 /* We are done with all of the arguments. */
6906 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
6907 arg_idx
+= pack_adjust
;
6914 if (PACK_EXPANSION_P (arg
))
6916 /* "If every valid specialization of a variadic template
6917 requires an empty template parameter pack, the template is
6918 ill-formed, no diagnostic required." So check that the
6919 pattern works with this parameter. */
6920 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
6921 tree conv
= convert_template_argument (TREE_VALUE (parm
),
6925 if (conv
== error_mark_node
)
6927 inform (input_location
, "so any instantiation with a "
6928 "non-empty parameter pack would be ill-formed");
6931 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
6932 /* Recover from missing typename. */
6933 TREE_VEC_ELT (inner_args
, arg_idx
)
6934 = make_pack_expansion (conv
);
6936 /* We don't know how many args we have yet, just
6937 use the unconverted ones for now. */
6938 new_inner_args
= inner_args
;
6943 else if (require_all_args
)
6945 /* There must be a default arg in this case. */
6946 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
6948 /* The position of the first default template argument,
6949 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6951 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
6952 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
6953 arg_idx
- pack_adjust
);
6958 if (arg
== error_mark_node
)
6960 if (complain
& tf_error
)
6961 error ("template argument %d is invalid", arg_idx
+ 1);
6964 /* This only occurs if there was an error in the template
6965 parameter list itself (which we would already have
6966 reported) that we are trying to recover from, e.g., a class
6967 template with a parameter list such as
6968 template<typename..., typename>. */
6971 arg
= convert_template_argument (TREE_VALUE (parm
),
6972 arg
, new_args
, complain
,
6975 if (arg
== error_mark_node
)
6977 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
6979 cp_unevaluated_operand
= saved_unevaluated_operand
;
6980 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
6982 if (variadic_p
&& arg_idx
< nargs
)
6984 if (complain
& tf_error
)
6986 error ("wrong number of template arguments "
6987 "(%d, should be %d)", nargs
, arg_idx
);
6989 error ("provided for %q+D", in_decl
);
6991 return error_mark_node
;
6995 return error_mark_node
;
6997 #ifdef ENABLE_CHECKING
6998 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
6999 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7000 TREE_VEC_LENGTH (new_inner_args
));
7003 return new_inner_args
;
7006 /* Like coerce_template_parms. If PARMS represents all template
7007 parameters levels, this function returns a vector of vectors
7008 representing all the resulting argument levels. Note that in this
7009 case, only the innermost arguments are coerced because the
7010 outermost ones are supposed to have been coerced already.
7012 Otherwise, if PARMS represents only (the innermost) vector of
7013 parameters, this function returns a vector containing just the
7014 innermost resulting arguments. */
7017 coerce_innermost_template_parms (tree parms
,
7020 tsubst_flags_t complain
,
7021 bool require_all_args
,
7022 bool use_default_args
)
7024 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7025 int args_depth
= TMPL_ARGS_DEPTH (args
);
7028 if (parms_depth
> 1)
7030 coerced_args
= make_tree_vec (parms_depth
);
7034 for (level
= parms
, cur_depth
= parms_depth
;
7035 parms_depth
> 0 && level
!= NULL_TREE
;
7036 level
= TREE_CHAIN (level
), --cur_depth
)
7039 if (cur_depth
== args_depth
)
7040 l
= coerce_template_parms (TREE_VALUE (level
),
7041 args
, in_decl
, complain
,
7045 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7047 if (l
== error_mark_node
)
7048 return error_mark_node
;
7050 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7054 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7055 args
, in_decl
, complain
,
7058 return coerced_args
;
7061 /* Returns 1 if template args OT and NT are equivalent. */
7064 template_args_equal (tree ot
, tree nt
)
7068 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7071 if (TREE_CODE (nt
) == TREE_VEC
)
7072 /* For member templates */
7073 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7074 else if (PACK_EXPANSION_P (ot
))
7075 return (PACK_EXPANSION_P (nt
)
7076 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7077 PACK_EXPANSION_PATTERN (nt
))
7078 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7079 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7080 else if (ARGUMENT_PACK_P (ot
))
7085 if (!ARGUMENT_PACK_P (nt
))
7088 opack
= ARGUMENT_PACK_ARGS (ot
);
7089 npack
= ARGUMENT_PACK_ARGS (nt
);
7090 len
= TREE_VEC_LENGTH (opack
);
7091 if (TREE_VEC_LENGTH (npack
) != len
)
7093 for (i
= 0; i
< len
; ++i
)
7094 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7095 TREE_VEC_ELT (npack
, i
)))
7099 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7101 /* We get here probably because we are in the middle of substituting
7102 into the pattern of a pack expansion. In that case the
7103 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7104 interested in. So we want to use the initial pack argument for
7106 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7107 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7108 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7109 return template_args_equal (ot
, nt
);
7111 else if (TYPE_P (nt
))
7112 return TYPE_P (ot
) && same_type_p (ot
, nt
);
7113 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7116 return cp_tree_equal (ot
, nt
);
7119 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7120 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7121 NEWARG_PTR with the offending arguments if they are non-NULL. */
7124 comp_template_args_with_info (tree oldargs
, tree newargs
,
7125 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7129 if (oldargs
== newargs
)
7132 if (!oldargs
|| !newargs
)
7135 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7138 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7140 tree nt
= TREE_VEC_ELT (newargs
, i
);
7141 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7143 if (! template_args_equal (ot
, nt
))
7145 if (oldarg_ptr
!= NULL
)
7147 if (newarg_ptr
!= NULL
)
7155 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7156 of template arguments. Returns 0 otherwise. */
7159 comp_template_args (tree oldargs
, tree newargs
)
7161 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7165 add_pending_template (tree d
)
7167 tree ti
= (TYPE_P (d
)
7168 ? CLASSTYPE_TEMPLATE_INFO (d
)
7169 : DECL_TEMPLATE_INFO (d
));
7170 struct pending_template
*pt
;
7173 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7176 /* We are called both from instantiate_decl, where we've already had a
7177 tinst_level pushed, and instantiate_template, where we haven't.
7179 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7182 push_tinst_level (d
);
7184 pt
= ggc_alloc_pending_template ();
7186 pt
->tinst
= current_tinst_level
;
7187 if (last_pending_template
)
7188 last_pending_template
->next
= pt
;
7190 pending_templates
= pt
;
7192 last_pending_template
= pt
;
7194 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7201 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7202 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7203 documentation for TEMPLATE_ID_EXPR. */
7206 lookup_template_function (tree fns
, tree arglist
)
7210 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7211 return error_mark_node
;
7213 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7215 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7217 error ("%q#D is not a function template", fns
);
7218 return error_mark_node
;
7221 if (BASELINK_P (fns
))
7223 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7225 BASELINK_FUNCTIONS (fns
),
7230 type
= TREE_TYPE (fns
);
7231 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7232 type
= unknown_type_node
;
7234 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7237 /* Within the scope of a template class S<T>, the name S gets bound
7238 (in build_self_reference) to a TYPE_DECL for the class, not a
7239 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7240 or one of its enclosing classes, and that type is a template,
7241 return the associated TEMPLATE_DECL. Otherwise, the original
7244 Also handle the case when DECL is a TREE_LIST of ambiguous
7245 injected-class-names from different bases. */
7248 maybe_get_template_decl_from_type_decl (tree decl
)
7250 if (decl
== NULL_TREE
)
7253 /* DR 176: A lookup that finds an injected-class-name (10.2
7254 [class.member.lookup]) can result in an ambiguity in certain cases
7255 (for example, if it is found in more than one base class). If all of
7256 the injected-class-names that are found refer to specializations of
7257 the same class template, and if the name is followed by a
7258 template-argument-list, the reference refers to the class template
7259 itself and not a specialization thereof, and is not ambiguous. */
7260 if (TREE_CODE (decl
) == TREE_LIST
)
7262 tree t
, tmpl
= NULL_TREE
;
7263 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7265 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7268 else if (tmpl
!= elt
)
7271 if (tmpl
&& t
== NULL_TREE
)
7277 return (decl
!= NULL_TREE
7278 && DECL_SELF_REFERENCE_P (decl
)
7279 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7280 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7283 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7284 parameters, find the desired type.
7286 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7288 IN_DECL, if non-NULL, is the template declaration we are trying to
7291 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7292 the class we are looking up.
7294 Issue error and warning messages under control of COMPLAIN.
7296 If the template class is really a local class in a template
7297 function, then the FUNCTION_CONTEXT is the function in which it is
7300 ??? Note that this function is currently called *twice* for each
7301 template-id: the first time from the parser, while creating the
7302 incomplete type (finish_template_type), and the second type during the
7303 real instantiation (instantiate_template_class). This is surely something
7304 that we want to avoid. It also causes some problems with argument
7305 coercion (see convert_nontype_argument for more information on this). */
7308 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7309 int entering_scope
, tsubst_flags_t complain
)
7311 tree templ
= NULL_TREE
, parmlist
;
7318 if (identifier_p (d1
))
7320 tree value
= innermost_non_namespace_value (d1
);
7321 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7326 push_decl_namespace (context
);
7327 templ
= lookup_name (d1
);
7328 templ
= maybe_get_template_decl_from_type_decl (templ
);
7330 pop_decl_namespace ();
7333 context
= DECL_CONTEXT (templ
);
7335 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7337 tree type
= TREE_TYPE (d1
);
7339 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7340 an implicit typename for the second A. Deal with it. */
7341 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7342 type
= TREE_TYPE (type
);
7344 if (CLASSTYPE_TEMPLATE_INFO (type
))
7346 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7347 d1
= DECL_NAME (templ
);
7350 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7351 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7353 templ
= TYPE_TI_TEMPLATE (d1
);
7354 d1
= DECL_NAME (templ
);
7356 else if (TREE_CODE (d1
) == TEMPLATE_DECL
7357 && DECL_TEMPLATE_RESULT (d1
)
7358 && TREE_CODE (DECL_TEMPLATE_RESULT (d1
)) == TYPE_DECL
)
7361 d1
= DECL_NAME (templ
);
7362 context
= DECL_CONTEXT (templ
);
7364 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7367 d1
= DECL_NAME (templ
);
7370 /* Issue an error message if we didn't find a template. */
7373 if (complain
& tf_error
)
7374 error ("%qT is not a template", d1
);
7375 return error_mark_node
;
7378 if (TREE_CODE (templ
) != TEMPLATE_DECL
7379 /* Make sure it's a user visible template, if it was named by
7381 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7382 && !PRIMARY_TEMPLATE_P (templ
)))
7384 if (complain
& tf_error
)
7386 error ("non-template type %qT used as a template", d1
);
7388 error ("for template declaration %q+D", in_decl
);
7390 return error_mark_node
;
7393 complain
&= ~tf_user
;
7395 /* An alias that just changes the name of a template is equivalent to the
7396 other template, so if any of the arguments are pack expansions, strip
7397 the alias to avoid problems with a pack expansion passed to a non-pack
7398 alias template parameter (DR 1430). */
7399 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7400 templ
= get_underlying_template (templ
);
7402 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7404 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7405 template arguments */
7411 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7413 /* Consider an example where a template template parameter declared as
7415 template <class T, class U = std::allocator<T> > class TT
7417 The template parameter level of T and U are one level larger than
7418 of TT. To proper process the default argument of U, say when an
7419 instantiation `TT<int>' is seen, we need to build the full
7420 arguments containing {int} as the innermost level. Outer levels,
7421 available when not appearing as default template argument, can be
7422 obtained from the arguments of the enclosing template.
7424 Suppose that TT is later substituted with std::vector. The above
7425 instantiation is `TT<int, std::allocator<T> >' with TT at
7426 level 1, and T at level 2, while the template arguments at level 1
7427 becomes {std::vector} and the inner level 2 is {int}. */
7429 outer
= DECL_CONTEXT (templ
);
7431 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7432 else if (current_template_parms
)
7433 /* This is an argument of the current template, so we haven't set
7434 DECL_CONTEXT yet. */
7435 outer
= current_template_args ();
7438 arglist
= add_to_template_args (outer
, arglist
);
7440 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7442 /*require_all_args=*/true,
7443 /*use_default_args=*/true);
7444 if (arglist2
== error_mark_node
7445 || (!uses_template_parms (arglist2
)
7446 && check_instantiated_args (templ
, arglist2
, complain
)))
7447 return error_mark_node
;
7449 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7454 tree template_type
= TREE_TYPE (templ
);
7457 tree found
= NULL_TREE
;
7460 int is_dependent_type
;
7461 int use_partial_inst_tmpl
= false;
7463 if (template_type
== error_mark_node
)
7464 /* An error occurred while building the template TEMPL, and a
7465 diagnostic has most certainly been emitted for that
7466 already. Let's propagate that error. */
7467 return error_mark_node
;
7469 gen_tmpl
= most_general_template (templ
);
7470 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7471 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7472 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7474 if (arg_depth
== 1 && parm_depth
> 1)
7476 /* We've been given an incomplete set of template arguments.
7479 template <class T> struct S1 {
7480 template <class U> struct S2 {};
7481 template <class U> struct S2<U*> {};
7484 we will be called with an ARGLIST of `U*', but the
7485 TEMPLATE will be `template <class T> template
7486 <class U> struct S1<T>::S2'. We must fill in the missing
7489 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7491 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7494 /* Now we should have enough arguments. */
7495 gcc_assert (parm_depth
== arg_depth
);
7497 /* From here on, we're only interested in the most general
7500 /* Calculate the BOUND_ARGS. These will be the args that are
7501 actually tsubst'd into the definition to create the
7505 /* We have multiple levels of arguments to coerce, at once. */
7507 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
7509 tree bound_args
= make_tree_vec (parm_depth
);
7511 for (i
= saved_depth
,
7512 t
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7513 i
> 0 && t
!= NULL_TREE
;
7514 --i
, t
= TREE_CHAIN (t
))
7517 if (i
== saved_depth
)
7518 a
= coerce_template_parms (TREE_VALUE (t
),
7521 /*require_all_args=*/true,
7522 /*use_default_args=*/true);
7524 /* Outer levels should have already been coerced. */
7525 a
= TMPL_ARGS_LEVEL (arglist
, i
);
7527 /* Don't process further if one of the levels fails. */
7528 if (a
== error_mark_node
)
7530 /* Restore the ARGLIST to its full size. */
7531 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7532 return error_mark_node
;
7535 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
7537 /* We temporarily reduce the length of the ARGLIST so
7538 that coerce_template_parms will see only the arguments
7539 corresponding to the template parameters it is
7541 TREE_VEC_LENGTH (arglist
)--;
7544 /* Restore the ARGLIST to its full size. */
7545 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7547 arglist
= bound_args
;
7551 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
7552 INNERMOST_TEMPLATE_ARGS (arglist
),
7555 /*require_all_args=*/true,
7556 /*use_default_args=*/true);
7558 if (arglist
== error_mark_node
)
7559 /* We were unable to bind the arguments. */
7560 return error_mark_node
;
7562 /* In the scope of a template class, explicit references to the
7563 template class refer to the type of the template, not any
7564 instantiation of it. For example, in:
7566 template <class T> class C { void f(C<T>); }
7568 the `C<T>' is just the same as `C'. Outside of the
7569 class, however, such a reference is an instantiation. */
7571 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7572 || currently_open_class (template_type
))
7573 /* comp_template_args is expensive, check it last. */
7574 && comp_template_args (TYPE_TI_ARGS (template_type
),
7576 return template_type
;
7578 /* If we already have this specialization, return it. */
7579 elt
.tmpl
= gen_tmpl
;
7581 hash
= hash_specialization (&elt
);
7582 entry
= (spec_entry
*) htab_find_with_hash (type_specializations
,
7588 is_dependent_type
= uses_template_parms (arglist
);
7590 /* If the deduced arguments are invalid, then the binding
7592 if (!is_dependent_type
7593 && check_instantiated_args (gen_tmpl
,
7594 INNERMOST_TEMPLATE_ARGS (arglist
),
7596 return error_mark_node
;
7598 if (!is_dependent_type
7599 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7600 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7601 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7603 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7604 DECL_NAME (gen_tmpl
),
7605 /*tag_scope=*/ts_global
);
7609 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7611 if (context
== error_mark_node
)
7612 return error_mark_node
;
7615 context
= global_namespace
;
7617 /* Create the type. */
7618 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7620 /* The user referred to a specialization of an alias
7621 template represented by GEN_TMPL.
7623 [temp.alias]/2 says:
7625 When a template-id refers to the specialization of an
7626 alias template, it is equivalent to the associated
7627 type obtained by substitution of its
7628 template-arguments for the template-parameters in the
7629 type-id of the alias template. */
7631 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7632 /* Note that the call above (by indirectly calling
7633 register_specialization in tsubst_decl) registers the
7634 TYPE_DECL representing the specialization of the alias
7635 template. So next time someone substitutes ARGLIST for
7636 the template parms into the alias template (GEN_TMPL),
7637 she'll get that TYPE_DECL back. */
7639 if (t
== error_mark_node
)
7642 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7644 if (!is_dependent_type
)
7646 set_current_access_from_decl (TYPE_NAME (template_type
));
7647 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7648 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7649 arglist
, complain
, in_decl
),
7650 SCOPED_ENUM_P (template_type
), NULL
);
7652 if (t
== error_mark_node
)
7657 /* We don't want to call start_enum for this type, since
7658 the values for the enumeration constants may involve
7659 template parameters. And, no one should be interested
7660 in the enumeration constants for such a type. */
7661 t
= cxx_make_type (ENUMERAL_TYPE
);
7662 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7664 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7665 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7666 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7668 else if (CLASS_TYPE_P (template_type
))
7670 t
= make_class_type (TREE_CODE (template_type
));
7671 CLASSTYPE_DECLARED_CLASS (t
)
7672 = CLASSTYPE_DECLARED_CLASS (template_type
);
7673 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7674 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7676 /* A local class. Make sure the decl gets registered properly. */
7677 if (context
== current_function_decl
)
7678 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7680 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7681 /* This instantiation is another name for the primary
7682 template type. Set the TYPE_CANONICAL field
7684 TYPE_CANONICAL (t
) = template_type
;
7685 else if (any_template_arguments_need_structural_equality_p (arglist
))
7686 /* Some of the template arguments require structural
7687 equality testing, so this template class requires
7688 structural equality testing. */
7689 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7694 /* If we called start_enum or pushtag above, this information
7695 will already be set up. */
7698 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7700 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7701 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7702 DECL_SOURCE_LOCATION (type_decl
)
7703 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7706 type_decl
= TYPE_NAME (t
);
7708 if (CLASS_TYPE_P (template_type
))
7710 TREE_PRIVATE (type_decl
)
7711 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7712 TREE_PROTECTED (type_decl
)
7713 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7714 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7716 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7717 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7721 /* Let's consider the explicit specialization of a member
7722 of a class template specialization that is implicitly instantiated,
7727 template<class U> struct M {}; //#0
7732 struct S<int>::M<char> //#1
7736 [temp.expl.spec]/4 says this is valid.
7738 In this case, when we write:
7741 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7744 When we encounter #1, we want to store the partial instantiation
7745 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7747 For all cases other than this "explicit specialization of member of a
7748 class template", we just want to store the most general template into
7749 the CLASSTYPE_TI_TEMPLATE of M.
7751 This case of "explicit specialization of member of a class template"
7753 1/ the enclosing class is an instantiation of, and therefore not
7754 the same as, the context of the most general template, and
7755 2/ we aren't looking at the partial instantiation itself, i.e.
7756 the innermost arguments are not the same as the innermost parms of
7757 the most general template.
7759 So it's only when 1/ and 2/ happens that we want to use the partial
7760 instantiation of the member template in lieu of its most general
7763 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
7764 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
7765 /* the enclosing class must be an instantiation... */
7766 && CLASS_TYPE_P (context
)
7767 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
7769 tree partial_inst_args
;
7770 TREE_VEC_LENGTH (arglist
)--;
7771 ++processing_template_decl
;
7773 tsubst (INNERMOST_TEMPLATE_ARGS
7774 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
7775 arglist
, complain
, NULL_TREE
);
7776 --processing_template_decl
;
7777 TREE_VEC_LENGTH (arglist
)++;
7778 use_partial_inst_tmpl
=
7779 /*...and we must not be looking at the partial instantiation
7781 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
7785 if (!use_partial_inst_tmpl
)
7786 /* This case is easy; there are no member templates involved. */
7790 /* This is a full instantiation of a member template. Find
7791 the partial instantiation of which this is an instance. */
7793 /* Temporarily reduce by one the number of levels in the ARGLIST
7794 so as to avoid comparing the last set of arguments. */
7795 TREE_VEC_LENGTH (arglist
)--;
7796 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
7797 TREE_VEC_LENGTH (arglist
)++;
7798 /* FOUND is either a proper class type, or an alias
7799 template specialization. In the later case, it's a
7800 TYPE_DECL, resulting from the substituting of arguments
7801 for parameters in the TYPE_DECL of the alias template
7802 done earlier. So be careful while getting the template
7804 found
= TREE_CODE (found
) == TYPE_DECL
7805 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
7806 : CLASSTYPE_TI_TEMPLATE (found
);
7809 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
7812 slot
= htab_find_slot_with_hash (type_specializations
,
7813 &elt
, hash
, INSERT
);
7814 entry
= ggc_alloc_spec_entry ();
7818 /* Note this use of the partial instantiation so we can check it
7819 later in maybe_process_partial_specialization. */
7820 DECL_TEMPLATE_INSTANTIATIONS (found
)
7821 = tree_cons (arglist
, t
,
7822 DECL_TEMPLATE_INSTANTIATIONS (found
));
7824 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
7825 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7826 /* Now that the type has been registered on the instantiations
7827 list, we set up the enumerators. Because the enumeration
7828 constants may involve the enumeration type itself, we make
7829 sure to register the type first, and then create the
7830 constants. That way, doing tsubst_expr for the enumeration
7831 constants won't result in recursive calls here; we'll find
7832 the instantiation and exit above. */
7833 tsubst_enum (template_type
, t
, arglist
);
7835 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
7836 /* If the type makes use of template parameters, the
7837 code that generates debugging information will crash. */
7838 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
7840 /* Possibly limit visibility based on template args. */
7841 TREE_PUBLIC (type_decl
) = 1;
7842 determine_visibility (type_decl
);
7848 /* Wrapper for lookup_template_class_1. */
7851 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
7852 int entering_scope
, tsubst_flags_t complain
)
7855 timevar_push (TV_TEMPLATE_INST
);
7856 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
7857 entering_scope
, complain
);
7858 timevar_pop (TV_TEMPLATE_INST
);
7866 /* True when we should also visit template parameters that occur in
7867 non-deduced contexts. */
7868 bool include_nondeduced_p
;
7869 struct pointer_set_t
*visited
;
7872 /* Called from for_each_template_parm via walk_tree. */
7875 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
7878 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
7879 tree_fn_t fn
= pfd
->fn
;
7880 void *data
= pfd
->data
;
7883 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
7884 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
7885 pfd
->include_nondeduced_p
))
7886 return error_mark_node
;
7888 switch (TREE_CODE (t
))
7891 if (TYPE_PTRMEMFUNC_P (t
))
7897 if (!TYPE_TEMPLATE_INFO (t
))
7899 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
7900 fn
, data
, pfd
->visited
,
7901 pfd
->include_nondeduced_p
))
7902 return error_mark_node
;
7906 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
7907 fn
, data
, pfd
->visited
,
7908 pfd
->include_nondeduced_p
)
7909 || for_each_template_parm (TYPE_MAX_VALUE (t
),
7910 fn
, data
, pfd
->visited
,
7911 pfd
->include_nondeduced_p
))
7912 return error_mark_node
;
7916 /* Since we're not going to walk subtrees, we have to do this
7918 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
7919 pfd
->visited
, pfd
->include_nondeduced_p
))
7920 return error_mark_node
;
7924 /* Check the return type. */
7925 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
7926 pfd
->include_nondeduced_p
))
7927 return error_mark_node
;
7929 /* Check the parameter types. Since default arguments are not
7930 instantiated until they are needed, the TYPE_ARG_TYPES may
7931 contain expressions that involve template parameters. But,
7932 no-one should be looking at them yet. And, once they're
7933 instantiated, they don't contain template parameters, so
7934 there's no point in looking at them then, either. */
7938 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
7939 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
7940 pfd
->visited
, pfd
->include_nondeduced_p
))
7941 return error_mark_node
;
7943 /* Since we've already handled the TYPE_ARG_TYPES, we don't
7944 want walk_tree walking into them itself. */
7950 case UNDERLYING_TYPE
:
7951 if (pfd
->include_nondeduced_p
7952 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
7954 pfd
->include_nondeduced_p
))
7955 return error_mark_node
;
7960 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
7961 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
7962 pfd
->visited
, pfd
->include_nondeduced_p
))
7963 return error_mark_node
;
7968 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
7969 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
7970 pfd
->visited
, pfd
->include_nondeduced_p
))
7971 return error_mark_node
;
7972 if (DECL_CONTEXT (t
)
7973 && pfd
->include_nondeduced_p
7974 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
7975 pfd
->visited
, pfd
->include_nondeduced_p
))
7976 return error_mark_node
;
7979 case BOUND_TEMPLATE_TEMPLATE_PARM
:
7980 /* Record template parameters such as `T' inside `TT<T>'. */
7981 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
7982 pfd
->include_nondeduced_p
))
7983 return error_mark_node
;
7986 case TEMPLATE_TEMPLATE_PARM
:
7987 case TEMPLATE_TYPE_PARM
:
7988 case TEMPLATE_PARM_INDEX
:
7989 if (fn
&& (*fn
)(t
, data
))
7990 return error_mark_node
;
7992 return error_mark_node
;
7996 /* A template template parameter is encountered. */
7997 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
7998 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
7999 pfd
->include_nondeduced_p
))
8000 return error_mark_node
;
8002 /* Already substituted template template parameter */
8008 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8010 pfd
->include_nondeduced_p
))
8011 return error_mark_node
;
8015 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8016 && pfd
->include_nondeduced_p
8017 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8018 (TREE_TYPE (t
)), fn
, data
,
8019 pfd
->visited
, pfd
->include_nondeduced_p
))
8020 return error_mark_node
;
8025 /* If there's no type, then this thing must be some expression
8026 involving template parameters. */
8027 if (!fn
&& !TREE_TYPE (t
))
8028 return error_mark_node
;
8033 case IMPLICIT_CONV_EXPR
:
8034 case REINTERPRET_CAST_EXPR
:
8035 case CONST_CAST_EXPR
:
8036 case STATIC_CAST_EXPR
:
8037 case DYNAMIC_CAST_EXPR
:
8041 case PSEUDO_DTOR_EXPR
:
8043 return error_mark_node
;
8050 /* We didn't find any template parameters we liked. */
8054 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8055 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8056 call FN with the parameter and the DATA.
8057 If FN returns nonzero, the iteration is terminated, and
8058 for_each_template_parm returns 1. Otherwise, the iteration
8059 continues. If FN never returns a nonzero value, the value
8060 returned by for_each_template_parm is 0. If FN is NULL, it is
8061 considered to be the function which always returns 1.
8063 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8064 parameters that occur in non-deduced contexts. When false, only
8065 visits those template parameters that can be deduced. */
8068 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8069 struct pointer_set_t
*visited
,
8070 bool include_nondeduced_p
)
8072 struct pair_fn_data pfd
;
8078 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8080 /* Walk the tree. (Conceptually, we would like to walk without
8081 duplicates, but for_each_template_parm_r recursively calls
8082 for_each_template_parm, so we would need to reorganize a fair
8083 bit to use walk_tree_without_duplicates, so we keep our own
8086 pfd
.visited
= visited
;
8088 pfd
.visited
= pointer_set_create ();
8089 result
= cp_walk_tree (&t
,
8090 for_each_template_parm_r
,
8092 pfd
.visited
) != NULL_TREE
;
8097 pointer_set_destroy (pfd
.visited
);
8104 /* Returns true if T depends on any template parameter. */
8107 uses_template_parms (tree t
)
8110 int saved_processing_template_decl
;
8112 saved_processing_template_decl
= processing_template_decl
;
8113 if (!saved_processing_template_decl
)
8114 processing_template_decl
= 1;
8116 dependent_p
= dependent_type_p (t
);
8117 else if (TREE_CODE (t
) == TREE_VEC
)
8118 dependent_p
= any_dependent_template_arguments_p (t
);
8119 else if (TREE_CODE (t
) == TREE_LIST
)
8120 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8121 || uses_template_parms (TREE_CHAIN (t
)));
8122 else if (TREE_CODE (t
) == TYPE_DECL
)
8123 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8126 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8127 || TREE_CODE (t
) == OVERLOAD
8130 || TREE_CODE (t
) == TRAIT_EXPR
8131 || TREE_CODE (t
) == CONSTRUCTOR
8132 || CONSTANT_CLASS_P (t
))
8133 dependent_p
= (type_dependent_expression_p (t
)
8134 || value_dependent_expression_p (t
));
8137 gcc_assert (t
== error_mark_node
);
8138 dependent_p
= false;
8141 processing_template_decl
= saved_processing_template_decl
;
8146 /* Returns true iff current_function_decl is an incompletely instantiated
8147 template. Useful instead of processing_template_decl because the latter
8148 is set to 0 during fold_non_dependent_expr. */
8151 in_template_function (void)
8153 tree fn
= current_function_decl
;
8155 ++processing_template_decl
;
8156 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8157 && DECL_TEMPLATE_INFO (fn
)
8158 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8159 --processing_template_decl
;
8163 /* Returns true if T depends on any template parameter with level LEVEL. */
8166 uses_template_parms_level (tree t
, int level
)
8168 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8169 /*include_nondeduced_p=*/true);
8172 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8173 ill-formed translation unit, i.e. a variable or function that isn't
8174 usable in a constant expression. */
8177 neglectable_inst_p (tree d
)
8180 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8181 : decl_maybe_constant_var_p (d
)));
8184 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8185 neglectable and instantiated from within an erroneous instantiation. */
8188 limit_bad_template_recursion (tree decl
)
8190 struct tinst_level
*lev
= current_tinst_level
;
8191 int errs
= errorcount
+ sorrycount
;
8192 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8195 for (; lev
; lev
= lev
->next
)
8196 if (neglectable_inst_p (lev
->decl
))
8199 return (lev
&& errs
> lev
->errors
);
8202 static int tinst_depth
;
8203 extern int max_tinst_depth
;
8206 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8208 /* We're starting to instantiate D; record the template instantiation context
8209 for diagnostics and to restore it later. */
8212 push_tinst_level (tree d
)
8214 struct tinst_level
*new_level
;
8216 if (tinst_depth
>= max_tinst_depth
)
8218 last_error_tinst_level
= current_tinst_level
;
8219 if (TREE_CODE (d
) == TREE_LIST
)
8220 error ("template instantiation depth exceeds maximum of %d (use "
8221 "-ftemplate-depth= to increase the maximum) substituting %qS",
8222 max_tinst_depth
, d
);
8224 error ("template instantiation depth exceeds maximum of %d (use "
8225 "-ftemplate-depth= to increase the maximum) instantiating %qD",
8226 max_tinst_depth
, d
);
8228 print_instantiation_context ();
8233 /* If the current instantiation caused problems, don't let it instantiate
8234 anything else. Do allow deduction substitution and decls usable in
8235 constant expressions. */
8236 if (limit_bad_template_recursion (d
))
8239 new_level
= ggc_alloc_tinst_level ();
8240 new_level
->decl
= d
;
8241 new_level
->locus
= input_location
;
8242 new_level
->errors
= errorcount
+sorrycount
;
8243 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8244 new_level
->next
= current_tinst_level
;
8245 current_tinst_level
= new_level
;
8248 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8249 depth_reached
= tinst_depth
;
8254 /* We're done instantiating this template; return to the instantiation
8258 pop_tinst_level (void)
8260 /* Restore the filename and line number stashed away when we started
8261 this instantiation. */
8262 input_location
= current_tinst_level
->locus
;
8263 current_tinst_level
= current_tinst_level
->next
;
8267 /* We're instantiating a deferred template; restore the template
8268 instantiation context in which the instantiation was requested, which
8269 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8272 reopen_tinst_level (struct tinst_level
*level
)
8274 struct tinst_level
*t
;
8277 for (t
= level
; t
; t
= t
->next
)
8280 current_tinst_level
= level
;
8282 if (current_tinst_level
)
8283 current_tinst_level
->errors
= errorcount
+sorrycount
;
8287 /* Returns the TINST_LEVEL which gives the original instantiation
8290 struct tinst_level
*
8291 outermost_tinst_level (void)
8293 struct tinst_level
*level
= current_tinst_level
;
8296 level
= level
->next
;
8300 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8301 vector of template arguments, as for tsubst.
8303 Returns an appropriate tsubst'd friend declaration. */
8306 tsubst_friend_function (tree decl
, tree args
)
8310 if (TREE_CODE (decl
) == FUNCTION_DECL
8311 && DECL_TEMPLATE_INSTANTIATION (decl
)
8312 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8313 /* This was a friend declared with an explicit template
8314 argument list, e.g.:
8318 to indicate that f was a template instantiation, not a new
8319 function declaration. Now, we have to figure out what
8320 instantiation of what template. */
8322 tree template_id
, arglist
, fns
;
8325 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8327 /* Friend functions are looked up in the containing namespace scope.
8328 We must enter that scope, to avoid finding member functions of the
8329 current class with same name. */
8330 push_nested_namespace (ns
);
8331 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8332 tf_warning_or_error
, NULL_TREE
,
8333 /*integral_constant_expression_p=*/false);
8334 pop_nested_namespace (ns
);
8335 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8336 tf_warning_or_error
, NULL_TREE
);
8337 template_id
= lookup_template_function (fns
, arglist
);
8339 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8340 tmpl
= determine_specialization (template_id
, new_friend
,
8342 /*need_member_template=*/0,
8343 TREE_VEC_LENGTH (args
),
8345 return instantiate_template (tmpl
, new_args
, tf_error
);
8348 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8350 /* The NEW_FRIEND will look like an instantiation, to the
8351 compiler, but is not an instantiation from the point of view of
8352 the language. For example, we might have had:
8354 template <class T> struct S {
8355 template <class U> friend void f(T, U);
8358 Then, in S<int>, template <class U> void f(int, U) is not an
8359 instantiation of anything. */
8360 if (new_friend
== error_mark_node
)
8361 return error_mark_node
;
8363 DECL_USE_TEMPLATE (new_friend
) = 0;
8364 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8366 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8367 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8368 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8371 /* The mangled name for the NEW_FRIEND is incorrect. The function
8372 is not a template instantiation and should not be mangled like
8373 one. Therefore, we forget the mangling here; we'll recompute it
8374 later if we need it. */
8375 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8377 SET_DECL_RTL (new_friend
, NULL
);
8378 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8381 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8384 tree new_friend_template_info
;
8385 tree new_friend_result_template_info
;
8387 int new_friend_is_defn
;
8389 /* We must save some information from NEW_FRIEND before calling
8390 duplicate decls since that function will free NEW_FRIEND if
8392 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8393 new_friend_is_defn
=
8394 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8395 (template_for_substitution (new_friend
)))
8397 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8399 /* This declaration is a `primary' template. */
8400 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8402 new_friend_result_template_info
8403 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8406 new_friend_result_template_info
= NULL_TREE
;
8408 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8409 if (new_friend_is_defn
)
8410 DECL_INITIAL (new_friend
) = error_mark_node
;
8412 /* Inside pushdecl_namespace_level, we will push into the
8413 current namespace. However, the friend function should go
8414 into the namespace of the template. */
8415 ns
= decl_namespace_context (new_friend
);
8416 push_nested_namespace (ns
);
8417 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8418 pop_nested_namespace (ns
);
8420 if (old_decl
== error_mark_node
)
8421 return error_mark_node
;
8423 if (old_decl
!= new_friend
)
8425 /* This new friend declaration matched an existing
8426 declaration. For example, given:
8428 template <class T> void f(T);
8429 template <class U> class C {
8430 template <class T> friend void f(T) {}
8433 the friend declaration actually provides the definition
8434 of `f', once C has been instantiated for some type. So,
8435 old_decl will be the out-of-class template declaration,
8436 while new_friend is the in-class definition.
8438 But, if `f' was called before this point, the
8439 instantiation of `f' will have DECL_TI_ARGS corresponding
8440 to `T' but not to `U', references to which might appear
8441 in the definition of `f'. Previously, the most general
8442 template for an instantiation of `f' was the out-of-class
8443 version; now it is the in-class version. Therefore, we
8444 run through all specialization of `f', adding to their
8445 DECL_TI_ARGS appropriately. In particular, they need a
8446 new set of outer arguments, corresponding to the
8447 arguments for this class instantiation.
8449 The same situation can arise with something like this:
8452 template <class T> class C {
8456 when `C<int>' is instantiated. Now, `f(int)' is defined
8459 if (!new_friend_is_defn
)
8460 /* On the other hand, if the in-class declaration does
8461 *not* provide a definition, then we don't want to alter
8462 existing definitions. We can just leave everything
8467 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8468 tree new_args
= TI_ARGS (new_friend_template_info
);
8470 /* Overwrite whatever template info was there before, if
8471 any, with the new template information pertaining to
8473 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8475 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8477 /* We should have called reregister_specialization in
8479 gcc_assert (retrieve_specialization (new_template
,
8483 /* Instantiate it if the global has already been used. */
8484 if (DECL_ODR_USED (old_decl
))
8485 instantiate_decl (old_decl
, /*defer_ok=*/true,
8486 /*expl_inst_class_mem_p=*/false);
8492 /* Indicate that the old function template is a partial
8494 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8495 = new_friend_result_template_info
;
8497 gcc_assert (new_template
8498 == most_general_template (new_template
));
8499 gcc_assert (new_template
!= old_decl
);
8501 /* Reassign any specializations already in the hash table
8502 to the new more general template, and add the
8503 additional template args. */
8504 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8508 tree spec
= TREE_VALUE (t
);
8511 elt
.tmpl
= old_decl
;
8512 elt
.args
= DECL_TI_ARGS (spec
);
8513 elt
.spec
= NULL_TREE
;
8515 htab_remove_elt (decl_specializations
, &elt
);
8518 = add_outermost_template_args (new_args
,
8519 DECL_TI_ARGS (spec
));
8521 register_specialization
8522 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8525 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8529 /* The information from NEW_FRIEND has been merged into OLD_DECL
8530 by duplicate_decls. */
8531 new_friend
= old_decl
;
8536 tree context
= DECL_CONTEXT (new_friend
);
8540 template <class T> class C {
8541 template <class U> friend void C1<U>::f (); // case 1
8542 friend void C2<T>::f (); // case 2
8544 we only need to make sure CONTEXT is a complete type for
8545 case 2. To distinguish between the two cases, we note that
8546 CONTEXT of case 1 remains dependent type after tsubst while
8547 this isn't true for case 2. */
8548 ++processing_template_decl
;
8549 dependent_p
= dependent_type_p (context
);
8550 --processing_template_decl
;
8553 && !complete_type_or_else (context
, NULL_TREE
))
8554 return error_mark_node
;
8556 if (COMPLETE_TYPE_P (context
))
8558 tree fn
= new_friend
;
8559 /* do_friend adds the TEMPLATE_DECL for any member friend
8560 template even if it isn't a member template, i.e.
8561 template <class T> friend A<T>::f();
8562 Look through it in that case. */
8563 if (TREE_CODE (fn
) == TEMPLATE_DECL
8564 && !PRIMARY_TEMPLATE_P (fn
))
8565 fn
= DECL_TEMPLATE_RESULT (fn
);
8566 /* Check to see that the declaration is really present, and,
8567 possibly obtain an improved declaration. */
8568 fn
= check_classfn (context
, fn
, NULL_TREE
);
8578 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8579 template arguments, as for tsubst.
8581 Returns an appropriate tsubst'd friend type or error_mark_node on
8585 tsubst_friend_class (tree friend_tmpl
, tree args
)
8591 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8593 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8594 return TREE_TYPE (t
);
8597 context
= CP_DECL_CONTEXT (friend_tmpl
);
8599 if (context
!= global_namespace
)
8601 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8602 push_nested_namespace (context
);
8604 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8607 /* Look for a class template declaration. We look for hidden names
8608 because two friend declarations of the same template are the
8609 same. For example, in:
8612 template <typename> friend class F;
8614 template <typename> struct B {
8615 template <typename> friend class F;
8618 both F templates are the same. */
8619 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8620 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8622 /* But, if we don't find one, it might be because we're in a
8623 situation like this:
8631 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8632 for `S<int>', not the TEMPLATE_DECL. */
8633 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8635 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8636 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8639 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8641 /* The friend template has already been declared. Just
8642 check to see that the declarations match, and install any new
8643 default parameters. We must tsubst the default parameters,
8644 of course. We only need the innermost template parameters
8645 because that is all that redeclare_class_template will look
8647 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8648 > TMPL_ARGS_DEPTH (args
))
8651 location_t saved_input_location
;
8652 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8653 args
, tf_warning_or_error
);
8655 saved_input_location
= input_location
;
8656 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8657 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8658 input_location
= saved_input_location
;
8662 friend_type
= TREE_TYPE (tmpl
);
8666 /* The friend template has not already been declared. In this
8667 case, the instantiation of the template class will cause the
8668 injection of this template into the global scope. */
8669 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8670 if (tmpl
== error_mark_node
)
8671 return error_mark_node
;
8673 /* The new TMPL is not an instantiation of anything, so we
8674 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8675 the new type because that is supposed to be the corresponding
8676 template decl, i.e., TMPL. */
8677 DECL_USE_TEMPLATE (tmpl
) = 0;
8678 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8679 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8680 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8681 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8683 /* Inject this template into the global scope. */
8684 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8687 if (context
!= global_namespace
)
8689 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8690 pop_nested_namespace (context
);
8692 pop_nested_class ();
8698 /* Returns zero if TYPE cannot be completed later due to circularity.
8699 Otherwise returns one. */
8702 can_complete_type_without_circularity (tree type
)
8704 if (type
== NULL_TREE
|| type
== error_mark_node
)
8706 else if (COMPLETE_TYPE_P (type
))
8708 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8709 return can_complete_type_without_circularity (TREE_TYPE (type
));
8710 else if (CLASS_TYPE_P (type
)
8711 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
8717 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
8719 /* Apply any attributes which had to be deferred until instantiation
8720 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8721 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8724 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
8725 tree args
, tsubst_flags_t complain
, tree in_decl
)
8727 tree last_dep
= NULL_TREE
;
8731 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
8732 if (ATTR_IS_DEPENDENT (t
))
8735 attributes
= copy_list (attributes
);
8739 if (DECL_P (*decl_p
))
8741 if (TREE_TYPE (*decl_p
) == error_mark_node
)
8743 p
= &DECL_ATTRIBUTES (*decl_p
);
8746 p
= &TYPE_ATTRIBUTES (*decl_p
);
8750 tree late_attrs
= NULL_TREE
;
8751 tree
*q
= &late_attrs
;
8753 for (*p
= attributes
; *p
; )
8756 if (ATTR_IS_DEPENDENT (t
))
8758 *p
= TREE_CHAIN (t
);
8759 TREE_CHAIN (t
) = NULL_TREE
;
8760 if ((flag_openmp
|| flag_cilkplus
)
8761 && is_attribute_p ("omp declare simd",
8762 get_attribute_name (t
))
8765 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
8766 clauses
= tsubst_omp_clauses (clauses
, true, args
,
8768 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
8769 clauses
= finish_omp_clauses (clauses
);
8770 tree parms
= DECL_ARGUMENTS (*decl_p
);
8772 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
8774 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
8776 TREE_VALUE (t
) = NULL_TREE
;
8778 /* If the first attribute argument is an identifier, don't
8779 pass it through tsubst. Attributes like mode, format,
8780 cleanup and several target specific attributes expect it
8782 else if (attribute_takes_identifier_p (get_attribute_name (t
))
8786 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
8788 /*integral_constant_expression_p=*/false);
8789 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
8791 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
8796 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
8797 /*integral_constant_expression_p=*/false);
8799 q
= &TREE_CHAIN (t
);
8802 p
= &TREE_CHAIN (t
);
8805 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
8809 /* Perform (or defer) access check for typedefs that were referenced
8810 from within the template TMPL code.
8811 This is a subroutine of instantiate_decl and instantiate_class_template.
8812 TMPL is the template to consider and TARGS is the list of arguments of
8816 perform_typedefs_access_check (tree tmpl
, tree targs
)
8818 location_t saved_location
;
8820 qualified_typedef_usage_t
*iter
;
8823 || (!CLASS_TYPE_P (tmpl
)
8824 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
8827 saved_location
= input_location
;
8828 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
8830 tree type_decl
= iter
->typedef_decl
;
8831 tree type_scope
= iter
->context
;
8833 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
8836 if (uses_template_parms (type_decl
))
8837 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
8838 if (uses_template_parms (type_scope
))
8839 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
8841 /* Make access check error messages point to the location
8842 of the use of the typedef. */
8843 input_location
= iter
->locus
;
8844 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
8845 type_decl
, type_decl
,
8846 tf_warning_or_error
);
8848 input_location
= saved_location
;
8852 instantiate_class_template_1 (tree type
)
8854 tree templ
, args
, pattern
, t
, member
;
8858 unsigned int saved_maximum_field_alignment
;
8861 if (type
== error_mark_node
)
8862 return error_mark_node
;
8864 if (COMPLETE_OR_OPEN_TYPE_P (type
)
8865 || uses_template_parms (type
))
8868 /* Figure out which template is being instantiated. */
8869 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
8870 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
8872 /* Determine what specialization of the original template to
8874 t
= most_specialized_class (type
, tf_warning_or_error
);
8875 if (t
== error_mark_node
)
8877 TYPE_BEING_DEFINED (type
) = 1;
8878 return error_mark_node
;
8882 /* This TYPE is actually an instantiation of a partial
8883 specialization. We replace the innermost set of ARGS with
8884 the arguments appropriate for substitution. For example,
8887 template <class T> struct S {};
8888 template <class T> struct S<T*> {};
8890 and supposing that we are instantiating S<int*>, ARGS will
8891 presently be {int*} -- but we need {int}. */
8892 pattern
= TREE_TYPE (t
);
8893 args
= TREE_PURPOSE (t
);
8897 pattern
= TREE_TYPE (templ
);
8898 args
= CLASSTYPE_TI_ARGS (type
);
8901 /* If the template we're instantiating is incomplete, then clearly
8902 there's nothing we can do. */
8903 if (!COMPLETE_TYPE_P (pattern
))
8906 /* If we've recursively instantiated too many templates, stop. */
8907 if (! push_tinst_level (type
))
8910 /* Now we're really doing the instantiation. Mark the type as in
8911 the process of being defined. */
8912 TYPE_BEING_DEFINED (type
) = 1;
8914 /* We may be in the middle of deferred access check. Disable
8916 push_deferring_access_checks (dk_no_deferred
);
8918 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
8920 push_to_top_level ();
8921 /* Use #pragma pack from the template context. */
8922 saved_maximum_field_alignment
= maximum_field_alignment
;
8923 maximum_field_alignment
= TYPE_PRECISION (pattern
);
8925 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
8927 /* Set the input location to the most specialized template definition.
8928 This is needed if tsubsting causes an error. */
8929 typedecl
= TYPE_MAIN_DECL (pattern
);
8930 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
8931 DECL_SOURCE_LOCATION (typedecl
);
8933 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
8934 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
8935 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
8936 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
8937 if (ANON_AGGR_TYPE_P (pattern
))
8938 SET_ANON_AGGR_TYPE_P (type
);
8939 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
8941 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
8942 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
8943 /* Adjust visibility for template arguments. */
8944 determine_visibility (TYPE_MAIN_DECL (type
));
8946 if (CLASS_TYPE_P (type
))
8947 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
8949 pbinfo
= TYPE_BINFO (pattern
);
8951 /* We should never instantiate a nested class before its enclosing
8952 class; we need to look up the nested class by name before we can
8953 instantiate it, and that lookup should instantiate the enclosing
8955 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
8956 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
8958 base_list
= NULL_TREE
;
8959 if (BINFO_N_BASE_BINFOS (pbinfo
))
8965 /* We must enter the scope containing the type, as that is where
8966 the accessibility of types named in dependent bases are
8968 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
8970 /* Substitute into each of the bases to determine the actual
8972 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
8975 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
8976 tree expanded_bases
= NULL_TREE
;
8979 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
8982 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
8983 args
, tf_error
, NULL_TREE
);
8984 if (expanded_bases
== error_mark_node
)
8987 len
= TREE_VEC_LENGTH (expanded_bases
);
8990 for (idx
= 0; idx
< len
; idx
++)
8993 /* Extract the already-expanded base class. */
8994 base
= TREE_VEC_ELT (expanded_bases
, idx
);
8996 /* Substitute to figure out the base class. */
8997 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9000 if (base
== error_mark_node
)
9003 base_list
= tree_cons (access
, base
, base_list
);
9004 if (BINFO_VIRTUAL_P (pbase_binfo
))
9005 TREE_TYPE (base_list
) = integer_type_node
;
9009 /* The list is now in reverse order; correct that. */
9010 base_list
= nreverse (base_list
);
9013 pop_scope (pushed_scope
);
9015 /* Now call xref_basetypes to set up all the base-class
9017 xref_basetypes (type
, base_list
);
9019 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9020 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9021 args
, tf_error
, NULL_TREE
);
9022 fixup_attribute_variants (type
);
9024 /* Now that our base classes are set up, enter the scope of the
9025 class, so that name lookups into base classes, etc. will work
9026 correctly. This is precisely analogous to what we do in
9027 begin_class_definition when defining an ordinary non-template
9028 class, except we also need to push the enclosing classes. */
9029 push_nested_class (type
);
9031 /* Now members are processed in the order of declaration. */
9032 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9033 member
; member
= TREE_CHAIN (member
))
9035 tree t
= TREE_VALUE (member
);
9037 if (TREE_PURPOSE (member
))
9041 /* Build new CLASSTYPE_NESTED_UTDS. */
9044 bool class_template_p
;
9046 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9047 && TYPE_LANG_SPECIFIC (t
)
9048 && CLASSTYPE_IS_TEMPLATE (t
));
9049 /* If the member is a class template, then -- even after
9050 substitution -- there may be dependent types in the
9051 template argument list for the class. We increment
9052 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9053 that function will assume that no types are dependent
9054 when outside of a template. */
9055 if (class_template_p
)
9056 ++processing_template_decl
;
9057 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9058 if (class_template_p
)
9059 --processing_template_decl
;
9060 if (newtag
== error_mark_node
)
9063 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9065 tree name
= TYPE_IDENTIFIER (t
);
9067 if (class_template_p
)
9068 /* Unfortunately, lookup_template_class sets
9069 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9070 instantiation (i.e., for the type of a member
9071 template class nested within a template class.)
9072 This behavior is required for
9073 maybe_process_partial_specialization to work
9074 correctly, but is not accurate in this case;
9075 the TAG is not an instantiation of anything.
9076 (The corresponding TEMPLATE_DECL is an
9077 instantiation, but the TYPE is not.) */
9078 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9080 /* Now, we call pushtag to put this NEWTAG into the scope of
9081 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9082 pushtag calling push_template_decl. We don't have to do
9083 this for enums because it will already have been done in
9086 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9087 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9090 else if (DECL_DECLARES_FUNCTION_P (t
))
9092 /* Build new TYPE_METHODS. */
9095 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9096 ++processing_template_decl
;
9097 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9098 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9099 --processing_template_decl
;
9100 set_current_access_from_decl (r
);
9101 finish_member_declaration (r
);
9102 /* Instantiate members marked with attribute used. */
9103 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9105 if (TREE_CODE (r
) == FUNCTION_DECL
9106 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9107 cp_check_omp_declare_reduction (r
);
9111 /* Build new TYPE_FIELDS. */
9112 if (TREE_CODE (t
) == STATIC_ASSERT
)
9116 ++c_inhibit_evaluation_warnings
;
9118 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9119 tf_warning_or_error
, NULL_TREE
,
9120 /*integral_constant_expression_p=*/true);
9121 --c_inhibit_evaluation_warnings
;
9123 finish_static_assert (condition
,
9124 STATIC_ASSERT_MESSAGE (t
),
9125 STATIC_ASSERT_SOURCE_LOCATION (t
),
9128 else if (TREE_CODE (t
) != CONST_DECL
)
9131 tree vec
= NULL_TREE
;
9134 /* The file and line for this declaration, to
9135 assist in error message reporting. Since we
9136 called push_tinst_level above, we don't need to
9138 input_location
= DECL_SOURCE_LOCATION (t
);
9140 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9141 ++processing_template_decl
;
9142 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9143 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9144 --processing_template_decl
;
9146 if (TREE_CODE (r
) == TREE_VEC
)
9148 /* A capture pack became multiple fields. */
9150 len
= TREE_VEC_LENGTH (vec
);
9153 for (int i
= 0; i
< len
; ++i
)
9156 r
= TREE_VEC_ELT (vec
, i
);
9161 [t]he initialization (and any associated
9162 side-effects) of a static data member does
9163 not occur unless the static data member is
9164 itself used in a way that requires the
9165 definition of the static data member to
9168 Therefore, we do not substitute into the
9169 initialized for the static data member here. */
9170 finish_static_data_member_decl
9173 /*init_const_expr_p=*/false,
9174 /*asmspec_tree=*/NULL_TREE
,
9176 /* Instantiate members marked with attribute used. */
9177 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9180 else if (TREE_CODE (r
) == FIELD_DECL
)
9182 /* Determine whether R has a valid type and can be
9183 completed later. If R is invalid, then its type
9184 is replaced by error_mark_node. */
9185 tree rtype
= TREE_TYPE (r
);
9186 if (can_complete_type_without_circularity (rtype
))
9187 complete_type (rtype
);
9189 if (!COMPLETE_TYPE_P (rtype
))
9191 cxx_incomplete_type_error (r
, rtype
);
9192 TREE_TYPE (r
) = error_mark_node
;
9196 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9197 such a thing will already have been added to the field
9198 list by tsubst_enum in finish_member_declaration in the
9199 CLASSTYPE_NESTED_UTDS case above. */
9200 if (!(TREE_CODE (r
) == TYPE_DECL
9201 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9202 && DECL_ARTIFICIAL (r
)))
9204 set_current_access_from_decl (r
);
9205 finish_member_declaration (r
);
9213 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9214 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9216 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9218 tree friend_type
= t
;
9219 bool adjust_processing_template_decl
= false;
9221 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9223 /* template <class T> friend class C; */
9224 friend_type
= tsubst_friend_class (friend_type
, args
);
9225 adjust_processing_template_decl
= true;
9227 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9229 /* template <class T> friend class C::D; */
9230 friend_type
= tsubst (friend_type
, args
,
9231 tf_warning_or_error
, NULL_TREE
);
9232 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9233 friend_type
= TREE_TYPE (friend_type
);
9234 adjust_processing_template_decl
= true;
9236 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9237 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9239 /* This could be either
9243 when dependent_type_p is false or
9245 template <class U> friend class T::C;
9248 friend_type
= tsubst (friend_type
, args
,
9249 tf_warning_or_error
, NULL_TREE
);
9250 /* Bump processing_template_decl for correct
9251 dependent_type_p calculation. */
9252 ++processing_template_decl
;
9253 if (dependent_type_p (friend_type
))
9254 adjust_processing_template_decl
= true;
9255 --processing_template_decl
;
9257 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9258 && hidden_name_p (TYPE_NAME (friend_type
)))
9262 where C hasn't been declared yet. Let's lookup name
9263 from namespace scope directly, bypassing any name that
9264 come from dependent base class. */
9265 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9267 /* The call to xref_tag_from_type does injection for friend
9269 push_nested_namespace (ns
);
9271 xref_tag_from_type (friend_type
, NULL_TREE
,
9272 /*tag_scope=*/ts_current
);
9273 pop_nested_namespace (ns
);
9275 else if (uses_template_parms (friend_type
))
9276 /* friend class C<T>; */
9277 friend_type
= tsubst (friend_type
, args
,
9278 tf_warning_or_error
, NULL_TREE
);
9283 where C is already declared or
9285 friend class C<int>;
9287 We don't have to do anything in these cases. */
9289 if (adjust_processing_template_decl
)
9290 /* Trick make_friend_class into realizing that the friend
9291 we're adding is a template, not an ordinary class. It's
9292 important that we use make_friend_class since it will
9293 perform some error-checking and output cross-reference
9295 ++processing_template_decl
;
9297 if (friend_type
!= error_mark_node
)
9298 make_friend_class (type
, friend_type
, /*complain=*/false);
9300 if (adjust_processing_template_decl
)
9301 --processing_template_decl
;
9305 /* Build new DECL_FRIENDLIST. */
9308 /* The file and line for this declaration, to
9309 assist in error message reporting. Since we
9310 called push_tinst_level above, we don't need to
9312 input_location
= DECL_SOURCE_LOCATION (t
);
9314 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9316 ++processing_template_decl
;
9317 push_deferring_access_checks (dk_no_check
);
9320 r
= tsubst_friend_function (t
, args
);
9321 add_friend (type
, r
, /*complain=*/false);
9322 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9324 pop_deferring_access_checks ();
9325 --processing_template_decl
;
9331 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9333 tree decl
= lambda_function (type
);
9336 if (!DECL_TEMPLATE_INFO (decl
)
9337 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9338 instantiate_decl (decl
, false, false);
9340 /* We need to instantiate the capture list from the template
9341 after we've instantiated the closure members, but before we
9342 consider adding the conversion op. Also keep any captures
9343 that may have been added during instantiation of the op(). */
9344 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9346 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9347 args
, tf_warning_or_error
, NULL_TREE
,
9350 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9351 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9353 maybe_add_lambda_conv_op (type
);
9356 gcc_assert (errorcount
);
9359 /* Set the file and line number information to whatever is given for
9360 the class itself. This puts error messages involving generated
9361 implicit functions at a predictable point, and the same point
9362 that would be used for non-template classes. */
9363 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9365 unreverse_member_declarations (type
);
9366 finish_struct_1 (type
);
9367 TYPE_BEING_DEFINED (type
) = 0;
9369 /* We don't instantiate default arguments for member functions. 14.7.1:
9371 The implicit instantiation of a class template specialization causes
9372 the implicit instantiation of the declarations, but not of the
9373 definitions or default arguments, of the class member functions,
9374 member classes, static data members and member templates.... */
9376 /* Some typedefs referenced from within the template code need to be access
9377 checked at template instantiation time, i.e now. These types were
9378 added to the template at parsing time. Let's get those and perform
9379 the access checks then. */
9380 perform_typedefs_access_check (pattern
, args
);
9381 perform_deferred_access_checks (tf_warning_or_error
);
9382 pop_nested_class ();
9383 maximum_field_alignment
= saved_maximum_field_alignment
;
9385 pop_from_top_level ();
9386 pop_deferring_access_checks ();
9389 /* The vtable for a template class can be emitted in any translation
9390 unit in which the class is instantiated. When there is no key
9391 method, however, finish_struct_1 will already have added TYPE to
9392 the keyed_classes list. */
9393 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9394 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9399 /* Wrapper for instantiate_class_template_1. */
9402 instantiate_class_template (tree type
)
9405 timevar_push (TV_TEMPLATE_INST
);
9406 ret
= instantiate_class_template_1 (type
);
9407 timevar_pop (TV_TEMPLATE_INST
);
9412 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9418 else if (TYPE_P (t
))
9419 r
= tsubst (t
, args
, complain
, in_decl
);
9422 if (!(complain
& tf_warning
))
9423 ++c_inhibit_evaluation_warnings
;
9424 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9425 /*integral_constant_expression_p=*/true);
9426 if (!(complain
& tf_warning
))
9427 --c_inhibit_evaluation_warnings
;
9432 /* Given a function parameter pack TMPL_PARM and some function parameters
9433 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9434 and set *SPEC_P to point at the next point in the list. */
9437 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9439 /* Collect all of the extra "packed" parameters into an
9443 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9444 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9445 tree spec_parm
= *spec_p
;
9448 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9450 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9453 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9454 parmvec
= make_tree_vec (len
);
9455 parmtypevec
= make_tree_vec (len
);
9456 spec_parm
= *spec_p
;
9457 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9459 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9460 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9463 /* Build the argument packs. */
9464 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9465 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9466 TREE_TYPE (argpack
) = argtypepack
;
9467 *spec_p
= spec_parm
;
9472 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9473 NONTYPE_ARGUMENT_PACK. */
9476 make_fnparm_pack (tree spec_parm
)
9478 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9481 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9485 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9487 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9488 if (i
>= TREE_VEC_LENGTH (vec
))
9490 return PACK_EXPANSION_P (TREE_VEC_ELT (vec
, i
));
9494 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9497 make_argument_pack_select (tree arg_pack
, unsigned index
)
9499 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9501 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9502 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9507 /* This is a subroutine of tsubst_pack_expansion.
9509 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9510 mechanism to store the (non complete list of) arguments of the
9511 substitution and return a non substituted pack expansion, in order
9512 to wait for when we have enough arguments to really perform the
9516 use_pack_expansion_extra_args_p (tree parm_packs
,
9520 /* If one pack has an expansion and another pack has a normal
9521 argument or if one pack has an empty argument and an another
9522 one hasn't then tsubst_pack_expansion cannot perform the
9523 substitution and need to fall back on the
9524 PACK_EXPANSION_EXTRA mechanism. */
9525 if (parm_packs
== NULL_TREE
)
9527 else if (has_empty_arg
)
9530 bool has_expansion_arg
= false;
9531 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9533 bool has_non_expansion_arg
= false;
9534 for (tree parm_pack
= parm_packs
;
9536 parm_pack
= TREE_CHAIN (parm_pack
))
9538 tree arg
= TREE_VALUE (parm_pack
);
9540 if (argument_pack_element_is_expansion_p (arg
, i
))
9541 has_expansion_arg
= true;
9543 has_non_expansion_arg
= true;
9546 if (has_expansion_arg
&& has_non_expansion_arg
)
9552 /* [temp.variadic]/6 says that:
9554 The instantiation of a pack expansion [...]
9555 produces a list E1,E2, ..., En, where N is the number of elements
9556 in the pack expansion parameters.
9558 This subroutine of tsubst_pack_expansion produces one of these Ei.
9560 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9561 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9562 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9563 INDEX is the index 'i' of the element Ei to produce. ARGS,
9564 COMPLAIN, and IN_DECL are the same parameters as for the
9565 tsubst_pack_expansion function.
9567 The function returns the resulting Ei upon successful completion,
9570 Note that this function possibly modifies the ARGS parameter, so
9571 it's the responsibility of the caller to restore it. */
9574 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9577 tree args
/* This parm gets
9579 tsubst_flags_t complain
,
9583 bool ith_elem_is_expansion
= false;
9585 /* For each parameter pack, change the substitution of the parameter
9586 pack to the ith argument in its argument pack, then expand the
9588 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9590 tree parm
= TREE_PURPOSE (pack
);
9591 tree arg_pack
= TREE_VALUE (pack
);
9592 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9594 ith_elem_is_expansion
|=
9595 argument_pack_element_is_expansion_p (arg_pack
, index
);
9597 /* Select the Ith argument from the pack. */
9598 if (TREE_CODE (parm
) == PARM_DECL
9599 || TREE_CODE (parm
) == FIELD_DECL
)
9603 aps
= make_argument_pack_select (arg_pack
, index
);
9605 register_local_specialization (aps
, parm
);
9608 aps
= retrieve_local_specialization (parm
);
9613 template_parm_level_and_index (parm
, &level
, &idx
);
9617 aps
= make_argument_pack_select (arg_pack
, index
);
9618 /* Update the corresponding argument. */
9619 TMPL_ARG (args
, level
, idx
) = aps
;
9622 /* Re-use the ARGUMENT_PACK_SELECT. */
9623 aps
= TMPL_ARG (args
, level
, idx
);
9625 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9628 /* Substitute into the PATTERN with the (possibly altered)
9630 if (pattern
== in_decl
)
9631 /* Expanding a fixed parameter pack from
9632 coerce_template_parameter_pack. */
9633 t
= tsubst_decl (pattern
, args
, complain
);
9634 else if (!TYPE_P (pattern
))
9635 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9636 /*integral_constant_expression_p=*/false);
9638 t
= tsubst (pattern
, args
, complain
, in_decl
);
9640 /* If the Ith argument pack element is a pack expansion, then
9641 the Ith element resulting from the substituting is going to
9642 be a pack expansion as well. */
9643 if (ith_elem_is_expansion
)
9644 t
= make_pack_expansion (t
);
9649 /* Substitute ARGS into T, which is an pack expansion
9650 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9651 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9652 (if only a partial substitution could be performed) or
9653 ERROR_MARK_NODE if there was an error. */
9655 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9659 tree pack
, packs
= NULL_TREE
;
9660 bool unsubstituted_packs
= false;
9663 struct pointer_map_t
*saved_local_specializations
= NULL
;
9664 bool need_local_specializations
= false;
9667 gcc_assert (PACK_EXPANSION_P (t
));
9668 pattern
= PACK_EXPANSION_PATTERN (t
);
9670 /* Add in any args remembered from an earlier partial instantiation. */
9671 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9673 levels
= TMPL_ARGS_DEPTH (args
);
9675 /* Determine the argument packs that will instantiate the parameter
9676 packs used in the expansion expression. While we're at it,
9677 compute the number of arguments to be expanded and make sure it
9679 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
9680 pack
= TREE_CHAIN (pack
))
9682 tree parm_pack
= TREE_VALUE (pack
);
9683 tree arg_pack
= NULL_TREE
;
9684 tree orig_arg
= NULL_TREE
;
9687 if (TREE_CODE (parm_pack
) == BASES
)
9689 if (BASES_DIRECT (parm_pack
))
9690 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9691 args
, complain
, in_decl
, false));
9693 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9694 args
, complain
, in_decl
, false));
9696 if (TREE_CODE (parm_pack
) == PARM_DECL
)
9698 if (PACK_EXPANSION_LOCAL_P (t
))
9699 arg_pack
= retrieve_local_specialization (parm_pack
);
9702 /* We can't rely on local_specializations for a parameter
9703 name used later in a function declaration (such as in a
9704 late-specified return type). Even if it exists, it might
9705 have the wrong value for a recursive call. Just make a
9706 dummy decl, since it's only used for its type. */
9707 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
9708 if (arg_pack
&& DECL_PACK_P (arg_pack
))
9709 /* Partial instantiation of the parm_pack, we can't build
9710 up an argument pack yet. */
9711 arg_pack
= NULL_TREE
;
9713 arg_pack
= make_fnparm_pack (arg_pack
);
9714 need_local_specializations
= true;
9717 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
9718 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
9722 template_parm_level_and_index (parm_pack
, &level
, &idx
);
9724 if (level
<= levels
)
9725 arg_pack
= TMPL_ARG (args
, level
, idx
);
9728 orig_arg
= arg_pack
;
9729 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
9730 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
9732 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
9733 /* This can only happen if we forget to expand an argument
9734 pack somewhere else. Just return an error, silently. */
9736 result
= make_tree_vec (1);
9737 TREE_VEC_ELT (result
, 0) = error_mark_node
;
9744 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
9746 /* Don't bother trying to do a partial substitution with
9747 incomplete packs; we'll try again after deduction. */
9748 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
9753 else if (len
!= my_len
)
9755 if (!(complain
& tf_error
))
9756 /* Fail quietly. */;
9757 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
9758 error ("mismatched argument pack lengths while expanding "
9762 error ("mismatched argument pack lengths while expanding "
9765 return error_mark_node
;
9768 /* Keep track of the parameter packs and their corresponding
9770 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
9771 TREE_TYPE (packs
) = orig_arg
;
9775 /* We can't substitute for this parameter pack. We use a flag as
9776 well as the missing_level counter because function parameter
9777 packs don't have a level. */
9778 unsubstituted_packs
= true;
9782 /* We cannot expand this expansion expression, because we don't have
9783 all of the argument packs we need. */
9784 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
9786 /* We got some full packs, but we can't substitute them in until we
9787 have values for all the packs. So remember these until then. */
9789 t
= make_pack_expansion (pattern
);
9790 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
9793 else if (unsubstituted_packs
)
9795 /* There were no real arguments, we're just replacing a parameter
9796 pack with another version of itself. Substitute into the
9797 pattern and return a PACK_EXPANSION_*. The caller will need to
9799 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
9800 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9801 /*integral_constant_expression_p=*/false);
9803 t
= tsubst (pattern
, args
, complain
, in_decl
);
9804 t
= make_pack_expansion (t
);
9808 gcc_assert (len
>= 0);
9810 if (need_local_specializations
)
9812 /* We're in a late-specified return type, so create our own local
9813 specializations map; the current map is either NULL or (in the
9814 case of recursive unification) might have bindings that we don't
9815 want to use or alter. */
9816 saved_local_specializations
= local_specializations
;
9817 local_specializations
= pointer_map_create ();
9820 /* For each argument in each argument pack, substitute into the
9822 result
= make_tree_vec (len
);
9823 for (i
= 0; i
< len
; ++i
)
9825 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
9829 TREE_VEC_ELT (result
, i
) = t
;
9830 if (t
== error_mark_node
)
9832 result
= error_mark_node
;
9837 /* Update ARGS to restore the substitution from parameter packs to
9838 their argument packs. */
9839 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
9841 tree parm
= TREE_PURPOSE (pack
);
9843 if (TREE_CODE (parm
) == PARM_DECL
9844 || TREE_CODE (parm
) == FIELD_DECL
)
9845 register_local_specialization (TREE_TYPE (pack
), parm
);
9850 if (TREE_VALUE (pack
) == NULL_TREE
)
9853 template_parm_level_and_index (parm
, &level
, &idx
);
9855 /* Update the corresponding argument. */
9856 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
9857 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
9860 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
9864 if (need_local_specializations
)
9866 pointer_map_destroy (local_specializations
);
9867 local_specializations
= saved_local_specializations
;
9873 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
9874 TMPL. We do this using DECL_PARM_INDEX, which should work even with
9875 parameter packs; all parms generated from a function parameter pack will
9876 have the same DECL_PARM_INDEX. */
9879 get_pattern_parm (tree parm
, tree tmpl
)
9881 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
9884 if (DECL_ARTIFICIAL (parm
))
9886 for (patparm
= DECL_ARGUMENTS (pattern
);
9887 patparm
; patparm
= DECL_CHAIN (patparm
))
9888 if (DECL_ARTIFICIAL (patparm
)
9889 && DECL_NAME (parm
) == DECL_NAME (patparm
))
9894 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
9895 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
9896 gcc_assert (DECL_PARM_INDEX (patparm
)
9897 == DECL_PARM_INDEX (parm
));
9903 /* Substitute ARGS into the vector or list of template arguments T. */
9906 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9909 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
9912 if (t
== error_mark_node
)
9913 return error_mark_node
;
9915 len
= TREE_VEC_LENGTH (t
);
9916 elts
= XALLOCAVEC (tree
, len
);
9918 for (i
= 0; i
< len
; i
++)
9920 tree orig_arg
= TREE_VEC_ELT (t
, i
);
9923 if (TREE_CODE (orig_arg
) == TREE_VEC
)
9924 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
9925 else if (PACK_EXPANSION_P (orig_arg
))
9927 /* Substitute into an expansion expression. */
9928 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
9930 if (TREE_CODE (new_arg
) == TREE_VEC
)
9931 /* Add to the expanded length adjustment the number of
9932 expanded arguments. We subtract one from this
9933 measurement, because the argument pack expression
9934 itself is already counted as 1 in
9935 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
9936 the argument pack is empty. */
9937 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
9939 else if (ARGUMENT_PACK_P (orig_arg
))
9941 /* Substitute into each of the arguments. */
9942 new_arg
= TYPE_P (orig_arg
)
9943 ? cxx_make_type (TREE_CODE (orig_arg
))
9944 : make_node (TREE_CODE (orig_arg
));
9946 SET_ARGUMENT_PACK_ARGS (
9948 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
9949 args
, complain
, in_decl
));
9951 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
9952 new_arg
= error_mark_node
;
9954 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
9955 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
9957 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
9959 if (TREE_TYPE (new_arg
) == error_mark_node
)
9960 new_arg
= error_mark_node
;
9964 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
9966 if (new_arg
== error_mark_node
)
9967 return error_mark_node
;
9970 if (new_arg
!= orig_arg
)
9977 /* Make space for the expanded arguments coming from template
9979 t
= make_tree_vec (len
+ expanded_len_adjust
);
9980 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
9981 arguments for a member template.
9982 In that case each TREE_VEC in ORIG_T represents a level of template
9983 arguments, and ORIG_T won't carry any non defaulted argument count.
9984 It will rather be the nested TREE_VECs that will carry one.
9985 In other words, ORIG_T carries a non defaulted argument count only
9986 if it doesn't contain any nested TREE_VEC. */
9987 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
9989 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
9990 count
+= expanded_len_adjust
;
9991 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
9993 for (i
= 0, out
= 0; i
< len
; i
++)
9995 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
9996 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
9997 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10001 /* Now expand the template argument pack "in place". */
10002 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10003 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10007 TREE_VEC_ELT (t
, out
) = elts
[i
];
10015 /* Return the result of substituting ARGS into the template parameters
10016 given by PARMS. If there are m levels of ARGS and m + n levels of
10017 PARMS, then the result will contain n levels of PARMS. For
10018 example, if PARMS is `template <class T> template <class U>
10019 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10020 result will be `template <int*, double, class V>'. */
10023 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10025 tree r
= NULL_TREE
;
10028 /* When substituting into a template, we must set
10029 PROCESSING_TEMPLATE_DECL as the template parameters may be
10030 dependent if they are based on one-another, and the dependency
10031 predicates are short-circuit outside of templates. */
10032 ++processing_template_decl
;
10034 for (new_parms
= &r
;
10035 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10036 new_parms
= &(TREE_CHAIN (*new_parms
)),
10037 parms
= TREE_CHAIN (parms
))
10040 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10043 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10047 if (parms
== error_mark_node
)
10050 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10052 if (tuple
== error_mark_node
)
10055 TREE_VEC_ELT (new_vec
, i
) =
10056 tsubst_template_parm (tuple
, args
, complain
);
10060 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10061 - TMPL_ARGS_DEPTH (args
)),
10062 new_vec
, NULL_TREE
);
10065 --processing_template_decl
;
10070 /* Return the result of substituting ARGS into one template parameter
10071 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10072 parameter and which TREE_PURPOSE is the default argument of the
10073 template parameter. */
10076 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10078 tree default_value
, parm_decl
;
10080 if (args
== NULL_TREE
10082 || t
== error_mark_node
)
10085 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10087 default_value
= TREE_PURPOSE (t
);
10088 parm_decl
= TREE_VALUE (t
);
10090 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10091 if (TREE_CODE (parm_decl
) == PARM_DECL
10092 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10093 parm_decl
= error_mark_node
;
10094 default_value
= tsubst_template_arg (default_value
, args
,
10095 complain
, NULL_TREE
);
10097 return build_tree_list (default_value
, parm_decl
);
10100 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10101 type T. If T is not an aggregate or enumeration type, it is
10102 handled as if by tsubst. IN_DECL is as for tsubst. If
10103 ENTERING_SCOPE is nonzero, T is the context for a template which
10104 we are presently tsubst'ing. Return the substituted value. */
10107 tsubst_aggr_type (tree t
,
10109 tsubst_flags_t complain
,
10111 int entering_scope
)
10113 if (t
== NULL_TREE
)
10116 switch (TREE_CODE (t
))
10119 if (TYPE_PTRMEMFUNC_P (t
))
10120 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10122 /* Else fall through. */
10123 case ENUMERAL_TYPE
:
10125 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10130 int saved_unevaluated_operand
;
10131 int saved_inhibit_evaluation_warnings
;
10133 /* In "sizeof(X<I>)" we need to evaluate "I". */
10134 saved_unevaluated_operand
= cp_unevaluated_operand
;
10135 cp_unevaluated_operand
= 0;
10136 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10137 c_inhibit_evaluation_warnings
= 0;
10139 /* First, determine the context for the type we are looking
10141 context
= TYPE_CONTEXT (t
);
10142 if (context
&& TYPE_P (context
))
10144 context
= tsubst_aggr_type (context
, args
, complain
,
10145 in_decl
, /*entering_scope=*/1);
10146 /* If context is a nested class inside a class template,
10147 it may still need to be instantiated (c++/33959). */
10148 context
= complete_type (context
);
10151 /* Then, figure out what arguments are appropriate for the
10152 type we are trying to find. For example, given:
10154 template <class T> struct S;
10155 template <class T, class U> void f(T, U) { S<U> su; }
10157 and supposing that we are instantiating f<int, double>,
10158 then our ARGS will be {int, double}, but, when looking up
10159 S we only want {double}. */
10160 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10161 complain
, in_decl
);
10162 if (argvec
== error_mark_node
)
10163 r
= error_mark_node
;
10166 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10167 entering_scope
, complain
);
10168 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10171 cp_unevaluated_operand
= saved_unevaluated_operand
;
10172 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10177 /* This is not a template type, so there's nothing to do. */
10181 return tsubst (t
, args
, complain
, in_decl
);
10185 /* Substitute into the default argument ARG (a default argument for
10186 FN), which has the indicated TYPE. */
10189 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10191 tree saved_class_ptr
= NULL_TREE
;
10192 tree saved_class_ref
= NULL_TREE
;
10193 int errs
= errorcount
+ sorrycount
;
10195 /* This can happen in invalid code. */
10196 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10199 /* This default argument came from a template. Instantiate the
10200 default argument here, not in tsubst. In the case of
10209 we must be careful to do name lookup in the scope of S<T>,
10210 rather than in the current class. */
10211 push_access_scope (fn
);
10212 /* The "this" pointer is not valid in a default argument. */
10215 saved_class_ptr
= current_class_ptr
;
10216 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10217 saved_class_ref
= current_class_ref
;
10218 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10221 push_deferring_access_checks(dk_no_deferred
);
10222 /* The default argument expression may cause implicitly defined
10223 member functions to be synthesized, which will result in garbage
10224 collection. We must treat this situation as if we were within
10225 the body of function so as to avoid collecting live data on the
10228 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10229 complain
, NULL_TREE
,
10230 /*integral_constant_expression_p=*/false);
10232 pop_deferring_access_checks();
10234 /* Restore the "this" pointer. */
10237 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10238 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10241 if (errorcount
+sorrycount
> errs
10242 && (complain
& tf_warning_or_error
))
10243 inform (input_location
,
10244 " when instantiating default argument for call to %D", fn
);
10246 /* Make sure the default argument is reasonable. */
10247 arg
= check_default_argument (type
, arg
, complain
);
10249 pop_access_scope (fn
);
10254 /* Substitute into all the default arguments for FN. */
10257 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10262 tmpl_args
= DECL_TI_ARGS (fn
);
10264 /* If this function is not yet instantiated, we certainly don't need
10265 its default arguments. */
10266 if (uses_template_parms (tmpl_args
))
10268 /* Don't do this again for clones. */
10269 if (DECL_CLONED_FUNCTION_P (fn
))
10272 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10274 arg
= TREE_CHAIN (arg
))
10275 if (TREE_PURPOSE (arg
))
10276 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10278 TREE_PURPOSE (arg
),
10282 /* Substitute the ARGS into the T, which is a _DECL. Return the
10283 result of the substitution. Issue error and warning messages under
10284 control of COMPLAIN. */
10287 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10289 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10290 location_t saved_loc
;
10291 tree r
= NULL_TREE
;
10293 hashval_t hash
= 0;
10295 /* Set the filename and linenumber to improve error-reporting. */
10296 saved_loc
= input_location
;
10297 input_location
= DECL_SOURCE_LOCATION (t
);
10299 switch (TREE_CODE (t
))
10301 case TEMPLATE_DECL
:
10303 /* We can get here when processing a member function template,
10304 member class template, or template template parameter. */
10305 tree decl
= DECL_TEMPLATE_RESULT (t
);
10310 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10312 /* Template template parameter is treated here. */
10313 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10314 if (new_type
== error_mark_node
)
10315 RETURN (error_mark_node
);
10316 /* If we get a real template back, return it. This can happen in
10317 the context of most_specialized_class. */
10318 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10322 DECL_CHAIN (r
) = NULL_TREE
;
10323 TREE_TYPE (r
) = new_type
;
10324 DECL_TEMPLATE_RESULT (r
)
10325 = build_decl (DECL_SOURCE_LOCATION (decl
),
10326 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10327 DECL_TEMPLATE_PARMS (r
)
10328 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10330 TYPE_NAME (new_type
) = r
;
10334 /* We might already have an instance of this template.
10335 The ARGS are for the surrounding class type, so the
10336 full args contain the tsubst'd args for the context,
10337 plus the innermost args from the template decl. */
10338 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10339 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10340 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10341 /* Because this is a template, the arguments will still be
10342 dependent, even after substitution. If
10343 PROCESSING_TEMPLATE_DECL is not set, the dependency
10344 predicates will short-circuit. */
10345 ++processing_template_decl
;
10346 full_args
= tsubst_template_args (tmpl_args
, args
,
10347 complain
, in_decl
);
10348 --processing_template_decl
;
10349 if (full_args
== error_mark_node
)
10350 RETURN (error_mark_node
);
10352 /* If this is a default template template argument,
10353 tsubst might not have changed anything. */
10354 if (full_args
== tmpl_args
)
10357 hash
= hash_tmpl_and_args (t
, full_args
);
10358 spec
= retrieve_specialization (t
, full_args
, hash
);
10359 if (spec
!= NULL_TREE
)
10365 /* Make a new template decl. It will be similar to the
10366 original, but will record the current template arguments.
10367 We also create a new function declaration, which is just
10368 like the old one, but points to this new template, rather
10369 than the old one. */
10371 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10372 DECL_CHAIN (r
) = NULL_TREE
;
10374 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10376 if (TREE_CODE (decl
) == TYPE_DECL
10377 && !TYPE_DECL_ALIAS_P (decl
))
10380 ++processing_template_decl
;
10381 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10382 --processing_template_decl
;
10383 if (new_type
== error_mark_node
)
10384 RETURN (error_mark_node
);
10386 TREE_TYPE (r
) = new_type
;
10387 /* For a partial specialization, we need to keep pointing to
10388 the primary template. */
10389 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10390 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10391 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10392 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10393 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10398 ++processing_template_decl
;
10399 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10400 --processing_template_decl
;
10401 if (new_decl
== error_mark_node
)
10402 RETURN (error_mark_node
);
10404 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10405 DECL_TI_TEMPLATE (new_decl
) = r
;
10406 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10407 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10408 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10411 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10412 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10413 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10415 /* The template parameters for this new template are all the
10416 template parameters for the old template, except the
10417 outermost level of parameters. */
10418 DECL_TEMPLATE_PARMS (r
)
10419 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10422 if (PRIMARY_TEMPLATE_P (t
))
10423 DECL_PRIMARY_TEMPLATE (r
) = r
;
10425 if (TREE_CODE (decl
) != TYPE_DECL
)
10426 /* Record this non-type partial instantiation. */
10427 register_specialization (r
, t
,
10428 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10433 case FUNCTION_DECL
:
10436 tree argvec
= NULL_TREE
;
10444 /* Nobody should be tsubst'ing into non-template functions. */
10445 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10447 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10452 /* If T is not dependent, just return it. We have to
10453 increment PROCESSING_TEMPLATE_DECL because
10454 value_dependent_expression_p assumes that nothing is
10455 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10456 ++processing_template_decl
;
10457 dependent_p
= value_dependent_expression_p (t
);
10458 --processing_template_decl
;
10462 /* Calculate the most general template of which R is a
10463 specialization, and the complete set of arguments used to
10465 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10466 argvec
= tsubst_template_args (DECL_TI_ARGS
10467 (DECL_TEMPLATE_RESULT
10468 (DECL_TI_TEMPLATE (t
))),
10469 args
, complain
, in_decl
);
10470 if (argvec
== error_mark_node
)
10471 RETURN (error_mark_node
);
10473 /* Check to see if we already have this specialization. */
10474 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10475 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10483 /* We can see more levels of arguments than parameters if
10484 there was a specialization of a member template, like
10487 template <class T> struct S { template <class U> void f(); }
10488 template <> template <class U> void S<int>::f(U);
10490 Here, we'll be substituting into the specialization,
10491 because that's where we can find the code we actually
10492 want to generate, but we'll have enough arguments for
10493 the most general template.
10495 We also deal with the peculiar case:
10497 template <class T> struct S {
10498 template <class U> friend void f();
10500 template <class U> void f() {}
10502 template void f<double>();
10504 Here, the ARGS for the instantiation of will be {int,
10505 double}. But, we only need as many ARGS as there are
10506 levels of template parameters in CODE_PATTERN. We are
10507 careful not to get fooled into reducing the ARGS in
10510 template <class T> struct S { template <class U> void f(U); }
10511 template <class T> template <> void S<T>::f(int) {}
10513 which we can spot because the pattern will be a
10514 specialization in this case. */
10515 args_depth
= TMPL_ARGS_DEPTH (args
);
10517 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10518 if (args_depth
> parms_depth
10519 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10520 args
= get_innermost_template_args (args
, parms_depth
);
10524 /* This special case arises when we have something like this:
10526 template <class T> struct S {
10527 friend void f<int>(int, double);
10530 Here, the DECL_TI_TEMPLATE for the friend declaration
10531 will be an IDENTIFIER_NODE. We are being called from
10532 tsubst_friend_function, and we want only to create a
10533 new decl (R) with appropriate types so that we can call
10534 determine_specialization. */
10535 gen_tmpl
= NULL_TREE
;
10538 if (DECL_CLASS_SCOPE_P (t
))
10540 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10544 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10545 complain
, t
, /*entering_scope=*/1);
10550 ctx
= DECL_CONTEXT (t
);
10552 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10553 if (type
== error_mark_node
)
10554 RETURN (error_mark_node
);
10556 /* If we hit excessive deduction depth, the type is bogus even if
10557 it isn't error_mark_node, so don't build a decl. */
10558 if (excessive_deduction_depth
)
10559 RETURN (error_mark_node
);
10561 /* We do NOT check for matching decls pushed separately at this
10562 point, as they may not represent instantiations of this
10563 template, and in any case are considered separate under the
10566 DECL_USE_TEMPLATE (r
) = 0;
10567 TREE_TYPE (r
) = type
;
10568 /* Clear out the mangled name and RTL for the instantiation. */
10569 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10570 SET_DECL_RTL (r
, NULL
);
10571 /* Leave DECL_INITIAL set on deleted instantiations. */
10572 if (!DECL_DELETED_FN (r
))
10573 DECL_INITIAL (r
) = NULL_TREE
;
10574 DECL_CONTEXT (r
) = ctx
;
10576 /* OpenMP UDRs have the only argument a reference to the declared
10577 type. We want to diagnose if the declared type is a reference,
10578 which is invalid, but as references to references are usually
10579 quietly merged, diagnose it here. */
10580 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10583 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10584 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10585 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10586 error_at (DECL_SOURCE_LOCATION (t
),
10587 "reference type %qT in "
10588 "%<#pragma omp declare reduction%>", argtype
);
10589 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10590 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10594 if (member
&& DECL_CONV_FN_P (r
))
10595 /* Type-conversion operator. Reconstruct the name, in
10596 case it's the name of one of the template's parameters. */
10597 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10599 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10601 DECL_RESULT (r
) = NULL_TREE
;
10603 TREE_STATIC (r
) = 0;
10604 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10605 DECL_EXTERNAL (r
) = 1;
10606 /* If this is an instantiation of a function with internal
10607 linkage, we already know what object file linkage will be
10608 assigned to the instantiation. */
10609 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10610 DECL_DEFER_OUTPUT (r
) = 0;
10611 DECL_CHAIN (r
) = NULL_TREE
;
10612 DECL_PENDING_INLINE_INFO (r
) = 0;
10613 DECL_PENDING_INLINE_P (r
) = 0;
10614 DECL_SAVED_TREE (r
) = NULL_TREE
;
10615 DECL_STRUCT_FUNCTION (r
) = NULL
;
10617 /* We'll re-clone as appropriate in instantiate_template. */
10618 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10620 /* If we aren't complaining now, return on error before we register
10621 the specialization so that we'll complain eventually. */
10622 if ((complain
& tf_error
) == 0
10623 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10624 && !grok_op_properties (r
, /*complain=*/false))
10625 RETURN (error_mark_node
);
10627 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10628 this in the special friend case mentioned above where
10629 GEN_TMPL is NULL. */
10632 DECL_TEMPLATE_INFO (r
)
10633 = build_template_info (gen_tmpl
, argvec
);
10634 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10637 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10639 /* We instantiated this while substituting into
10640 the type earlier (template/friend54.C). */
10643 /* We're not supposed to instantiate default arguments
10644 until they are called, for a template. But, for a
10647 template <class T> void f ()
10648 { extern void g(int i = T()); }
10650 we should do the substitution when the template is
10651 instantiated. We handle the member function case in
10652 instantiate_class_template since the default arguments
10653 might refer to other members of the class. */
10655 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10656 && !uses_template_parms (argvec
))
10657 tsubst_default_arguments (r
, complain
);
10660 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10662 /* Copy the list of befriending classes. */
10663 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10665 friends
= &TREE_CHAIN (*friends
))
10667 *friends
= copy_node (*friends
);
10668 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
10673 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
10675 maybe_retrofit_in_chrg (r
);
10676 if (DECL_CONSTRUCTOR_P (r
))
10677 grok_ctor_properties (ctx
, r
);
10678 if (DECL_INHERITED_CTOR_BASE (r
))
10679 deduce_inheriting_ctor (r
);
10680 /* If this is an instantiation of a member template, clone it.
10681 If it isn't, that'll be handled by
10682 clone_constructors_and_destructors. */
10683 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
10684 clone_function_decl (r
, /*update_method_vec_p=*/0);
10686 else if ((complain
& tf_error
) != 0
10687 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10688 && !grok_op_properties (r
, /*complain=*/true))
10689 RETURN (error_mark_node
);
10691 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
10692 SET_DECL_FRIEND_CONTEXT (r
,
10693 tsubst (DECL_FRIEND_CONTEXT (t
),
10694 args
, complain
, in_decl
));
10696 /* Possibly limit visibility based on template args. */
10697 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10698 if (DECL_VISIBILITY_SPECIFIED (t
))
10700 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10701 DECL_ATTRIBUTES (r
)
10702 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10704 determine_visibility (r
);
10705 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
10706 && !processing_template_decl
)
10707 defaulted_late_check (r
);
10709 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10710 args
, complain
, in_decl
);
10716 tree type
= NULL_TREE
;
10718 tree expanded_types
= NULL_TREE
;
10719 tree prev_r
= NULL_TREE
;
10720 tree first_r
= NULL_TREE
;
10722 if (DECL_PACK_P (t
))
10724 /* If there is a local specialization that isn't a
10725 parameter pack, it means that we're doing a "simple"
10726 substitution from inside tsubst_pack_expansion. Just
10727 return the local specialization (which will be a single
10729 tree spec
= retrieve_local_specialization (t
);
10731 && TREE_CODE (spec
) == PARM_DECL
10732 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
10735 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10736 the parameters in this function parameter pack. */
10737 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10738 complain
, in_decl
);
10739 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10741 len
= TREE_VEC_LENGTH (expanded_types
);
10743 /* Zero-length parameter packs are boring. Just substitute
10746 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
10751 /* All we did was update the type. Make a note of that. */
10752 type
= expanded_types
;
10753 expanded_types
= NULL_TREE
;
10757 /* Loop through all of the parameters we'll build. When T is
10758 a function parameter pack, LEN is the number of expanded
10759 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10761 for (i
= 0; i
< len
; ++i
)
10765 if (DECL_TEMPLATE_PARM_P (t
))
10766 SET_DECL_TEMPLATE_PARM_P (r
);
10768 if (expanded_types
)
10769 /* We're on the Ith parameter of the function parameter
10772 /* Get the Ith type. */
10773 type
= TREE_VEC_ELT (expanded_types
, i
);
10775 /* Rename the parameter to include the index. */
10777 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10780 /* We're dealing with a normal parameter. */
10781 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10783 type
= type_decays_to (type
);
10784 TREE_TYPE (r
) = type
;
10785 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10787 if (DECL_INITIAL (r
))
10789 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
10790 DECL_INITIAL (r
) = TREE_TYPE (r
);
10792 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
10793 complain
, in_decl
);
10796 DECL_CONTEXT (r
) = NULL_TREE
;
10798 if (!DECL_TEMPLATE_PARM_P (r
))
10799 DECL_ARG_TYPE (r
) = type_passed_as (type
);
10801 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10802 args
, complain
, in_decl
);
10804 /* Keep track of the first new parameter we
10805 generate. That's what will be returned to the
10810 /* Build a proper chain of parameters when substituting
10811 into a function parameter pack. */
10813 DECL_CHAIN (prev_r
) = r
;
10816 /* If cp_unevaluated_operand is set, we're just looking for a
10817 single dummy parameter, so don't keep going. */
10818 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
10819 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
10820 complain
, DECL_CHAIN (t
));
10822 /* FIRST_R contains the start of the chain we've built. */
10829 tree type
= NULL_TREE
;
10830 tree vec
= NULL_TREE
;
10831 tree expanded_types
= NULL_TREE
;
10834 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
10836 /* This field is a lambda capture pack. Return a TREE_VEC of
10837 the expanded fields to instantiate_class_template_1 and
10838 store them in the specializations hash table as a
10839 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
10840 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10841 complain
, in_decl
);
10842 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10844 len
= TREE_VEC_LENGTH (expanded_types
);
10845 vec
= make_tree_vec (len
);
10849 /* All we did was update the type. Make a note of that. */
10850 type
= expanded_types
;
10851 expanded_types
= NULL_TREE
;
10855 for (int i
= 0; i
< len
; ++i
)
10858 if (expanded_types
)
10860 type
= TREE_VEC_ELT (expanded_types
, i
);
10862 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10865 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10867 if (type
== error_mark_node
)
10868 RETURN (error_mark_node
);
10869 TREE_TYPE (r
) = type
;
10870 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10872 if (DECL_C_BIT_FIELD (r
))
10873 /* For bit-fields, DECL_INITIAL gives the number of bits. For
10874 non-bit-fields DECL_INITIAL is a non-static data member
10875 initializer, which gets deferred instantiation. */
10877 = tsubst_expr (DECL_INITIAL (t
), args
,
10879 /*integral_constant_expression_p=*/true);
10880 else if (DECL_INITIAL (t
))
10882 /* Set up DECL_TEMPLATE_INFO so that we can get at the
10883 NSDMI in perform_member_init. Still set DECL_INITIAL
10884 so that we know there is one. */
10885 DECL_INITIAL (r
) = void_zero_node
;
10886 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
10887 retrofit_lang_decl (r
);
10888 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10890 /* We don't have to set DECL_CONTEXT here; it is set by
10891 finish_member_declaration. */
10892 DECL_CHAIN (r
) = NULL_TREE
;
10894 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10895 args
, complain
, in_decl
);
10898 TREE_VEC_ELT (vec
, i
) = r
;
10904 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
10905 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
10906 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
10907 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
10908 TREE_TYPE (pack
) = tpack
;
10909 register_specialization (pack
, t
, args
, false, 0);
10915 /* We reach here only for member using decls. We also need to check
10916 uses_template_parms because DECL_DEPENDENT_P is not set for a
10917 using-declaration that designates a member of the current
10918 instantiation (c++/53549). */
10919 if (DECL_DEPENDENT_P (t
)
10920 || uses_template_parms (USING_DECL_SCOPE (t
)))
10922 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
10923 complain
, in_decl
);
10924 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
10925 r
= do_class_using_decl (inst_scope
, name
);
10927 r
= error_mark_node
;
10930 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
10931 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
10937 DECL_CHAIN (r
) = NULL_TREE
;
10944 tree argvec
= NULL_TREE
;
10945 tree gen_tmpl
= NULL_TREE
;
10947 tree tmpl
= NULL_TREE
;
10949 tree type
= NULL_TREE
;
10952 if (TREE_TYPE (t
) == error_mark_node
)
10953 RETURN (error_mark_node
);
10955 if (TREE_CODE (t
) == TYPE_DECL
10956 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
10958 /* If this is the canonical decl, we don't have to
10959 mess with instantiations, and often we can't (for
10960 typename, template type parms and such). Note that
10961 TYPE_NAME is not correct for the above test if
10962 we've copied the type for a typedef. */
10963 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10964 if (type
== error_mark_node
)
10965 RETURN (error_mark_node
);
10966 r
= TYPE_NAME (type
);
10970 /* Check to see if we already have the specialization we
10973 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
10975 /* T is a static data member or namespace-scope entity.
10976 We have to substitute into namespace-scope variables
10977 (even though such entities are never templates) because
10980 template <class T> void f() { extern T t; }
10982 where the entity referenced is not known until
10983 instantiation time. */
10985 ctx
= DECL_CONTEXT (t
);
10986 if (DECL_CLASS_SCOPE_P (t
))
10988 ctx
= tsubst_aggr_type (ctx
, args
,
10990 in_decl
, /*entering_scope=*/1);
10991 /* If CTX is unchanged, then T is in fact the
10992 specialization we want. That situation occurs when
10993 referencing a static data member within in its own
10994 class. We can use pointer equality, rather than
10995 same_type_p, because DECL_CONTEXT is always
10997 if (ctx
== DECL_CONTEXT (t
)
10998 && (TREE_CODE (t
) != TYPE_DECL
10999 /* ... unless T is a member template; in which
11000 case our caller can be willing to create a
11001 specialization of that template represented
11003 || !(DECL_TI_TEMPLATE (t
)
11004 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))))
11010 tmpl
= DECL_TI_TEMPLATE (t
);
11011 gen_tmpl
= most_general_template (tmpl
);
11012 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11013 if (argvec
== error_mark_node
)
11014 RETURN (error_mark_node
);
11015 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11016 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11021 /* A local variable. */
11023 /* Subsequent calls to pushdecl will fill this in. */
11025 spec
= retrieve_local_specialization (t
);
11027 /* If we already have the specialization we need, there is
11028 nothing more to do. */
11035 /* Create a new node for the specialization we need. */
11037 if (type
== NULL_TREE
)
11039 if (is_typedef_decl (t
))
11040 type
= DECL_ORIGINAL_TYPE (t
);
11042 type
= TREE_TYPE (t
);
11044 && VAR_HAD_UNKNOWN_BOUND (t
)
11045 && type
!= error_mark_node
)
11046 type
= strip_array_domain (type
);
11047 type
= tsubst (type
, args
, complain
, in_decl
);
11051 /* Even if the original location is out of scope, the
11052 newly substituted one is not. */
11053 DECL_DEAD_FOR_LOCAL (r
) = 0;
11054 DECL_INITIALIZED_P (r
) = 0;
11055 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11056 if (type
== error_mark_node
)
11057 RETURN (error_mark_node
);
11058 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11060 /* It may seem that this case cannot occur, since:
11065 declares a function, not a variable. However:
11068 template <typename T> void g() { T t; }
11069 template void g<f>();
11071 is an attempt to declare a variable with function
11073 error ("variable %qD has function type",
11074 /* R is not yet sufficiently initialized, so we
11075 just use its name. */
11077 RETURN (error_mark_node
);
11079 type
= complete_type (type
);
11080 /* Wait until cp_finish_decl to set this again, to handle
11081 circular dependency (template/instantiate6.C). */
11082 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11083 type
= check_var_type (DECL_NAME (r
), type
);
11085 if (DECL_HAS_VALUE_EXPR_P (t
))
11087 tree ve
= DECL_VALUE_EXPR (t
);
11088 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11089 /*constant_expression_p=*/false);
11090 if (REFERENCE_REF_P (ve
))
11092 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11093 ve
= TREE_OPERAND (ve
, 0);
11095 SET_DECL_VALUE_EXPR (r
, ve
);
11098 else if (DECL_SELF_REFERENCE_P (t
))
11099 SET_DECL_SELF_REFERENCE_P (r
);
11100 TREE_TYPE (r
) = type
;
11101 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11102 DECL_CONTEXT (r
) = ctx
;
11103 /* Clear out the mangled name and RTL for the instantiation. */
11104 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11105 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11106 SET_DECL_RTL (r
, NULL
);
11107 /* The initializer must not be expanded until it is required;
11108 see [temp.inst]. */
11109 DECL_INITIAL (r
) = NULL_TREE
;
11110 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11111 SET_DECL_RTL (r
, NULL
);
11112 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11115 /* Possibly limit visibility based on template args. */
11116 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11117 if (DECL_VISIBILITY_SPECIFIED (t
))
11119 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11120 DECL_ATTRIBUTES (r
)
11121 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11123 determine_visibility (r
);
11128 /* A static data member declaration is always marked
11129 external when it is declared in-class, even if an
11130 initializer is present. We mimic the non-template
11131 processing here. */
11132 DECL_EXTERNAL (r
) = 1;
11134 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11135 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11136 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11138 else if (!cp_unevaluated_operand
)
11139 register_local_specialization (r
, t
);
11141 DECL_CHAIN (r
) = NULL_TREE
;
11143 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11145 args
, complain
, in_decl
);
11147 /* Preserve a typedef that names a type. */
11148 if (is_typedef_decl (r
))
11150 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11151 set_underlying_type (r
);
11154 layout_decl (r
, 0);
11159 gcc_unreachable ();
11164 /* Restore the file and line information. */
11165 input_location
= saved_loc
;
11170 /* Substitute into the ARG_TYPES of a function type.
11171 If END is a TREE_CHAIN, leave it and any following types
11175 tsubst_arg_types (tree arg_types
,
11178 tsubst_flags_t complain
,
11181 tree remaining_arg_types
;
11182 tree type
= NULL_TREE
;
11184 tree expanded_args
= NULL_TREE
;
11187 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11190 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11191 args
, end
, complain
, in_decl
);
11192 if (remaining_arg_types
== error_mark_node
)
11193 return error_mark_node
;
11195 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11197 /* For a pack expansion, perform substitution on the
11198 entire expression. Later on, we'll handle the arguments
11200 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11201 args
, complain
, in_decl
);
11203 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11204 /* So that we'll spin through the parameters, one by one. */
11205 i
= TREE_VEC_LENGTH (expanded_args
);
11208 /* We only partially substituted into the parameter
11209 pack. Our type is TYPE_PACK_EXPANSION. */
11210 type
= expanded_args
;
11211 expanded_args
= NULL_TREE
;
11219 type
= TREE_VEC_ELT (expanded_args
, i
);
11221 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11223 if (type
== error_mark_node
)
11224 return error_mark_node
;
11225 if (VOID_TYPE_P (type
))
11227 if (complain
& tf_error
)
11229 error ("invalid parameter type %qT", type
);
11231 error ("in declaration %q+D", in_decl
);
11233 return error_mark_node
;
11236 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11237 return error_mark_node
;
11239 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11240 top-level qualifiers as required. */
11241 type
= cv_unqualified (type_decays_to (type
));
11243 /* We do not substitute into default arguments here. The standard
11244 mandates that they be instantiated only when needed, which is
11245 done in build_over_call. */
11246 default_arg
= TREE_PURPOSE (arg_types
);
11248 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11250 /* We've instantiated a template before its default arguments
11251 have been parsed. This can happen for a nested template
11252 class, and is not an error unless we require the default
11253 argument in a call of this function. */
11254 remaining_arg_types
=
11255 tree_cons (default_arg
, type
, remaining_arg_types
);
11256 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11259 remaining_arg_types
=
11260 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11263 return remaining_arg_types
;
11266 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11267 *not* handle the exception-specification for FNTYPE, because the
11268 initial substitution of explicitly provided template parameters
11269 during argument deduction forbids substitution into the
11270 exception-specification:
11274 All references in the function type of the function template to the
11275 corresponding template parameters are replaced by the specified tem-
11276 plate argument values. If a substitution in a template parameter or
11277 in the function type of the function template results in an invalid
11278 type, type deduction fails. [Note: The equivalent substitution in
11279 exception specifications is done only when the function is instanti-
11280 ated, at which point a program is ill-formed if the substitution
11281 results in an invalid type.] */
11284 tsubst_function_type (tree t
,
11286 tsubst_flags_t complain
,
11293 /* The TYPE_CONTEXT is not used for function/method types. */
11294 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11296 /* Substitute the return type. */
11297 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11298 if (return_type
== error_mark_node
)
11299 return error_mark_node
;
11300 /* DR 486 clarifies that creation of a function type with an
11301 invalid return type is a deduction failure. */
11302 if (TREE_CODE (return_type
) == ARRAY_TYPE
11303 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11305 if (complain
& tf_error
)
11307 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11308 error ("function returning an array");
11310 error ("function returning a function");
11312 return error_mark_node
;
11315 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11316 return error_mark_node
;
11318 /* Substitute the argument types. */
11319 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11320 complain
, in_decl
);
11321 if (arg_types
== error_mark_node
)
11322 return error_mark_node
;
11324 /* Construct a new type node and return it. */
11325 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11327 fntype
= build_function_type (return_type
, arg_types
);
11328 fntype
= apply_memfn_quals (fntype
,
11329 type_memfn_quals (t
),
11330 type_memfn_rqual (t
));
11334 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11335 /* Don't pick up extra function qualifiers from the basetype. */
11336 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11337 if (! MAYBE_CLASS_TYPE_P (r
))
11341 Type deduction may fail for any of the following
11344 -- Attempting to create "pointer to member of T" when T
11345 is not a class type. */
11346 if (complain
& tf_error
)
11347 error ("creating pointer to member function of non-class type %qT",
11349 return error_mark_node
;
11352 fntype
= build_method_type_directly (r
, return_type
,
11353 TREE_CHAIN (arg_types
));
11354 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11356 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11361 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11362 ARGS into that specification, and return the substituted
11363 specification. If there is no specification, return NULL_TREE. */
11366 tsubst_exception_specification (tree fntype
,
11368 tsubst_flags_t complain
,
11375 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11376 new_specs
= NULL_TREE
;
11377 if (specs
&& TREE_PURPOSE (specs
))
11379 /* A noexcept-specifier. */
11380 tree expr
= TREE_PURPOSE (specs
);
11381 if (TREE_CODE (expr
) == INTEGER_CST
)
11385 /* Defer instantiation of noexcept-specifiers to avoid
11386 excessive instantiations (c++/49107). */
11387 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11388 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11390 /* We already partially instantiated this member template,
11391 so combine the new args with the old. */
11392 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11393 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11394 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11395 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11399 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11400 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11404 new_specs
= tsubst_copy_and_build
11405 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11406 /*integral_constant_expression_p=*/true);
11407 new_specs
= build_noexcept_spec (new_specs
, complain
);
11411 if (! TREE_VALUE (specs
))
11418 tree expanded_specs
= NULL_TREE
;
11420 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11422 /* Expand the pack expansion type. */
11423 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11427 if (expanded_specs
== error_mark_node
)
11428 return error_mark_node
;
11429 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11430 len
= TREE_VEC_LENGTH (expanded_specs
);
11433 /* We're substituting into a member template, so
11434 we got a TYPE_PACK_EXPANSION back. Add that
11435 expansion and move on. */
11436 gcc_assert (TREE_CODE (expanded_specs
)
11437 == TYPE_PACK_EXPANSION
);
11438 new_specs
= add_exception_specifier (new_specs
,
11441 specs
= TREE_CHAIN (specs
);
11446 for (i
= 0; i
< len
; ++i
)
11448 if (expanded_specs
)
11449 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11451 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11452 if (spec
== error_mark_node
)
11454 new_specs
= add_exception_specifier (new_specs
, spec
,
11458 specs
= TREE_CHAIN (specs
);
11464 /* Take the tree structure T and replace template parameters used
11465 therein with the argument vector ARGS. IN_DECL is an associated
11466 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11467 Issue error and warning messages under control of COMPLAIN. Note
11468 that we must be relatively non-tolerant of extensions here, in
11469 order to preserve conformance; if we allow substitutions that
11470 should not be allowed, we may allow argument deductions that should
11471 not succeed, and therefore report ambiguous overload situations
11472 where there are none. In theory, we could allow the substitution,
11473 but indicate that it should have failed, and allow our caller to
11474 make sure that the right thing happens, but we don't try to do this
11477 This function is used for dealing with types, decls and the like;
11478 for expressions, use tsubst_expr or tsubst_copy. */
11481 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11483 enum tree_code code
;
11484 tree type
, r
= NULL_TREE
;
11486 if (t
== NULL_TREE
|| t
== error_mark_node
11487 || t
== integer_type_node
11488 || t
== void_type_node
11489 || t
== char_type_node
11490 || t
== unknown_type_node
11491 || TREE_CODE (t
) == NAMESPACE_DECL
11492 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11496 return tsubst_decl (t
, args
, complain
);
11498 if (args
== NULL_TREE
)
11501 code
= TREE_CODE (t
);
11503 if (code
== IDENTIFIER_NODE
)
11504 type
= IDENTIFIER_TYPE_VALUE (t
);
11506 type
= TREE_TYPE (t
);
11508 gcc_assert (type
!= unknown_type_node
);
11510 /* Reuse typedefs. We need to do this to handle dependent attributes,
11511 such as attribute aligned. */
11513 && typedef_variant_p (t
))
11515 tree decl
= TYPE_NAME (t
);
11517 if (alias_template_specialization_p (t
))
11519 /* DECL represents an alias template and we want to
11521 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11522 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11523 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11525 else if (DECL_CLASS_SCOPE_P (decl
)
11526 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11527 && uses_template_parms (DECL_CONTEXT (decl
)))
11529 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11530 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11531 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11533 else if (DECL_FUNCTION_SCOPE_P (decl
)
11534 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11535 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11536 r
= retrieve_local_specialization (decl
);
11538 /* The typedef is from a non-template context. */
11544 r
= cp_build_qualified_type_real
11545 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11546 complain
| tf_ignore_bad_quals
);
11551 /* We don't have an instantiation yet, so drop the typedef. */
11552 int quals
= cp_type_quals (t
);
11553 t
= DECL_ORIGINAL_TYPE (decl
);
11554 t
= cp_build_qualified_type_real (t
, quals
,
11555 complain
| tf_ignore_bad_quals
);
11560 && code
!= TYPENAME_TYPE
11561 && code
!= TEMPLATE_TYPE_PARM
11562 && code
!= IDENTIFIER_NODE
11563 && code
!= FUNCTION_TYPE
11564 && code
!= METHOD_TYPE
)
11565 type
= tsubst (type
, args
, complain
, in_decl
);
11566 if (type
== error_mark_node
)
11567 return error_mark_node
;
11573 case ENUMERAL_TYPE
:
11574 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11575 /*entering_scope=*/0);
11578 case IDENTIFIER_NODE
:
11589 if (t
== integer_type_node
)
11592 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11593 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11597 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11599 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11600 /*integral_constant_expression_p=*/false);
11602 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11604 if (TREE_CODE (max
) == NOP_EXPR
11605 && TREE_SIDE_EFFECTS (omax
)
11606 && !TREE_TYPE (max
))
11607 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11609 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11610 with TREE_SIDE_EFFECTS that indicates this is not an integral
11611 constant expression. */
11612 if (processing_template_decl
11613 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11615 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11616 TREE_SIDE_EFFECTS (max
) = 1;
11619 return compute_array_index_type (NULL_TREE
, max
, complain
);
11622 case TEMPLATE_TYPE_PARM
:
11623 case TEMPLATE_TEMPLATE_PARM
:
11624 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11625 case TEMPLATE_PARM_INDEX
:
11630 tree arg
= NULL_TREE
;
11634 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
11635 template_parm_level_and_index (t
, &level
, &idx
);
11637 levels
= TMPL_ARGS_DEPTH (args
);
11638 if (level
<= levels
)
11640 arg
= TMPL_ARG (args
, level
, idx
);
11642 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
11644 /* See through ARGUMENT_PACK_SELECT arguments. */
11645 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
11646 /* If the selected argument is an expansion E, that most
11647 likely means we were called from
11648 gen_elem_of_pack_expansion_instantiation during the
11649 substituting of pack an argument pack (which Ith
11650 element is a pack expansion, where I is
11651 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11652 In this case, the Ith element resulting from this
11653 substituting is going to be a pack expansion, which
11654 pattern is the pattern of E. Let's return the
11656 gen_elem_of_pack_expansion_instantiation will
11657 build the resulting pack expansion from it. */
11658 if (PACK_EXPANSION_P (arg
))
11659 arg
= PACK_EXPANSION_PATTERN (arg
);
11663 if (arg
== error_mark_node
)
11664 return error_mark_node
;
11665 else if (arg
!= NULL_TREE
)
11667 if (ARGUMENT_PACK_P (arg
))
11668 /* If ARG is an argument pack, we don't actually want to
11669 perform a substitution here, because substitutions
11670 for argument packs are only done
11671 element-by-element. We can get to this point when
11672 substituting the type of a non-type template
11673 parameter pack, when that type actually contains
11674 template parameter packs from an outer template, e.g.,
11676 template<typename... Types> struct A {
11677 template<Types... Values> struct B { };
11681 if (code
== TEMPLATE_TYPE_PARM
)
11684 gcc_assert (TYPE_P (arg
));
11686 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
11688 return cp_build_qualified_type_real
11689 (arg
, quals
, complain
| tf_ignore_bad_quals
);
11691 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11693 /* We are processing a type constructed from a
11694 template template parameter. */
11695 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
11696 args
, complain
, in_decl
);
11697 if (argvec
== error_mark_node
)
11698 return error_mark_node
;
11700 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
11701 || TREE_CODE (arg
) == TEMPLATE_DECL
11702 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
11704 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
11705 /* Consider this code:
11707 template <template <class> class Template>
11709 template <class Arg> using Bind = Template<Arg>;
11712 template <template <class> class Template, class Arg>
11713 using Instantiate = Template<Arg>; //#0
11715 template <template <class> class Template,
11718 Instantiate<Internal<Template>::template Bind,
11721 When #1 is parsed, the
11722 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11723 parameter `Template' in #0 matches the
11724 UNBOUND_CLASS_TEMPLATE representing the argument
11725 `Internal<Template>::template Bind'; We then want
11726 to assemble the type `Bind<Argument>' that can't
11727 be fully created right now, because
11728 `Internal<Template>' not being complete, the Bind
11729 template cannot be looked up in that context. So
11730 we need to "store" `Bind<Argument>' for later
11731 when the context of Bind becomes complete. Let's
11732 store that in a TYPENAME_TYPE. */
11733 return make_typename_type (TYPE_CONTEXT (arg
),
11734 build_nt (TEMPLATE_ID_EXPR
,
11735 TYPE_IDENTIFIER (arg
),
11740 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11741 are resolving nested-types in the signature of a
11742 member function templates. Otherwise ARG is a
11743 TEMPLATE_DECL and is the real template to be
11745 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11746 arg
= TYPE_NAME (arg
);
11748 r
= lookup_template_class (arg
,
11750 DECL_CONTEXT (arg
),
11751 /*entering_scope=*/0,
11753 return cp_build_qualified_type_real
11754 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
11757 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11758 return convert_from_reference (unshare_expr (arg
));
11762 /* This can happen during the attempted tsubst'ing in
11763 unify. This means that we don't yet have any information
11764 about the template parameter in question. */
11767 /* Early in template argument deduction substitution, we don't
11768 want to reduce the level of 'auto', or it will be confused
11769 with a normal template parm in subsequent deduction. */
11770 if (is_auto (t
) && (complain
& tf_partial
))
11773 /* If we get here, we must have been looking at a parm for a
11774 more deeply nested template. Make a new version of this
11775 template parameter, but with a lower level. */
11778 case TEMPLATE_TYPE_PARM
:
11779 case TEMPLATE_TEMPLATE_PARM
:
11780 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11781 if (cp_type_quals (t
))
11783 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
11784 r
= cp_build_qualified_type_real
11785 (r
, cp_type_quals (t
),
11786 complain
| (code
== TEMPLATE_TYPE_PARM
11787 ? tf_ignore_bad_quals
: 0));
11792 TEMPLATE_TYPE_PARM_INDEX (r
)
11793 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
11794 r
, levels
, args
, complain
);
11795 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
11796 TYPE_MAIN_VARIANT (r
) = r
;
11797 TYPE_POINTER_TO (r
) = NULL_TREE
;
11798 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
11800 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
11801 /* We have reduced the level of the template
11802 template parameter, but not the levels of its
11803 template parameters, so canonical_type_parameter
11804 will not be able to find the canonical template
11805 template parameter for this level. Thus, we
11806 require structural equality checking to compare
11807 TEMPLATE_TEMPLATE_PARMs. */
11808 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11809 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
11810 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11812 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
11814 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11816 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
11817 complain
, in_decl
);
11818 if (argvec
== error_mark_node
)
11819 return error_mark_node
;
11821 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
11822 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
11827 case TEMPLATE_PARM_INDEX
:
11828 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
11832 gcc_unreachable ();
11840 tree purpose
, value
, chain
;
11842 if (t
== void_list_node
)
11845 purpose
= TREE_PURPOSE (t
);
11848 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
11849 if (purpose
== error_mark_node
)
11850 return error_mark_node
;
11852 value
= TREE_VALUE (t
);
11855 value
= tsubst (value
, args
, complain
, in_decl
);
11856 if (value
== error_mark_node
)
11857 return error_mark_node
;
11859 chain
= TREE_CHAIN (t
);
11860 if (chain
&& chain
!= void_type_node
)
11862 chain
= tsubst (chain
, args
, complain
, in_decl
);
11863 if (chain
== error_mark_node
)
11864 return error_mark_node
;
11866 if (purpose
== TREE_PURPOSE (t
)
11867 && value
== TREE_VALUE (t
)
11868 && chain
== TREE_CHAIN (t
))
11870 return hash_tree_cons (purpose
, value
, chain
);
11874 /* We should never be tsubsting a binfo. */
11875 gcc_unreachable ();
11878 /* A vector of template arguments. */
11879 gcc_assert (!type
);
11880 return tsubst_template_args (t
, args
, complain
, in_decl
);
11883 case REFERENCE_TYPE
:
11885 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
11890 Type deduction may fail for any of the following
11893 -- Attempting to create a pointer to reference type.
11894 -- Attempting to create a reference to a reference type or
11895 a reference to void.
11897 Core issue 106 says that creating a reference to a reference
11898 during instantiation is no longer a cause for failure. We
11899 only enforce this check in strict C++98 mode. */
11900 if ((TREE_CODE (type
) == REFERENCE_TYPE
11901 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
11902 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
11904 static location_t last_loc
;
11906 /* We keep track of the last time we issued this error
11907 message to avoid spewing a ton of messages during a
11908 single bad template instantiation. */
11909 if (complain
& tf_error
11910 && last_loc
!= input_location
)
11912 if (VOID_TYPE_P (type
))
11913 error ("forming reference to void");
11914 else if (code
== POINTER_TYPE
)
11915 error ("forming pointer to reference type %qT", type
);
11917 error ("forming reference to reference type %qT", type
);
11918 last_loc
= input_location
;
11921 return error_mark_node
;
11923 else if (TREE_CODE (type
) == FUNCTION_TYPE
11924 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
11925 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
11927 if (complain
& tf_error
)
11929 if (code
== POINTER_TYPE
)
11930 error ("forming pointer to qualified function type %qT",
11933 error ("forming reference to qualified function type %qT",
11936 return error_mark_node
;
11938 else if (code
== POINTER_TYPE
)
11940 r
= build_pointer_type (type
);
11941 if (TREE_CODE (type
) == METHOD_TYPE
)
11942 r
= build_ptrmemfunc_type (r
);
11944 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
11945 /* In C++0x, during template argument substitution, when there is an
11946 attempt to create a reference to a reference type, reference
11947 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
11949 "If a template-argument for a template-parameter T names a type
11950 that is a reference to a type A, an attempt to create the type
11951 'lvalue reference to cv T' creates the type 'lvalue reference to
11952 A,' while an attempt to create the type type rvalue reference to
11953 cv T' creates the type T"
11955 r
= cp_build_reference_type
11957 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
11959 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
11960 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
11962 if (cxx_dialect
>= cxx1y
11963 && !(TREE_CODE (t
) == REFERENCE_TYPE
&& REFERENCE_VLA_OK (t
))
11964 && array_of_runtime_bound_p (type
)
11965 && (flag_iso
|| warn_vla
> 0))
11967 if (complain
& tf_warning_or_error
)
11969 (input_location
, OPT_Wvla
,
11970 code
== REFERENCE_TYPE
11971 ? G_("cannot declare reference to array of runtime bound")
11972 : G_("cannot declare pointer to array of runtime bound"));
11974 r
= error_mark_node
;
11977 if (r
!= error_mark_node
)
11978 /* Will this ever be needed for TYPE_..._TO values? */
11985 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
11986 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
11990 Type deduction may fail for any of the following
11993 -- Attempting to create "pointer to member of T" when T
11994 is not a class type. */
11995 if (complain
& tf_error
)
11996 error ("creating pointer to member of non-class type %qT", r
);
11997 return error_mark_node
;
11999 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12001 if (complain
& tf_error
)
12002 error ("creating pointer to member reference type %qT", type
);
12003 return error_mark_node
;
12005 if (VOID_TYPE_P (type
))
12007 if (complain
& tf_error
)
12008 error ("creating pointer to member of type void");
12009 return error_mark_node
;
12011 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12012 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12014 /* The type of the implicit object parameter gets its
12015 cv-qualifiers from the FUNCTION_TYPE. */
12018 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12019 type_memfn_rqual (type
));
12020 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12021 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12025 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12029 case FUNCTION_TYPE
:
12034 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12035 if (fntype
== error_mark_node
)
12036 return error_mark_node
;
12038 /* Substitute the exception specification. */
12039 specs
= tsubst_exception_specification (t
, args
, complain
,
12040 in_decl
, /*defer_ok*/true);
12041 if (specs
== error_mark_node
)
12042 return error_mark_node
;
12044 fntype
= build_exception_variant (fntype
, specs
);
12049 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12050 if (domain
== error_mark_node
)
12051 return error_mark_node
;
12053 /* As an optimization, we avoid regenerating the array type if
12054 it will obviously be the same as T. */
12055 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12058 /* These checks should match the ones in grokdeclarator.
12062 The deduction may fail for any of the following reasons:
12064 -- Attempting to create an array with an element type that
12065 is void, a function type, or a reference type, or [DR337]
12066 an abstract class type. */
12067 if (VOID_TYPE_P (type
)
12068 || TREE_CODE (type
) == FUNCTION_TYPE
12069 || TREE_CODE (type
) == REFERENCE_TYPE
)
12071 if (complain
& tf_error
)
12072 error ("creating array of %qT", type
);
12073 return error_mark_node
;
12076 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12077 return error_mark_node
;
12079 r
= build_cplus_array_type (type
, domain
);
12081 if (TYPE_USER_ALIGN (t
))
12083 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12084 TYPE_USER_ALIGN (r
) = 1;
12090 case TYPENAME_TYPE
:
12092 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12093 in_decl
, /*entering_scope=*/1);
12094 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12095 complain
, in_decl
);
12097 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12098 return error_mark_node
;
12100 if (!MAYBE_CLASS_TYPE_P (ctx
))
12102 if (complain
& tf_error
)
12103 error ("%qT is not a class, struct, or union type", ctx
);
12104 return error_mark_node
;
12106 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12108 /* Normally, make_typename_type does not require that the CTX
12109 have complete type in order to allow things like:
12111 template <class T> struct S { typename S<T>::X Y; };
12113 But, such constructs have already been resolved by this
12114 point, so here CTX really should have complete type, unless
12115 it's a partial instantiation. */
12116 ctx
= complete_type (ctx
);
12117 if (!COMPLETE_TYPE_P (ctx
))
12119 if (complain
& tf_error
)
12120 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12121 return error_mark_node
;
12125 f
= make_typename_type (ctx
, f
, typename_type
,
12126 complain
| tf_keep_type_decl
);
12127 if (f
== error_mark_node
)
12129 if (TREE_CODE (f
) == TYPE_DECL
)
12131 complain
|= tf_ignore_bad_quals
;
12135 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12137 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12139 if (complain
& tf_error
)
12140 error ("%qT resolves to %qT, which is not an enumeration type",
12143 return error_mark_node
;
12145 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12147 if (complain
& tf_error
)
12148 error ("%qT resolves to %qT, which is is not a class type",
12151 return error_mark_node
;
12155 return cp_build_qualified_type_real
12156 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12159 case UNBOUND_CLASS_TEMPLATE
:
12161 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12162 in_decl
, /*entering_scope=*/1);
12163 tree name
= TYPE_IDENTIFIER (t
);
12164 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12166 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12167 return error_mark_node
;
12170 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12171 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12178 ++cp_unevaluated_operand
;
12179 ++c_inhibit_evaluation_warnings
;
12181 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12183 /*integral_constant_expression_p=*/false);
12185 --cp_unevaluated_operand
;
12186 --c_inhibit_evaluation_warnings
;
12188 type
= finish_typeof (type
);
12189 return cp_build_qualified_type_real (type
,
12191 | cp_type_quals (type
),
12195 case DECLTYPE_TYPE
:
12199 ++cp_unevaluated_operand
;
12200 ++c_inhibit_evaluation_warnings
;
12202 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12203 complain
|tf_decltype
, in_decl
,
12204 /*function_p*/false,
12205 /*integral_constant_expression*/false);
12207 --cp_unevaluated_operand
;
12208 --c_inhibit_evaluation_warnings
;
12210 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12211 type
= lambda_capture_field_type (type
,
12212 DECLTYPE_FOR_INIT_CAPTURE (t
));
12213 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12214 type
= lambda_proxy_type (type
);
12217 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12218 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12220 /* In a template ~id could be either a complement expression
12221 or an unqualified-id naming a destructor; if instantiating
12222 it produces an expression, it's not an id-expression or
12225 type
= finish_decltype_type (type
, id
, complain
);
12227 return cp_build_qualified_type_real (type
,
12229 | cp_type_quals (type
),
12233 case UNDERLYING_TYPE
:
12235 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12236 complain
, in_decl
);
12237 return finish_underlying_type (type
);
12240 case TYPE_ARGUMENT_PACK
:
12241 case NONTYPE_ARGUMENT_PACK
:
12243 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12245 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12249 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12251 /* For template nontype argument packs, also substitute into
12253 if (code
== NONTYPE_ARGUMENT_PACK
)
12254 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12272 /* We should use one of the expression tsubsts for these codes. */
12273 gcc_unreachable ();
12276 sorry ("use of %qs in template", get_tree_code_name (code
));
12277 return error_mark_node
;
12281 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12282 type of the expression on the left-hand side of the "." or "->"
12286 tsubst_baselink (tree baselink
, tree object_type
,
12287 tree args
, tsubst_flags_t complain
, tree in_decl
)
12290 tree qualifying_scope
;
12293 tree template_args
= 0;
12294 bool template_id_p
= false;
12295 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12297 /* A baselink indicates a function from a base class. Both the
12298 BASELINK_ACCESS_BINFO and the base class referenced may
12299 indicate bases of the template class, rather than the
12300 instantiated class. In addition, lookups that were not
12301 ambiguous before may be ambiguous now. Therefore, we perform
12302 the lookup again. */
12303 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12304 qualifying_scope
= tsubst (qualifying_scope
, args
,
12305 complain
, in_decl
);
12306 fns
= BASELINK_FUNCTIONS (baselink
);
12307 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12308 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12310 template_id_p
= true;
12311 template_args
= TREE_OPERAND (fns
, 1);
12312 fns
= TREE_OPERAND (fns
, 0);
12314 template_args
= tsubst_template_args (template_args
, args
,
12315 complain
, in_decl
);
12317 name
= DECL_NAME (get_first_fn (fns
));
12318 if (IDENTIFIER_TYPENAME_P (name
))
12319 name
= mangle_conv_op_name_for_type (optype
);
12320 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12322 return error_mark_node
;
12324 /* If lookup found a single function, mark it as used at this
12325 point. (If it lookup found multiple functions the one selected
12326 later by overload resolution will be marked as used at that
12328 if (BASELINK_P (baselink
))
12329 fns
= BASELINK_FUNCTIONS (baselink
);
12330 if (!template_id_p
&& !really_overloaded_fn (fns
))
12331 mark_used (OVL_CURRENT (fns
));
12333 /* Add back the template arguments, if present. */
12334 if (BASELINK_P (baselink
) && template_id_p
)
12335 BASELINK_FUNCTIONS (baselink
)
12336 = build_nt (TEMPLATE_ID_EXPR
,
12337 BASELINK_FUNCTIONS (baselink
),
12339 /* Update the conversion operator type. */
12340 BASELINK_OPTYPE (baselink
) = optype
;
12343 object_type
= current_class_type
;
12346 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12352 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12353 true if the qualified-id will be a postfix-expression in-and-of
12354 itself; false if more of the postfix-expression follows the
12355 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12359 tsubst_qualified_id (tree qualified_id
, tree args
,
12360 tsubst_flags_t complain
, tree in_decl
,
12361 bool done
, bool address_p
)
12367 tree template_args
;
12368 location_t loc
= UNKNOWN_LOCATION
;
12370 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12372 /* Figure out what name to look up. */
12373 name
= TREE_OPERAND (qualified_id
, 1);
12374 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12376 is_template
= true;
12377 loc
= EXPR_LOCATION (name
);
12378 template_args
= TREE_OPERAND (name
, 1);
12380 template_args
= tsubst_template_args (template_args
, args
,
12381 complain
, in_decl
);
12382 name
= TREE_OPERAND (name
, 0);
12386 is_template
= false;
12387 template_args
= NULL_TREE
;
12390 /* Substitute into the qualifying scope. When there are no ARGS, we
12391 are just trying to simplify a non-dependent expression. In that
12392 case the qualifying scope may be dependent, and, in any case,
12393 substituting will not help. */
12394 scope
= TREE_OPERAND (qualified_id
, 0);
12397 scope
= tsubst (scope
, args
, complain
, in_decl
);
12398 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12403 if (dependent_scope_p (scope
))
12406 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12407 return build_qualified_name (NULL_TREE
, scope
, expr
,
12408 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12411 if (!BASELINK_P (name
) && !DECL_P (expr
))
12413 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12415 /* A BIT_NOT_EXPR is used to represent a destructor. */
12416 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12418 error ("qualifying type %qT does not match destructor name ~%qT",
12419 scope
, TREE_OPERAND (expr
, 0));
12420 expr
= error_mark_node
;
12423 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12424 /*is_type_p=*/0, false);
12427 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12428 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12429 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12431 if (complain
& tf_error
)
12433 error ("dependent-name %qE is parsed as a non-type, but "
12434 "instantiation yields a type", qualified_id
);
12435 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12437 return error_mark_node
;
12443 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12445 /* Remember that there was a reference to this entity. */
12449 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12451 if (complain
& tf_error
)
12452 qualified_name_lookup_error (scope
,
12453 TREE_OPERAND (qualified_id
, 1),
12454 expr
, input_location
);
12455 return error_mark_node
;
12459 expr
= lookup_template_function (expr
, template_args
);
12461 if (expr
== error_mark_node
&& complain
& tf_error
)
12462 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12463 expr
, input_location
);
12464 else if (TYPE_P (scope
))
12466 expr
= (adjust_result_of_qualified_name_lookup
12467 (expr
, scope
, current_nonlambda_class_type ()));
12468 expr
= (finish_qualified_id_expr
12469 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12470 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12471 /*template_arg_p=*/false, complain
));
12474 /* Expressions do not generally have reference type. */
12475 if (TREE_CODE (expr
) != SCOPE_REF
12476 /* However, if we're about to form a pointer-to-member, we just
12477 want the referenced member referenced. */
12478 && TREE_CODE (expr
) != OFFSET_REF
)
12479 expr
= convert_from_reference (expr
);
12484 /* Like tsubst, but deals with expressions. This function just replaces
12485 template parms; to finish processing the resultant expression, use
12486 tsubst_copy_and_build or tsubst_expr. */
12489 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12491 enum tree_code code
;
12494 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12497 code
= TREE_CODE (t
);
12502 r
= retrieve_local_specialization (t
);
12504 if (r
== NULL_TREE
)
12506 /* We get here for a use of 'this' in an NSDMI. */
12507 if (DECL_NAME (t
) == this_identifier
12508 && at_function_scope_p ()
12509 && DECL_CONSTRUCTOR_P (current_function_decl
))
12510 return current_class_ptr
;
12512 /* This can happen for a parameter name used later in a function
12513 declaration (such as in a late-specified return type). Just
12514 make a dummy decl, since it's only used for its type. */
12515 gcc_assert (cp_unevaluated_operand
!= 0);
12516 r
= tsubst_decl (t
, args
, complain
);
12517 /* Give it the template pattern as its context; its true context
12518 hasn't been instantiated yet and this is good enough for
12520 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12523 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12524 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12533 if (DECL_TEMPLATE_PARM_P (t
))
12534 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12535 /* There is no need to substitute into namespace-scope
12537 if (DECL_NAMESPACE_SCOPE_P (t
))
12539 /* If ARGS is NULL, then T is known to be non-dependent. */
12540 if (args
== NULL_TREE
)
12541 return integral_constant_value (t
);
12543 /* Unfortunately, we cannot just call lookup_name here.
12546 template <int I> int f() {
12548 struct S { void g() { E e = a; } };
12551 When we instantiate f<7>::S::g(), say, lookup_name is not
12552 clever enough to find f<7>::a. */
12554 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12555 /*entering_scope=*/0);
12557 for (v
= TYPE_VALUES (enum_type
);
12559 v
= TREE_CHAIN (v
))
12560 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12561 return TREE_VALUE (v
);
12563 /* We didn't find the name. That should never happen; if
12564 name-lookup found it during preliminary parsing, we
12565 should find it again here during instantiation. */
12566 gcc_unreachable ();
12571 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12573 /* Check for a local specialization set up by
12574 tsubst_pack_expansion. */
12575 if (tree r
= retrieve_local_specialization (t
))
12577 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12578 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12582 /* When retrieving a capture pack from a generic lambda, remove the
12583 lambda call op's own template argument list from ARGS. Only the
12584 template arguments active for the closure type should be used to
12585 retrieve the pack specialization. */
12586 if (LAMBDA_FUNCTION_P (current_function_decl
)
12587 && (template_class_depth (DECL_CONTEXT (t
))
12588 != TMPL_ARGS_DEPTH (args
)))
12589 args
= strip_innermost_template_args (args
, 1);
12591 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12592 tsubst_decl put in the hash table. */
12593 return retrieve_specialization (t
, args
, 0);
12596 if (DECL_CONTEXT (t
))
12600 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12601 /*entering_scope=*/1);
12602 if (ctx
!= DECL_CONTEXT (t
))
12604 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
12607 if (complain
& tf_error
)
12608 error ("using invalid field %qD", t
);
12609 return error_mark_node
;
12618 case FUNCTION_DECL
:
12619 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
12620 r
= tsubst (t
, args
, complain
, in_decl
);
12621 else if (local_variable_p (t
))
12623 r
= retrieve_local_specialization (t
);
12624 if (r
== NULL_TREE
)
12626 if (DECL_ANON_UNION_VAR_P (t
))
12628 /* Just use name lookup to find a member alias for an
12629 anonymous union, but then add it to the hash table. */
12630 r
= lookup_name (DECL_NAME (t
));
12631 gcc_assert (DECL_ANON_UNION_VAR_P (r
));
12632 register_local_specialization (r
, t
);
12636 /* This can happen for a variable used in a
12637 late-specified return type of a local lambda, or for a
12638 local static or constant. Building a new VAR_DECL
12639 should be OK in all those cases. */
12640 r
= tsubst_decl (t
, args
, complain
);
12641 if (decl_constant_var_p (r
))
12642 /* A use of a local constant must decay to its value. */
12643 return integral_constant_value (r
);
12644 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
12645 || errorcount
|| sorrycount
);
12655 case NAMESPACE_DECL
:
12659 /* An OVERLOAD will always be a non-dependent overload set; an
12660 overload set from function scope will just be represented with an
12661 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12662 gcc_assert (!uses_template_parms (t
));
12666 return tsubst_baselink (t
, current_nonlambda_class_type (),
12667 args
, complain
, in_decl
);
12669 case TEMPLATE_DECL
:
12670 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12671 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
12672 args
, complain
, in_decl
);
12673 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
12674 return tsubst (t
, args
, complain
, in_decl
);
12675 else if (DECL_CLASS_SCOPE_P (t
)
12676 && uses_template_parms (DECL_CONTEXT (t
)))
12678 /* Template template argument like the following example need
12681 template <template <class> class TT> struct C {};
12682 template <class T> struct D {
12683 template <class U> struct E {};
12688 We are processing the template argument `E' in #1 for
12689 the template instantiation #2. Originally, `E' is a
12690 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12691 have to substitute this with one having context `D<int>'. */
12693 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
12694 return lookup_field (context
, DECL_NAME(t
), 0, false);
12697 /* Ordinary template template argument. */
12701 case REINTERPRET_CAST_EXPR
:
12702 case CONST_CAST_EXPR
:
12703 case STATIC_CAST_EXPR
:
12704 case DYNAMIC_CAST_EXPR
:
12705 case IMPLICIT_CONV_EXPR
:
12709 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
12710 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
12713 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
12716 tree expanded
, op
= TREE_OPERAND (t
, 0);
12719 if (SIZEOF_EXPR_TYPE_P (t
))
12720 op
= TREE_TYPE (op
);
12722 ++cp_unevaluated_operand
;
12723 ++c_inhibit_evaluation_warnings
;
12724 /* We only want to compute the number of arguments. */
12725 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
12726 --cp_unevaluated_operand
;
12727 --c_inhibit_evaluation_warnings
;
12729 if (TREE_CODE (expanded
) == TREE_VEC
)
12730 len
= TREE_VEC_LENGTH (expanded
);
12732 if (expanded
== error_mark_node
)
12733 return error_mark_node
;
12734 else if (PACK_EXPANSION_P (expanded
)
12735 || (TREE_CODE (expanded
) == TREE_VEC
12737 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
12739 if (TREE_CODE (expanded
) == TREE_VEC
)
12740 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
12742 if (TYPE_P (expanded
))
12743 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
12744 complain
& tf_error
);
12746 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
12747 complain
& tf_error
);
12750 return build_int_cst (size_type_node
, len
);
12752 if (SIZEOF_EXPR_TYPE_P (t
))
12754 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
12755 args
, complain
, in_decl
);
12756 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
12757 r
= build1 (SIZEOF_EXPR
,
12758 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
12759 SIZEOF_EXPR_TYPE_P (r
) = 1;
12766 case TRUTH_NOT_EXPR
:
12769 case UNARY_PLUS_EXPR
: /* Unary + */
12771 case AT_ENCODE_EXPR
:
12775 case REALPART_EXPR
:
12776 case IMAGPART_EXPR
:
12779 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
12780 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
12782 case COMPONENT_REF
:
12787 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12788 name
= TREE_OPERAND (t
, 1);
12789 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
12791 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12792 complain
, in_decl
);
12793 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12795 else if (TREE_CODE (name
) == SCOPE_REF
12796 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
12798 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12799 complain
, in_decl
);
12800 name
= TREE_OPERAND (name
, 1);
12801 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12802 complain
, in_decl
);
12803 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12804 name
= build_qualified_name (/*type=*/NULL_TREE
,
12806 /*template_p=*/false);
12808 else if (BASELINK_P (name
))
12809 name
= tsubst_baselink (name
,
12810 non_reference (TREE_TYPE (object
)),
12814 name
= tsubst_copy (name
, args
, complain
, in_decl
);
12815 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
12821 case TRUNC_DIV_EXPR
:
12822 case CEIL_DIV_EXPR
:
12823 case FLOOR_DIV_EXPR
:
12824 case ROUND_DIV_EXPR
:
12825 case EXACT_DIV_EXPR
:
12829 case TRUNC_MOD_EXPR
:
12830 case FLOOR_MOD_EXPR
:
12831 case TRUTH_ANDIF_EXPR
:
12832 case TRUTH_ORIF_EXPR
:
12833 case TRUTH_AND_EXPR
:
12834 case TRUTH_OR_EXPR
:
12847 case COMPOUND_EXPR
:
12850 case PREDECREMENT_EXPR
:
12851 case PREINCREMENT_EXPR
:
12852 case POSTDECREMENT_EXPR
:
12853 case POSTINCREMENT_EXPR
:
12855 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12856 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
12859 return build_qualified_name (/*type=*/NULL_TREE
,
12860 tsubst_copy (TREE_OPERAND (t
, 0),
12861 args
, complain
, in_decl
),
12862 tsubst_copy (TREE_OPERAND (t
, 1),
12863 args
, complain
, in_decl
),
12864 QUALIFIED_NAME_IS_TEMPLATE (t
));
12869 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12870 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12871 NULL_TREE
, NULL_TREE
);
12875 int n
= VL_EXP_OPERAND_LENGTH (t
);
12876 tree result
= build_vl_exp (CALL_EXPR
, n
);
12878 for (i
= 0; i
< n
; i
++)
12879 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
12880 complain
, in_decl
);
12886 case PSEUDO_DTOR_EXPR
:
12887 case VEC_PERM_EXPR
:
12890 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12891 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12892 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
12893 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
12900 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12901 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12902 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
12903 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
12910 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12911 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
12912 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
12913 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
12917 case TEMPLATE_ID_EXPR
:
12919 /* Substituted template arguments */
12920 tree fn
= TREE_OPERAND (t
, 0);
12921 tree targs
= TREE_OPERAND (t
, 1);
12923 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
12925 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
12927 return lookup_template_function (fn
, targs
);
12932 tree purpose
, value
, chain
;
12934 if (t
== void_list_node
)
12937 purpose
= TREE_PURPOSE (t
);
12939 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
12940 value
= TREE_VALUE (t
);
12942 value
= tsubst_copy (value
, args
, complain
, in_decl
);
12943 chain
= TREE_CHAIN (t
);
12944 if (chain
&& chain
!= void_type_node
)
12945 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
12946 if (purpose
== TREE_PURPOSE (t
)
12947 && value
== TREE_VALUE (t
)
12948 && chain
== TREE_CHAIN (t
))
12950 return tree_cons (purpose
, value
, chain
);
12955 case ENUMERAL_TYPE
:
12957 case TEMPLATE_TYPE_PARM
:
12958 case TEMPLATE_TEMPLATE_PARM
:
12959 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12960 case TEMPLATE_PARM_INDEX
:
12962 case REFERENCE_TYPE
:
12964 case FUNCTION_TYPE
:
12967 case TYPENAME_TYPE
:
12968 case UNBOUND_CLASS_TEMPLATE
:
12970 case DECLTYPE_TYPE
:
12972 return tsubst (t
, args
, complain
, in_decl
);
12976 /* Fall through. */
12977 case IDENTIFIER_NODE
:
12978 if (IDENTIFIER_TYPENAME_P (t
))
12980 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12981 return mangle_conv_op_name_for_type (new_type
);
12987 /* This is handled by tsubst_copy_and_build. */
12988 gcc_unreachable ();
12991 return build_x_va_arg (EXPR_LOCATION (t
),
12992 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
,
12994 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
12996 case CLEANUP_POINT_EXPR
:
12997 /* We shouldn't have built any of these during initial template
12998 generation. Instead, they should be built during instantiation
12999 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13000 gcc_unreachable ();
13004 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
13005 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
13006 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
13007 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13008 mark_used (TREE_OPERAND (r
, 1));
13011 case EXPR_PACK_EXPANSION
:
13012 error ("invalid use of pack expansion expression");
13013 return error_mark_node
;
13015 case NONTYPE_ARGUMENT_PACK
:
13016 error ("use %<...%> to expand argument pack");
13017 return error_mark_node
;
13024 /* Instantiate any typedefs in the type. */
13025 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13026 r
= fold_convert (type
, t
);
13027 gcc_assert (TREE_CODE (r
) == code
);
13032 /* These can sometimes show up in a partial instantiation, but never
13033 involve template parms. */
13034 gcc_assert (!uses_template_parms (t
));
13038 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13039 gcc_checking_assert (false);
13044 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13047 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13048 tree args
, tsubst_flags_t complain
, tree in_decl
)
13050 tree new_clauses
= NULL
, nc
, oc
;
13052 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13054 nc
= copy_node (oc
);
13055 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13058 switch (OMP_CLAUSE_CODE (nc
))
13060 case OMP_CLAUSE_LASTPRIVATE
:
13061 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13063 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13064 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13065 in_decl
, /*integral_constant_expression_p=*/false);
13066 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13067 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13070 case OMP_CLAUSE_PRIVATE
:
13071 case OMP_CLAUSE_SHARED
:
13072 case OMP_CLAUSE_FIRSTPRIVATE
:
13073 case OMP_CLAUSE_COPYIN
:
13074 case OMP_CLAUSE_COPYPRIVATE
:
13075 case OMP_CLAUSE_IF
:
13076 case OMP_CLAUSE_NUM_THREADS
:
13077 case OMP_CLAUSE_SCHEDULE
:
13078 case OMP_CLAUSE_COLLAPSE
:
13079 case OMP_CLAUSE_FINAL
:
13080 case OMP_CLAUSE_DEPEND
:
13081 case OMP_CLAUSE_FROM
:
13082 case OMP_CLAUSE_TO
:
13083 case OMP_CLAUSE_UNIFORM
:
13084 case OMP_CLAUSE_MAP
:
13085 case OMP_CLAUSE_DEVICE
:
13086 case OMP_CLAUSE_DIST_SCHEDULE
:
13087 case OMP_CLAUSE_NUM_TEAMS
:
13088 case OMP_CLAUSE_THREAD_LIMIT
:
13089 case OMP_CLAUSE_SAFELEN
:
13090 case OMP_CLAUSE_SIMDLEN
:
13091 OMP_CLAUSE_OPERAND (nc
, 0)
13092 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13093 in_decl
, /*integral_constant_expression_p=*/false);
13095 case OMP_CLAUSE_REDUCTION
:
13096 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13098 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13099 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13101 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13102 complain
, in_decl
);
13103 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13104 = build_qualified_name (NULL_TREE
, scope
,
13105 TREE_OPERAND (placeholder
, 1),
13109 gcc_assert (identifier_p (placeholder
));
13111 OMP_CLAUSE_OPERAND (nc
, 0)
13112 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13113 in_decl
, /*integral_constant_expression_p=*/false);
13115 case OMP_CLAUSE_LINEAR
:
13116 case OMP_CLAUSE_ALIGNED
:
13117 OMP_CLAUSE_OPERAND (nc
, 0)
13118 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13119 in_decl
, /*integral_constant_expression_p=*/false);
13120 OMP_CLAUSE_OPERAND (nc
, 1)
13121 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13122 in_decl
, /*integral_constant_expression_p=*/false);
13125 case OMP_CLAUSE_NOWAIT
:
13126 case OMP_CLAUSE_ORDERED
:
13127 case OMP_CLAUSE_DEFAULT
:
13128 case OMP_CLAUSE_UNTIED
:
13129 case OMP_CLAUSE_MERGEABLE
:
13130 case OMP_CLAUSE_INBRANCH
:
13131 case OMP_CLAUSE_NOTINBRANCH
:
13132 case OMP_CLAUSE_PROC_BIND
:
13133 case OMP_CLAUSE_FOR
:
13134 case OMP_CLAUSE_PARALLEL
:
13135 case OMP_CLAUSE_SECTIONS
:
13136 case OMP_CLAUSE_TASKGROUP
:
13139 gcc_unreachable ();
13143 new_clauses
= nreverse (new_clauses
);
13145 new_clauses
= finish_omp_clauses (new_clauses
);
13146 return new_clauses
;
13149 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13152 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13155 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13157 tree purpose
, value
, chain
;
13162 if (TREE_CODE (t
) != TREE_LIST
)
13163 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13164 /*function_p=*/false,
13165 /*integral_constant_expression_p=*/false);
13167 if (t
== void_list_node
)
13170 purpose
= TREE_PURPOSE (t
);
13172 purpose
= RECUR (purpose
);
13173 value
= TREE_VALUE (t
);
13176 if (TREE_CODE (value
) != LABEL_DECL
)
13177 value
= RECUR (value
);
13180 value
= lookup_label (DECL_NAME (value
));
13181 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13182 TREE_USED (value
) = 1;
13185 chain
= TREE_CHAIN (t
);
13186 if (chain
&& chain
!= void_type_node
)
13187 chain
= RECUR (chain
);
13188 return tree_cons (purpose
, value
, chain
);
13192 /* Substitute one OMP_FOR iterator. */
13195 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13196 tree condv
, tree incrv
, tree
*clauses
,
13197 tree args
, tsubst_flags_t complain
, tree in_decl
,
13198 bool integral_constant_expression_p
)
13200 #define RECUR(NODE) \
13201 tsubst_expr ((NODE), args, complain, in_decl, \
13202 integral_constant_expression_p)
13203 tree decl
, init
, cond
, incr
;
13205 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13206 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13207 decl
= TREE_OPERAND (init
, 0);
13208 init
= TREE_OPERAND (init
, 1);
13209 tree decl_expr
= NULL_TREE
;
13210 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13212 /* We need to jump through some hoops to handle declarations in the
13213 for-init-statement, since we might need to handle auto deduction,
13214 but we need to keep control of initialization. */
13216 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13217 decl
= tsubst_decl (decl
, args
, complain
);
13220 decl
= RECUR (decl
);
13221 init
= RECUR (init
);
13223 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13224 if (auto_node
&& init
)
13226 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13228 gcc_assert (!type_dependent_expression_p (decl
));
13230 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13234 /* Declare the variable, but don't let that initialize it. */
13235 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13236 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13238 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13241 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13242 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13243 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13244 incr
= build_x_modify_expr (EXPR_LOCATION (incr
),
13245 RECUR (TREE_OPERAND (incr
, 0)), NOP_EXPR
,
13246 RECUR (TREE_OPERAND (incr
, 1)),
13249 incr
= RECUR (incr
);
13250 TREE_VEC_ELT (declv
, i
) = decl
;
13251 TREE_VEC_ELT (initv
, i
) = init
;
13252 TREE_VEC_ELT (condv
, i
) = cond
;
13253 TREE_VEC_ELT (incrv
, i
) = incr
;
13259 /* Declare and initialize the variable. */
13266 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13268 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13269 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13270 && OMP_CLAUSE_DECL (c
) == decl
)
13272 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13273 && OMP_CLAUSE_DECL (c
) == decl
)
13274 error ("iteration variable %qD should not be firstprivate", decl
);
13275 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13276 && OMP_CLAUSE_DECL (c
) == decl
)
13277 error ("iteration variable %qD should not be reduction", decl
);
13281 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13282 OMP_CLAUSE_DECL (c
) = decl
;
13283 c
= finish_omp_clauses (c
);
13286 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13291 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13292 if (COMPARISON_CLASS_P (cond
))
13293 cond
= build2 (TREE_CODE (cond
), boolean_type_node
,
13294 RECUR (TREE_OPERAND (cond
, 0)),
13295 RECUR (TREE_OPERAND (cond
, 1)));
13297 cond
= RECUR (cond
);
13298 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13299 switch (TREE_CODE (incr
))
13301 case PREINCREMENT_EXPR
:
13302 case PREDECREMENT_EXPR
:
13303 case POSTINCREMENT_EXPR
:
13304 case POSTDECREMENT_EXPR
:
13305 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13306 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13309 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13310 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13312 tree rhs
= TREE_OPERAND (incr
, 1);
13313 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
),
13314 RECUR (TREE_OPERAND (incr
, 0)),
13315 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13316 RECUR (TREE_OPERAND (rhs
, 0)),
13317 RECUR (TREE_OPERAND (rhs
, 1))));
13320 incr
= RECUR (incr
);
13323 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13324 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13326 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13327 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13328 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13329 TREE_TYPE (decl
), lhs
,
13330 RECUR (TREE_OPERAND (incr
, 2))));
13332 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13333 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13334 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13336 tree rhs
= TREE_OPERAND (incr
, 2);
13337 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
),
13338 RECUR (TREE_OPERAND (incr
, 0)),
13339 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13340 RECUR (TREE_OPERAND (rhs
, 0)),
13341 RECUR (TREE_OPERAND (rhs
, 1))));
13344 incr
= RECUR (incr
);
13347 incr
= RECUR (incr
);
13351 TREE_VEC_ELT (declv
, i
) = decl
;
13352 TREE_VEC_ELT (initv
, i
) = init
;
13353 TREE_VEC_ELT (condv
, i
) = cond
;
13354 TREE_VEC_ELT (incrv
, i
) = incr
;
13358 /* Like tsubst_copy for expressions, etc. but also does semantic
13362 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13363 bool integral_constant_expression_p
)
13365 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13366 #define RECUR(NODE) \
13367 tsubst_expr ((NODE), args, complain, in_decl, \
13368 integral_constant_expression_p)
13374 if (t
== NULL_TREE
|| t
== error_mark_node
)
13377 loc
= input_location
;
13378 if (EXPR_HAS_LOCATION (t
))
13379 input_location
= EXPR_LOCATION (t
);
13380 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13381 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13383 switch (TREE_CODE (t
))
13385 case STATEMENT_LIST
:
13387 tree_stmt_iterator i
;
13388 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13389 RECUR (tsi_stmt (i
));
13393 case CTOR_INITIALIZER
:
13394 finish_mem_initializers (tsubst_initializer_list
13395 (TREE_OPERAND (t
, 0), args
));
13399 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13403 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13404 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13405 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13407 finish_expr_stmt (tmp
);
13411 do_using_directive (USING_STMT_NAMESPACE (t
));
13416 tree decl
, pattern_decl
;
13419 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13420 if (TREE_CODE (decl
) == LABEL_DECL
)
13421 finish_label_decl (DECL_NAME (decl
));
13422 else if (TREE_CODE (decl
) == USING_DECL
)
13424 tree scope
= USING_DECL_SCOPE (decl
);
13425 tree name
= DECL_NAME (decl
);
13428 scope
= tsubst (scope
, args
, complain
, in_decl
);
13429 decl
= lookup_qualified_name (scope
, name
,
13430 /*is_type_p=*/false,
13431 /*complain=*/false);
13432 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13433 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13435 do_local_using_decl (decl
, scope
, name
);
13437 else if (DECL_PACK_P (decl
))
13439 /* Don't build up decls for a variadic capture proxy, we'll
13440 instantiate the elements directly as needed. */
13445 init
= DECL_INITIAL (decl
);
13446 decl
= tsubst (decl
, args
, complain
, in_decl
);
13447 if (decl
!= error_mark_node
)
13449 /* By marking the declaration as instantiated, we avoid
13450 trying to instantiate it. Since instantiate_decl can't
13451 handle local variables, and since we've already done
13452 all that needs to be done, that's the right thing to
13455 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13457 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13458 /* Anonymous aggregates are a special case. */
13459 finish_anon_union (decl
);
13460 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13462 DECL_CONTEXT (decl
) = current_function_decl
;
13463 if (DECL_NAME (decl
) == this_identifier
)
13465 tree lam
= DECL_CONTEXT (current_function_decl
);
13466 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13467 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13469 insert_capture_proxy (decl
);
13471 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13472 /* We already did a pushtag. */;
13473 else if (TREE_CODE (decl
) == FUNCTION_DECL
13474 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13475 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13477 DECL_CONTEXT (decl
) = NULL_TREE
;
13479 DECL_CONTEXT (decl
) = current_function_decl
;
13480 cp_check_omp_declare_reduction (decl
);
13484 int const_init
= false;
13485 maybe_push_decl (decl
);
13487 && DECL_PRETTY_FUNCTION_P (decl
))
13489 /* For __PRETTY_FUNCTION__ we have to adjust the
13491 const char *const name
13492 = cxx_printable_name (current_function_decl
, 2);
13493 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13497 tree t
= RECUR (init
);
13501 /* If we had an initializer but it
13502 instantiated to nothing,
13503 value-initialize the object. This will
13504 only occur when the initializer was a
13505 pack expansion where the parameter packs
13506 used in that expansion were of length
13508 init
= build_value_init (TREE_TYPE (decl
),
13510 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
13511 init
= get_target_expr_sfinae (init
, complain
);
13518 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13520 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13529 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13530 RECUR (FOR_INIT_STMT (t
));
13531 finish_for_init_stmt (stmt
);
13532 tmp
= RECUR (FOR_COND (t
));
13533 finish_for_cond (tmp
, stmt
, false);
13534 tmp
= RECUR (FOR_EXPR (t
));
13535 finish_for_expr (tmp
, stmt
);
13536 RECUR (FOR_BODY (t
));
13537 finish_for_stmt (stmt
);
13540 case RANGE_FOR_STMT
:
13543 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13544 decl
= RANGE_FOR_DECL (t
);
13545 decl
= tsubst (decl
, args
, complain
, in_decl
);
13546 maybe_push_decl (decl
);
13547 expr
= RECUR (RANGE_FOR_EXPR (t
));
13548 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13549 RECUR (RANGE_FOR_BODY (t
));
13550 finish_for_stmt (stmt
);
13555 stmt
= begin_while_stmt ();
13556 tmp
= RECUR (WHILE_COND (t
));
13557 finish_while_stmt_cond (tmp
, stmt
, false);
13558 RECUR (WHILE_BODY (t
));
13559 finish_while_stmt (stmt
);
13563 stmt
= begin_do_stmt ();
13564 RECUR (DO_BODY (t
));
13565 finish_do_body (stmt
);
13566 tmp
= RECUR (DO_COND (t
));
13567 finish_do_stmt (tmp
, stmt
, false);
13571 stmt
= begin_if_stmt ();
13572 tmp
= RECUR (IF_COND (t
));
13573 finish_if_stmt_cond (tmp
, stmt
);
13574 RECUR (THEN_CLAUSE (t
));
13575 finish_then_clause (stmt
);
13577 if (ELSE_CLAUSE (t
))
13579 begin_else_clause (stmt
);
13580 RECUR (ELSE_CLAUSE (t
));
13581 finish_else_clause (stmt
);
13584 finish_if_stmt (stmt
);
13588 if (BIND_EXPR_BODY_BLOCK (t
))
13589 stmt
= begin_function_body ();
13591 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
13592 ? BCS_TRY_BLOCK
: 0);
13594 RECUR (BIND_EXPR_BODY (t
));
13596 if (BIND_EXPR_BODY_BLOCK (t
))
13597 finish_function_body (stmt
);
13599 finish_compound_stmt (stmt
);
13603 finish_break_stmt ();
13606 case CONTINUE_STMT
:
13607 finish_continue_stmt ();
13611 stmt
= begin_switch_stmt ();
13612 tmp
= RECUR (SWITCH_STMT_COND (t
));
13613 finish_switch_cond (tmp
, stmt
);
13614 RECUR (SWITCH_STMT_BODY (t
));
13615 finish_switch_stmt (stmt
);
13618 case CASE_LABEL_EXPR
:
13619 finish_case_label (EXPR_LOCATION (t
),
13620 RECUR (CASE_LOW (t
)),
13621 RECUR (CASE_HIGH (t
)));
13626 tree decl
= LABEL_EXPR_LABEL (t
);
13629 label
= finish_label_stmt (DECL_NAME (decl
));
13630 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13631 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13636 tmp
= GOTO_DESTINATION (t
);
13637 if (TREE_CODE (tmp
) != LABEL_DECL
)
13638 /* Computed goto's must be tsubst'd into. On the other hand,
13639 non-computed gotos must not be; the identifier in question
13640 will have no binding. */
13643 tmp
= DECL_NAME (tmp
);
13644 finish_goto_stmt (tmp
);
13648 tmp
= finish_asm_stmt
13649 (ASM_VOLATILE_P (t
),
13650 RECUR (ASM_STRING (t
)),
13651 tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
, complain
, in_decl
),
13652 tsubst_copy_asm_operands (ASM_INPUTS (t
), args
, complain
, in_decl
),
13653 tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
, complain
, in_decl
),
13654 tsubst_copy_asm_operands (ASM_LABELS (t
), args
, complain
, in_decl
));
13656 tree asm_expr
= tmp
;
13657 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
13658 asm_expr
= TREE_OPERAND (asm_expr
, 0);
13659 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
13666 stmt
= begin_try_block ();
13667 RECUR (TRY_STMTS (t
));
13668 finish_cleanup_try_block (stmt
);
13669 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
13673 tree compound_stmt
= NULL_TREE
;
13675 if (FN_TRY_BLOCK_P (t
))
13676 stmt
= begin_function_try_block (&compound_stmt
);
13678 stmt
= begin_try_block ();
13680 RECUR (TRY_STMTS (t
));
13682 if (FN_TRY_BLOCK_P (t
))
13683 finish_function_try_block (stmt
);
13685 finish_try_block (stmt
);
13687 RECUR (TRY_HANDLERS (t
));
13688 if (FN_TRY_BLOCK_P (t
))
13689 finish_function_handler_sequence (stmt
, compound_stmt
);
13691 finish_handler_sequence (stmt
);
13697 tree decl
= HANDLER_PARMS (t
);
13701 decl
= tsubst (decl
, args
, complain
, in_decl
);
13702 /* Prevent instantiate_decl from trying to instantiate
13703 this variable. We've already done all that needs to be
13705 if (decl
!= error_mark_node
)
13706 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13708 stmt
= begin_handler ();
13709 finish_handler_parms (decl
, stmt
);
13710 RECUR (HANDLER_BODY (t
));
13711 finish_handler (stmt
);
13716 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
13717 if (CLASS_TYPE_P (tmp
))
13719 /* Local classes are not independent templates; they are
13720 instantiated along with their containing function. And this
13721 way we don't have to deal with pushing out of one local class
13722 to instantiate a member of another local class. */
13724 /* Closures are handled by the LAMBDA_EXPR. */
13725 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
13726 complete_type (tmp
);
13727 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
13728 if (!DECL_ARTIFICIAL (fn
))
13729 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
13733 case STATIC_ASSERT
:
13737 ++c_inhibit_evaluation_warnings
;
13739 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
13742 /*integral_constant_expression_p=*/true);
13743 --c_inhibit_evaluation_warnings
;
13745 finish_static_assert (condition
,
13746 STATIC_ASSERT_MESSAGE (t
),
13747 STATIC_ASSERT_SOURCE_LOCATION (t
),
13748 /*member_p=*/false);
13753 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
13754 args
, complain
, in_decl
);
13755 stmt
= begin_omp_parallel ();
13756 RECUR (OMP_PARALLEL_BODY (t
));
13757 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
13758 = OMP_PARALLEL_COMBINED (t
);
13762 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
13763 args
, complain
, in_decl
);
13764 stmt
= begin_omp_task ();
13765 RECUR (OMP_TASK_BODY (t
));
13766 finish_omp_task (tmp
, stmt
);
13772 case OMP_DISTRIBUTE
:
13774 tree clauses
, body
, pre_body
;
13775 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
13776 tree incrv
= NULL_TREE
;
13779 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
13780 args
, complain
, in_decl
);
13781 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13783 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13784 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13785 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13786 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13789 stmt
= begin_omp_structured_block ();
13791 pre_body
= push_stmt_list ();
13792 RECUR (OMP_FOR_PRE_BODY (t
));
13793 pre_body
= pop_stmt_list (pre_body
);
13795 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13796 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
13797 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
13798 &clauses
, args
, complain
, in_decl
,
13799 integral_constant_expression_p
);
13801 body
= push_stmt_list ();
13802 RECUR (OMP_FOR_BODY (t
));
13803 body
= pop_stmt_list (body
);
13805 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13806 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
13807 condv
, incrv
, body
, pre_body
, clauses
);
13810 t
= make_node (TREE_CODE (t
));
13811 TREE_TYPE (t
) = void_type_node
;
13812 OMP_FOR_BODY (t
) = body
;
13813 OMP_FOR_PRE_BODY (t
) = pre_body
;
13814 OMP_FOR_CLAUSES (t
) = clauses
;
13815 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
13819 add_stmt (finish_omp_structured_block (stmt
));
13826 case OMP_TARGET_DATA
:
13828 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
13829 args
, complain
, in_decl
);
13830 stmt
= push_stmt_list ();
13831 RECUR (OMP_BODY (t
));
13832 stmt
= pop_stmt_list (stmt
);
13835 OMP_BODY (t
) = stmt
;
13836 OMP_CLAUSES (t
) = tmp
;
13840 case OMP_TARGET_UPDATE
:
13841 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
13842 args
, complain
, in_decl
);
13844 OMP_CLAUSES (t
) = tmp
;
13851 case OMP_TASKGROUP
:
13853 stmt
= push_stmt_list ();
13854 RECUR (OMP_BODY (t
));
13855 stmt
= pop_stmt_list (stmt
);
13858 OMP_BODY (t
) = stmt
;
13863 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
13864 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
13866 tree op1
= TREE_OPERAND (t
, 1);
13867 tree rhs1
= NULL_TREE
;
13869 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
13871 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
13872 op1
= TREE_OPERAND (op1
, 1);
13874 lhs
= RECUR (TREE_OPERAND (op1
, 0));
13875 rhs
= RECUR (TREE_OPERAND (op1
, 1));
13876 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
13877 NULL_TREE
, NULL_TREE
, rhs1
,
13878 OMP_ATOMIC_SEQ_CST (t
));
13882 tree op1
= TREE_OPERAND (t
, 1);
13883 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
13884 tree rhs1
= NULL_TREE
;
13885 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
13886 enum tree_code opcode
= NOP_EXPR
;
13887 if (code
== OMP_ATOMIC_READ
)
13889 v
= RECUR (TREE_OPERAND (op1
, 0));
13890 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
13892 else if (code
== OMP_ATOMIC_CAPTURE_OLD
13893 || code
== OMP_ATOMIC_CAPTURE_NEW
)
13895 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
13896 v
= RECUR (TREE_OPERAND (op1
, 0));
13897 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
13898 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
13900 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
13901 op11
= TREE_OPERAND (op11
, 1);
13903 lhs
= RECUR (TREE_OPERAND (op11
, 0));
13904 rhs
= RECUR (TREE_OPERAND (op11
, 1));
13905 opcode
= TREE_CODE (op11
);
13906 if (opcode
== MODIFY_EXPR
)
13912 lhs
= RECUR (TREE_OPERAND (op1
, 0));
13913 rhs
= RECUR (TREE_OPERAND (op1
, 1));
13915 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
13916 OMP_ATOMIC_SEQ_CST (t
));
13920 case TRANSACTION_EXPR
:
13923 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
13924 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
13926 if (TRANSACTION_EXPR_IS_STMT (t
))
13928 tree body
= TRANSACTION_EXPR_BODY (t
);
13929 tree noex
= NULL_TREE
;
13930 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
13932 noex
= MUST_NOT_THROW_COND (body
);
13933 if (noex
== NULL_TREE
)
13934 noex
= boolean_true_node
;
13935 body
= TREE_OPERAND (body
, 0);
13937 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
13939 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
13943 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
13944 RECUR (TRANSACTION_EXPR_BODY (t
)),
13951 case MUST_NOT_THROW_EXPR
:
13952 RETURN (build_must_not_throw_expr (RECUR (TREE_OPERAND (t
, 0)),
13953 RECUR (MUST_NOT_THROW_COND (t
))));
13955 case EXPR_PACK_EXPANSION
:
13956 error ("invalid use of pack expansion expression");
13957 RETURN (error_mark_node
);
13959 case NONTYPE_ARGUMENT_PACK
:
13960 error ("use %<...%> to expand argument pack");
13961 RETURN (error_mark_node
);
13963 case CILK_SPAWN_STMT
:
13964 cfun
->calls_cilk_spawn
= 1;
13965 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
13967 case CILK_SYNC_STMT
:
13968 RETURN (build_cilk_sync ());
13970 case COMPOUND_EXPR
:
13971 tmp
= RECUR (TREE_OPERAND (t
, 0));
13972 if (tmp
== NULL_TREE
)
13973 /* If the first operand was a statement, we're done with it. */
13974 RETURN (RECUR (TREE_OPERAND (t
, 1)));
13975 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
13976 RECUR (TREE_OPERAND (t
, 1)),
13979 case ANNOTATE_EXPR
:
13980 tmp
= RECUR (TREE_OPERAND (t
, 0));
13981 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
13982 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
13985 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
13987 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13988 /*function_p=*/false,
13989 integral_constant_expression_p
));
13992 RETURN (NULL_TREE
);
13994 input_location
= loc
;
14000 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14001 function. For description of the body see comment above
14002 cp_parser_omp_declare_reduction_exprs. */
14005 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14007 if (t
== NULL_TREE
|| t
== error_mark_node
)
14010 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14012 tree_stmt_iterator tsi
;
14015 memset (stmts
, 0, sizeof stmts
);
14016 for (i
= 0, tsi
= tsi_start (t
);
14017 i
< 7 && !tsi_end_p (tsi
);
14018 i
++, tsi_next (&tsi
))
14019 stmts
[i
] = tsi_stmt (tsi
);
14020 gcc_assert (tsi_end_p (tsi
));
14024 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14025 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14026 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14027 args
, complain
, in_decl
);
14028 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14029 args
, complain
, in_decl
);
14030 DECL_CONTEXT (omp_out
) = current_function_decl
;
14031 DECL_CONTEXT (omp_in
) = current_function_decl
;
14032 keep_next_level (true);
14033 tree block
= begin_omp_structured_block ();
14034 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14035 block
= finish_omp_structured_block (block
);
14036 block
= maybe_cleanup_point_expr_void (block
);
14037 add_decl_expr (omp_out
);
14038 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14039 TREE_NO_WARNING (omp_out
) = 1;
14040 add_decl_expr (omp_in
);
14041 finish_expr_stmt (block
);
14045 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14046 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14047 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14048 args
, complain
, in_decl
);
14049 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14050 args
, complain
, in_decl
);
14051 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14052 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14053 keep_next_level (true);
14054 tree block
= begin_omp_structured_block ();
14055 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14056 block
= finish_omp_structured_block (block
);
14057 block
= maybe_cleanup_point_expr_void (block
);
14058 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14059 add_decl_expr (omp_priv
);
14060 add_decl_expr (omp_orig
);
14061 finish_expr_stmt (block
);
14063 add_decl_expr (omp_orig
);
14067 /* T is a postfix-expression that is not being used in a function
14068 call. Return the substituted version of T. */
14071 tsubst_non_call_postfix_expression (tree t
, tree args
,
14072 tsubst_flags_t complain
,
14075 if (TREE_CODE (t
) == SCOPE_REF
)
14076 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14077 /*done=*/false, /*address_p=*/false);
14079 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14080 /*function_p=*/false,
14081 /*integral_constant_expression_p=*/false);
14086 /* Sentinel to disable certain warnings during template substitution. */
14088 struct warning_sentinel
{
14091 warning_sentinel(int& flag
, bool suppress
=true)
14092 : flag(flag
), val(flag
) { if (suppress
) flag
= 0; }
14093 ~warning_sentinel() { flag
= val
; }
14096 /* Like tsubst but deals with expressions and performs semantic
14097 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14100 tsubst_copy_and_build (tree t
,
14102 tsubst_flags_t complain
,
14105 bool integral_constant_expression_p
)
14107 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14108 #define RECUR(NODE) \
14109 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14110 /*function_p=*/false, \
14111 integral_constant_expression_p)
14116 if (t
== NULL_TREE
|| t
== error_mark_node
)
14119 loc
= input_location
;
14120 if (EXPR_HAS_LOCATION (t
))
14121 input_location
= EXPR_LOCATION (t
);
14123 /* N3276 decltype magic only applies to calls at the top level or on the
14124 right side of a comma. */
14125 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14126 complain
&= ~tf_decltype
;
14128 switch (TREE_CODE (t
))
14132 /* Fall through. */
14133 case IDENTIFIER_NODE
:
14137 bool non_integral_constant_expression_p
;
14138 const char *error_msg
;
14140 if (IDENTIFIER_TYPENAME_P (t
))
14142 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14143 t
= mangle_conv_op_name_for_type (new_type
);
14146 /* Look up the name. */
14147 decl
= lookup_name (t
);
14149 /* By convention, expressions use ERROR_MARK_NODE to indicate
14150 failure, not NULL_TREE. */
14151 if (decl
== NULL_TREE
)
14152 decl
= error_mark_node
;
14154 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14156 integral_constant_expression_p
,
14157 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14158 &non_integral_constant_expression_p
,
14159 /*template_p=*/false,
14161 /*address_p=*/false,
14162 /*template_arg_p=*/false,
14167 if (!function_p
&& identifier_p (decl
))
14169 if (complain
& tf_error
)
14170 unqualified_name_lookup_error (decl
);
14171 decl
= error_mark_node
;
14176 case TEMPLATE_ID_EXPR
:
14179 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14180 tree targs
= TREE_OPERAND (t
, 1);
14183 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14185 if (TREE_CODE (templ
) == COMPONENT_REF
)
14187 object
= TREE_OPERAND (templ
, 0);
14188 templ
= TREE_OPERAND (templ
, 1);
14191 object
= NULL_TREE
;
14192 templ
= lookup_template_function (templ
, targs
);
14195 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14196 object
, templ
, NULL_TREE
));
14198 RETURN (baselink_for_fns (templ
));
14203 tree r
= RECUR (TREE_OPERAND (t
, 0));
14205 if (REFERENCE_REF_P (t
))
14207 /* A type conversion to reference type will be enclosed in
14208 such an indirect ref, but the substitution of the cast
14209 will have also added such an indirect ref. */
14210 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14211 r
= convert_from_reference (r
);
14214 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14215 complain
|decltype_flag
);
14221 (tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
14222 RECUR (TREE_OPERAND (t
, 0))));
14224 case IMPLICIT_CONV_EXPR
:
14226 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14227 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14228 int flags
= LOOKUP_IMPLICIT
;
14229 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14230 flags
= LOOKUP_NORMAL
;
14231 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14238 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
14239 RECUR (TREE_OPERAND (t
, 0))));
14242 case REINTERPRET_CAST_EXPR
:
14243 case CONST_CAST_EXPR
:
14244 case DYNAMIC_CAST_EXPR
:
14245 case STATIC_CAST_EXPR
:
14248 tree op
, r
= NULL_TREE
;
14250 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14251 if (integral_constant_expression_p
14252 && !cast_valid_in_integral_constant_expression_p (type
))
14254 if (complain
& tf_error
)
14255 error ("a cast to a type other than an integral or "
14256 "enumeration type cannot appear in a constant-expression");
14257 RETURN (error_mark_node
);
14260 op
= RECUR (TREE_OPERAND (t
, 0));
14262 warning_sentinel
s(warn_useless_cast
);
14263 switch (TREE_CODE (t
))
14266 r
= build_functional_cast (type
, op
, complain
);
14268 case REINTERPRET_CAST_EXPR
:
14269 r
= build_reinterpret_cast (type
, op
, complain
);
14271 case CONST_CAST_EXPR
:
14272 r
= build_const_cast (type
, op
, complain
);
14274 case DYNAMIC_CAST_EXPR
:
14275 r
= build_dynamic_cast (type
, op
, complain
);
14277 case STATIC_CAST_EXPR
:
14278 r
= build_static_cast (type
, op
, complain
);
14281 gcc_unreachable ();
14287 case POSTDECREMENT_EXPR
:
14288 case POSTINCREMENT_EXPR
:
14289 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14290 args
, complain
, in_decl
);
14291 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14292 complain
|decltype_flag
));
14294 case PREDECREMENT_EXPR
:
14295 case PREINCREMENT_EXPR
:
14299 case TRUTH_NOT_EXPR
:
14300 case UNARY_PLUS_EXPR
: /* Unary + */
14301 case REALPART_EXPR
:
14302 case IMAGPART_EXPR
:
14303 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14304 RECUR (TREE_OPERAND (t
, 0)),
14305 complain
|decltype_flag
));
14307 case FIX_TRUNC_EXPR
:
14308 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14312 op1
= TREE_OPERAND (t
, 0);
14313 if (TREE_CODE (op1
) == LABEL_DECL
)
14314 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14315 EXPR_LOCATION (op1
)));
14316 if (TREE_CODE (op1
) == SCOPE_REF
)
14317 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14318 /*done=*/true, /*address_p=*/true);
14320 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14322 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14323 complain
|decltype_flag
));
14328 case TRUNC_DIV_EXPR
:
14329 case CEIL_DIV_EXPR
:
14330 case FLOOR_DIV_EXPR
:
14331 case ROUND_DIV_EXPR
:
14332 case EXACT_DIV_EXPR
:
14336 case TRUNC_MOD_EXPR
:
14337 case FLOOR_MOD_EXPR
:
14338 case TRUTH_ANDIF_EXPR
:
14339 case TRUTH_ORIF_EXPR
:
14340 case TRUTH_AND_EXPR
:
14341 case TRUTH_OR_EXPR
:
14357 warning_sentinel
s1(warn_type_limits
);
14358 warning_sentinel
s2(warn_div_by_zero
);
14359 tree r
= build_x_binary_op
14360 (input_location
, TREE_CODE (t
),
14361 RECUR (TREE_OPERAND (t
, 0)),
14362 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14364 : TREE_CODE (TREE_OPERAND (t
, 0))),
14365 RECUR (TREE_OPERAND (t
, 1)),
14366 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14368 : TREE_CODE (TREE_OPERAND (t
, 1))),
14370 complain
|decltype_flag
);
14371 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14372 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14377 case POINTER_PLUS_EXPR
:
14378 return fold_build_pointer_plus (RECUR (TREE_OPERAND (t
, 0)),
14379 RECUR (TREE_OPERAND (t
, 1)));
14382 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14383 /*address_p=*/false));
14385 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14386 args
, complain
, in_decl
);
14387 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14388 RECUR (TREE_OPERAND (t
, 1)),
14389 complain
|decltype_flag
));
14391 case ARRAY_NOTATION_REF
:
14393 tree start_index
, length
, stride
;
14394 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14395 args
, complain
, in_decl
);
14396 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14397 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14398 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14399 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14400 length
, stride
, TREE_TYPE (op1
)));
14403 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14404 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14411 op1
= TREE_OPERAND (t
, 0);
14412 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14413 op1
= TREE_TYPE (op1
);
14416 /* When there are no ARGS, we are trying to evaluate a
14417 non-dependent expression from the parser. Trying to do
14418 the substitutions may not work. */
14420 op1
= TREE_TYPE (op1
);
14424 ++cp_unevaluated_operand
;
14425 ++c_inhibit_evaluation_warnings
;
14427 op1
= tsubst (op1
, args
, complain
, in_decl
);
14429 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14430 /*function_p=*/false,
14431 /*integral_constant_expression_p=*/
14433 --cp_unevaluated_operand
;
14434 --c_inhibit_evaluation_warnings
;
14437 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14438 complain
& tf_error
);
14440 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14441 complain
& tf_error
);
14442 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14444 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14446 if (!processing_template_decl
&& TYPE_P (op1
))
14448 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14449 build1 (NOP_EXPR
, op1
, error_mark_node
));
14450 SIZEOF_EXPR_TYPE_P (r
) = 1;
14453 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14454 TREE_SIDE_EFFECTS (r
) = 0;
14455 TREE_READONLY (r
) = 1;
14457 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14462 case AT_ENCODE_EXPR
:
14464 op1
= TREE_OPERAND (t
, 0);
14465 ++cp_unevaluated_operand
;
14466 ++c_inhibit_evaluation_warnings
;
14467 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14468 /*function_p=*/false,
14469 /*integral_constant_expression_p=*/false);
14470 --cp_unevaluated_operand
;
14471 --c_inhibit_evaluation_warnings
;
14472 RETURN (objc_build_encode_expr (op1
));
14475 case NOEXCEPT_EXPR
:
14476 op1
= TREE_OPERAND (t
, 0);
14477 ++cp_unevaluated_operand
;
14478 ++c_inhibit_evaluation_warnings
;
14479 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14480 /*function_p=*/false,
14481 /*integral_constant_expression_p=*/false);
14482 --cp_unevaluated_operand
;
14483 --c_inhibit_evaluation_warnings
;
14484 RETURN (finish_noexcept_expr (op1
, complain
));
14488 warning_sentinel
s(warn_div_by_zero
);
14489 tree r
= build_x_modify_expr
14490 (EXPR_LOCATION (t
),
14491 RECUR (TREE_OPERAND (t
, 0)),
14492 TREE_CODE (TREE_OPERAND (t
, 1)),
14493 RECUR (TREE_OPERAND (t
, 2)),
14494 complain
|decltype_flag
);
14495 /* TREE_NO_WARNING must be set if either the expression was
14496 parenthesized or it uses an operator such as >>= rather
14497 than plain assignment. In the former case, it was already
14498 set and must be copied. In the latter case,
14499 build_x_modify_expr sets it and it must not be reset
14501 if (TREE_NO_WARNING (t
))
14502 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14508 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14509 args
, complain
, in_decl
);
14510 /* Remember that there was a reference to this entity. */
14513 RETURN (build_x_arrow (input_location
, op1
, complain
));
14517 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14518 tree init
= RECUR (TREE_OPERAND (t
, 3));
14519 vec
<tree
, va_gc
> *placement_vec
;
14520 vec
<tree
, va_gc
> *init_vec
;
14523 if (placement
== NULL_TREE
)
14524 placement_vec
= NULL
;
14527 placement_vec
= make_tree_vector ();
14528 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14529 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14532 /* If there was an initializer in the original tree, but it
14533 instantiated to an empty list, then we should pass a
14534 non-NULL empty vector to tell build_new that it was an
14535 empty initializer() rather than no initializer. This can
14536 only happen when the initializer is a pack expansion whose
14537 parameter packs are of length zero. */
14538 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
14542 init_vec
= make_tree_vector ();
14543 if (init
== void_zero_node
)
14544 gcc_assert (init_vec
!= NULL
);
14547 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
14548 vec_safe_push (init_vec
, TREE_VALUE (init
));
14552 ret
= build_new (&placement_vec
,
14553 tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
14554 RECUR (TREE_OPERAND (t
, 2)),
14556 NEW_EXPR_USE_GLOBAL (t
),
14559 if (placement_vec
!= NULL
)
14560 release_tree_vector (placement_vec
);
14561 if (init_vec
!= NULL
)
14562 release_tree_vector (init_vec
);
14568 RETURN (delete_sanity
14569 (RECUR (TREE_OPERAND (t
, 0)),
14570 RECUR (TREE_OPERAND (t
, 1)),
14571 DELETE_EXPR_USE_VEC (t
),
14572 DELETE_EXPR_USE_GLOBAL (t
),
14575 case COMPOUND_EXPR
:
14577 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
14578 complain
& ~tf_decltype
, in_decl
,
14579 /*function_p=*/false,
14580 integral_constant_expression_p
);
14581 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
14583 RECUR (TREE_OPERAND (t
, 1)),
14584 complain
|decltype_flag
));
14590 vec
<tree
, va_gc
> *call_args
;
14591 unsigned int nargs
, i
;
14596 function
= CALL_EXPR_FN (t
);
14597 /* When we parsed the expression, we determined whether or
14598 not Koenig lookup should be performed. */
14599 koenig_p
= KOENIG_LOOKUP_P (t
);
14600 if (TREE_CODE (function
) == SCOPE_REF
)
14602 qualified_p
= true;
14603 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
14605 /*address_p=*/false);
14607 else if (koenig_p
&& identifier_p (function
))
14609 /* Do nothing; calling tsubst_copy_and_build on an identifier
14610 would incorrectly perform unqualified lookup again.
14612 Note that we can also have an IDENTIFIER_NODE if the earlier
14613 unqualified lookup found a member function; in that case
14614 koenig_p will be false and we do want to do the lookup
14615 again to find the instantiated member function.
14617 FIXME but doing that causes c++/15272, so we need to stop
14618 using IDENTIFIER_NODE in that situation. */
14619 qualified_p
= false;
14623 if (TREE_CODE (function
) == COMPONENT_REF
)
14625 tree op
= TREE_OPERAND (function
, 1);
14627 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
14628 || (BASELINK_P (op
)
14629 && BASELINK_QUALIFIED_P (op
)));
14632 qualified_p
= false;
14634 if (TREE_CODE (function
) == ADDR_EXPR
14635 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
14636 /* Avoid error about taking the address of a constructor. */
14637 function
= TREE_OPERAND (function
, 0);
14639 function
= tsubst_copy_and_build (function
, args
, complain
,
14642 integral_constant_expression_p
);
14644 if (BASELINK_P (function
))
14645 qualified_p
= true;
14648 nargs
= call_expr_nargs (t
);
14649 call_args
= make_tree_vector ();
14650 for (i
= 0; i
< nargs
; ++i
)
14652 tree arg
= CALL_EXPR_ARG (t
, i
);
14654 if (!PACK_EXPANSION_P (arg
))
14655 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
14658 /* Expand the pack expansion and push each entry onto
14660 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
14661 if (TREE_CODE (arg
) == TREE_VEC
)
14663 unsigned int len
, j
;
14665 len
= TREE_VEC_LENGTH (arg
);
14666 for (j
= 0; j
< len
; ++j
)
14668 tree value
= TREE_VEC_ELT (arg
, j
);
14669 if (value
!= NULL_TREE
)
14670 value
= convert_from_reference (value
);
14671 vec_safe_push (call_args
, value
);
14676 /* A partial substitution. Add one entry. */
14677 vec_safe_push (call_args
, arg
);
14682 /* We do not perform argument-dependent lookup if normal
14683 lookup finds a non-function, in accordance with the
14684 expected resolution of DR 218. */
14686 && ((is_overloaded_fn (function
)
14687 /* If lookup found a member function, the Koenig lookup is
14688 not appropriate, even if an unqualified-name was used
14689 to denote the function. */
14690 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
14691 || identifier_p (function
))
14692 /* Only do this when substitution turns a dependent call
14693 into a non-dependent call. */
14694 && type_dependent_expression_p_push (t
)
14695 && !any_type_dependent_arguments_p (call_args
))
14696 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
14698 if (identifier_p (function
)
14699 && !any_type_dependent_arguments_p (call_args
))
14701 if (koenig_p
&& (complain
& tf_warning_or_error
))
14703 /* For backwards compatibility and good diagnostics, try
14704 the unqualified lookup again if we aren't in SFINAE
14706 tree unq
= (tsubst_copy_and_build
14707 (function
, args
, complain
, in_decl
, true,
14708 integral_constant_expression_p
));
14709 if (unq
== error_mark_node
)
14710 RETURN (error_mark_node
);
14712 if (unq
!= function
)
14715 if (INDIRECT_REF_P (fn
))
14716 fn
= TREE_OPERAND (fn
, 0);
14717 if (TREE_CODE (fn
) == COMPONENT_REF
)
14718 fn
= TREE_OPERAND (fn
, 1);
14719 if (is_overloaded_fn (fn
))
14720 fn
= get_first_fn (fn
);
14721 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
14722 "%qD was not declared in this scope, "
14723 "and no declarations were found by "
14724 "argument-dependent lookup at the point "
14725 "of instantiation", function
))
14728 /* Can't say anything more. */;
14729 else if (DECL_CLASS_SCOPE_P (fn
))
14731 location_t loc
= EXPR_LOC_OR_LOC (t
,
14734 "declarations in dependent base %qT are "
14735 "not found by unqualified lookup",
14736 DECL_CLASS_CONTEXT (fn
));
14737 if (current_class_ptr
)
14739 "use %<this->%D%> instead", function
);
14742 "use %<%T::%D%> instead",
14743 current_class_name
, function
);
14746 inform (0, "%q+D declared here, later in the "
14747 "translation unit", fn
);
14752 if (identifier_p (function
))
14754 if (complain
& tf_error
)
14755 unqualified_name_lookup_error (function
);
14756 release_tree_vector (call_args
);
14757 RETURN (error_mark_node
);
14761 /* Remember that there was a reference to this entity. */
14762 if (DECL_P (function
))
14763 mark_used (function
);
14765 /* Put back tf_decltype for the actual call. */
14766 complain
|= decltype_flag
;
14768 if (TREE_CODE (function
) == OFFSET_REF
)
14769 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
14771 else if (TREE_CODE (function
) == COMPONENT_REF
)
14773 tree instance
= TREE_OPERAND (function
, 0);
14774 tree fn
= TREE_OPERAND (function
, 1);
14776 if (processing_template_decl
14777 && (type_dependent_expression_p (instance
)
14778 || (!BASELINK_P (fn
)
14779 && TREE_CODE (fn
) != FIELD_DECL
)
14780 || type_dependent_expression_p (fn
)
14781 || any_type_dependent_arguments_p (call_args
)))
14782 ret
= build_nt_call_vec (function
, call_args
);
14783 else if (!BASELINK_P (fn
))
14784 ret
= finish_call_expr (function
, &call_args
,
14785 /*disallow_virtual=*/false,
14786 /*koenig_p=*/false,
14789 ret
= (build_new_method_call
14791 &call_args
, NULL_TREE
,
14792 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
14797 ret
= finish_call_expr (function
, &call_args
,
14798 /*disallow_virtual=*/qualified_p
,
14802 release_tree_vector (call_args
);
14809 tree cond
= RECUR (TREE_OPERAND (t
, 0));
14812 if (TREE_CODE (cond
) == INTEGER_CST
)
14814 if (integer_zerop (cond
))
14816 ++c_inhibit_evaluation_warnings
;
14817 exp1
= RECUR (TREE_OPERAND (t
, 1));
14818 --c_inhibit_evaluation_warnings
;
14819 exp2
= RECUR (TREE_OPERAND (t
, 2));
14823 exp1
= RECUR (TREE_OPERAND (t
, 1));
14824 ++c_inhibit_evaluation_warnings
;
14825 exp2
= RECUR (TREE_OPERAND (t
, 2));
14826 --c_inhibit_evaluation_warnings
;
14831 exp1
= RECUR (TREE_OPERAND (t
, 1));
14832 exp2
= RECUR (TREE_OPERAND (t
, 2));
14835 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
14836 cond
, exp1
, exp2
, complain
));
14839 case PSEUDO_DTOR_EXPR
:
14840 RETURN (finish_pseudo_destructor_expr
14841 (RECUR (TREE_OPERAND (t
, 0)),
14842 RECUR (TREE_OPERAND (t
, 1)),
14843 tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
),
14848 tree purpose
, value
, chain
;
14850 if (t
== void_list_node
)
14853 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
14854 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
14856 /* We have pack expansions, so expand those and
14857 create a new list out of it. */
14858 tree purposevec
= NULL_TREE
;
14859 tree valuevec
= NULL_TREE
;
14863 /* Expand the argument expressions. */
14864 if (TREE_PURPOSE (t
))
14865 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
14866 complain
, in_decl
);
14867 if (TREE_VALUE (t
))
14868 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
14869 complain
, in_decl
);
14871 /* Build the rest of the list. */
14872 chain
= TREE_CHAIN (t
);
14873 if (chain
&& chain
!= void_type_node
)
14874 chain
= RECUR (chain
);
14876 /* Determine the number of arguments. */
14877 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
14879 len
= TREE_VEC_LENGTH (purposevec
);
14880 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
14882 else if (TREE_CODE (valuevec
) == TREE_VEC
)
14883 len
= TREE_VEC_LENGTH (valuevec
);
14886 /* Since we only performed a partial substitution into
14887 the argument pack, we only RETURN (a single list
14889 if (purposevec
== TREE_PURPOSE (t
)
14890 && valuevec
== TREE_VALUE (t
)
14891 && chain
== TREE_CHAIN (t
))
14894 RETURN (tree_cons (purposevec
, valuevec
, chain
));
14897 /* Convert the argument vectors into a TREE_LIST */
14901 /* Grab the Ith values. */
14903 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
14906 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
14909 /* Build the list (backwards). */
14910 chain
= tree_cons (purpose
, value
, chain
);
14916 purpose
= TREE_PURPOSE (t
);
14918 purpose
= RECUR (purpose
);
14919 value
= TREE_VALUE (t
);
14921 value
= RECUR (value
);
14922 chain
= TREE_CHAIN (t
);
14923 if (chain
&& chain
!= void_type_node
)
14924 chain
= RECUR (chain
);
14925 if (purpose
== TREE_PURPOSE (t
)
14926 && value
== TREE_VALUE (t
)
14927 && chain
== TREE_CHAIN (t
))
14929 RETURN (tree_cons (purpose
, value
, chain
));
14932 case COMPONENT_REF
:
14939 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14940 args
, complain
, in_decl
);
14941 /* Remember that there was a reference to this entity. */
14942 if (DECL_P (object
))
14943 mark_used (object
);
14944 object_type
= TREE_TYPE (object
);
14946 member
= TREE_OPERAND (t
, 1);
14947 if (BASELINK_P (member
))
14948 member
= tsubst_baselink (member
,
14949 non_reference (TREE_TYPE (object
)),
14950 args
, complain
, in_decl
);
14952 member
= tsubst_copy (member
, args
, complain
, in_decl
);
14953 if (member
== error_mark_node
)
14954 RETURN (error_mark_node
);
14956 if (type_dependent_expression_p (object
))
14957 /* We can't do much here. */;
14958 else if (!CLASS_TYPE_P (object_type
))
14960 if (scalarish_type_p (object_type
))
14962 tree s
= NULL_TREE
;
14963 tree dtor
= member
;
14965 if (TREE_CODE (dtor
) == SCOPE_REF
)
14967 s
= TREE_OPERAND (dtor
, 0);
14968 dtor
= TREE_OPERAND (dtor
, 1);
14970 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
14972 dtor
= TREE_OPERAND (dtor
, 0);
14974 RETURN (finish_pseudo_destructor_expr
14975 (object
, s
, dtor
, input_location
));
14979 else if (TREE_CODE (member
) == SCOPE_REF
14980 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
14982 /* Lookup the template functions now that we know what the
14984 tree scope
= TREE_OPERAND (member
, 0);
14985 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
14986 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
14987 member
= lookup_qualified_name (scope
, tmpl
,
14988 /*is_type_p=*/false,
14989 /*complain=*/false);
14990 if (BASELINK_P (member
))
14992 BASELINK_FUNCTIONS (member
)
14993 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
14995 member
= (adjust_result_of_qualified_name_lookup
14996 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15001 qualified_name_lookup_error (scope
, tmpl
, member
,
15003 RETURN (error_mark_node
);
15006 else if (TREE_CODE (member
) == SCOPE_REF
15007 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15008 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15010 if (complain
& tf_error
)
15012 if (TYPE_P (TREE_OPERAND (member
, 0)))
15013 error ("%qT is not a class or namespace",
15014 TREE_OPERAND (member
, 0));
15016 error ("%qD is not a class or namespace",
15017 TREE_OPERAND (member
, 0));
15019 RETURN (error_mark_node
);
15021 else if (TREE_CODE (member
) == FIELD_DECL
)
15023 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15024 if (TREE_CODE (r
) == COMPONENT_REF
)
15025 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15029 r
= finish_class_member_access_expr (object
, member
,
15030 /*template_p=*/false,
15032 if (TREE_CODE (r
) == COMPONENT_REF
)
15033 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15038 RETURN (build_throw
15039 (RECUR (TREE_OPERAND (t
, 0))));
15043 vec
<constructor_elt
, va_gc
> *n
;
15044 constructor_elt
*ce
;
15045 unsigned HOST_WIDE_INT idx
;
15046 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15047 bool process_index_p
;
15049 bool need_copy_p
= false;
15052 if (type
== error_mark_node
)
15053 RETURN (error_mark_node
);
15055 /* digest_init will do the wrong thing if we let it. */
15056 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15059 /* We do not want to process the index of aggregate
15060 initializers as they are identifier nodes which will be
15061 looked up by digest_init. */
15062 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15064 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15065 newlen
= vec_safe_length (n
);
15066 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15068 if (ce
->index
&& process_index_p
15069 /* An identifier index is looked up in the type
15070 being initialized, not the current scope. */
15071 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15072 ce
->index
= RECUR (ce
->index
);
15074 if (PACK_EXPANSION_P (ce
->value
))
15076 /* Substitute into the pack expansion. */
15077 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15080 if (ce
->value
== error_mark_node
15081 || PACK_EXPANSION_P (ce
->value
))
15083 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15084 /* Just move the argument into place. */
15085 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15088 /* Update the length of the final CONSTRUCTOR
15089 arguments vector, and note that we will need to
15091 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15092 need_copy_p
= true;
15096 ce
->value
= RECUR (ce
->value
);
15101 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15103 vec_alloc (n
, newlen
);
15104 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15106 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15108 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15109 for (i
= 0; i
< len
; ++i
)
15110 CONSTRUCTOR_APPEND_ELT (n
, 0,
15111 TREE_VEC_ELT (ce
->value
, i
));
15114 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15118 r
= build_constructor (init_list_type_node
, n
);
15119 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15121 if (TREE_HAS_CONSTRUCTOR (t
))
15122 RETURN (finish_compound_literal (type
, r
, complain
));
15124 TREE_TYPE (r
) = type
;
15130 tree operand_0
= TREE_OPERAND (t
, 0);
15131 if (TYPE_P (operand_0
))
15133 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15134 RETURN (get_typeid (operand_0
, complain
));
15138 operand_0
= RECUR (operand_0
);
15139 RETURN (build_typeid (operand_0
, complain
));
15146 else if (DECL_PACK_P (t
))
15148 /* We don't build decls for an instantiation of a
15149 variadic capture proxy, we instantiate the elements
15151 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15152 return RECUR (DECL_VALUE_EXPR (t
));
15158 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15160 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15161 /* If the original type was a reference, we'll be wrapped in
15162 the appropriate INDIRECT_REF. */
15163 r
= convert_from_reference (r
);
15168 RETURN (build_x_va_arg (EXPR_LOCATION (t
),
15169 RECUR (TREE_OPERAND (t
, 0)),
15170 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
)));
15172 case OFFSETOF_EXPR
:
15173 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0))));
15177 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15178 complain
, in_decl
);
15180 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15182 type2
= tsubst (type2
, args
, complain
, in_decl
);
15184 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15189 tree old_stmt_expr
= cur_stmt_expr
;
15190 tree stmt_expr
= begin_stmt_expr ();
15192 cur_stmt_expr
= stmt_expr
;
15193 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15194 integral_constant_expression_p
);
15195 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15196 cur_stmt_expr
= old_stmt_expr
;
15198 /* If the resulting list of expression statement is empty,
15199 fold it further into void_zero_node. */
15200 if (empty_expr_stmt_p (stmt_expr
))
15201 stmt_expr
= void_zero_node
;
15203 RETURN (stmt_expr
);
15208 tree r
= build_lambda_expr ();
15210 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15211 LAMBDA_EXPR_CLOSURE (r
) = type
;
15212 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15214 LAMBDA_EXPR_LOCATION (r
)
15215 = LAMBDA_EXPR_LOCATION (t
);
15216 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15217 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15218 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15219 LAMBDA_EXPR_DISCRIMINATOR (r
)
15220 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15221 /* For a function scope, we want to use tsubst so that we don't
15222 complain about referring to an auto function before its return
15223 type has been deduced. Otherwise, we want to use tsubst_copy so
15224 that we look up the existing field/parameter/variable rather
15225 than build a new one. */
15226 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15227 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15228 scope
= tsubst (scope
, args
, complain
, in_decl
);
15229 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15231 /* Look up the parameter we want directly, as tsubst_copy
15232 doesn't do what we need. */
15233 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15234 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15235 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15236 parm
= DECL_CHAIN (parm
);
15238 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15239 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15240 DECL_CONTEXT (scope
) = fn
;
15243 scope
= RECUR (scope
);
15244 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15245 LAMBDA_EXPR_RETURN_TYPE (r
)
15246 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15248 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15249 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15251 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15252 determine_visibility (TYPE_NAME (type
));
15253 /* Now that we know visibility, instantiate the type so we have a
15254 declaration of the op() for later calls to lambda_function. */
15255 complete_type (type
);
15257 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15259 RETURN (build_lambda_object (r
));
15263 /* We can get here for a constant initializer of non-dependent type.
15264 FIXME stop folding in cp_parser_initializer_clause. */
15266 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15271 case TRANSACTION_EXPR
:
15272 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15273 integral_constant_expression_p
));
15276 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15278 case VEC_PERM_EXPR
:
15279 RETURN (build_x_vec_perm_expr (input_location
,
15280 RECUR (TREE_OPERAND (t
, 0)),
15281 RECUR (TREE_OPERAND (t
, 1)),
15282 RECUR (TREE_OPERAND (t
, 2)),
15286 /* Handle Objective-C++ constructs, if appropriate. */
15289 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15290 in_decl
, /*function_p=*/false);
15294 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15300 input_location
= loc
;
15304 /* Verify that the instantiated ARGS are valid. For type arguments,
15305 make sure that the type's linkage is ok. For non-type arguments,
15306 make sure they are constants if they are integral or enumerations.
15307 Emit an error under control of COMPLAIN, and return TRUE on error. */
15310 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15312 if (dependent_template_arg_p (t
))
15314 if (ARGUMENT_PACK_P (t
))
15316 tree vec
= ARGUMENT_PACK_ARGS (t
);
15317 int len
= TREE_VEC_LENGTH (vec
);
15318 bool result
= false;
15321 for (i
= 0; i
< len
; ++i
)
15322 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15326 else if (TYPE_P (t
))
15328 /* [basic.link]: A name with no linkage (notably, the name
15329 of a class or enumeration declared in a local scope)
15330 shall not be used to declare an entity with linkage.
15331 This implies that names with no linkage cannot be used as
15334 DR 757 relaxes this restriction for C++0x. */
15335 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15336 : no_linkage_check (t
, /*relaxed_p=*/false));
15340 /* DR 488 makes use of a type with no linkage cause
15341 type deduction to fail. */
15342 if (complain
& tf_error
)
15344 if (TYPE_ANONYMOUS_P (nt
))
15345 error ("%qT is/uses anonymous type", t
);
15347 error ("template argument for %qD uses local type %qT",
15352 /* In order to avoid all sorts of complications, we do not
15353 allow variably-modified types as template arguments. */
15354 else if (variably_modified_type_p (t
, NULL_TREE
))
15356 if (complain
& tf_error
)
15357 error ("%qT is a variably modified type", t
);
15361 /* Class template and alias template arguments should be OK. */
15362 else if (DECL_TYPE_TEMPLATE_P (t
))
15364 /* A non-type argument of integral or enumerated type must be a
15366 else if (TREE_TYPE (t
)
15367 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15368 && !TREE_CONSTANT (t
))
15370 if (complain
& tf_error
)
15371 error ("integral expression %qE is not constant", t
);
15378 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15380 int ix
, len
= DECL_NTPARMS (tmpl
);
15381 bool result
= false;
15383 for (ix
= 0; ix
!= len
; ix
++)
15385 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15388 if (result
&& (complain
& tf_error
))
15389 error (" trying to instantiate %qD", tmpl
);
15393 /* We're out of SFINAE context now, so generate diagnostics for the access
15394 errors we saw earlier when instantiating D from TMPL and ARGS. */
15397 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15399 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15400 tree type
= TREE_TYPE (pattern
);
15401 location_t loc
= input_location
;
15403 push_access_scope (d
);
15404 push_deferring_access_checks (dk_no_deferred
);
15405 input_location
= DECL_SOURCE_LOCATION (pattern
);
15406 tsubst (type
, args
, tf_warning_or_error
, d
);
15407 input_location
= loc
;
15408 pop_deferring_access_checks ();
15409 pop_access_scope (d
);
15412 /* Instantiate the indicated variable, function, or alias template TMPL with
15413 the template arguments in TARG_PTR. */
15416 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15418 tree targ_ptr
= orig_args
;
15422 bool access_ok
= true;
15424 if (tmpl
== error_mark_node
)
15425 return error_mark_node
;
15427 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15429 /* If this function is a clone, handle it specially. */
15430 if (DECL_CLONED_FUNCTION_P (tmpl
))
15435 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15436 DECL_CLONED_FUNCTION. */
15437 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15438 targ_ptr
, complain
);
15439 if (spec
== error_mark_node
)
15440 return error_mark_node
;
15442 /* Look for the clone. */
15443 FOR_EACH_CLONE (clone
, spec
)
15444 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15446 /* We should always have found the clone by now. */
15447 gcc_unreachable ();
15451 if (targ_ptr
== error_mark_node
)
15452 return error_mark_node
;
15454 /* Check to see if we already have this specialization. */
15455 gen_tmpl
= most_general_template (tmpl
);
15456 if (tmpl
!= gen_tmpl
)
15457 /* The TMPL is a partial instantiation. To get a full set of
15458 arguments we must add the arguments used to perform the
15459 partial instantiation. */
15460 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15463 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15464 but it doesn't seem to be on the hot path. */
15465 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15467 gcc_assert (tmpl
== gen_tmpl
15468 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15470 || fndecl
== NULL_TREE
);
15472 if (spec
!= NULL_TREE
)
15474 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15476 if (complain
& tf_error
)
15477 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15478 return error_mark_node
;
15483 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15485 return error_mark_node
;
15487 /* We are building a FUNCTION_DECL, during which the access of its
15488 parameters and return types have to be checked. However this
15489 FUNCTION_DECL which is the desired context for access checking
15490 is not built yet. We solve this chicken-and-egg problem by
15491 deferring all checks until we have the FUNCTION_DECL. */
15492 push_deferring_access_checks (dk_deferred
);
15494 /* Instantiation of the function happens in the context of the function
15495 template, not the context of the overload resolution we're doing. */
15496 push_to_top_level ();
15497 /* If there are dependent arguments, e.g. because we're doing partial
15498 ordering, make sure processing_template_decl stays set. */
15499 if (uses_template_parms (targ_ptr
))
15500 ++processing_template_decl
;
15501 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15503 tree ctx
= tsubst (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15504 complain
, gen_tmpl
);
15505 push_nested_class (ctx
);
15507 /* Substitute template parameters to obtain the specialization. */
15508 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
15509 targ_ptr
, complain
, gen_tmpl
);
15510 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15511 pop_nested_class ();
15512 pop_from_top_level ();
15514 if (fndecl
== error_mark_node
)
15516 pop_deferring_access_checks ();
15517 return error_mark_node
;
15520 /* The DECL_TI_TEMPLATE should always be the immediate parent
15521 template, not the most general template. */
15522 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
15524 /* Now we know the specialization, compute access previously
15526 push_access_scope (fndecl
);
15527 if (!perform_deferred_access_checks (complain
))
15529 pop_access_scope (fndecl
);
15530 pop_deferring_access_checks ();
15532 /* If we've just instantiated the main entry point for a function,
15533 instantiate all the alternate entry points as well. We do this
15534 by cloning the instantiation of the main entry point, not by
15535 instantiating the template clones. */
15536 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
15537 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
15541 if (!(complain
& tf_error
))
15543 /* Remember to reinstantiate when we're out of SFINAE so the user
15544 can see the errors. */
15545 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
15547 return error_mark_node
;
15552 /* Wrapper for instantiate_template_1. */
15555 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15558 timevar_push (TV_TEMPLATE_INST
);
15559 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
15560 timevar_pop (TV_TEMPLATE_INST
);
15564 /* Instantiate the alias template TMPL with ARGS. Also push a template
15565 instantiation level, which instantiate_template doesn't do because
15566 functions and variables have sufficient context established by the
15570 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
15572 struct pending_template
*old_last_pend
= last_pending_template
;
15573 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15574 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
15575 return error_mark_node
;
15576 tree tinst
= build_tree_list (tmpl
, args
);
15577 if (!push_tinst_level (tinst
))
15580 return error_mark_node
;
15584 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
15585 args
, tmpl
, complain
,
15586 /*require_all_args=*/true,
15587 /*use_default_args=*/true);
15589 tree r
= instantiate_template (tmpl
, args
, complain
);
15590 pop_tinst_level ();
15591 /* We can't free this if a pending_template entry or last_error_tinst_level
15592 is pointing at it. */
15593 if (last_pending_template
== old_last_pend
15594 && last_error_tinst_level
== old_error_tinst
)
15600 /* PARM is a template parameter pack for FN. Returns true iff
15601 PARM is used in a deducible way in the argument list of FN. */
15604 pack_deducible_p (tree parm
, tree fn
)
15606 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
15607 for (; t
; t
= TREE_CHAIN (t
))
15609 tree type
= TREE_VALUE (t
);
15611 if (!PACK_EXPANSION_P (type
))
15613 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
15614 packs
; packs
= TREE_CHAIN (packs
))
15615 if (TREE_VALUE (packs
) == parm
)
15617 /* The template parameter pack is used in a function parameter
15618 pack. If this is the end of the parameter list, the
15619 template parameter pack is deducible. */
15620 if (TREE_CHAIN (t
) == void_list_node
)
15623 /* Otherwise, not. Well, it could be deduced from
15624 a non-pack parameter, but doing so would end up with
15625 a deduction mismatch, so don't bother. */
15629 /* The template parameter pack isn't used in any function parameter
15630 packs, but it might be used deeper, e.g. tuple<Args...>. */
15634 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
15635 NARGS elements of the arguments that are being used when calling
15636 it. TARGS is a vector into which the deduced template arguments
15639 Returns either a FUNCTION_DECL for the matching specialization of FN or
15640 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
15641 true, diagnostics will be printed to explain why it failed.
15643 If FN is a conversion operator, or we are trying to produce a specific
15644 specialization, RETURN_TYPE is the return type desired.
15646 The EXPLICIT_TARGS are explicit template arguments provided via a
15649 The parameter STRICT is one of:
15652 We are deducing arguments for a function call, as in
15653 [temp.deduct.call].
15656 We are deducing arguments for a conversion function, as in
15657 [temp.deduct.conv].
15660 We are deducing arguments when doing an explicit instantiation
15661 as in [temp.explicit], when determining an explicit specialization
15662 as in [temp.expl.spec], or when taking the address of a function
15663 template, as in [temp.deduct.funcaddr]. */
15666 fn_type_unification (tree fn
,
15667 tree explicit_targs
,
15670 unsigned int nargs
,
15672 unification_kind_t strict
,
15679 tree decl
= NULL_TREE
;
15680 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
15682 static int deduction_depth
;
15683 struct pending_template
*old_last_pend
= last_pending_template
;
15684 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15685 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
15687 tree r
= error_mark_node
;
15690 complain
|= tf_decltype
;
15692 /* In C++0x, it's possible to have a function template whose type depends
15693 on itself recursively. This is most obvious with decltype, but can also
15694 occur with enumeration scope (c++/48969). So we need to catch infinite
15695 recursion and reject the substitution at deduction time; this function
15696 will return error_mark_node for any repeated substitution.
15698 This also catches excessive recursion such as when f<N> depends on
15699 f<N-1> across all integers, and returns error_mark_node for all the
15700 substitutions back up to the initial one.
15702 This is, of course, not reentrant. */
15703 if (excessive_deduction_depth
)
15704 return error_mark_node
;
15705 tinst
= build_tree_list (fn
, NULL_TREE
);
15708 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
15710 fntype
= TREE_TYPE (fn
);
15711 if (explicit_targs
)
15715 The specified template arguments must match the template
15716 parameters in kind (i.e., type, nontype, template), and there
15717 must not be more arguments than there are parameters;
15718 otherwise type deduction fails.
15720 Nontype arguments must match the types of the corresponding
15721 nontype template parameters, or must be convertible to the
15722 types of the corresponding nontype parameters as specified in
15723 _temp.arg.nontype_, otherwise type deduction fails.
15725 All references in the function type of the function template
15726 to the corresponding template parameters are replaced by the
15727 specified template argument values. If a substitution in a
15728 template parameter or in the function type of the function
15729 template results in an invalid type, type deduction fails. */
15730 int i
, len
= TREE_VEC_LENGTH (tparms
);
15731 location_t loc
= input_location
;
15732 bool incomplete
= false;
15734 /* Adjust any explicit template arguments before entering the
15735 substitution context. */
15737 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
15739 /*require_all_args=*/false,
15740 /*use_default_args=*/false));
15741 if (explicit_targs
== error_mark_node
)
15744 /* Substitute the explicit args into the function type. This is
15745 necessary so that, for instance, explicitly declared function
15746 arguments can match null pointed constants. If we were given
15747 an incomplete set of explicit args, we must not do semantic
15748 processing during substitution as we could create partial
15750 for (i
= 0; i
< len
; i
++)
15752 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
15753 bool parameter_pack
= false;
15754 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
15756 /* Dig out the actual parm. */
15757 if (TREE_CODE (parm
) == TYPE_DECL
15758 || TREE_CODE (parm
) == TEMPLATE_DECL
)
15760 parm
= TREE_TYPE (parm
);
15761 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
15763 else if (TREE_CODE (parm
) == PARM_DECL
)
15765 parm
= DECL_INITIAL (parm
);
15766 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
15769 if (!parameter_pack
&& targ
== NULL_TREE
)
15770 /* No explicit argument for this template parameter. */
15773 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
15775 /* Mark the argument pack as "incomplete". We could
15776 still deduce more arguments during unification.
15777 We remove this mark in type_unification_real. */
15780 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
15781 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
15782 = ARGUMENT_PACK_ARGS (targ
);
15785 /* We have some incomplete argument packs. */
15790 TREE_VALUE (tinst
) = explicit_targs
;
15791 if (!push_tinst_level (tinst
))
15793 excessive_deduction_depth
= true;
15796 processing_template_decl
+= incomplete
;
15797 input_location
= DECL_SOURCE_LOCATION (fn
);
15798 /* Ignore any access checks; we'll see them again in
15799 instantiate_template and they might have the wrong
15800 access path at this point. */
15801 push_deferring_access_checks (dk_deferred
);
15802 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
15803 complain
| tf_partial
, NULL_TREE
);
15804 pop_deferring_access_checks ();
15805 input_location
= loc
;
15806 processing_template_decl
-= incomplete
;
15807 pop_tinst_level ();
15809 if (fntype
== error_mark_node
)
15812 /* Place the explicitly specified arguments in TARGS. */
15813 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
15814 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
15817 /* Never do unification on the 'this' parameter. */
15818 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
15824 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
15825 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
15826 new_args
[0] = return_type
;
15827 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
15832 /* We allow incomplete unification without an error message here
15833 because the standard doesn't seem to explicitly prohibit it. Our
15834 callers must be ready to deal with unification failures in any
15837 TREE_VALUE (tinst
) = targs
;
15838 /* If we aren't explaining yet, push tinst context so we can see where
15839 any errors (e.g. from class instantiations triggered by instantiation
15840 of default template arguments) come from. If we are explaining, this
15841 context is redundant. */
15842 if (!explain_p
&& !push_tinst_level (tinst
))
15844 excessive_deduction_depth
= true;
15848 /* type_unification_real will pass back any access checks from default
15849 template argument substitution. */
15850 vec
<deferred_access_check
, va_gc
> *checks
;
15853 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
15854 targs
, parms
, args
, nargs
, /*subr=*/0,
15855 strict
, flags
, &checks
, explain_p
);
15857 pop_tinst_level ();
15861 /* Now that we have bindings for all of the template arguments,
15862 ensure that the arguments deduced for the template template
15863 parameters have compatible template parameter lists. We cannot
15864 check this property before we have deduced all template
15865 arguments, because the template parameter types of a template
15866 template parameter might depend on prior template parameters
15867 deduced after the template template parameter. The following
15868 ill-formed example illustrates this issue:
15870 template<typename T, template<T> class C> void f(C<5>, T);
15872 template<int N> struct X {};
15875 f(X<5>(), 5l); // error: template argument deduction fails
15878 The template parameter list of 'C' depends on the template type
15879 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
15880 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
15881 time that we deduce 'C'. */
15882 if (!template_template_parm_bindings_ok_p
15883 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
15885 unify_inconsistent_template_template_parameters (explain_p
);
15889 /* All is well so far. Now, check:
15893 When all template arguments have been deduced, all uses of
15894 template parameters in nondeduced contexts are replaced with
15895 the corresponding deduced argument values. If the
15896 substitution results in an invalid type, as described above,
15897 type deduction fails. */
15898 TREE_VALUE (tinst
) = targs
;
15899 if (!push_tinst_level (tinst
))
15901 excessive_deduction_depth
= true;
15905 /* Also collect access checks from the instantiation. */
15906 reopen_deferring_access_checks (checks
);
15908 decl
= instantiate_template (fn
, targs
, complain
);
15910 checks
= get_deferred_access_checks ();
15911 pop_deferring_access_checks ();
15913 pop_tinst_level ();
15915 if (decl
== error_mark_node
)
15918 /* Now perform any access checks encountered during substitution. */
15919 push_access_scope (decl
);
15920 ok
= perform_access_checks (checks
, complain
);
15921 pop_access_scope (decl
);
15925 /* If we're looking for an exact match, check that what we got
15926 is indeed an exact match. It might not be if some template
15927 parameters are used in non-deduced contexts. But don't check
15928 for an exact match if we have dependent template arguments;
15929 in that case we're doing partial ordering, and we already know
15930 that we have two candidates that will provide the actual type. */
15931 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
15933 tree substed
= TREE_TYPE (decl
);
15937 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
15939 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
15940 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
15941 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
15943 unify_type_mismatch (explain_p
, args
[i
],
15944 TREE_VALUE (sarg
));
15953 if (excessive_deduction_depth
)
15955 if (deduction_depth
== 0)
15956 /* Reset once we're all the way out. */
15957 excessive_deduction_depth
= false;
15960 /* We can't free this if a pending_template entry or last_error_tinst_level
15961 is pointing at it. */
15962 if (last_pending_template
== old_last_pend
15963 && last_error_tinst_level
== old_error_tinst
)
15969 /* Adjust types before performing type deduction, as described in
15970 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
15971 sections are symmetric. PARM is the type of a function parameter
15972 or the return type of the conversion function. ARG is the type of
15973 the argument passed to the call, or the type of the value
15974 initialized with the result of the conversion function.
15975 ARG_EXPR is the original argument expression, which may be null. */
15978 maybe_adjust_types_for_deduction (unification_kind_t strict
,
15992 /* Swap PARM and ARG throughout the remainder of this
15993 function; the handling is precisely symmetric since PARM
15994 will initialize ARG rather than vice versa. */
16002 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16003 too, but here handle it by stripping the reference from PARM
16004 rather than by adding it to ARG. */
16005 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16006 && TYPE_REF_IS_RVALUE (*parm
)
16007 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16008 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16009 && TREE_CODE (*arg
) == REFERENCE_TYPE
16010 && !TYPE_REF_IS_RVALUE (*arg
))
16011 *parm
= TREE_TYPE (*parm
);
16012 /* Nothing else to do in this case. */
16016 gcc_unreachable ();
16019 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16021 /* [temp.deduct.call]
16023 If P is not a reference type:
16025 --If A is an array type, the pointer type produced by the
16026 array-to-pointer standard conversion (_conv.array_) is
16027 used in place of A for type deduction; otherwise,
16029 --If A is a function type, the pointer type produced by
16030 the function-to-pointer standard conversion
16031 (_conv.func_) is used in place of A for type deduction;
16034 --If A is a cv-qualified type, the top level
16035 cv-qualifiers of A's type are ignored for type
16037 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16038 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16039 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16040 *arg
= build_pointer_type (*arg
);
16042 *arg
= TYPE_MAIN_VARIANT (*arg
);
16045 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16046 of the form T&&, where T is a template parameter, and the argument
16047 is an lvalue, T is deduced as A& */
16048 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16049 && TYPE_REF_IS_RVALUE (*parm
)
16050 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16051 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16052 && (arg_expr
? real_lvalue_p (arg_expr
)
16053 /* try_one_overload doesn't provide an arg_expr, but
16054 functions are always lvalues. */
16055 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16056 *arg
= build_reference_type (*arg
);
16058 /* [temp.deduct.call]
16060 If P is a cv-qualified type, the top level cv-qualifiers
16061 of P's type are ignored for type deduction. If P is a
16062 reference type, the type referred to by P is used for
16064 *parm
= TYPE_MAIN_VARIANT (*parm
);
16065 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16067 *parm
= TREE_TYPE (*parm
);
16068 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16071 /* DR 322. For conversion deduction, remove a reference type on parm
16072 too (which has been swapped into ARG). */
16073 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16074 *arg
= TREE_TYPE (*arg
);
16079 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16080 template which does contain any deducible template parameters; check if
16081 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16082 unify_one_argument. */
16085 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16086 int flags
, bool explain_p
)
16091 type
= TREE_TYPE (arg
);
16095 if (same_type_p (parm
, type
))
16096 return unify_success (explain_p
);
16098 if (strict
== DEDUCE_CONV
)
16100 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16101 explain_p
? tf_warning_or_error
: tf_none
))
16102 return unify_success (explain_p
);
16104 else if (strict
!= DEDUCE_EXACT
)
16106 if (can_convert_arg (parm
, type
,
16107 TYPE_P (arg
) ? NULL_TREE
: arg
,
16108 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16109 return unify_success (explain_p
);
16112 if (strict
== DEDUCE_EXACT
)
16113 return unify_type_mismatch (explain_p
, parm
, arg
);
16115 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16118 static bool uses_deducible_template_parms (tree type
);
16120 /* Returns true iff the expression EXPR is one from which a template
16121 argument can be deduced. In other words, if it's an undecorated
16122 use of a template non-type parameter. */
16125 deducible_expression (tree expr
)
16127 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16130 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16131 deducible way; that is, if it has a max value of <PARM> - 1. */
16134 deducible_array_bound (tree domain
)
16136 if (domain
== NULL_TREE
)
16139 tree max
= TYPE_MAX_VALUE (domain
);
16140 if (TREE_CODE (max
) != MINUS_EXPR
)
16143 return deducible_expression (TREE_OPERAND (max
, 0));
16146 /* Returns true iff the template arguments ARGS use a template parameter
16147 in a deducible way. */
16150 deducible_template_args (tree args
)
16152 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16155 tree elt
= TREE_VEC_ELT (args
, i
);
16156 if (ARGUMENT_PACK_P (elt
))
16157 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16160 if (PACK_EXPANSION_P (elt
))
16161 elt
= PACK_EXPANSION_PATTERN (elt
);
16162 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16164 else if (TYPE_P (elt
))
16165 deducible
= uses_deducible_template_parms (elt
);
16167 deducible
= deducible_expression (elt
);
16175 /* Returns true iff TYPE contains any deducible references to template
16176 parameters, as per 14.8.2.5. */
16179 uses_deducible_template_parms (tree type
)
16181 if (PACK_EXPANSION_P (type
))
16182 type
= PACK_EXPANSION_PATTERN (type
);
16189 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16190 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16196 if (POINTER_TYPE_P (type
))
16197 return uses_deducible_template_parms (TREE_TYPE (type
));
16199 /* T[integer-constant ]
16201 if (TREE_CODE (type
) == ARRAY_TYPE
)
16202 return (uses_deducible_template_parms (TREE_TYPE (type
))
16203 || deducible_array_bound (TYPE_DOMAIN (type
)));
16215 if (TYPE_PTRMEM_P (type
))
16216 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16217 || (uses_deducible_template_parms
16218 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16220 /* template-name <T> (where template-name refers to a class template)
16221 template-name <i> (where template-name refers to a class template) */
16222 if (CLASS_TYPE_P (type
)
16223 && CLASSTYPE_TEMPLATE_INFO (type
)
16224 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16225 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16226 (CLASSTYPE_TI_ARGS (type
)));
16231 if (TREE_CODE (type
) == FUNCTION_TYPE
16232 || TREE_CODE (type
) == METHOD_TYPE
)
16234 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16236 tree parm
= TYPE_ARG_TYPES (type
);
16237 if (TREE_CODE (type
) == METHOD_TYPE
)
16238 parm
= TREE_CHAIN (parm
);
16239 for (; parm
; parm
= TREE_CHAIN (parm
))
16240 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16247 /* Subroutine of type_unification_real and unify_pack_expansion to
16248 handle unification of a single P/A pair. Parameters are as
16249 for those functions. */
16252 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16253 int subr
, unification_kind_t strict
, int flags
,
16256 tree arg_expr
= NULL_TREE
;
16259 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16260 return unify_invalid (explain_p
);
16261 if (arg
== unknown_type_node
)
16262 /* We can't deduce anything from this, but we might get all the
16263 template args from other function args. */
16264 return unify_success (explain_p
);
16266 /* Implicit conversions (Clause 4) will be performed on a function
16267 argument to convert it to the type of the corresponding function
16268 parameter if the parameter type contains no template-parameters that
16269 participate in template argument deduction. */
16270 if (TYPE_P (parm
) && !uses_template_parms (parm
))
16271 /* For function parameters that contain no template-parameters at all,
16272 we have historically checked for convertibility in order to shortcut
16273 consideration of this candidate. */
16274 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
16276 else if (strict
== DEDUCE_CALL
16277 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16278 /* For function parameters with only non-deducible template parameters,
16280 return unify_success (explain_p
);
16285 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16286 | UNIFY_ALLOW_MORE_CV_QUAL
16287 | UNIFY_ALLOW_DERIVED
);
16291 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16295 arg_strict
= UNIFY_ALLOW_NONE
;
16299 gcc_unreachable ();
16302 /* We only do these transformations if this is the top-level
16303 parameter_type_list in a call or declaration matching; in other
16304 situations (nested function declarators, template argument lists) we
16305 won't be comparing a type to an expression, and we don't do any type
16311 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16312 if (type_unknown_p (arg
))
16314 /* [temp.deduct.type] A template-argument can be
16315 deduced from a pointer to function or pointer
16316 to member function argument if the set of
16317 overloaded functions does not contain function
16318 templates and at most one of a set of
16319 overloaded functions provides a unique
16322 if (resolve_overloaded_unification
16323 (tparms
, targs
, parm
, arg
, strict
,
16324 arg_strict
, explain_p
))
16325 return unify_success (explain_p
);
16326 return unify_overload_resolution_failure (explain_p
, arg
);
16330 arg
= unlowered_expr_type (arg
);
16331 if (arg
== error_mark_node
)
16332 return unify_invalid (explain_p
);
16336 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16339 gcc_assert ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16340 == (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
));
16342 /* For deduction from an init-list we need the actual list. */
16343 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16345 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16348 /* Most parms like fn_type_unification.
16350 If SUBR is 1, we're being called recursively (to unify the
16351 arguments of a function or method parameter of a function
16354 CHECKS is a pointer to a vector of access checks encountered while
16355 substituting default template arguments. */
16358 type_unification_real (tree tparms
,
16362 unsigned int xnargs
,
16364 unification_kind_t strict
,
16366 vec
<deferred_access_check
, va_gc
> **checks
,
16371 int ntparms
= TREE_VEC_LENGTH (tparms
);
16372 int saw_undeduced
= 0;
16375 unsigned int nargs
;
16378 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16379 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16380 gcc_assert (ntparms
> 0);
16382 /* Reset the number of non-defaulted template arguments contained
16384 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16392 while (parms
&& parms
!= void_list_node
16395 parm
= TREE_VALUE (parms
);
16397 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16398 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16399 /* For a function parameter pack that occurs at the end of the
16400 parameter-declaration-list, the type A of each remaining
16401 argument of the call is compared with the type P of the
16402 declarator-id of the function parameter pack. */
16405 parms
= TREE_CHAIN (parms
);
16407 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16408 /* For a function parameter pack that does not occur at the
16409 end of the parameter-declaration-list, the type of the
16410 parameter pack is a non-deduced context. */
16416 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16422 && parms
!= void_list_node
16423 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16425 /* Unify the remaining arguments with the pack expansion type. */
16427 tree parmvec
= make_tree_vec (1);
16429 /* Allocate a TREE_VEC and copy in all of the arguments */
16430 argvec
= make_tree_vec (nargs
- ia
);
16431 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16432 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16434 /* Copy the parameter into parmvec. */
16435 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16436 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16437 /*subr=*/subr
, explain_p
))
16440 /* Advance to the end of the list of parameters. */
16441 parms
= TREE_CHAIN (parms
);
16444 /* Fail if we've reached the end of the parm list, and more args
16445 are present, and the parm list isn't variadic. */
16446 if (ia
< nargs
&& parms
== void_list_node
)
16447 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16448 /* Fail if parms are left and they don't have default values. */
16449 if (parms
&& parms
!= void_list_node
16450 && TREE_PURPOSE (parms
) == NULL_TREE
)
16452 unsigned int count
= nargs
;
16454 while (p
&& p
!= void_list_node
)
16457 p
= TREE_CHAIN (p
);
16459 return unify_too_few_arguments (explain_p
, ia
, count
);
16464 tsubst_flags_t complain
= (explain_p
16465 ? tf_warning_or_error
16468 for (i
= 0; i
< ntparms
; i
++)
16470 tree targ
= TREE_VEC_ELT (targs
, i
);
16471 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16473 /* Clear the "incomplete" flags on all argument packs now so that
16474 substituting them into later default arguments works. */
16475 if (targ
&& ARGUMENT_PACK_P (targ
))
16477 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16478 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16481 if (targ
|| tparm
== error_mark_node
)
16483 tparm
= TREE_VALUE (tparm
);
16485 /* If this is an undeduced nontype parameter that depends on
16486 a type parameter, try another pass; its type may have been
16487 deduced from a later argument than the one from which
16488 this parameter can be deduced. */
16489 if (TREE_CODE (tparm
) == PARM_DECL
16490 && uses_template_parms (TREE_TYPE (tparm
))
16491 && !saw_undeduced
++)
16494 /* Core issue #226 (C++0x) [temp.deduct]:
16496 If a template argument has not been deduced, its
16497 default template argument, if any, is used.
16499 When we are in C++98 mode, TREE_PURPOSE will either
16500 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16501 to explicitly check cxx_dialect here. */
16502 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
16504 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16505 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
16506 reopen_deferring_access_checks (*checks
);
16507 location_t save_loc
= input_location
;
16509 input_location
= DECL_SOURCE_LOCATION (parm
);
16510 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
16511 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
16513 input_location
= save_loc
;
16514 *checks
= get_deferred_access_checks ();
16515 pop_deferring_access_checks ();
16516 if (arg
== error_mark_node
)
16520 TREE_VEC_ELT (targs
, i
) = arg
;
16521 /* The position of the first default template argument,
16522 is also the number of non-defaulted arguments in TARGS.
16524 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16525 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
16530 /* If the type parameter is a parameter pack, then it will
16531 be deduced to an empty parameter pack. */
16532 if (template_parameter_pack_p (tparm
))
16536 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
16538 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
16539 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
16540 TREE_CONSTANT (arg
) = 1;
16543 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16545 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
16547 TREE_VEC_ELT (targs
, i
) = arg
;
16551 return unify_parameter_deduction_failure (explain_p
, tparm
);
16554 #ifdef ENABLE_CHECKING
16555 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16556 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
16559 return unify_success (explain_p
);
16562 /* Subroutine of type_unification_real. Args are like the variables
16563 at the call site. ARG is an overloaded function (or template-id);
16564 we try deducing template args from each of the overloads, and if
16565 only one succeeds, we go with that. Modifies TARGS and returns
16566 true on success. */
16569 resolve_overloaded_unification (tree tparms
,
16573 unification_kind_t strict
,
16577 tree tempargs
= copy_node (targs
);
16579 tree goodfn
= NULL_TREE
;
16582 if (TREE_CODE (arg
) == ADDR_EXPR
)
16584 arg
= TREE_OPERAND (arg
, 0);
16590 if (TREE_CODE (arg
) == COMPONENT_REF
)
16591 /* Handle `&x' where `x' is some static or non-static member
16593 arg
= TREE_OPERAND (arg
, 1);
16595 if (TREE_CODE (arg
) == OFFSET_REF
)
16596 arg
= TREE_OPERAND (arg
, 1);
16598 /* Strip baselink information. */
16599 if (BASELINK_P (arg
))
16600 arg
= BASELINK_FUNCTIONS (arg
);
16602 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
16604 /* If we got some explicit template args, we need to plug them into
16605 the affected templates before we try to unify, in case the
16606 explicit args will completely resolve the templates in question. */
16609 tree expl_subargs
= TREE_OPERAND (arg
, 1);
16610 arg
= TREE_OPERAND (arg
, 0);
16612 for (; arg
; arg
= OVL_NEXT (arg
))
16614 tree fn
= OVL_CURRENT (arg
);
16615 tree subargs
, elem
;
16617 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16620 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16621 expl_subargs
, NULL_TREE
, tf_none
,
16622 /*require_all_args=*/true,
16623 /*use_default_args=*/true);
16624 if (subargs
!= error_mark_node
16625 && !any_dependent_template_arguments_p (subargs
))
16627 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
16628 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16629 elem
, strict
, sub_strict
, addr_p
, explain_p
)
16630 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
16639 /* If no templates (or more than one) are fully resolved by the
16640 explicit arguments, this template-id is a non-deduced context; it
16641 could still be OK if we deduce all template arguments for the
16642 enclosing call through other arguments. */
16646 else if (TREE_CODE (arg
) != OVERLOAD
16647 && TREE_CODE (arg
) != FUNCTION_DECL
)
16648 /* If ARG is, for example, "(0, &f)" then its type will be unknown
16649 -- but the deduction does not succeed because the expression is
16650 not just the function on its own. */
16653 for (; arg
; arg
= OVL_NEXT (arg
))
16654 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16655 TREE_TYPE (OVL_CURRENT (arg
)),
16656 strict
, sub_strict
, addr_p
, explain_p
)
16657 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
16659 goodfn
= OVL_CURRENT (arg
);
16663 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16664 to function or pointer to member function argument if the set of
16665 overloaded functions does not contain function templates and at most
16666 one of a set of overloaded functions provides a unique match.
16668 So if we found multiple possibilities, we return success but don't
16669 deduce anything. */
16673 int i
= TREE_VEC_LENGTH (targs
);
16675 if (TREE_VEC_ELT (tempargs
, i
))
16676 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
16684 /* Core DR 115: In contexts where deduction is done and fails, or in
16685 contexts where deduction is not done, if a template argument list is
16686 specified and it, along with any default template arguments, identifies
16687 a single function template specialization, then the template-id is an
16688 lvalue for the function template specialization. */
16691 resolve_nondeduced_context (tree orig_expr
)
16693 tree expr
, offset
, baselink
;
16696 if (!type_unknown_p (orig_expr
))
16701 offset
= NULL_TREE
;
16702 baselink
= NULL_TREE
;
16704 if (TREE_CODE (expr
) == ADDR_EXPR
)
16706 expr
= TREE_OPERAND (expr
, 0);
16709 if (TREE_CODE (expr
) == OFFSET_REF
)
16712 expr
= TREE_OPERAND (expr
, 1);
16714 if (BASELINK_P (expr
))
16717 expr
= BASELINK_FUNCTIONS (expr
);
16720 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
16723 tree goodfn
= NULL_TREE
;
16725 /* If we got some explicit template args, we need to plug them into
16726 the affected templates before we try to unify, in case the
16727 explicit args will completely resolve the templates in question. */
16729 tree expl_subargs
= TREE_OPERAND (expr
, 1);
16730 tree arg
= TREE_OPERAND (expr
, 0);
16731 tree badfn
= NULL_TREE
;
16732 tree badargs
= NULL_TREE
;
16734 for (; arg
; arg
= OVL_NEXT (arg
))
16736 tree fn
= OVL_CURRENT (arg
);
16737 tree subargs
, elem
;
16739 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16742 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16743 expl_subargs
, NULL_TREE
, tf_none
,
16744 /*require_all_args=*/true,
16745 /*use_default_args=*/true);
16746 if (subargs
!= error_mark_node
16747 && !any_dependent_template_arguments_p (subargs
))
16749 elem
= instantiate_template (fn
, subargs
, tf_none
);
16750 if (elem
== error_mark_node
)
16755 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
16764 mark_used (goodfn
);
16767 expr
= build_baselink (BASELINK_BINFO (baselink
),
16768 BASELINK_ACCESS_BINFO (baselink
),
16769 expr
, BASELINK_OPTYPE (baselink
));
16773 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
16774 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
16777 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
16780 else if (good
== 0 && badargs
)
16781 /* There were no good options and at least one bad one, so let the
16782 user know what the problem is. */
16783 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
16788 /* Subroutine of resolve_overloaded_unification; does deduction for a single
16789 overload. Fills TARGS with any deduced arguments, or error_mark_node if
16790 different overloads deduce different arguments for a given parm.
16791 ADDR_P is true if the expression for which deduction is being
16792 performed was of the form "& fn" rather than simply "fn".
16794 Returns 1 on success. */
16797 try_one_overload (tree tparms
,
16802 unification_kind_t strict
,
16811 if (arg
== error_mark_node
)
16814 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16815 to function or pointer to member function argument if the set of
16816 overloaded functions does not contain function templates and at most
16817 one of a set of overloaded functions provides a unique match.
16819 So if this is a template, just return success. */
16821 if (uses_template_parms (arg
))
16824 if (TREE_CODE (arg
) == METHOD_TYPE
)
16825 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
16827 arg
= build_pointer_type (arg
);
16829 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
16831 /* We don't copy orig_targs for this because if we have already deduced
16832 some template args from previous args, unify would complain when we
16833 try to deduce a template parameter for the same argument, even though
16834 there isn't really a conflict. */
16835 nargs
= TREE_VEC_LENGTH (targs
);
16836 tempargs
= make_tree_vec (nargs
);
16838 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
16841 /* First make sure we didn't deduce anything that conflicts with
16842 explicitly specified args. */
16843 for (i
= nargs
; i
--; )
16845 tree elt
= TREE_VEC_ELT (tempargs
, i
);
16846 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
16850 else if (uses_template_parms (elt
))
16851 /* Since we're unifying against ourselves, we will fill in
16852 template args used in the function parm list with our own
16853 template parms. Discard them. */
16854 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
16855 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
16859 for (i
= nargs
; i
--; )
16861 tree elt
= TREE_VEC_ELT (tempargs
, i
);
16864 TREE_VEC_ELT (targs
, i
) = elt
;
16870 /* PARM is a template class (perhaps with unbound template
16871 parameters). ARG is a fully instantiated type. If ARG can be
16872 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
16873 TARGS are as for unify. */
16876 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
16879 tree copy_of_targs
;
16881 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
16882 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
16883 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
16886 /* We need to make a new template argument vector for the call to
16887 unify. If we used TARGS, we'd clutter it up with the result of
16888 the attempted unification, even if this class didn't work out.
16889 We also don't want to commit ourselves to all the unifications
16890 we've already done, since unification is supposed to be done on
16891 an argument-by-argument basis. In other words, consider the
16892 following pathological case:
16894 template <int I, int J, int K>
16897 template <int I, int J>
16898 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
16900 template <int I, int J, int K>
16901 void f(S<I, J, K>, S<I, I, I>);
16910 Now, by the time we consider the unification involving `s2', we
16911 already know that we must have `f<0, 0, 0>'. But, even though
16912 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
16913 because there are two ways to unify base classes of S<0, 1, 2>
16914 with S<I, I, I>. If we kept the already deduced knowledge, we
16915 would reject the possibility I=1. */
16916 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
16918 /* If unification failed, we're done. */
16919 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
16920 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
16926 /* Given a template type PARM and a class type ARG, find the unique
16927 base type in ARG that is an instance of PARM. We do not examine
16928 ARG itself; only its base-classes. If there is not exactly one
16929 appropriate base class, return NULL_TREE. PARM may be the type of
16930 a partial specialization, as well as a plain template type. Used
16933 static enum template_base_result
16934 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
16935 bool explain_p
, tree
*result
)
16937 tree rval
= NULL_TREE
;
16940 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
16942 binfo
= TYPE_BINFO (complete_type (arg
));
16945 /* The type could not be completed. */
16946 *result
= NULL_TREE
;
16947 return tbr_incomplete_type
;
16950 /* Walk in inheritance graph order. The search order is not
16951 important, and this avoids multiple walks of virtual bases. */
16952 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
16954 tree r
= try_class_unification (tparms
, targs
, parm
,
16955 BINFO_TYPE (binfo
), explain_p
);
16959 /* If there is more than one satisfactory baseclass, then:
16963 If they yield more than one possible deduced A, the type
16967 if (rval
&& !same_type_p (r
, rval
))
16969 *result
= NULL_TREE
;
16970 return tbr_ambiguous_baseclass
;
16978 return tbr_success
;
16981 /* Returns the level of DECL, which declares a template parameter. */
16984 template_decl_level (tree decl
)
16986 switch (TREE_CODE (decl
))
16989 case TEMPLATE_DECL
:
16990 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
16993 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
16996 gcc_unreachable ();
17001 /* Decide whether ARG can be unified with PARM, considering only the
17002 cv-qualifiers of each type, given STRICT as documented for unify.
17003 Returns nonzero iff the unification is OK on that basis. */
17006 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17008 int arg_quals
= cp_type_quals (arg
);
17009 int parm_quals
= cp_type_quals (parm
);
17011 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17012 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17014 /* Although a CVR qualifier is ignored when being applied to a
17015 substituted template parameter ([8.3.2]/1 for example), that
17016 does not allow us to unify "const T" with "int&" because both
17017 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17018 It is ok when we're allowing additional CV qualifiers
17019 at the outer level [14.8.2.1]/3,1st bullet. */
17020 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17021 || TREE_CODE (arg
) == FUNCTION_TYPE
17022 || TREE_CODE (arg
) == METHOD_TYPE
)
17023 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17026 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17027 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17031 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17032 && (arg_quals
& parm_quals
) != parm_quals
)
17035 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17036 && (parm_quals
& arg_quals
) != arg_quals
)
17042 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17044 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17046 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17047 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17048 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17050 *index
= TEMPLATE_TYPE_IDX (parm
);
17051 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17055 *index
= TEMPLATE_PARM_IDX (parm
);
17056 *level
= TEMPLATE_PARM_LEVEL (parm
);
17060 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17062 if (unify (TP, TA, P, A, S, EP)) \
17066 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17067 expansion at the end of PACKED_PARMS. Returns 0 if the type
17068 deduction succeeds, 1 otherwise. STRICT is the same as in
17069 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17070 call argument list. We'll need to adjust the arguments to make them
17071 types. SUBR tells us if this is from a recursive call to
17072 type_unification_real, or for comparing two template argument
17076 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17077 tree packed_args
, unification_kind_t strict
,
17078 bool subr
, bool explain_p
)
17081 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17082 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17083 tree pack
, packs
= NULL_TREE
;
17084 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17086 packed_args
= expand_template_argument_pack (packed_args
);
17088 int len
= TREE_VEC_LENGTH (packed_args
);
17090 /* Determine the parameter packs we will be deducing from the
17091 pattern, and record their current deductions. */
17092 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17093 pack
; pack
= TREE_CHAIN (pack
))
17095 tree parm_pack
= TREE_VALUE (pack
);
17098 /* Determine the index and level of this parameter pack. */
17099 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17101 /* Keep track of the parameter packs and their corresponding
17103 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17104 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17107 /* Loop through all of the arguments that have not yet been
17108 unified and unify each with the pattern. */
17109 for (i
= start
; i
< len
; i
++)
17112 bool any_explicit
= false;
17113 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17115 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17116 or the element of its argument pack at the current index if
17117 this argument was explicitly specified. */
17118 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17122 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17125 if (TREE_VALUE (pack
)
17126 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17127 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17129 any_explicit
= true;
17130 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17132 TMPL_ARG (targs
, level
, idx
) = arg
;
17135 /* If we had explicit template arguments, substitute them into the
17136 pattern before deduction. */
17139 /* Some arguments might still be unspecified or dependent. */
17141 ++processing_template_decl
;
17142 dependent
= any_dependent_template_arguments_p (targs
);
17144 --processing_template_decl
;
17145 parm
= tsubst (pattern
, targs
,
17146 explain_p
? tf_warning_or_error
: tf_none
,
17149 --processing_template_decl
;
17150 if (parm
== error_mark_node
)
17156 /* Unify the pattern with the current argument. */
17157 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17158 LOOKUP_IMPLICIT
, explain_p
))
17161 /* For each parameter pack, collect the deduced value. */
17162 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17165 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17167 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17168 TMPL_ARG (targs
, level
, idx
);
17172 /* Verify that the results of unification with the parameter packs
17173 produce results consistent with what we've seen before, and make
17174 the deduced argument packs available. */
17175 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17177 tree old_pack
= TREE_VALUE (pack
);
17178 tree new_args
= TREE_TYPE (pack
);
17179 int i
, len
= TREE_VEC_LENGTH (new_args
);
17181 bool nondeduced_p
= false;
17183 /* By default keep the original deduced argument pack.
17184 If necessary, more specific code is going to update the
17185 resulting deduced argument later down in this function. */
17186 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17187 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17189 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17190 actually deduce anything. */
17191 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17192 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17193 nondeduced_p
= true;
17197 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17199 /* If we had fewer function args than explicit template args,
17200 just use the explicits. */
17201 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17202 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17203 if (len
< explicit_len
)
17204 new_args
= explicit_args
;
17210 /* Build the deduced *_ARGUMENT_PACK. */
17211 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17213 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17214 TREE_TYPE (result
) =
17215 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17216 TREE_CONSTANT (result
) = 1;
17219 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17221 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17223 /* Note the deduced argument packs for this parameter
17225 TMPL_ARG (targs
, level
, idx
) = result
;
17227 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17228 && (ARGUMENT_PACK_ARGS (old_pack
)
17229 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17231 /* We only had the explicitly-provided arguments before, but
17232 now we have a complete set of arguments. */
17233 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17235 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17236 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17237 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17241 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17242 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17244 if (!comp_template_args_with_info (old_args
, new_args
,
17245 &bad_old_arg
, &bad_new_arg
))
17246 /* Inconsistent unification of this parameter pack. */
17247 return unify_parameter_pack_inconsistent (explain_p
,
17253 return unify_success (explain_p
);
17256 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17257 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17258 parameters and return value are as for unify. */
17261 unify_array_domain (tree tparms
, tree targs
,
17262 tree parm_dom
, tree arg_dom
,
17270 /* Our representation of array types uses "N - 1" as the
17271 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17272 not an integer constant. We cannot unify arbitrarily
17273 complex expressions, so we eliminate the MINUS_EXPRs
17275 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17276 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17279 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17280 parm_max
= TREE_OPERAND (parm_max
, 0);
17282 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17283 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17286 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17287 trying to unify the type of a variable with the type
17288 of a template parameter. For example:
17290 template <unsigned int N>
17291 void f (char (&) [N]);
17298 Here, the type of the ARG will be "int [g(i)]", and
17299 may be a SAVE_EXPR, etc. */
17300 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17301 return unify_vla_arg (explain_p
, arg_dom
);
17302 arg_max
= TREE_OPERAND (arg_max
, 0);
17305 /* If only one of the bounds used a MINUS_EXPR, compensate
17306 by adding one to the other bound. */
17307 if (parm_cst
&& !arg_cst
)
17308 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17312 else if (arg_cst
&& !parm_cst
)
17313 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17318 return unify (tparms
, targs
, parm_max
, arg_max
,
17319 UNIFY_ALLOW_INTEGER
, explain_p
);
17322 /* Deduce the value of template parameters. TPARMS is the (innermost)
17323 set of template parameters to a template. TARGS is the bindings
17324 for those template parameters, as determined thus far; TARGS may
17325 include template arguments for outer levels of template parameters
17326 as well. PARM is a parameter to a template function, or a
17327 subcomponent of that parameter; ARG is the corresponding argument.
17328 This function attempts to match PARM with ARG in a manner
17329 consistent with the existing assignments in TARGS. If more values
17330 are deduced, then TARGS is updated.
17332 Returns 0 if the type deduction succeeds, 1 otherwise. The
17333 parameter STRICT is a bitwise or of the following flags:
17336 Require an exact match between PARM and ARG.
17337 UNIFY_ALLOW_MORE_CV_QUAL:
17338 Allow the deduced ARG to be more cv-qualified (by qualification
17339 conversion) than ARG.
17340 UNIFY_ALLOW_LESS_CV_QUAL:
17341 Allow the deduced ARG to be less cv-qualified than ARG.
17342 UNIFY_ALLOW_DERIVED:
17343 Allow the deduced ARG to be a template base class of ARG,
17344 or a pointer to a template base class of the type pointed to by
17346 UNIFY_ALLOW_INTEGER:
17347 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17348 case for more information.
17349 UNIFY_ALLOW_OUTER_LEVEL:
17350 This is the outermost level of a deduction. Used to determine validity
17351 of qualification conversions. A valid qualification conversion must
17352 have const qualified pointers leading up to the inner type which
17353 requires additional CV quals, except at the outer level, where const
17354 is not required [conv.qual]. It would be normal to set this flag in
17355 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17356 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17357 This is the outermost level of a deduction, and PARM can be more CV
17358 qualified at this point.
17359 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17360 This is the outermost level of a deduction, and PARM can be less CV
17361 qualified at this point. */
17364 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17370 int strict_in
= strict
;
17372 /* I don't think this will do the right thing with respect to types.
17373 But the only case I've seen it in so far has been array bounds, where
17374 signedness is the only information lost, and I think that will be
17376 while (TREE_CODE (parm
) == NOP_EXPR
)
17377 parm
= TREE_OPERAND (parm
, 0);
17379 if (arg
== error_mark_node
)
17380 return unify_invalid (explain_p
);
17381 if (arg
== unknown_type_node
17382 || arg
== init_list_type_node
)
17383 /* We can't deduce anything from this, but we might get all the
17384 template args from other function args. */
17385 return unify_success (explain_p
);
17387 /* If PARM uses template parameters, then we can't bail out here,
17388 even if ARG == PARM, since we won't record unifications for the
17389 template parameters. We might need them if we're trying to
17390 figure out which of two things is more specialized. */
17391 if (arg
== parm
&& !uses_template_parms (parm
))
17392 return unify_success (explain_p
);
17394 /* Handle init lists early, so the rest of the function can assume
17395 we're dealing with a type. */
17396 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17400 tree orig_parm
= parm
;
17402 /* Replace T with std::initializer_list<T> for deduction. */
17403 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17404 && flag_deduce_init_list
)
17405 parm
= listify (parm
);
17407 if (!is_std_init_list (parm
)
17408 && TREE_CODE (parm
) != ARRAY_TYPE
)
17409 /* We can only deduce from an initializer list argument if the
17410 parameter is std::initializer_list or an array; otherwise this
17411 is a non-deduced context. */
17412 return unify_success (explain_p
);
17414 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17415 elttype
= TREE_TYPE (parm
);
17417 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17419 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
17421 int elt_strict
= strict
;
17423 if (elt
== error_mark_node
)
17424 return unify_invalid (explain_p
);
17426 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
17428 tree type
= TREE_TYPE (elt
);
17429 /* It should only be possible to get here for a call. */
17430 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
17431 elt_strict
|= maybe_adjust_types_for_deduction
17432 (DEDUCE_CALL
, &elttype
, &type
, elt
);
17436 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
17440 if (TREE_CODE (parm
) == ARRAY_TYPE
17441 && deducible_array_bound (TYPE_DOMAIN (parm
)))
17443 /* Also deduce from the length of the initializer list. */
17444 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
17445 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
17446 if (idx
== error_mark_node
)
17447 return unify_invalid (explain_p
);
17448 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17452 /* If the std::initializer_list<T> deduction worked, replace the
17453 deduced A with std::initializer_list<A>. */
17454 if (orig_parm
!= parm
)
17456 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
17457 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17458 targ
= listify (targ
);
17459 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
17461 return unify_success (explain_p
);
17464 /* Immediately reject some pairs that won't unify because of
17465 cv-qualification mismatches. */
17466 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17468 /* It is the elements of the array which hold the cv quals of an array
17469 type, and the elements might be template type parms. We'll check
17470 when we recurse. */
17471 && TREE_CODE (arg
) != ARRAY_TYPE
17472 /* We check the cv-qualifiers when unifying with template type
17473 parameters below. We want to allow ARG `const T' to unify with
17474 PARM `T' for example, when computing which of two templates
17475 is more specialized, for example. */
17476 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
17477 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
17478 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17480 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
17481 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
17482 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
17483 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
17484 strict
&= ~UNIFY_ALLOW_DERIVED
;
17485 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17486 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
17488 switch (TREE_CODE (parm
))
17490 case TYPENAME_TYPE
:
17492 case UNBOUND_CLASS_TEMPLATE
:
17493 /* In a type which contains a nested-name-specifier, template
17494 argument values cannot be deduced for template parameters used
17495 within the nested-name-specifier. */
17496 return unify_success (explain_p
);
17498 case TEMPLATE_TYPE_PARM
:
17499 case TEMPLATE_TEMPLATE_PARM
:
17500 case BOUND_TEMPLATE_TEMPLATE_PARM
:
17501 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17502 if (error_operand_p (tparm
))
17503 return unify_invalid (explain_p
);
17505 if (TEMPLATE_TYPE_LEVEL (parm
)
17506 != template_decl_level (tparm
))
17507 /* The PARM is not one we're trying to unify. Just check
17508 to see if it matches ARG. */
17510 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17511 && (is_auto (parm
) ? is_auto (arg
)
17512 : same_type_p (parm
, arg
)))
17513 return unify_success (explain_p
);
17515 return unify_type_mismatch (explain_p
, parm
, arg
);
17517 idx
= TEMPLATE_TYPE_IDX (parm
);
17518 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17519 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
17520 if (error_operand_p (tparm
))
17521 return unify_invalid (explain_p
);
17523 /* Check for mixed types and values. */
17524 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17525 && TREE_CODE (tparm
) != TYPE_DECL
)
17526 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17527 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
17528 gcc_unreachable ();
17530 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17532 /* ARG must be constructed from a template class or a template
17533 template parameter. */
17534 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
17535 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
17536 return unify_template_deduction_failure (explain_p
, parm
, arg
);
17538 tree parmvec
= TYPE_TI_ARGS (parm
);
17539 /* An alias template name is never deduced. */
17540 if (TYPE_ALIAS_P (arg
))
17541 arg
= strip_typedefs (arg
);
17542 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
17543 tree full_argvec
= add_to_template_args (targs
, argvec
);
17545 = DECL_INNERMOST_TEMPLATE_PARMS
17546 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
17548 int parm_variadic_p
= 0;
17550 /* The resolution to DR150 makes clear that default
17551 arguments for an N-argument may not be used to bind T
17552 to a template template parameter with fewer than N
17553 parameters. It is not safe to permit the binding of
17554 default arguments as an extension, as that may change
17555 the meaning of a conforming program. Consider:
17557 struct Dense { static const unsigned int dim = 1; };
17559 template <template <typename> class View,
17561 void operator+(float, View<Block> const&);
17563 template <typename Block,
17564 unsigned int Dim = Block::dim>
17565 struct Lvalue_proxy { operator float() const; };
17569 Lvalue_proxy<Dense> p;
17574 Here, if Lvalue_proxy is permitted to bind to View, then
17575 the global operator+ will be used; if they are not, the
17576 Lvalue_proxy will be converted to float. */
17577 if (coerce_template_parms (parm_parms
,
17579 TYPE_TI_TEMPLATE (parm
),
17581 ? tf_warning_or_error
17583 /*require_all_args=*/true,
17584 /*use_default_args=*/false)
17585 == error_mark_node
)
17588 /* Deduce arguments T, i from TT<T> or TT<i>.
17589 We check each element of PARMVEC and ARGVEC individually
17590 rather than the whole TREE_VEC since they can have
17591 different number of elements. */
17593 parmvec
= expand_template_argument_pack (parmvec
);
17594 argvec
= expand_template_argument_pack (argvec
);
17596 len
= TREE_VEC_LENGTH (parmvec
);
17598 /* Check if the parameters end in a pack, making them
17601 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
17602 parm_variadic_p
= 1;
17604 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17605 /* If the template argument list of P contains a pack
17606 expansion that is not the last template argument, the
17607 entire template argument list is a non-deduced
17609 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
17610 return unify_success (explain_p
);
17612 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
17613 return unify_too_few_arguments (explain_p
,
17614 TREE_VEC_LENGTH (argvec
), len
);
17616 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17618 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17619 TREE_VEC_ELT (parmvec
, i
),
17620 TREE_VEC_ELT (argvec
, i
),
17621 UNIFY_ALLOW_NONE
, explain_p
);
17624 if (parm_variadic_p
17625 && unify_pack_expansion (tparms
, targs
,
17628 /*subr=*/true, explain_p
))
17631 arg
= TYPE_TI_TEMPLATE (arg
);
17633 /* Fall through to deduce template name. */
17636 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17637 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17639 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
17641 /* Simple cases: Value already set, does match or doesn't. */
17642 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
17643 return unify_success (explain_p
);
17645 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17649 /* If PARM is `const T' and ARG is only `int', we don't have
17650 a match unless we are allowing additional qualification.
17651 If ARG is `const int' and PARM is just `T' that's OK;
17652 that binds `const int' to `T'. */
17653 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
17655 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17657 /* Consider the case where ARG is `const volatile int' and
17658 PARM is `const T'. Then, T should be `volatile int'. */
17659 arg
= cp_build_qualified_type_real
17660 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
17661 if (arg
== error_mark_node
)
17662 return unify_invalid (explain_p
);
17664 /* Simple cases: Value already set, does match or doesn't. */
17665 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
17666 return unify_success (explain_p
);
17668 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17670 /* Make sure that ARG is not a variable-sized array. (Note
17671 that were talking about variable-sized arrays (like
17672 `int[n]'), rather than arrays of unknown size (like
17673 `int[]').) We'll get very confused by such a type since
17674 the bound of the array is not constant, and therefore
17675 not mangleable. Besides, such types are not allowed in
17676 ISO C++, so we can do as we please here. We do allow
17677 them for 'auto' deduction, since that isn't ABI-exposed. */
17678 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
17679 return unify_vla_arg (explain_p
, arg
);
17681 /* Strip typedefs as in convert_template_argument. */
17682 arg
= canonicalize_type_argument (arg
, tf_none
);
17685 /* If ARG is a parameter pack or an expansion, we cannot unify
17686 against it unless PARM is also a parameter pack. */
17687 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17688 && !template_parameter_pack_p (parm
))
17689 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17691 /* If the argument deduction results is a METHOD_TYPE,
17692 then there is a problem.
17693 METHOD_TYPE doesn't map to any real C++ type the result of
17694 the deduction can not be of that type. */
17695 if (TREE_CODE (arg
) == METHOD_TYPE
)
17696 return unify_method_type_error (explain_p
, arg
);
17698 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17699 return unify_success (explain_p
);
17701 case TEMPLATE_PARM_INDEX
:
17702 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17703 if (error_operand_p (tparm
))
17704 return unify_invalid (explain_p
);
17706 if (TEMPLATE_PARM_LEVEL (parm
)
17707 != template_decl_level (tparm
))
17709 /* The PARM is not one we're trying to unify. Just check
17710 to see if it matches ARG. */
17711 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
17712 && cp_tree_equal (parm
, arg
));
17714 unify_expression_unequal (explain_p
, parm
, arg
);
17718 idx
= TEMPLATE_PARM_IDX (parm
);
17719 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17723 int x
= !cp_tree_equal (targ
, arg
);
17725 unify_inconsistency (explain_p
, parm
, targ
, arg
);
17729 /* [temp.deduct.type] If, in the declaration of a function template
17730 with a non-type template-parameter, the non-type
17731 template-parameter is used in an expression in the function
17732 parameter-list and, if the corresponding template-argument is
17733 deduced, the template-argument type shall match the type of the
17734 template-parameter exactly, except that a template-argument
17735 deduced from an array bound may be of any integral type.
17736 The non-type parameter might use already deduced type parameters. */
17737 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
17738 if (!TREE_TYPE (arg
))
17739 /* Template-parameter dependent expression. Just accept it for now.
17740 It will later be processed in convert_template_argument. */
17742 else if (same_type_p (TREE_TYPE (arg
), tparm
))
17744 else if ((strict
& UNIFY_ALLOW_INTEGER
)
17745 && CP_INTEGRAL_TYPE_P (tparm
))
17746 /* Convert the ARG to the type of PARM; the deduced non-type
17747 template argument must exactly match the types of the
17748 corresponding parameter. */
17749 arg
= fold (build_nop (tparm
, arg
));
17750 else if (uses_template_parms (tparm
))
17751 /* We haven't deduced the type of this parameter yet. Try again
17753 return unify_success (explain_p
);
17755 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
17757 /* If ARG is a parameter pack or an expansion, we cannot unify
17758 against it unless PARM is also a parameter pack. */
17759 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17760 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
17761 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17763 arg
= strip_typedefs_expr (arg
);
17764 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17765 return unify_success (explain_p
);
17769 /* A pointer-to-member constant can be unified only with
17770 another constant. */
17771 if (TREE_CODE (arg
) != PTRMEM_CST
)
17772 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
17774 /* Just unify the class member. It would be useless (and possibly
17775 wrong, depending on the strict flags) to unify also
17776 PTRMEM_CST_CLASS, because we want to be sure that both parm and
17777 arg refer to the same variable, even if through different
17778 classes. For instance:
17780 struct A { int x; };
17783 Unification of &A::x and &B::x must succeed. */
17784 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
17785 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
17790 if (!TYPE_PTR_P (arg
))
17791 return unify_type_mismatch (explain_p
, parm
, arg
);
17793 /* [temp.deduct.call]
17795 A can be another pointer or pointer to member type that can
17796 be converted to the deduced A via a qualification
17797 conversion (_conv.qual_).
17799 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
17800 This will allow for additional cv-qualification of the
17801 pointed-to types if appropriate. */
17803 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
17804 /* The derived-to-base conversion only persists through one
17805 level of pointers. */
17806 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
17808 return unify (tparms
, targs
, TREE_TYPE (parm
),
17809 TREE_TYPE (arg
), strict
, explain_p
);
17812 case REFERENCE_TYPE
:
17813 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
17814 return unify_type_mismatch (explain_p
, parm
, arg
);
17815 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
17816 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
17819 if (TREE_CODE (arg
) != ARRAY_TYPE
)
17820 return unify_type_mismatch (explain_p
, parm
, arg
);
17821 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
17822 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
17823 return unify_type_mismatch (explain_p
, parm
, arg
);
17824 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
17825 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
17826 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
17827 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17828 TYPE_DOMAIN (arg
), explain_p
);
17829 return unify_success (explain_p
);
17836 case ENUMERAL_TYPE
:
17839 if (TREE_CODE (arg
) != TREE_CODE (parm
))
17840 return unify_type_mismatch (explain_p
, parm
, arg
);
17842 /* We have already checked cv-qualification at the top of the
17844 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
17845 return unify_type_mismatch (explain_p
, parm
, arg
);
17847 /* As far as unification is concerned, this wins. Later checks
17848 will invalidate it if necessary. */
17849 return unify_success (explain_p
);
17851 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
17852 /* Type INTEGER_CST can come from ordinary constant template args. */
17854 while (TREE_CODE (arg
) == NOP_EXPR
)
17855 arg
= TREE_OPERAND (arg
, 0);
17857 if (TREE_CODE (arg
) != INTEGER_CST
)
17858 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
17859 return (tree_int_cst_equal (parm
, arg
)
17860 ? unify_success (explain_p
)
17861 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
17865 int i
, len
, argslen
;
17866 int parm_variadic_p
= 0;
17868 if (TREE_CODE (arg
) != TREE_VEC
)
17869 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
17871 len
= TREE_VEC_LENGTH (parm
);
17872 argslen
= TREE_VEC_LENGTH (arg
);
17874 /* Check for pack expansions in the parameters. */
17875 for (i
= 0; i
< len
; ++i
)
17877 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
17880 /* We can unify against something with a trailing
17882 parm_variadic_p
= 1;
17884 /* [temp.deduct.type]/9: If the template argument list of
17885 P contains a pack expansion that is not the last
17886 template argument, the entire template argument list
17887 is a non-deduced context. */
17888 return unify_success (explain_p
);
17892 /* If we don't have enough arguments to satisfy the parameters
17893 (not counting the pack expression at the end), or we have
17894 too many arguments for a parameter list that doesn't end in
17895 a pack expression, we can't unify. */
17896 if (parm_variadic_p
17897 ? argslen
< len
- parm_variadic_p
17899 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
17901 /* Unify all of the parameters that precede the (optional)
17902 pack expression. */
17903 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17905 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17906 TREE_VEC_ELT (parm
, i
),
17907 TREE_VEC_ELT (arg
, i
),
17908 UNIFY_ALLOW_NONE
, explain_p
);
17910 if (parm_variadic_p
)
17911 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
17913 /*subr=*/true, explain_p
);
17914 return unify_success (explain_p
);
17919 if (TREE_CODE (arg
) != TREE_CODE (parm
))
17920 return unify_type_mismatch (explain_p
, parm
, arg
);
17922 if (TYPE_PTRMEMFUNC_P (parm
))
17924 if (!TYPE_PTRMEMFUNC_P (arg
))
17925 return unify_type_mismatch (explain_p
, parm
, arg
);
17927 return unify (tparms
, targs
,
17928 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
17929 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
17930 strict
, explain_p
);
17933 if (CLASSTYPE_TEMPLATE_INFO (parm
))
17935 tree t
= NULL_TREE
;
17937 if (strict_in
& UNIFY_ALLOW_DERIVED
)
17939 /* First, we try to unify the PARM and ARG directly. */
17940 t
= try_class_unification (tparms
, targs
,
17941 parm
, arg
, explain_p
);
17945 /* Fallback to the special case allowed in
17946 [temp.deduct.call]:
17948 If P is a class, and P has the form
17949 template-id, then A can be a derived class of
17950 the deduced A. Likewise, if P is a pointer to
17951 a class of the form template-id, A can be a
17952 pointer to a derived class pointed to by the
17954 enum template_base_result r
;
17955 r
= get_template_base (tparms
, targs
, parm
, arg
,
17959 return unify_no_common_base (explain_p
, r
, parm
, arg
);
17962 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
17963 && (CLASSTYPE_TI_TEMPLATE (parm
)
17964 == CLASSTYPE_TI_TEMPLATE (arg
)))
17965 /* Perhaps PARM is something like S<U> and ARG is S<int>.
17966 Then, we should unify `int' and `U'. */
17969 /* There's no chance of unification succeeding. */
17970 return unify_type_mismatch (explain_p
, parm
, arg
);
17972 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
17973 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
17975 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
17976 return unify_type_mismatch (explain_p
, parm
, arg
);
17977 return unify_success (explain_p
);
17980 case FUNCTION_TYPE
:
17982 unsigned int nargs
;
17987 if (TREE_CODE (arg
) != TREE_CODE (parm
))
17988 return unify_type_mismatch (explain_p
, parm
, arg
);
17990 /* CV qualifications for methods can never be deduced, they must
17991 match exactly. We need to check them explicitly here,
17992 because type_unification_real treats them as any other
17993 cv-qualified parameter. */
17994 if (TREE_CODE (parm
) == METHOD_TYPE
17995 && (!check_cv_quals_for_unify
17997 class_of_this_parm (arg
),
17998 class_of_this_parm (parm
))))
17999 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18001 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18002 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18004 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18005 args
= XALLOCAVEC (tree
, nargs
);
18006 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18007 a
!= NULL_TREE
&& a
!= void_list_node
;
18008 a
= TREE_CHAIN (a
), ++i
)
18009 args
[i
] = TREE_VALUE (a
);
18012 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18013 args
, nargs
, 1, DEDUCE_EXACT
,
18014 LOOKUP_NORMAL
, NULL
, explain_p
);
18018 /* Unify a pointer to member with a pointer to member function, which
18019 deduces the type of the member as a function type. */
18020 if (TYPE_PTRMEMFUNC_P (arg
))
18022 /* Check top-level cv qualifiers */
18023 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18024 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18026 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18027 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18028 UNIFY_ALLOW_NONE
, explain_p
);
18030 /* Determine the type of the function we are unifying against. */
18031 tree fntype
= static_fn_type (arg
);
18033 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18036 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18037 return unify_type_mismatch (explain_p
, parm
, arg
);
18038 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18039 TYPE_OFFSET_BASETYPE (arg
),
18040 UNIFY_ALLOW_NONE
, explain_p
);
18041 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18042 strict
, explain_p
);
18045 if (DECL_TEMPLATE_PARM_P (parm
))
18046 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18047 if (arg
!= integral_constant_value (parm
))
18048 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18049 return unify_success (explain_p
);
18052 case TEMPLATE_DECL
:
18053 /* Matched cases are handled by the ARG == PARM test above. */
18054 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18057 /* A non-type template parameter that is a variable should be a
18058 an integral constant, in which case, it whould have been
18059 folded into its (constant) value. So we should not be getting
18060 a variable here. */
18061 gcc_unreachable ();
18063 case TYPE_ARGUMENT_PACK
:
18064 case NONTYPE_ARGUMENT_PACK
:
18065 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18066 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18069 case DECLTYPE_TYPE
:
18070 case UNDERLYING_TYPE
:
18071 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18072 or UNDERLYING_TYPE nodes. */
18073 return unify_success (explain_p
);
18076 /* Unification fails if we hit an error node. */
18077 return unify_invalid (explain_p
);
18080 if (REFERENCE_REF_P (parm
))
18081 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18082 strict
, explain_p
);
18086 /* An unresolved overload is a nondeduced context. */
18087 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18088 return unify_success (explain_p
);
18089 gcc_assert (EXPR_P (parm
));
18091 /* We must be looking at an expression. This can happen with
18095 void foo(S<I>, S<I + 2>);
18097 This is a "nondeduced context":
18101 The nondeduced contexts are:
18103 --A type that is a template-id in which one or more of
18104 the template-arguments is an expression that references
18105 a template-parameter.
18107 In these cases, we assume deduction succeeded, but don't
18108 actually infer any unifications. */
18110 if (!uses_template_parms (parm
)
18111 && !template_args_equal (parm
, arg
))
18112 return unify_expression_unequal (explain_p
, parm
, arg
);
18114 return unify_success (explain_p
);
18117 #undef RECUR_AND_CHECK_FAILURE
18119 /* Note that DECL can be defined in this translation unit, if
18123 mark_definable (tree decl
)
18126 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18127 FOR_EACH_CLONE (clone
, decl
)
18128 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18131 /* Called if RESULT is explicitly instantiated, or is a member of an
18132 explicitly instantiated class. */
18135 mark_decl_instantiated (tree result
, int extern_p
)
18137 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18139 /* If this entity has already been written out, it's too late to
18140 make any modifications. */
18141 if (TREE_ASM_WRITTEN (result
))
18144 /* For anonymous namespace we don't need to do anything. */
18145 if (decl_anon_ns_mem_p (result
))
18147 gcc_assert (!TREE_PUBLIC (result
));
18151 if (TREE_CODE (result
) != FUNCTION_DECL
)
18152 /* The TREE_PUBLIC flag for function declarations will have been
18153 set correctly by tsubst. */
18154 TREE_PUBLIC (result
) = 1;
18156 /* This might have been set by an earlier implicit instantiation. */
18157 DECL_COMDAT (result
) = 0;
18160 DECL_NOT_REALLY_EXTERN (result
) = 0;
18163 mark_definable (result
);
18164 mark_needed (result
);
18165 /* Always make artificials weak. */
18166 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18167 comdat_linkage (result
);
18168 /* For WIN32 we also want to put explicit instantiations in
18169 linkonce sections. */
18170 else if (TREE_PUBLIC (result
))
18171 maybe_make_one_only (result
);
18174 /* If EXTERN_P, then this function will not be emitted -- unless
18175 followed by an explicit instantiation, at which point its linkage
18176 will be adjusted. If !EXTERN_P, then this function will be
18177 emitted here. In neither circumstance do we want
18178 import_export_decl to adjust the linkage. */
18179 DECL_INTERFACE_KNOWN (result
) = 1;
18182 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18183 important template arguments. If any are missing, we check whether
18184 they're important by using error_mark_node for substituting into any
18185 args that were used for partial ordering (the ones between ARGS and END)
18186 and seeing if it bubbles up. */
18189 check_undeduced_parms (tree targs
, tree args
, tree end
)
18191 bool found
= false;
18193 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18194 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18197 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18201 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18202 if (substed
== error_mark_node
)
18208 /* Given two function templates PAT1 and PAT2, return:
18210 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18211 -1 if PAT2 is more specialized than PAT1.
18212 0 if neither is more specialized.
18214 LEN indicates the number of parameters we should consider
18215 (defaulted parameters should not be considered).
18217 The 1998 std underspecified function template partial ordering, and
18218 DR214 addresses the issue. We take pairs of arguments, one from
18219 each of the templates, and deduce them against each other. One of
18220 the templates will be more specialized if all the *other*
18221 template's arguments deduce against its arguments and at least one
18222 of its arguments *does* *not* deduce against the other template's
18223 corresponding argument. Deduction is done as for class templates.
18224 The arguments used in deduction have reference and top level cv
18225 qualifiers removed. Iff both arguments were originally reference
18226 types *and* deduction succeeds in both directions, an lvalue reference
18227 wins against an rvalue reference and otherwise the template
18228 with the more cv-qualified argument wins for that pairing (if
18229 neither is more cv-qualified, they both are equal). Unlike regular
18230 deduction, after all the arguments have been deduced in this way,
18231 we do *not* verify the deduced template argument values can be
18232 substituted into non-deduced contexts.
18234 The logic can be a bit confusing here, because we look at deduce1 and
18235 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18236 can find template arguments for pat1 to make arg1 look like arg2, that
18237 means that arg2 is at least as specialized as arg1. */
18240 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18242 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18243 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18244 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18245 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18246 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18247 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18248 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18249 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18250 tree origs1
, origs2
;
18251 bool lose1
= false;
18252 bool lose2
= false;
18254 /* Remove the this parameter from non-static member functions. If
18255 one is a non-static member function and the other is not a static
18256 member function, remove the first parameter from that function
18257 also. This situation occurs for operator functions where we
18258 locate both a member function (with this pointer) and non-member
18259 operator (with explicit first operand). */
18260 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18262 len
--; /* LEN is the number of significant arguments for DECL1 */
18263 args1
= TREE_CHAIN (args1
);
18264 if (!DECL_STATIC_FUNCTION_P (decl2
))
18265 args2
= TREE_CHAIN (args2
);
18267 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18269 args2
= TREE_CHAIN (args2
);
18270 if (!DECL_STATIC_FUNCTION_P (decl1
))
18273 args1
= TREE_CHAIN (args1
);
18277 /* If only one is a conversion operator, they are unordered. */
18278 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18281 /* Consider the return type for a conversion function */
18282 if (DECL_CONV_FN_P (decl1
))
18284 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18285 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18289 processing_template_decl
++;
18295 /* Stop when an ellipsis is seen. */
18296 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18298 tree arg1
= TREE_VALUE (args1
);
18299 tree arg2
= TREE_VALUE (args2
);
18300 int deduce1
, deduce2
;
18306 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18307 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18309 /* When both arguments are pack expansions, we need only
18310 unify the patterns themselves. */
18311 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18312 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18314 /* This is the last comparison we need to do. */
18318 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18320 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18321 arg1
= TREE_TYPE (arg1
);
18322 quals1
= cp_type_quals (arg1
);
18325 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18327 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18328 arg2
= TREE_TYPE (arg2
);
18329 quals2
= cp_type_quals (arg2
);
18332 arg1
= TYPE_MAIN_VARIANT (arg1
);
18333 arg2
= TYPE_MAIN_VARIANT (arg2
);
18335 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18337 int i
, len2
= list_length (args2
);
18338 tree parmvec
= make_tree_vec (1);
18339 tree argvec
= make_tree_vec (len2
);
18342 /* Setup the parameter vector, which contains only ARG1. */
18343 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18345 /* Setup the argument vector, which contains the remaining
18347 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18348 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18350 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18351 argvec
, DEDUCE_EXACT
,
18352 /*subr=*/true, /*explain_p=*/false)
18355 /* We cannot deduce in the other direction, because ARG1 is
18356 a pack expansion but ARG2 is not. */
18359 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18361 int i
, len1
= list_length (args1
);
18362 tree parmvec
= make_tree_vec (1);
18363 tree argvec
= make_tree_vec (len1
);
18366 /* Setup the parameter vector, which contains only ARG1. */
18367 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18369 /* Setup the argument vector, which contains the remaining
18371 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18372 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18374 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18375 argvec
, DEDUCE_EXACT
,
18376 /*subr=*/true, /*explain_p=*/false)
18379 /* We cannot deduce in the other direction, because ARG2 is
18380 a pack expansion but ARG1 is not.*/
18386 /* The normal case, where neither argument is a pack
18388 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18389 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18391 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18392 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18396 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18397 arg2, then arg2 is not as specialized as arg1. */
18403 /* "If, for a given type, deduction succeeds in both directions
18404 (i.e., the types are identical after the transformations above)
18405 and both P and A were reference types (before being replaced with
18406 the type referred to above):
18407 - if the type from the argument template was an lvalue reference and
18408 the type from the parameter template was not, the argument type is
18409 considered to be more specialized than the other; otherwise,
18410 - if the type from the argument template is more cv-qualified
18411 than the type from the parameter template (as described above),
18412 the argument type is considered to be more specialized than the other;
18414 - neither type is more specialized than the other." */
18416 if (deduce1
&& deduce2
)
18418 if (ref1
&& ref2
&& ref1
!= ref2
)
18425 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
18427 if ((quals1
& quals2
) == quals2
)
18429 if ((quals1
& quals2
) == quals1
)
18434 if (lose1
&& lose2
)
18435 /* We've failed to deduce something in either direction.
18436 These must be unordered. */
18439 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18440 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18441 /* We have already processed all of the arguments in our
18442 handing of the pack expansion type. */
18445 args1
= TREE_CHAIN (args1
);
18446 args2
= TREE_CHAIN (args2
);
18449 /* "In most cases, all template parameters must have values in order for
18450 deduction to succeed, but for partial ordering purposes a template
18451 parameter may remain without a value provided it is not used in the
18452 types being used for partial ordering."
18454 Thus, if we are missing any of the targs1 we need to substitute into
18455 origs1, then pat2 is not as specialized as pat1. This can happen when
18456 there is a nondeduced context. */
18457 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
18459 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
18462 processing_template_decl
--;
18464 /* All things being equal, if the next argument is a pack expansion
18465 for one function but not for the other, prefer the
18466 non-variadic function. FIXME this is bogus; see c++/41958. */
18468 && args1
&& TREE_VALUE (args1
)
18469 && args2
&& TREE_VALUE (args2
))
18471 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
18472 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
18475 if (lose1
== lose2
)
18483 /* Determine which of two partial specializations of TMPL is more
18486 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18487 to the first partial specialization. The TREE_VALUE is the
18488 innermost set of template parameters for the partial
18489 specialization. PAT2 is similar, but for the second template.
18491 Return 1 if the first partial specialization is more specialized;
18492 -1 if the second is more specialized; 0 if neither is more
18495 See [temp.class.order] for information about determining which of
18496 two templates is more specialized. */
18499 more_specialized_class (tree tmpl
, tree pat1
, tree pat2
)
18504 bool any_deductions
= false;
18506 tmpl1
= TREE_TYPE (pat1
);
18507 tmpl2
= TREE_TYPE (pat2
);
18509 /* Just like what happens for functions, if we are ordering between
18510 different class template specializations, we may encounter dependent
18511 types in the arguments, and we need our dependency check functions
18512 to behave correctly. */
18513 ++processing_template_decl
;
18514 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat1
),
18515 CLASSTYPE_TI_ARGS (tmpl1
),
18516 CLASSTYPE_TI_ARGS (tmpl2
));
18520 any_deductions
= true;
18523 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat2
),
18524 CLASSTYPE_TI_ARGS (tmpl2
),
18525 CLASSTYPE_TI_ARGS (tmpl1
));
18529 any_deductions
= true;
18531 --processing_template_decl
;
18533 /* In the case of a tie where at least one of the class templates
18534 has a parameter pack at the end, the template with the most
18535 non-packed parameters wins. */
18538 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
18539 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
18541 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
18542 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
18543 int len1
= TREE_VEC_LENGTH (args1
);
18544 int len2
= TREE_VEC_LENGTH (args2
);
18546 /* We don't count the pack expansion at the end. */
18547 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
18549 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
18554 else if (len1
< len2
)
18561 /* Return the template arguments that will produce the function signature
18562 DECL from the function template FN, with the explicit template
18563 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18564 also match. Return NULL_TREE if no satisfactory arguments could be
18568 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
18570 int ntparms
= DECL_NTPARMS (fn
);
18571 tree targs
= make_tree_vec (ntparms
);
18572 tree decl_type
= TREE_TYPE (decl
);
18573 tree decl_arg_types
;
18575 unsigned int nargs
, ix
;
18578 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
18580 /* Never do unification on the 'this' parameter. */
18581 decl_arg_types
= skip_artificial_parms_for (decl
,
18582 TYPE_ARG_TYPES (decl_type
));
18584 nargs
= list_length (decl_arg_types
);
18585 args
= XALLOCAVEC (tree
, nargs
);
18586 for (arg
= decl_arg_types
, ix
= 0;
18587 arg
!= NULL_TREE
&& arg
!= void_list_node
;
18588 arg
= TREE_CHAIN (arg
), ++ix
)
18589 args
[ix
] = TREE_VALUE (arg
);
18591 if (fn_type_unification (fn
, explicit_args
, targs
,
18593 (check_rettype
|| DECL_CONV_FN_P (fn
)
18594 ? TREE_TYPE (decl_type
) : NULL_TREE
),
18595 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
18597 == error_mark_node
)
18603 /* Return the innermost template arguments that, when applied to a partial
18604 specialization of TMPL whose innermost template parameters are
18605 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
18608 For example, suppose we have:
18610 template <class T, class U> struct S {};
18611 template <class T> struct S<T*, int> {};
18613 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
18614 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
18615 int}. The resulting vector will be {double}, indicating that `T'
18616 is bound to `double'. */
18619 get_class_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
18621 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
18623 tree innermost_deduced_args
;
18625 innermost_deduced_args
= make_tree_vec (ntparms
);
18626 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18628 deduced_args
= copy_node (args
);
18629 SET_TMPL_ARGS_LEVEL (deduced_args
,
18630 TMPL_ARGS_DEPTH (deduced_args
),
18631 innermost_deduced_args
);
18634 deduced_args
= innermost_deduced_args
;
18636 if (unify (tparms
, deduced_args
,
18637 INNERMOST_TEMPLATE_ARGS (spec_args
),
18638 INNERMOST_TEMPLATE_ARGS (args
),
18639 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
18642 for (i
= 0; i
< ntparms
; ++i
)
18643 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
18646 /* Verify that nondeduced template arguments agree with the type
18647 obtained from argument deduction.
18651 struct A { typedef int X; };
18652 template <class T, class U> struct C {};
18653 template <class T> struct C<T, typename T::X> {};
18655 Then with the instantiation `C<A, int>', we can deduce that
18656 `T' is `A' but unify () does not check whether `typename T::X'
18658 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
18659 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
18661 tf_none
, false, false);
18662 if (spec_args
== error_mark_node
18663 /* We only need to check the innermost arguments; the other
18664 arguments will always agree. */
18665 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
18666 INNERMOST_TEMPLATE_ARGS (args
)))
18669 /* Now that we have bindings for all of the template arguments,
18670 ensure that the arguments deduced for the template template
18671 parameters have compatible template parameter lists. See the use
18672 of template_template_parm_bindings_ok_p in fn_type_unification
18673 for more information. */
18674 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
18677 return deduced_args
;
18680 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
18681 Return the TREE_LIST node with the most specialized template, if
18682 any. If there is no most specialized template, the error_mark_node
18685 Note that this function does not look at, or modify, the
18686 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
18687 returned is one of the elements of INSTANTIATIONS, callers may
18688 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
18689 and retrieve it from the value returned. */
18692 most_specialized_instantiation (tree templates
)
18696 ++processing_template_decl
;
18699 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
18703 if (get_bindings (TREE_VALUE (champ
),
18704 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18705 NULL_TREE
, /*check_ret=*/true))
18708 if (get_bindings (TREE_VALUE (fn
),
18709 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18710 NULL_TREE
, /*check_ret=*/true))
18717 /* Equally specialized, move to next function. If there
18718 is no next function, nothing's most specialized. */
18719 fn
= TREE_CHAIN (fn
);
18727 /* Now verify that champ is better than everything earlier in the
18728 instantiation list. */
18729 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
18730 if (get_bindings (TREE_VALUE (champ
),
18731 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18732 NULL_TREE
, /*check_ret=*/true)
18733 || !get_bindings (TREE_VALUE (fn
),
18734 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18735 NULL_TREE
, /*check_ret=*/true))
18741 processing_template_decl
--;
18744 return error_mark_node
;
18749 /* If DECL is a specialization of some template, return the most
18750 general such template. Otherwise, returns NULL_TREE.
18752 For example, given:
18754 template <class T> struct S { template <class U> void f(U); };
18756 if TMPL is `template <class U> void S<int>::f(U)' this will return
18757 the full template. This function will not trace past partial
18758 specializations, however. For example, given in addition:
18760 template <class T> struct S<T*> { template <class U> void f(U); };
18762 if TMPL is `template <class U> void S<int*>::f(U)' this will return
18763 `template <class T> template <class U> S<T*>::f(U)'. */
18766 most_general_template (tree decl
)
18768 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18770 if (tree tinfo
= get_template_info (decl
))
18771 decl
= TI_TEMPLATE (tinfo
);
18772 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
18773 template friend, or a FIELD_DECL for a capture pack. */
18774 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18778 /* Look for more and more general templates. */
18779 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
18781 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
18782 (See cp-tree.h for details.) */
18783 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
18786 if (CLASS_TYPE_P (TREE_TYPE (decl
))
18787 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
18790 /* Stop if we run into an explicitly specialized class template. */
18791 if (!DECL_NAMESPACE_SCOPE_P (decl
)
18792 && DECL_CONTEXT (decl
)
18793 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
18796 decl
= DECL_TI_TEMPLATE (decl
);
18802 /* Return the most specialized of the class template partial
18803 specializations which can produce TYPE, a specialization of some class
18804 template. The value returned is actually a TREE_LIST; the TREE_TYPE is
18805 a _TYPE node corresponding to the partial specialization, while the
18806 TREE_PURPOSE is the set of template arguments that must be
18807 substituted into the TREE_TYPE in order to generate TYPE.
18809 If the choice of partial specialization is ambiguous, a diagnostic
18810 is issued, and the error_mark_node is returned. If there are no
18811 partial specializations matching TYPE, then NULL_TREE is
18812 returned, indicating that the primary template should be used. */
18815 most_specialized_class (tree type
, tsubst_flags_t complain
)
18817 tree list
= NULL_TREE
;
18822 tree outer_args
= NULL_TREE
;
18824 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
18825 tree main_tmpl
= most_general_template (tmpl
);
18826 tree args
= CLASSTYPE_TI_ARGS (type
);
18828 /* For determining which partial specialization to use, only the
18829 innermost args are interesting. */
18830 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18832 outer_args
= strip_innermost_template_args (args
, 1);
18833 args
= INNERMOST_TEMPLATE_ARGS (args
);
18836 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
18838 tree partial_spec_args
;
18840 tree spec_tmpl
= TREE_VALUE (t
);
18841 tree orig_parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
18843 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
18845 ++processing_template_decl
;
18849 /* Discard the outer levels of args, and then substitute in the
18850 template args from the enclosing class. */
18851 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
18852 partial_spec_args
= tsubst_template_args
18853 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
18855 /* And the same for the partial specialization TEMPLATE_DECL. */
18856 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
18859 partial_spec_args
=
18860 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
18863 /*require_all_args=*/true,
18864 /*use_default_args=*/true);
18866 --processing_template_decl
;
18868 if (partial_spec_args
== error_mark_node
)
18869 return error_mark_node
;
18870 if (spec_tmpl
== error_mark_node
)
18871 return error_mark_node
;
18873 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
18874 spec_args
= get_class_bindings (tmpl
, parms
,
18880 spec_args
= add_to_template_args (outer_args
, spec_args
);
18881 list
= tree_cons (spec_args
, orig_parms
, list
);
18882 TREE_TYPE (list
) = TREE_TYPE (t
);
18889 ambiguous_p
= false;
18892 t
= TREE_CHAIN (t
);
18893 for (; t
; t
= TREE_CHAIN (t
))
18895 fate
= more_specialized_class (tmpl
, champ
, t
);
18902 t
= TREE_CHAIN (t
);
18905 ambiguous_p
= true;
18914 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
18916 fate
= more_specialized_class (tmpl
, champ
, t
);
18919 ambiguous_p
= true;
18927 char *spaces
= NULL
;
18928 if (!(complain
& tf_error
))
18929 return error_mark_node
;
18930 error ("ambiguous class template instantiation for %q#T", type
);
18931 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
18932 for (t
= list
; t
; t
= TREE_CHAIN (t
))
18934 error ("%s %+#T", spaces
? spaces
: str
, TREE_TYPE (t
));
18935 spaces
= spaces
? spaces
: get_spaces (str
);
18938 return error_mark_node
;
18944 /* Explicitly instantiate DECL. */
18947 do_decl_instantiation (tree decl
, tree storage
)
18949 tree result
= NULL_TREE
;
18952 if (!decl
|| decl
== error_mark_node
)
18953 /* An error occurred, for which grokdeclarator has already issued
18954 an appropriate message. */
18956 else if (! DECL_LANG_SPECIFIC (decl
))
18958 error ("explicit instantiation of non-template %q#D", decl
);
18961 else if (VAR_P (decl
))
18963 /* There is an asymmetry here in the way VAR_DECLs and
18964 FUNCTION_DECLs are handled by grokdeclarator. In the case of
18965 the latter, the DECL we get back will be marked as a
18966 template instantiation, and the appropriate
18967 DECL_TEMPLATE_INFO will be set up. This does not happen for
18968 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
18969 should handle VAR_DECLs as it currently handles
18971 if (!DECL_CLASS_SCOPE_P (decl
))
18973 error ("%qD is not a static data member of a class template", decl
);
18976 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
18977 if (!result
|| !VAR_P (result
))
18979 error ("no matching template for %qD found", decl
);
18982 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
18984 error ("type %qT for explicit instantiation %qD does not match "
18985 "declared type %qT", TREE_TYPE (result
), decl
,
18990 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
18992 error ("explicit instantiation of %q#D", decl
);
18998 /* Check for various error cases. Note that if the explicit
18999 instantiation is valid the RESULT will currently be marked as an
19000 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19001 until we get here. */
19003 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19005 /* DR 259 [temp.spec].
19007 Both an explicit instantiation and a declaration of an explicit
19008 specialization shall not appear in a program unless the explicit
19009 instantiation follows a declaration of the explicit specialization.
19011 For a given set of template parameters, if an explicit
19012 instantiation of a template appears after a declaration of an
19013 explicit specialization for that template, the explicit
19014 instantiation has no effect. */
19017 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19021 No program shall explicitly instantiate any template more
19024 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19025 the first instantiation was `extern' and the second is not,
19026 and EXTERN_P for the opposite case. */
19027 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19028 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19029 /* If an "extern" explicit instantiation follows an ordinary
19030 explicit instantiation, the template is instantiated. */
19034 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19036 error ("no matching template for %qD found", result
);
19039 else if (!DECL_TEMPLATE_INFO (result
))
19041 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19045 if (storage
== NULL_TREE
)
19047 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19049 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19050 pedwarn (input_location
, OPT_Wpedantic
,
19051 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19056 error ("storage class %qD applied to template instantiation", storage
);
19058 check_explicit_instantiation_namespace (result
);
19059 mark_decl_instantiated (result
, extern_p
);
19061 instantiate_decl (result
, /*defer_ok=*/1,
19062 /*expl_inst_class_mem_p=*/false);
19066 mark_class_instantiated (tree t
, int extern_p
)
19068 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19069 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19070 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19071 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19074 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19075 rest_of_type_compilation (t
, 1);
19079 /* Called from do_type_instantiation through binding_table_foreach to
19080 do recursive instantiation for the type bound in ENTRY. */
19082 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19084 tree storage
= *(tree
*) data
;
19086 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19087 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19088 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19091 /* Called from do_type_instantiation to instantiate a member
19092 (a member function or a static member variable) of an
19093 explicitly instantiated class template. */
19095 instantiate_class_member (tree decl
, int extern_p
)
19097 mark_decl_instantiated (decl
, extern_p
);
19099 instantiate_decl (decl
, /*defer_ok=*/1,
19100 /*expl_inst_class_mem_p=*/true);
19103 /* Perform an explicit instantiation of template class T. STORAGE, if
19104 non-null, is the RID for extern, inline or static. COMPLAIN is
19105 nonzero if this is called from the parser, zero if called recursively,
19106 since the standard is unclear (as detailed below). */
19109 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19114 int previous_instantiation_extern_p
= 0;
19116 if (TREE_CODE (t
) == TYPE_DECL
)
19119 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19122 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19124 error ("explicit instantiation of non-class template %qD", tmpl
);
19126 error ("explicit instantiation of non-template type %qT", t
);
19132 if (!COMPLETE_TYPE_P (t
))
19134 if (complain
& tf_error
)
19135 error ("explicit instantiation of %q#T before definition of template",
19140 if (storage
!= NULL_TREE
)
19142 if (!in_system_header_at (input_location
))
19144 if (storage
== ridpointers
[(int) RID_EXTERN
])
19146 if (cxx_dialect
== cxx98
)
19147 pedwarn (input_location
, OPT_Wpedantic
,
19148 "ISO C++ 1998 forbids the use of %<extern%> on "
19149 "explicit instantiations");
19152 pedwarn (input_location
, OPT_Wpedantic
,
19153 "ISO C++ forbids the use of %qE"
19154 " on explicit instantiations", storage
);
19157 if (storage
== ridpointers
[(int) RID_INLINE
])
19159 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19161 else if (storage
== ridpointers
[(int) RID_STATIC
])
19165 error ("storage class %qD applied to template instantiation",
19171 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19173 /* DR 259 [temp.spec].
19175 Both an explicit instantiation and a declaration of an explicit
19176 specialization shall not appear in a program unless the explicit
19177 instantiation follows a declaration of the explicit specialization.
19179 For a given set of template parameters, if an explicit
19180 instantiation of a template appears after a declaration of an
19181 explicit specialization for that template, the explicit
19182 instantiation has no effect. */
19185 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19189 No program shall explicitly instantiate any template more
19192 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19193 instantiation was `extern'. If EXTERN_P then the second is.
19194 These cases are OK. */
19195 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19197 if (!previous_instantiation_extern_p
&& !extern_p
19198 && (complain
& tf_error
))
19199 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19201 /* If we've already instantiated the template, just return now. */
19202 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19206 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19207 mark_class_instantiated (t
, extern_p
);
19215 /* In contrast to implicit instantiation, where only the
19216 declarations, and not the definitions, of members are
19217 instantiated, we have here:
19221 The explicit instantiation of a class template specialization
19222 implies the instantiation of all of its members not
19223 previously explicitly specialized in the translation unit
19224 containing the explicit instantiation.
19226 Of course, we can't instantiate member template classes, since
19227 we don't have any arguments for them. Note that the standard
19228 is unclear on whether the instantiation of the members are
19229 *explicit* instantiations or not. However, the most natural
19230 interpretation is that it should be an explicit instantiation. */
19233 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19234 if (TREE_CODE (tmp
) == FUNCTION_DECL
19235 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19236 instantiate_class_member (tmp
, extern_p
);
19238 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19239 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19240 instantiate_class_member (tmp
, extern_p
);
19242 if (CLASSTYPE_NESTED_UTDS (t
))
19243 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19244 bt_instantiate_type_proc
, &storage
);
19248 /* Given a function DECL, which is a specialization of TMPL, modify
19249 DECL to be a re-instantiation of TMPL with the same template
19250 arguments. TMPL should be the template into which tsubst'ing
19251 should occur for DECL, not the most general template.
19253 One reason for doing this is a scenario like this:
19256 void f(const T&, int i);
19258 void g() { f(3, 7); }
19261 void f(const T& t, const int i) { }
19263 Note that when the template is first instantiated, with
19264 instantiate_template, the resulting DECL will have no name for the
19265 first parameter, and the wrong type for the second. So, when we go
19266 to instantiate the DECL, we regenerate it. */
19269 regenerate_decl_from_template (tree decl
, tree tmpl
)
19271 /* The arguments used to instantiate DECL, from the most general
19276 args
= DECL_TI_ARGS (decl
);
19277 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19279 /* Make sure that we can see identifiers, and compute access
19281 push_access_scope (decl
);
19283 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19291 args_depth
= TMPL_ARGS_DEPTH (args
);
19292 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19293 if (args_depth
> parms_depth
)
19294 args
= get_innermost_template_args (args
, parms_depth
);
19296 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19297 args
, tf_error
, NULL_TREE
,
19298 /*defer_ok*/false);
19299 if (specs
&& specs
!= error_mark_node
)
19300 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19303 /* Merge parameter declarations. */
19304 decl_parm
= skip_artificial_parms_for (decl
,
19305 DECL_ARGUMENTS (decl
));
19307 = skip_artificial_parms_for (code_pattern
,
19308 DECL_ARGUMENTS (code_pattern
));
19309 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19314 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19315 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19316 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19318 parm_type
= type_decays_to (parm_type
);
19319 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19320 TREE_TYPE (decl_parm
) = parm_type
;
19321 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19322 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19324 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19325 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19327 decl_parm
= DECL_CHAIN (decl_parm
);
19328 pattern_parm
= DECL_CHAIN (pattern_parm
);
19330 /* Merge any parameters that match with the function parameter
19332 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19335 tree expanded_types
;
19336 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19337 the parameters in this function parameter pack. */
19338 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19339 args
, tf_error
, NULL_TREE
);
19340 len
= TREE_VEC_LENGTH (expanded_types
);
19341 for (i
= 0; i
< len
; i
++)
19346 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19347 /* Rename the parameter to include the index. */
19348 DECL_NAME (decl_parm
) =
19349 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19350 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19351 parm_type
= type_decays_to (parm_type
);
19352 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19353 TREE_TYPE (decl_parm
) = parm_type
;
19354 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19355 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19357 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19358 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19360 decl_parm
= DECL_CHAIN (decl_parm
);
19363 /* Merge additional specifiers from the CODE_PATTERN. */
19364 if (DECL_DECLARED_INLINE_P (code_pattern
)
19365 && !DECL_DECLARED_INLINE_P (decl
))
19366 DECL_DECLARED_INLINE_P (decl
) = 1;
19368 else if (VAR_P (decl
))
19370 DECL_INITIAL (decl
) =
19371 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19372 tf_error
, DECL_TI_TEMPLATE (decl
),
19373 /*integral_constant_expression_p=*/false);
19374 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19375 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19376 tf_error
, DECL_TI_TEMPLATE (decl
));
19379 gcc_unreachable ();
19381 pop_access_scope (decl
);
19384 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19385 substituted to get DECL. */
19388 template_for_substitution (tree decl
)
19390 tree tmpl
= DECL_TI_TEMPLATE (decl
);
19392 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19393 for the instantiation. This is not always the most general
19394 template. Consider, for example:
19397 struct S { template <class U> void f();
19398 template <> void f<int>(); };
19400 and an instantiation of S<double>::f<int>. We want TD to be the
19401 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19402 while (/* An instantiation cannot have a definition, so we need a
19403 more general template. */
19404 DECL_TEMPLATE_INSTANTIATION (tmpl
)
19405 /* We must also deal with friend templates. Given:
19407 template <class T> struct S {
19408 template <class U> friend void f() {};
19411 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19412 so far as the language is concerned, but that's still
19413 where we get the pattern for the instantiation from. On
19414 other hand, if the definition comes outside the class, say:
19416 template <class T> struct S {
19417 template <class U> friend void f();
19419 template <class U> friend void f() {}
19421 we don't need to look any further. That's what the check for
19422 DECL_INITIAL is for. */
19423 || (TREE_CODE (decl
) == FUNCTION_DECL
19424 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
19425 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
19427 /* The present template, TD, should not be a definition. If it
19428 were a definition, we should be using it! Note that we
19429 cannot restructure the loop to just keep going until we find
19430 a template with a definition, since that might go too far if
19431 a specialization was declared, but not defined. */
19432 gcc_assert (!VAR_P (decl
)
19433 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl
)));
19435 /* Fetch the more general template. */
19436 tmpl
= DECL_TI_TEMPLATE (tmpl
);
19442 /* Returns true if we need to instantiate this template instance even if we
19443 know we aren't going to emit it.. */
19446 always_instantiate_p (tree decl
)
19448 /* We always instantiate inline functions so that we can inline them. An
19449 explicit instantiation declaration prohibits implicit instantiation of
19450 non-inline functions. With high levels of optimization, we would
19451 normally inline non-inline functions -- but we're not allowed to do
19452 that for "extern template" functions. Therefore, we check
19453 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19454 return ((TREE_CODE (decl
) == FUNCTION_DECL
19455 && (DECL_DECLARED_INLINE_P (decl
)
19456 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
19457 /* And we need to instantiate static data members so that
19458 their initializers are available in integral constant
19461 && decl_maybe_constant_var_p (decl
)));
19464 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19465 instantiate it now, modifying TREE_TYPE (fn). */
19468 maybe_instantiate_noexcept (tree fn
)
19470 tree fntype
, spec
, noex
, clone
;
19472 /* Don't instantiate a noexcept-specification from template context. */
19473 if (processing_template_decl
)
19476 if (DECL_CLONED_FUNCTION_P (fn
))
19477 fn
= DECL_CLONED_FUNCTION (fn
);
19478 fntype
= TREE_TYPE (fn
);
19479 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
19481 if (!spec
|| !TREE_PURPOSE (spec
))
19484 noex
= TREE_PURPOSE (spec
);
19486 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
19488 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
19489 spec
= get_defaulted_eh_spec (fn
);
19490 else if (push_tinst_level (fn
))
19492 push_access_scope (fn
);
19493 push_deferring_access_checks (dk_no_deferred
);
19494 input_location
= DECL_SOURCE_LOCATION (fn
);
19495 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
19496 DEFERRED_NOEXCEPT_ARGS (noex
),
19497 tf_warning_or_error
, fn
,
19498 /*function_p=*/false,
19499 /*integral_constant_expression_p=*/true);
19500 pop_deferring_access_checks ();
19501 pop_access_scope (fn
);
19502 pop_tinst_level ();
19503 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
19504 if (spec
== error_mark_node
)
19505 spec
= noexcept_false_spec
;
19508 spec
= noexcept_false_spec
;
19510 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
19513 FOR_EACH_CLONE (clone
, fn
)
19515 if (TREE_TYPE (clone
) == fntype
)
19516 TREE_TYPE (clone
) = TREE_TYPE (fn
);
19518 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
19522 /* Produce the definition of D, a _DECL generated from a template. If
19523 DEFER_OK is nonzero, then we don't have to actually do the
19524 instantiation now; we just have to do it sometime. Normally it is
19525 an error if this is an explicit instantiation but D is undefined.
19526 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19527 explicitly instantiated class template. */
19530 instantiate_decl (tree d
, int defer_ok
,
19531 bool expl_inst_class_mem_p
)
19533 tree tmpl
= DECL_TI_TEMPLATE (d
);
19540 bool pattern_defined
;
19541 location_t saved_loc
= input_location
;
19542 int saved_unevaluated_operand
= cp_unevaluated_operand
;
19543 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
19548 /* This function should only be used to instantiate templates for
19549 functions and static member variables. */
19550 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
19552 /* Variables are never deferred; if instantiation is required, they
19553 are instantiated right away. That allows for better code in the
19554 case that an expression refers to the value of the variable --
19555 if the variable has a constant value the referring expression can
19556 take advantage of that fact. */
19558 || DECL_DECLARED_CONSTEXPR_P (d
))
19561 /* Don't instantiate cloned functions. Instead, instantiate the
19562 functions they cloned. */
19563 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
19564 d
= DECL_CLONED_FUNCTION (d
);
19566 if (DECL_TEMPLATE_INSTANTIATED (d
)
19567 || (TREE_CODE (d
) == FUNCTION_DECL
19568 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
19569 || DECL_TEMPLATE_SPECIALIZATION (d
))
19570 /* D has already been instantiated or explicitly specialized, so
19571 there's nothing for us to do here.
19573 It might seem reasonable to check whether or not D is an explicit
19574 instantiation, and, if so, stop here. But when an explicit
19575 instantiation is deferred until the end of the compilation,
19576 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
19577 the instantiation. */
19580 /* Check to see whether we know that this template will be
19581 instantiated in some other file, as with "extern template"
19583 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
19585 /* In general, we do not instantiate such templates. */
19586 if (external_p
&& !always_instantiate_p (d
))
19589 gen_tmpl
= most_general_template (tmpl
);
19590 gen_args
= DECL_TI_ARGS (d
);
19592 if (tmpl
!= gen_tmpl
)
19593 /* We should already have the extra args. */
19594 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
19595 == TMPL_ARGS_DEPTH (gen_args
));
19596 /* And what's in the hash table should match D. */
19597 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
19598 || spec
== NULL_TREE
);
19600 /* This needs to happen before any tsubsting. */
19601 if (! push_tinst_level (d
))
19604 timevar_push (TV_TEMPLATE_INST
);
19606 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
19607 for the instantiation. */
19608 td
= template_for_substitution (d
);
19609 code_pattern
= DECL_TEMPLATE_RESULT (td
);
19611 /* We should never be trying to instantiate a member of a class
19612 template or partial specialization. */
19613 gcc_assert (d
!= code_pattern
);
19615 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
19616 || DECL_TEMPLATE_SPECIALIZATION (td
))
19617 /* In the case of a friend template whose definition is provided
19618 outside the class, we may have too many arguments. Drop the
19619 ones we don't need. The same is true for specializations. */
19620 args
= get_innermost_template_args
19621 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
19625 if (TREE_CODE (d
) == FUNCTION_DECL
)
19626 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
19627 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
19628 || DECL_DELETED_FN (code_pattern
));
19630 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
19632 /* We may be in the middle of deferred access check. Disable it now. */
19633 push_deferring_access_checks (dk_no_deferred
);
19635 /* Unless an explicit instantiation directive has already determined
19636 the linkage of D, remember that a definition is available for
19638 if (pattern_defined
19639 && !DECL_INTERFACE_KNOWN (d
)
19640 && !DECL_NOT_REALLY_EXTERN (d
))
19641 mark_definable (d
);
19643 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
19644 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
19645 input_location
= DECL_SOURCE_LOCATION (d
);
19647 /* If D is a member of an explicitly instantiated class template,
19648 and no definition is available, treat it like an implicit
19650 if (!pattern_defined
&& expl_inst_class_mem_p
19651 && DECL_EXPLICIT_INSTANTIATION (d
))
19653 /* Leave linkage flags alone on instantiations with anonymous
19655 if (TREE_PUBLIC (d
))
19657 DECL_NOT_REALLY_EXTERN (d
) = 0;
19658 DECL_INTERFACE_KNOWN (d
) = 0;
19660 SET_DECL_IMPLICIT_INSTANTIATION (d
);
19663 /* Defer all other templates, unless we have been explicitly
19664 forbidden from doing so. */
19665 if (/* If there is no definition, we cannot instantiate the
19668 /* If it's OK to postpone instantiation, do so. */
19670 /* If this is a static data member that will be defined
19671 elsewhere, we don't want to instantiate the entire data
19672 member, but we do want to instantiate the initializer so that
19673 we can substitute that elsewhere. */
19674 || (external_p
&& VAR_P (d
)))
19676 /* The definition of the static data member is now required so
19677 we must substitute the initializer. */
19679 && !DECL_INITIAL (d
)
19680 && DECL_INITIAL (code_pattern
))
19684 bool const_init
= false;
19686 ns
= decl_namespace_context (d
);
19687 push_nested_namespace (ns
);
19688 push_nested_class (DECL_CONTEXT (d
));
19689 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
19691 tf_warning_or_error
, NULL_TREE
,
19692 /*integral_constant_expression_p=*/false);
19693 /* Make sure the initializer is still constant, in case of
19694 circular dependency (template/instantiate6.C). */
19696 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19697 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
19698 /*asmspec_tree=*/NULL_TREE
,
19699 LOOKUP_ONLYCONVERTING
);
19700 pop_nested_class ();
19701 pop_nested_namespace (ns
);
19704 /* We restore the source position here because it's used by
19705 add_pending_template. */
19706 input_location
= saved_loc
;
19708 if (at_eof
&& !pattern_defined
19709 && DECL_EXPLICIT_INSTANTIATION (d
)
19710 && DECL_NOT_REALLY_EXTERN (d
))
19713 The definition of a non-exported function template, a
19714 non-exported member function template, or a non-exported
19715 member function or static data member of a class template
19716 shall be present in every translation unit in which it is
19717 explicitly instantiated. */
19718 permerror (input_location
, "explicit instantiation of %qD "
19719 "but no definition available", d
);
19721 /* If we're in unevaluated context, we just wanted to get the
19722 constant value; this isn't an odr use, so don't queue
19723 a full instantiation. */
19724 if (cp_unevaluated_operand
!= 0)
19726 /* ??? Historically, we have instantiated inline functions, even
19727 when marked as "extern template". */
19728 if (!(external_p
&& VAR_P (d
)))
19729 add_pending_template (d
);
19732 /* Tell the repository that D is available in this translation unit
19733 -- and see if it is supposed to be instantiated here. */
19734 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
19736 /* In a PCH file, despite the fact that the repository hasn't
19737 requested instantiation in the PCH it is still possible that
19738 an instantiation will be required in a file that includes the
19741 add_pending_template (d
);
19742 /* Instantiate inline functions so that the inliner can do its
19743 job, even though we'll not be emitting a copy of this
19745 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
19749 fn_context
= decl_function_context (d
);
19750 nested
= (current_function_decl
!= NULL_TREE
);
19752 push_to_top_level ();
19756 push_function_context ();
19757 cp_unevaluated_operand
= 0;
19758 c_inhibit_evaluation_warnings
= 0;
19761 /* Mark D as instantiated so that recursive calls to
19762 instantiate_decl do not try to instantiate it again. */
19763 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
19765 /* Regenerate the declaration in case the template has been modified
19766 by a subsequent redeclaration. */
19767 regenerate_decl_from_template (d
, td
);
19769 /* We already set the file and line above. Reset them now in case
19770 they changed as a result of calling regenerate_decl_from_template. */
19771 input_location
= DECL_SOURCE_LOCATION (d
);
19776 bool const_init
= false;
19778 /* Clear out DECL_RTL; whatever was there before may not be right
19779 since we've reset the type of the declaration. */
19780 SET_DECL_RTL (d
, NULL
);
19781 DECL_IN_AGGR_P (d
) = 0;
19783 /* The initializer is placed in DECL_INITIAL by
19784 regenerate_decl_from_template so we don't need to
19785 push/pop_access_scope again here. Pull it out so that
19786 cp_finish_decl can process it. */
19787 init
= DECL_INITIAL (d
);
19788 DECL_INITIAL (d
) = NULL_TREE
;
19789 DECL_INITIALIZED_P (d
) = 0;
19791 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
19792 initializer. That function will defer actual emission until
19793 we have a chance to determine linkage. */
19794 DECL_EXTERNAL (d
) = 0;
19796 /* Enter the scope of D so that access-checking works correctly. */
19797 push_nested_class (DECL_CONTEXT (d
));
19798 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19799 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
19800 pop_nested_class ();
19802 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
19803 synthesize_method (d
);
19804 else if (TREE_CODE (d
) == FUNCTION_DECL
)
19806 struct pointer_map_t
*saved_local_specializations
;
19810 tree block
= NULL_TREE
;
19812 /* Save away the current list, in case we are instantiating one
19813 template from within the body of another. */
19814 saved_local_specializations
= local_specializations
;
19816 /* Set up the list of local specializations. */
19817 local_specializations
= pointer_map_create ();
19819 /* Set up context. */
19820 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
19821 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
19822 block
= push_stmt_list ();
19824 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
19826 /* Some typedefs referenced from within the template code need to be
19827 access checked at template instantiation time, i.e now. These
19828 types were added to the template at parsing time. Let's get those
19829 and perform the access checks then. */
19830 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
19833 /* Create substitution entries for the parameters. */
19834 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
19835 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
19836 spec_parm
= DECL_ARGUMENTS (d
);
19837 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
19839 register_local_specialization (spec_parm
, tmpl_parm
);
19840 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
19841 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
19843 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
19845 if (!DECL_PACK_P (tmpl_parm
))
19847 register_local_specialization (spec_parm
, tmpl_parm
);
19848 spec_parm
= DECL_CHAIN (spec_parm
);
19852 /* Register the (value) argument pack as a specialization of
19853 TMPL_PARM, then move on. */
19854 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
19855 register_local_specialization (argpack
, tmpl_parm
);
19858 gcc_assert (!spec_parm
);
19860 /* Substitute into the body of the function. */
19861 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
19862 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
19863 tf_warning_or_error
, tmpl
);
19866 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
19867 tf_warning_or_error
, tmpl
,
19868 /*integral_constant_expression_p=*/false);
19870 if (DECL_STRUCT_FUNCTION (code_pattern
))
19872 /* Set the current input_location to the end of the function
19873 so that finish_function knows where we are. */
19875 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
19877 /* Remember if we saw an infinite loop in the template. */
19878 current_function_infinite_loop
19879 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
19883 /* We don't need the local specializations any more. */
19884 pointer_map_destroy (local_specializations
);
19885 local_specializations
= saved_local_specializations
;
19887 /* Finish the function. */
19888 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
19889 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
19890 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
19893 d
= finish_function (0);
19894 expand_or_defer_fn (d
);
19897 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
19898 cp_check_omp_declare_reduction (d
);
19901 /* We're not deferring instantiation any more. */
19902 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
19905 pop_from_top_level ();
19907 pop_function_context ();
19910 input_location
= saved_loc
;
19911 cp_unevaluated_operand
= saved_unevaluated_operand
;
19912 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
19913 pop_deferring_access_checks ();
19914 pop_tinst_level ();
19916 timevar_pop (TV_TEMPLATE_INST
);
19921 /* Run through the list of templates that we wish we could
19922 instantiate, and instantiate any we can. RETRIES is the
19923 number of times we retry pending template instantiation. */
19926 instantiate_pending_templates (int retries
)
19929 location_t saved_loc
= input_location
;
19931 /* Instantiating templates may trigger vtable generation. This in turn
19932 may require further template instantiations. We place a limit here
19933 to avoid infinite loop. */
19934 if (pending_templates
&& retries
>= max_tinst_depth
)
19936 tree decl
= pending_templates
->tinst
->decl
;
19938 error ("template instantiation depth exceeds maximum of %d"
19939 " instantiating %q+D, possibly from virtual table generation"
19940 " (use -ftemplate-depth= to increase the maximum)",
19941 max_tinst_depth
, decl
);
19942 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19943 /* Pretend that we defined it. */
19944 DECL_INITIAL (decl
) = error_mark_node
;
19950 struct pending_template
**t
= &pending_templates
;
19951 struct pending_template
*last
= NULL
;
19955 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
19956 bool complete
= false;
19958 if (TYPE_P (instantiation
))
19962 if (!COMPLETE_TYPE_P (instantiation
))
19964 instantiate_class_template (instantiation
);
19965 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
19966 for (fn
= TYPE_METHODS (instantiation
);
19968 fn
= TREE_CHAIN (fn
))
19969 if (! DECL_ARTIFICIAL (fn
))
19970 instantiate_decl (fn
,
19972 /*expl_inst_class_mem_p=*/false);
19973 if (COMPLETE_TYPE_P (instantiation
))
19977 complete
= COMPLETE_TYPE_P (instantiation
);
19981 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
19982 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
19985 = instantiate_decl (instantiation
,
19987 /*expl_inst_class_mem_p=*/false);
19988 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
19992 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
19993 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
19997 /* If INSTANTIATION has been instantiated, then we don't
19998 need to consider it again in the future. */
20006 current_tinst_level
= NULL
;
20008 last_pending_template
= last
;
20010 while (reconsider
);
20012 input_location
= saved_loc
;
20015 /* Substitute ARGVEC into T, which is a list of initializers for
20016 either base class or a non-static data member. The TREE_PURPOSEs
20017 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20018 instantiate_decl. */
20021 tsubst_initializer_list (tree t
, tree argvec
)
20023 tree inits
= NULL_TREE
;
20025 for (; t
; t
= TREE_CHAIN (t
))
20029 tree expanded_bases
= NULL_TREE
;
20030 tree expanded_arguments
= NULL_TREE
;
20033 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20038 /* Expand the base class expansion type into separate base
20040 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20041 tf_warning_or_error
,
20043 if (expanded_bases
== error_mark_node
)
20046 /* We'll be building separate TREE_LISTs of arguments for
20048 len
= TREE_VEC_LENGTH (expanded_bases
);
20049 expanded_arguments
= make_tree_vec (len
);
20050 for (i
= 0; i
< len
; i
++)
20051 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20053 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20054 expand each argument in the TREE_VALUE of t. */
20055 expr
= make_node (EXPR_PACK_EXPANSION
);
20056 PACK_EXPANSION_LOCAL_P (expr
) = true;
20057 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20058 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20060 if (TREE_VALUE (t
) == void_type_node
)
20061 /* VOID_TYPE_NODE is used to indicate
20062 value-initialization. */
20064 for (i
= 0; i
< len
; i
++)
20065 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20069 /* Substitute parameter packs into each argument in the
20071 in_base_initializer
= 1;
20072 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20074 tree expanded_exprs
;
20076 /* Expand the argument. */
20077 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20079 = tsubst_pack_expansion (expr
, argvec
,
20080 tf_warning_or_error
,
20082 if (expanded_exprs
== error_mark_node
)
20085 /* Prepend each of the expanded expressions to the
20086 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20087 for (i
= 0; i
< len
; i
++)
20089 TREE_VEC_ELT (expanded_arguments
, i
) =
20090 tree_cons (NULL_TREE
,
20091 TREE_VEC_ELT (expanded_exprs
, i
),
20092 TREE_VEC_ELT (expanded_arguments
, i
));
20095 in_base_initializer
= 0;
20097 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20098 since we built them backwards. */
20099 for (i
= 0; i
< len
; i
++)
20101 TREE_VEC_ELT (expanded_arguments
, i
) =
20102 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20107 for (i
= 0; i
< len
; ++i
)
20109 if (expanded_bases
)
20111 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20112 decl
= expand_member_init (decl
);
20113 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20118 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20119 tf_warning_or_error
, NULL_TREE
);
20121 decl
= expand_member_init (decl
);
20122 if (decl
&& !DECL_P (decl
))
20123 in_base_initializer
= 1;
20125 init
= TREE_VALUE (t
);
20127 if (init
!= void_type_node
)
20128 init
= tsubst_expr (init
, argvec
,
20129 tf_warning_or_error
, NULL_TREE
,
20130 /*integral_constant_expression_p=*/false);
20131 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20132 /* If we had an initializer but it instantiated to nothing,
20133 value-initialize the object. This will only occur when
20134 the initializer was a pack expansion where the parameter
20135 packs used in that expansion were of length zero. */
20136 init
= void_type_node
;
20137 in_base_initializer
= 0;
20142 init
= build_tree_list (decl
, init
);
20143 TREE_CHAIN (init
) = inits
;
20151 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20154 set_current_access_from_decl (tree decl
)
20156 if (TREE_PRIVATE (decl
))
20157 current_access_specifier
= access_private_node
;
20158 else if (TREE_PROTECTED (decl
))
20159 current_access_specifier
= access_protected_node
;
20161 current_access_specifier
= access_public_node
;
20164 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20165 is the instantiation (which should have been created with
20166 start_enum) and ARGS are the template arguments to use. */
20169 tsubst_enum (tree tag
, tree newtag
, tree args
)
20173 if (SCOPED_ENUM_P (newtag
))
20174 begin_scope (sk_scoped_enum
, newtag
);
20176 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20181 decl
= TREE_VALUE (e
);
20182 /* Note that in a template enum, the TREE_VALUE is the
20183 CONST_DECL, not the corresponding INTEGER_CST. */
20184 value
= tsubst_expr (DECL_INITIAL (decl
),
20185 args
, tf_warning_or_error
, NULL_TREE
,
20186 /*integral_constant_expression_p=*/true);
20188 /* Give this enumeration constant the correct access. */
20189 set_current_access_from_decl (decl
);
20191 /* Actually build the enumerator itself. */
20193 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
20196 if (SCOPED_ENUM_P (newtag
))
20199 finish_enum_value_list (newtag
);
20200 finish_enum (newtag
);
20202 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20203 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20206 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20207 its type -- but without substituting the innermost set of template
20208 arguments. So, innermost set of template parameters will appear in
20212 get_mostly_instantiated_function_type (tree decl
)
20220 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
20221 targs
= DECL_TI_ARGS (decl
);
20222 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
20223 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
20225 /* There should be as many levels of arguments as there are levels
20227 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
20229 fn_type
= TREE_TYPE (tmpl
);
20231 if (parm_depth
== 1)
20232 /* No substitution is necessary. */
20239 /* Replace the innermost level of the TARGS with NULL_TREEs to
20240 let tsubst know not to substitute for those parameters. */
20241 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20242 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
20243 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
20244 TMPL_ARGS_LEVEL (targs
, i
));
20245 SET_TMPL_ARGS_LEVEL (partial_args
,
20246 TMPL_ARGS_DEPTH (targs
),
20247 make_tree_vec (DECL_NTPARMS (tmpl
)));
20249 /* Make sure that we can see identifiers, and compute access
20251 push_access_scope (decl
);
20253 ++processing_template_decl
;
20254 /* Now, do the (partial) substitution to figure out the
20255 appropriate function type. */
20256 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
20257 --processing_template_decl
;
20259 /* Substitute into the template parameters to obtain the real
20260 innermost set of parameters. This step is important if the
20261 innermost set of template parameters contains value
20262 parameters whose types depend on outer template parameters. */
20263 TREE_VEC_LENGTH (partial_args
)--;
20264 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
20266 pop_access_scope (decl
);
20272 /* Return truthvalue if we're processing a template different from
20273 the last one involved in diagnostics. */
20275 problematic_instantiation_changed (void)
20277 return current_tinst_level
!= last_error_tinst_level
;
20280 /* Remember current template involved in diagnostics. */
20282 record_last_problematic_instantiation (void)
20284 last_error_tinst_level
= current_tinst_level
;
20287 struct tinst_level
*
20288 current_instantiation (void)
20290 return current_tinst_level
;
20293 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20294 type. Return zero for ok, nonzero for disallowed. Issue error and
20295 warning messages under control of COMPLAIN. */
20298 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20300 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20302 else if (POINTER_TYPE_P (type
))
20304 else if (TYPE_PTRMEM_P (type
))
20306 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20308 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20310 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20312 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20315 if (complain
& tf_error
)
20317 if (type
== error_mark_node
)
20318 inform (input_location
, "invalid template non-type parameter");
20320 error ("%q#T is not a valid type for a template non-type parameter",
20326 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20327 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20330 dependent_type_p_r (tree type
)
20336 A type is dependent if it is:
20338 -- a template parameter. Template template parameters are types
20339 for us (since TYPE_P holds true for them) so we handle
20341 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20342 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20344 /* -- a qualified-id with a nested-name-specifier which contains a
20345 class-name that names a dependent type or whose unqualified-id
20346 names a dependent type. */
20347 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20349 /* -- a cv-qualified type where the cv-unqualified type is
20351 type
= TYPE_MAIN_VARIANT (type
);
20352 /* -- a compound type constructed from any dependent type. */
20353 if (TYPE_PTRMEM_P (type
))
20354 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20355 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20357 else if (TYPE_PTR_P (type
)
20358 || TREE_CODE (type
) == REFERENCE_TYPE
)
20359 return dependent_type_p (TREE_TYPE (type
));
20360 else if (TREE_CODE (type
) == FUNCTION_TYPE
20361 || TREE_CODE (type
) == METHOD_TYPE
)
20365 if (dependent_type_p (TREE_TYPE (type
)))
20367 for (arg_type
= TYPE_ARG_TYPES (type
);
20369 arg_type
= TREE_CHAIN (arg_type
))
20370 if (dependent_type_p (TREE_VALUE (arg_type
)))
20374 /* -- an array type constructed from any dependent type or whose
20375 size is specified by a constant expression that is
20378 We checked for type- and value-dependence of the bounds in
20379 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20380 if (TREE_CODE (type
) == ARRAY_TYPE
)
20382 if (TYPE_DOMAIN (type
)
20383 && dependent_type_p (TYPE_DOMAIN (type
)))
20385 return dependent_type_p (TREE_TYPE (type
));
20388 /* -- a template-id in which either the template name is a template
20390 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20392 /* ... or any of the template arguments is a dependent type or
20393 an expression that is type-dependent or value-dependent. */
20394 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
20395 && (any_dependent_template_arguments_p
20396 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
20399 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20400 dependent; if the argument of the `typeof' expression is not
20401 type-dependent, then it should already been have resolved. */
20402 if (TREE_CODE (type
) == TYPEOF_TYPE
20403 || TREE_CODE (type
) == DECLTYPE_TYPE
20404 || TREE_CODE (type
) == UNDERLYING_TYPE
)
20407 /* A template argument pack is dependent if any of its packed
20409 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
20411 tree args
= ARGUMENT_PACK_ARGS (type
);
20412 int i
, len
= TREE_VEC_LENGTH (args
);
20413 for (i
= 0; i
< len
; ++i
)
20414 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20418 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20419 be template parameters. */
20420 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
20423 /* The standard does not specifically mention types that are local
20424 to template functions or local classes, but they should be
20425 considered dependent too. For example:
20427 template <int I> void f() {
20432 The size of `E' cannot be known until the value of `I' has been
20433 determined. Therefore, `E' must be considered dependent. */
20434 scope
= TYPE_CONTEXT (type
);
20435 if (scope
&& TYPE_P (scope
))
20436 return dependent_type_p (scope
);
20437 /* Don't use type_dependent_expression_p here, as it can lead
20438 to infinite recursion trying to determine whether a lambda
20439 nested in a lambda is dependent (c++/47687). */
20440 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
20441 && DECL_LANG_SPECIFIC (scope
)
20442 && DECL_TEMPLATE_INFO (scope
)
20443 && (any_dependent_template_arguments_p
20444 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
20447 /* Other types are non-dependent. */
20451 /* Returns TRUE if TYPE is dependent, in the sense of
20452 [temp.dep.type]. Note that a NULL type is considered dependent. */
20455 dependent_type_p (tree type
)
20457 /* If there are no template parameters in scope, then there can't be
20458 any dependent types. */
20459 if (!processing_template_decl
)
20461 /* If we are not processing a template, then nobody should be
20462 providing us with a dependent type. */
20464 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
20468 /* If the type is NULL, we have not computed a type for the entity
20469 in question; in that case, the type is dependent. */
20473 /* Erroneous types can be considered non-dependent. */
20474 if (type
== error_mark_node
)
20477 /* If we have not already computed the appropriate value for TYPE,
20479 if (!TYPE_DEPENDENT_P_VALID (type
))
20481 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
20482 TYPE_DEPENDENT_P_VALID (type
) = 1;
20485 return TYPE_DEPENDENT_P (type
);
20488 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20489 lookup. In other words, a dependent type that is not the current
20493 dependent_scope_p (tree scope
)
20495 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
20496 && !currently_open_class (scope
));
20499 /* T is a SCOPE_REF; return whether we need to consider it
20500 instantiation-dependent so that we can check access at instantiation
20501 time even though we know which member it resolves to. */
20504 instantiation_dependent_scope_ref_p (tree t
)
20506 if (DECL_P (TREE_OPERAND (t
, 1))
20507 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
20508 && accessible_in_template_p (TREE_OPERAND (t
, 0),
20509 TREE_OPERAND (t
, 1)))
20515 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20516 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20519 /* Note that this predicate is not appropriate for general expressions;
20520 only constant expressions (that satisfy potential_constant_expression)
20521 can be tested for value dependence. */
20524 value_dependent_expression_p (tree expression
)
20526 if (!processing_template_decl
)
20529 /* A name declared with a dependent type. */
20530 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
20533 switch (TREE_CODE (expression
))
20535 case IDENTIFIER_NODE
:
20536 /* A name that has not been looked up -- must be dependent. */
20539 case TEMPLATE_PARM_INDEX
:
20540 /* A non-type template parm. */
20544 /* A non-type template parm. */
20545 if (DECL_TEMPLATE_PARM_P (expression
))
20547 return value_dependent_expression_p (DECL_INITIAL (expression
));
20550 /* A constant with literal type and is initialized
20551 with an expression that is value-dependent.
20553 Note that a non-dependent parenthesized initializer will have
20554 already been replaced with its constant value, so if we see
20555 a TREE_LIST it must be dependent. */
20556 if (DECL_INITIAL (expression
)
20557 && decl_constant_var_p (expression
)
20558 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
20559 || value_dependent_expression_p (DECL_INITIAL (expression
))))
20563 case DYNAMIC_CAST_EXPR
:
20564 case STATIC_CAST_EXPR
:
20565 case CONST_CAST_EXPR
:
20566 case REINTERPRET_CAST_EXPR
:
20568 /* These expressions are value-dependent if the type to which
20569 the cast occurs is dependent or the expression being casted
20570 is value-dependent. */
20572 tree type
= TREE_TYPE (expression
);
20574 if (dependent_type_p (type
))
20577 /* A functional cast has a list of operands. */
20578 expression
= TREE_OPERAND (expression
, 0);
20581 /* If there are no operands, it must be an expression such
20582 as "int()". This should not happen for aggregate types
20583 because it would form non-constant expressions. */
20584 gcc_assert (cxx_dialect
>= cxx11
20585 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
20590 if (TREE_CODE (expression
) == TREE_LIST
)
20591 return any_value_dependent_elements_p (expression
);
20593 return value_dependent_expression_p (expression
);
20597 if (SIZEOF_EXPR_TYPE_P (expression
))
20598 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
20602 /* A `sizeof' expression is value-dependent if the operand is
20603 type-dependent or is a pack expansion. */
20604 expression
= TREE_OPERAND (expression
, 0);
20605 if (PACK_EXPANSION_P (expression
))
20607 else if (TYPE_P (expression
))
20608 return dependent_type_p (expression
);
20609 return instantiation_dependent_expression_p (expression
);
20611 case AT_ENCODE_EXPR
:
20612 /* An 'encode' expression is value-dependent if the operand is
20614 expression
= TREE_OPERAND (expression
, 0);
20615 return dependent_type_p (expression
);
20617 case NOEXCEPT_EXPR
:
20618 expression
= TREE_OPERAND (expression
, 0);
20619 return instantiation_dependent_expression_p (expression
);
20622 /* All instantiation-dependent expressions should also be considered
20623 value-dependent. */
20624 return instantiation_dependent_scope_ref_p (expression
);
20626 case COMPONENT_REF
:
20627 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
20628 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
20630 case NONTYPE_ARGUMENT_PACK
:
20631 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
20632 is value-dependent. */
20634 tree values
= ARGUMENT_PACK_ARGS (expression
);
20635 int i
, len
= TREE_VEC_LENGTH (values
);
20637 for (i
= 0; i
< len
; ++i
)
20638 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
20646 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
20647 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
20648 || (type2
? dependent_type_p (type2
) : false));
20652 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20653 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
20656 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20657 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
20661 tree op
= TREE_OPERAND (expression
, 0);
20662 return (value_dependent_expression_p (op
)
20663 || has_value_dependent_address (op
));
20668 tree fn
= get_callee_fndecl (expression
);
20670 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
20672 nargs
= call_expr_nargs (expression
);
20673 for (i
= 0; i
< nargs
; ++i
)
20675 tree op
= CALL_EXPR_ARG (expression
, i
);
20676 /* In a call to a constexpr member function, look through the
20677 implicit ADDR_EXPR on the object argument so that it doesn't
20678 cause the call to be considered value-dependent. We also
20679 look through it in potential_constant_expression. */
20680 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
20681 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
20682 && TREE_CODE (op
) == ADDR_EXPR
)
20683 op
= TREE_OPERAND (op
, 0);
20684 if (value_dependent_expression_p (op
))
20690 case TEMPLATE_ID_EXPR
:
20691 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
20693 return type_dependent_expression_p (expression
);
20699 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
20700 if (value_dependent_expression_p (val
))
20706 /* Treat a GNU statement expression as dependent to avoid crashing
20707 under fold_non_dependent_expr; it can't be constant. */
20711 /* A constant expression is value-dependent if any subexpression is
20712 value-dependent. */
20713 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
20715 case tcc_reference
:
20717 case tcc_comparison
:
20719 case tcc_expression
:
20722 int i
, len
= cp_tree_operand_length (expression
);
20724 for (i
= 0; i
< len
; i
++)
20726 tree t
= TREE_OPERAND (expression
, i
);
20728 /* In some cases, some of the operands may be missing.l
20729 (For example, in the case of PREDECREMENT_EXPR, the
20730 amount to increment by may be missing.) That doesn't
20731 make the expression dependent. */
20732 if (t
&& value_dependent_expression_p (t
))
20743 /* The expression is not value-dependent. */
20747 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
20748 [temp.dep.expr]. Note that an expression with no type is
20749 considered dependent. Other parts of the compiler arrange for an
20750 expression with type-dependent subexpressions to have no type, so
20751 this function doesn't have to be fully recursive. */
20754 type_dependent_expression_p (tree expression
)
20756 if (!processing_template_decl
)
20759 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
20762 /* An unresolved name is always dependent. */
20763 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
20766 /* Some expression forms are never type-dependent. */
20767 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
20768 || TREE_CODE (expression
) == SIZEOF_EXPR
20769 || TREE_CODE (expression
) == ALIGNOF_EXPR
20770 || TREE_CODE (expression
) == AT_ENCODE_EXPR
20771 || TREE_CODE (expression
) == NOEXCEPT_EXPR
20772 || TREE_CODE (expression
) == TRAIT_EXPR
20773 || TREE_CODE (expression
) == TYPEID_EXPR
20774 || TREE_CODE (expression
) == DELETE_EXPR
20775 || TREE_CODE (expression
) == VEC_DELETE_EXPR
20776 || TREE_CODE (expression
) == THROW_EXPR
)
20779 /* The types of these expressions depends only on the type to which
20780 the cast occurs. */
20781 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
20782 || TREE_CODE (expression
) == STATIC_CAST_EXPR
20783 || TREE_CODE (expression
) == CONST_CAST_EXPR
20784 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
20785 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
20786 || TREE_CODE (expression
) == CAST_EXPR
)
20787 return dependent_type_p (TREE_TYPE (expression
));
20789 /* The types of these expressions depends only on the type created
20790 by the expression. */
20791 if (TREE_CODE (expression
) == NEW_EXPR
20792 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
20794 /* For NEW_EXPR tree nodes created inside a template, either
20795 the object type itself or a TREE_LIST may appear as the
20797 tree type
= TREE_OPERAND (expression
, 1);
20798 if (TREE_CODE (type
) == TREE_LIST
)
20799 /* This is an array type. We need to check array dimensions
20801 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
20802 || value_dependent_expression_p
20803 (TREE_OPERAND (TREE_VALUE (type
), 1));
20805 return dependent_type_p (type
);
20808 if (TREE_CODE (expression
) == SCOPE_REF
)
20810 tree scope
= TREE_OPERAND (expression
, 0);
20811 tree name
= TREE_OPERAND (expression
, 1);
20813 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
20814 contains an identifier associated by name lookup with one or more
20815 declarations declared with a dependent type, or...a
20816 nested-name-specifier or qualified-id that names a member of an
20817 unknown specialization. */
20818 return (type_dependent_expression_p (name
)
20819 || dependent_scope_p (scope
));
20822 if (TREE_CODE (expression
) == FUNCTION_DECL
20823 && DECL_LANG_SPECIFIC (expression
)
20824 && DECL_TEMPLATE_INFO (expression
)
20825 && (any_dependent_template_arguments_p
20826 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
20829 if (TREE_CODE (expression
) == TEMPLATE_DECL
20830 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
20833 if (TREE_CODE (expression
) == STMT_EXPR
)
20834 expression
= stmt_expr_value_expr (expression
);
20836 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
20841 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
20843 if (type_dependent_expression_p (elt
))
20849 /* A static data member of the current instantiation with incomplete
20850 array type is type-dependent, as the definition and specializations
20851 can have different bounds. */
20852 if (VAR_P (expression
)
20853 && DECL_CLASS_SCOPE_P (expression
)
20854 && dependent_type_p (DECL_CONTEXT (expression
))
20855 && VAR_HAD_UNKNOWN_BOUND (expression
))
20858 /* An array of unknown bound depending on a variadic parameter, eg:
20860 template<typename... Args>
20861 void foo (Args... args)
20863 int arr[] = { args... };
20866 template<int... vals>
20869 int arr[] = { vals... };
20872 If the array has no length and has an initializer, it must be that
20873 we couldn't determine its length in cp_complete_array_type because
20874 it is dependent. */
20875 if (VAR_P (expression
)
20876 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
20877 && !TYPE_DOMAIN (TREE_TYPE (expression
))
20878 && DECL_INITIAL (expression
))
20881 if (TREE_TYPE (expression
) == unknown_type_node
)
20883 if (TREE_CODE (expression
) == ADDR_EXPR
)
20884 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
20885 if (TREE_CODE (expression
) == COMPONENT_REF
20886 || TREE_CODE (expression
) == OFFSET_REF
)
20888 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20890 expression
= TREE_OPERAND (expression
, 1);
20891 if (identifier_p (expression
))
20894 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
20895 if (TREE_CODE (expression
) == SCOPE_REF
)
20898 /* Always dependent, on the number of arguments if nothing else. */
20899 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
20902 if (BASELINK_P (expression
))
20903 expression
= BASELINK_FUNCTIONS (expression
);
20905 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
20907 if (any_dependent_template_arguments_p
20908 (TREE_OPERAND (expression
, 1)))
20910 expression
= TREE_OPERAND (expression
, 0);
20912 gcc_assert (TREE_CODE (expression
) == OVERLOAD
20913 || TREE_CODE (expression
) == FUNCTION_DECL
);
20917 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
20919 expression
= OVL_NEXT (expression
);
20924 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
20926 return (dependent_type_p (TREE_TYPE (expression
)));
20929 /* walk_tree callback function for instantiation_dependent_expression_p,
20930 below. Returns non-zero if a dependent subexpression is found. */
20933 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
20938 /* We don't have to worry about decltype currently because decltype
20939 of an instantiation-dependent expr is a dependent type. This
20940 might change depending on the resolution of DR 1172. */
20941 *walk_subtrees
= false;
20944 enum tree_code code
= TREE_CODE (*tp
);
20947 /* Don't treat an argument list as dependent just because it has no
20955 /* A constant with a dependent initializer is dependent. */
20956 if (value_dependent_expression_p (*tp
))
20960 case TEMPLATE_PARM_INDEX
:
20963 /* Handle expressions with type operands. */
20967 case AT_ENCODE_EXPR
:
20969 tree op
= TREE_OPERAND (*tp
, 0);
20970 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
20971 op
= TREE_TYPE (op
);
20974 if (dependent_type_p (op
))
20978 *walk_subtrees
= false;
20986 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
20987 || (TRAIT_EXPR_TYPE2 (*tp
)
20988 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
20990 *walk_subtrees
= false;
20993 case COMPONENT_REF
:
20994 if (identifier_p (TREE_OPERAND (*tp
, 1)))
20995 /* In a template, finish_class_member_access_expr creates a
20996 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
20997 type-dependent, so that we can check access control at
20998 instantiation time (PR 42277). See also Core issue 1273. */
21003 if (instantiation_dependent_scope_ref_p (*tp
))
21008 /* Treat statement-expressions as dependent. */
21016 if (type_dependent_expression_p (*tp
))
21022 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21023 sense defined by the ABI:
21025 "An expression is instantiation-dependent if it is type-dependent
21026 or value-dependent, or it has a subexpression that is type-dependent
21027 or value-dependent." */
21030 instantiation_dependent_expression_p (tree expression
)
21034 if (!processing_template_decl
)
21037 if (expression
== error_mark_node
)
21040 result
= cp_walk_tree_without_duplicates (&expression
,
21041 instantiation_dependent_r
, NULL
);
21042 return result
!= NULL_TREE
;
21045 /* Like type_dependent_expression_p, but it also works while not processing
21046 a template definition, i.e. during substitution or mangling. */
21049 type_dependent_expression_p_push (tree expr
)
21052 ++processing_template_decl
;
21053 b
= type_dependent_expression_p (expr
);
21054 --processing_template_decl
;
21058 /* Returns TRUE if ARGS contains a type-dependent expression. */
21061 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21066 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21068 if (type_dependent_expression_p (arg
))
21074 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21075 expressions) contains any type-dependent expressions. */
21078 any_type_dependent_elements_p (const_tree list
)
21080 for (; list
; list
= TREE_CHAIN (list
))
21081 if (type_dependent_expression_p (TREE_VALUE (list
)))
21087 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21088 expressions) contains any value-dependent expressions. */
21091 any_value_dependent_elements_p (const_tree list
)
21093 for (; list
; list
= TREE_CHAIN (list
))
21094 if (value_dependent_expression_p (TREE_VALUE (list
)))
21100 /* Returns TRUE if the ARG (a template argument) is dependent. */
21103 dependent_template_arg_p (tree arg
)
21105 if (!processing_template_decl
)
21108 /* Assume a template argument that was wrongly written by the user
21109 is dependent. This is consistent with what
21110 any_dependent_template_arguments_p [that calls this function]
21112 if (!arg
|| arg
== error_mark_node
)
21115 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21116 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21118 if (TREE_CODE (arg
) == TEMPLATE_DECL
21119 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21120 return dependent_template_p (arg
);
21121 else if (ARGUMENT_PACK_P (arg
))
21123 tree args
= ARGUMENT_PACK_ARGS (arg
);
21124 int i
, len
= TREE_VEC_LENGTH (args
);
21125 for (i
= 0; i
< len
; ++i
)
21127 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21133 else if (TYPE_P (arg
))
21134 return dependent_type_p (arg
);
21136 return (type_dependent_expression_p (arg
)
21137 || value_dependent_expression_p (arg
));
21140 /* Returns true if ARGS (a collection of template arguments) contains
21141 any types that require structural equality testing. */
21144 any_template_arguments_need_structural_equality_p (tree args
)
21151 if (args
== error_mark_node
)
21154 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21156 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21157 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21159 tree arg
= TREE_VEC_ELT (level
, j
);
21160 tree packed_args
= NULL_TREE
;
21163 if (ARGUMENT_PACK_P (arg
))
21165 /* Look inside the argument pack. */
21166 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21167 len
= TREE_VEC_LENGTH (packed_args
);
21170 for (k
= 0; k
< len
; ++k
)
21173 arg
= TREE_VEC_ELT (packed_args
, k
);
21175 if (error_operand_p (arg
))
21177 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21179 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21181 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21182 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21191 /* Returns true if ARGS (a collection of template arguments) contains
21192 any dependent arguments. */
21195 any_dependent_template_arguments_p (const_tree args
)
21202 if (args
== error_mark_node
)
21205 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21207 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21208 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21209 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21216 /* Returns TRUE if the template TMPL is dependent. */
21219 dependent_template_p (tree tmpl
)
21221 if (TREE_CODE (tmpl
) == OVERLOAD
)
21225 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21227 tmpl
= OVL_NEXT (tmpl
);
21232 /* Template template parameters are dependent. */
21233 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21234 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21236 /* So are names that have not been looked up. */
21237 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21239 /* So are member templates of dependent classes. */
21240 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21241 return dependent_type_p (DECL_CONTEXT (tmpl
));
21245 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21248 dependent_template_id_p (tree tmpl
, tree args
)
21250 return (dependent_template_p (tmpl
)
21251 || any_dependent_template_arguments_p (args
));
21254 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21258 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21262 if (!processing_template_decl
)
21265 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21267 tree decl
= TREE_VEC_ELT (declv
, i
);
21268 tree init
= TREE_VEC_ELT (initv
, i
);
21269 tree cond
= TREE_VEC_ELT (condv
, i
);
21270 tree incr
= TREE_VEC_ELT (incrv
, i
);
21272 if (type_dependent_expression_p (decl
))
21275 if (init
&& type_dependent_expression_p (init
))
21278 if (type_dependent_expression_p (cond
))
21281 if (COMPARISON_CLASS_P (cond
)
21282 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21283 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21286 if (TREE_CODE (incr
) == MODOP_EXPR
)
21288 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21289 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21292 else if (type_dependent_expression_p (incr
))
21294 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21296 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21298 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21300 tree t
= TREE_OPERAND (incr
, 1);
21301 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21302 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21311 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21312 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21313 no such TYPE can be found. Note that this function peers inside
21314 uninstantiated templates and therefore should be used only in
21315 extremely limited situations. ONLY_CURRENT_P restricts this
21316 peering to the currently open classes hierarchy (which is required
21317 when comparing types). */
21320 resolve_typename_type (tree type
, bool only_current_p
)
21329 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21331 scope
= TYPE_CONTEXT (type
);
21332 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21333 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21334 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21335 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21336 identifier of the TYPENAME_TYPE anymore.
21337 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21338 TYPENAME_TYPE instead, we avoid messing up with a possible
21339 typedef variant case. */
21340 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21342 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21343 it first before we can figure out what NAME refers to. */
21344 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21346 if (TYPENAME_IS_RESOLVING_P (scope
))
21347 /* Given a class template A with a dependent base with nested type C,
21348 typedef typename A::C::C C will land us here, as trying to resolve
21349 the initial A::C leads to the local C typedef, which leads back to
21350 A::C::C. So we break the recursion now. */
21353 scope
= resolve_typename_type (scope
, only_current_p
);
21355 /* If we don't know what SCOPE refers to, then we cannot resolve the
21357 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21359 /* If the SCOPE is a template type parameter, we have no way of
21360 resolving the name. */
21361 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21363 /* If the SCOPE is not the current instantiation, there's no reason
21364 to look inside it. */
21365 if (only_current_p
&& !currently_open_class (scope
))
21367 /* If this is a typedef, we don't want to look inside (c++/11987). */
21368 if (typedef_variant_p (type
))
21370 /* If SCOPE isn't the template itself, it will not have a valid
21371 TYPE_FIELDS list. */
21372 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21373 /* scope is either the template itself or a compatible instantiation
21374 like X<T>, so look up the name in the original template. */
21375 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
21377 /* scope is a partial instantiation, so we can't do the lookup or we
21378 will lose the template arguments. */
21380 /* Enter the SCOPE so that name lookup will be resolved as if we
21381 were in the class definition. In particular, SCOPE will no
21382 longer be considered a dependent type. */
21383 pushed_scope
= push_scope (scope
);
21384 /* Look up the declaration. */
21385 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
21386 tf_warning_or_error
);
21388 result
= NULL_TREE
;
21390 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21391 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21394 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
21395 && TREE_CODE (decl
) == TYPE_DECL
)
21397 result
= TREE_TYPE (decl
);
21398 if (result
== error_mark_node
)
21399 result
= NULL_TREE
;
21401 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
21402 && DECL_CLASS_TEMPLATE_P (decl
))
21406 /* Obtain the template and the arguments. */
21407 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
21408 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
21409 /* Instantiate the template. */
21410 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
21411 /*entering_scope=*/0,
21412 tf_error
| tf_user
);
21413 if (result
== error_mark_node
)
21414 result
= NULL_TREE
;
21417 /* Leave the SCOPE. */
21419 pop_scope (pushed_scope
);
21421 /* If we failed to resolve it, return the original typename. */
21425 /* If lookup found a typename type, resolve that too. */
21426 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
21428 /* Ill-formed programs can cause infinite recursion here, so we
21429 must catch that. */
21430 TYPENAME_IS_RESOLVING_P (type
) = 1;
21431 result
= resolve_typename_type (result
, only_current_p
);
21432 TYPENAME_IS_RESOLVING_P (type
) = 0;
21435 /* Qualify the resulting type. */
21436 quals
= cp_type_quals (type
);
21438 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
21443 /* EXPR is an expression which is not type-dependent. Return a proxy
21444 for EXPR that can be used to compute the types of larger
21445 expressions containing EXPR. */
21448 build_non_dependent_expr (tree expr
)
21452 #ifdef ENABLE_CHECKING
21453 /* Try to get a constant value for all non-dependent expressions in
21454 order to expose bugs in *_dependent_expression_p and constexpr. */
21455 if (cxx_dialect
>= cxx11
)
21456 maybe_constant_value (fold_non_dependent_expr_sfinae (expr
, tf_none
));
21459 /* Preserve OVERLOADs; the functions must be available to resolve
21462 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
21463 inner_expr
= stmt_expr_value_expr (inner_expr
);
21464 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
21465 inner_expr
= TREE_OPERAND (inner_expr
, 0);
21466 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
21467 inner_expr
= TREE_OPERAND (inner_expr
, 1);
21468 if (is_overloaded_fn (inner_expr
)
21469 || TREE_CODE (inner_expr
) == OFFSET_REF
)
21471 /* There is no need to return a proxy for a variable. */
21474 /* Preserve string constants; conversions from string constants to
21475 "char *" are allowed, even though normally a "const char *"
21476 cannot be used to initialize a "char *". */
21477 if (TREE_CODE (expr
) == STRING_CST
)
21479 /* Preserve arithmetic constants, as an optimization -- there is no
21480 reason to create a new node. */
21481 if (TREE_CODE (expr
) == INTEGER_CST
|| TREE_CODE (expr
) == REAL_CST
)
21483 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21484 There is at least one place where we want to know that a
21485 particular expression is a throw-expression: when checking a ?:
21486 expression, there are special rules if the second or third
21487 argument is a throw-expression. */
21488 if (TREE_CODE (expr
) == THROW_EXPR
)
21491 /* Don't wrap an initializer list, we need to be able to look inside. */
21492 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
21495 /* Don't wrap a dummy object, we need to be able to test for it. */
21496 if (is_dummy_object (expr
))
21499 if (TREE_CODE (expr
) == COND_EXPR
)
21500 return build3 (COND_EXPR
,
21502 TREE_OPERAND (expr
, 0),
21503 (TREE_OPERAND (expr
, 1)
21504 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
21505 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
21506 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
21507 if (TREE_CODE (expr
) == COMPOUND_EXPR
21508 && !COMPOUND_EXPR_OVERLOADED (expr
))
21509 return build2 (COMPOUND_EXPR
,
21511 TREE_OPERAND (expr
, 0),
21512 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
21514 /* If the type is unknown, it can't really be non-dependent */
21515 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
21517 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21518 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
21521 /* ARGS is a vector of expressions as arguments to a function call.
21522 Replace the arguments with equivalent non-dependent expressions.
21523 This modifies ARGS in place. */
21526 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
21531 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
21533 tree newarg
= build_non_dependent_expr (arg
);
21535 (*args
)[ix
] = newarg
;
21539 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21540 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21544 make_auto_1 (tree name
)
21546 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
21547 TYPE_NAME (au
) = build_decl (input_location
,
21548 TYPE_DECL
, name
, au
);
21549 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
21550 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
21551 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
21552 TYPE_NAME (au
), NULL_TREE
);
21553 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
21554 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
21555 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
21561 make_decltype_auto (void)
21563 return make_auto_1 (get_identifier ("decltype(auto)"));
21569 return make_auto_1 (get_identifier ("auto"));
21572 /* Given type ARG, return std::initializer_list<ARG>. */
21577 tree std_init_list
= namespace_binding
21578 (get_identifier ("initializer_list"), std_node
);
21580 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
21582 error ("deducing from brace-enclosed initializer list requires "
21583 "#include <initializer_list>");
21584 return error_mark_node
;
21586 argvec
= make_tree_vec (1);
21587 TREE_VEC_ELT (argvec
, 0) = arg
;
21588 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
21589 NULL_TREE
, 0, tf_warning_or_error
);
21592 /* Replace auto in TYPE with std::initializer_list<auto>. */
21595 listify_autos (tree type
, tree auto_node
)
21597 tree init_auto
= listify (auto_node
);
21598 tree argvec
= make_tree_vec (1);
21599 TREE_VEC_ELT (argvec
, 0) = init_auto
;
21600 if (processing_template_decl
)
21601 argvec
= add_to_template_args (current_template_args (), argvec
);
21602 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21605 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
21606 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
21609 do_auto_deduction (tree type
, tree init
, tree auto_node
)
21613 if (init
== error_mark_node
)
21614 return error_mark_node
;
21616 if (type_dependent_expression_p (init
))
21617 /* Defining a subset of type-dependent expressions that we can deduce
21618 from ahead of time isn't worth the trouble. */
21621 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
21622 with either a new invented type template parameter U or, if the
21623 initializer is a braced-init-list (8.5.4), with
21624 std::initializer_list<U>. */
21625 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
21626 type
= listify_autos (type
, auto_node
);
21628 init
= resolve_nondeduced_context (init
);
21630 targs
= make_tree_vec (1);
21631 if (AUTO_IS_DECLTYPE (auto_node
))
21633 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
21634 && !REF_PARENTHESIZED_P (init
)));
21635 TREE_VEC_ELT (targs
, 0)
21636 = finish_decltype_type (init
, id
, tf_warning_or_error
);
21637 if (type
!= auto_node
)
21639 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
21640 return error_mark_node
;
21645 tree parms
= build_tree_list (NULL_TREE
, type
);
21646 tree tparms
= make_tree_vec (1);
21649 TREE_VEC_ELT (tparms
, 0)
21650 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
21651 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
21652 DEDUCE_CALL
, LOOKUP_NORMAL
,
21653 NULL
, /*explain_p=*/false);
21656 if (processing_template_decl
)
21657 /* Try again at instantiation time. */
21659 if (type
&& type
!= error_mark_node
)
21660 /* If type is error_mark_node a diagnostic must have been
21661 emitted by now. Also, having a mention to '<type error>'
21662 in the diagnostic is not really useful to the user. */
21664 if (cfun
&& auto_node
== current_function_auto_return_pattern
21665 && LAMBDA_FUNCTION_P (current_function_decl
))
21666 error ("unable to deduce lambda return type from %qE", init
);
21668 error ("unable to deduce %qT from %qE", type
, init
);
21670 return error_mark_node
;
21674 /* If the list of declarators contains more than one declarator, the type
21675 of each declared variable is determined as described above. If the
21676 type deduced for the template parameter U is not the same in each
21677 deduction, the program is ill-formed. */
21678 if (TREE_TYPE (auto_node
)
21679 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
21681 if (cfun
&& auto_node
== current_function_auto_return_pattern
21682 && LAMBDA_FUNCTION_P (current_function_decl
))
21683 error ("inconsistent types %qT and %qT deduced for "
21684 "lambda return type", TREE_TYPE (auto_node
),
21685 TREE_VEC_ELT (targs
, 0));
21687 error ("inconsistent deduction for %qT: %qT and then %qT",
21688 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
21689 return error_mark_node
;
21691 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
21693 if (processing_template_decl
)
21694 targs
= add_to_template_args (current_template_args (), targs
);
21695 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
21698 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
21702 splice_late_return_type (tree type
, tree late_return_type
)
21706 if (late_return_type
== NULL_TREE
)
21708 argvec
= make_tree_vec (1);
21709 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
21710 if (processing_template_parmlist
)
21711 /* For a late-specified return type in a template type-parameter, we
21712 need to add a dummy argument level for its parmlist. */
21713 argvec
= add_to_template_args
21714 (make_tree_vec (processing_template_parmlist
), argvec
);
21715 if (current_template_parms
)
21716 argvec
= add_to_template_args (current_template_args (), argvec
);
21717 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21720 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
21721 'decltype(auto)'. */
21724 is_auto (const_tree type
)
21726 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
21727 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
21728 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
21734 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
21735 a use of `auto'. Returns NULL_TREE otherwise. */
21738 type_uses_auto (tree type
)
21740 return find_type_usage (type
, is_auto
);
21743 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
21744 'decltype(auto)' or a concept. */
21747 is_auto_or_concept (const_tree type
)
21749 return is_auto (type
); // or concept
21752 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
21753 a concept identifier) iff TYPE contains a use of a generic type. Returns
21754 NULL_TREE otherwise. */
21757 type_uses_auto_or_concept (tree type
)
21759 return find_type_usage (type
, is_auto_or_concept
);
21763 /* For a given template T, return the vector of typedefs referenced
21764 in T for which access check is needed at T instantiation time.
21765 T is either a FUNCTION_DECL or a RECORD_TYPE.
21766 Those typedefs were added to T by the function
21767 append_type_to_template_for_access_check. */
21769 vec
<qualified_typedef_usage_t
, va_gc
> *
21770 get_types_needing_access_check (tree t
)
21773 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
21775 if (!t
|| t
== error_mark_node
)
21778 if (!(ti
= get_template_info (t
)))
21781 if (CLASS_TYPE_P (t
)
21782 || TREE_CODE (t
) == FUNCTION_DECL
)
21784 if (!TI_TEMPLATE (ti
))
21787 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
21793 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
21794 tied to T. That list of typedefs will be access checked at
21795 T instantiation time.
21796 T is either a FUNCTION_DECL or a RECORD_TYPE.
21797 TYPE_DECL is a TYPE_DECL node representing a typedef.
21798 SCOPE is the scope through which TYPE_DECL is accessed.
21799 LOCATION is the location of the usage point of TYPE_DECL.
21801 This function is a subroutine of
21802 append_type_to_template_for_access_check. */
21805 append_type_to_template_for_access_check_1 (tree t
,
21808 location_t location
)
21810 qualified_typedef_usage_t typedef_usage
;
21813 if (!t
|| t
== error_mark_node
)
21816 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
21817 || CLASS_TYPE_P (t
))
21819 && TREE_CODE (type_decl
) == TYPE_DECL
21822 if (!(ti
= get_template_info (t
)))
21825 gcc_assert (TI_TEMPLATE (ti
));
21827 typedef_usage
.typedef_decl
= type_decl
;
21828 typedef_usage
.context
= scope
;
21829 typedef_usage
.locus
= location
;
21831 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
21834 /* Append TYPE_DECL to the template TEMPL.
21835 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
21836 At TEMPL instanciation time, TYPE_DECL will be checked to see
21837 if it can be accessed through SCOPE.
21838 LOCATION is the location of the usage point of TYPE_DECL.
21840 e.g. consider the following code snippet:
21847 template<class U> struct S
21849 C::myint mi; // <-- usage point of the typedef C::myint
21854 At S<char> instantiation time, we need to check the access of C::myint
21855 In other words, we need to check the access of the myint typedef through
21856 the C scope. For that purpose, this function will add the myint typedef
21857 and the scope C through which its being accessed to a list of typedefs
21858 tied to the template S. That list will be walked at template instantiation
21859 time and access check performed on each typedefs it contains.
21860 Note that this particular code snippet should yield an error because
21861 myint is private to C. */
21864 append_type_to_template_for_access_check (tree templ
,
21867 location_t location
)
21869 qualified_typedef_usage_t
*iter
;
21872 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
21874 /* Make sure we don't append the type to the template twice. */
21875 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
21876 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
21879 append_type_to_template_for_access_check_1 (templ
, type_decl
,
21883 /* Convert the generic type parameters in PARM that match the types given in the
21884 range [START_IDX, END_IDX) from the current_template_parms into generic type
21888 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
21890 tree current
= current_template_parms
;
21891 int depth
= TMPL_PARMS_DEPTH (current
);
21892 current
= INNERMOST_TEMPLATE_PARMS (current
);
21893 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
21895 for (int i
= 0; i
< start_idx
; ++i
)
21896 TREE_VEC_ELT (replacement
, i
)
21897 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
21899 for (int i
= start_idx
; i
< end_idx
; ++i
)
21901 /* Create a distinct parameter pack type from the current parm and add it
21902 to the replacement args to tsubst below into the generic function
21905 tree o
= TREE_TYPE (TREE_VALUE
21906 (TREE_VEC_ELT (current
, i
)));
21907 tree t
= copy_type (o
);
21908 TEMPLATE_TYPE_PARM_INDEX (t
)
21909 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
21911 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
21912 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
21913 TYPE_MAIN_VARIANT (t
) = t
;
21914 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
21915 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
21916 TREE_VEC_ELT (replacement
, i
) = t
;
21917 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
21920 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
21921 TREE_VEC_ELT (replacement
, i
)
21922 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
21924 /* If there are more levels then build up the replacement with the outer
21927 replacement
= add_to_template_args (template_parms_to_args
21928 (TREE_CHAIN (current_template_parms
)),
21931 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
21935 /* Set up the hash tables for template instantiations. */
21938 init_template_processing (void)
21940 decl_specializations
= htab_create_ggc (37,
21941 hash_specialization
,
21942 eq_specializations
,
21944 type_specializations
= htab_create_ggc (37,
21945 hash_specialization
,
21946 eq_specializations
,
21950 /* Print stats about the template hash tables for -fstats. */
21953 print_template_statistics (void)
21955 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
21956 "%f collisions\n", (long) htab_size (decl_specializations
),
21957 (long) htab_elements (decl_specializations
),
21958 htab_collisions (decl_specializations
));
21959 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
21960 "%f collisions\n", (long) htab_size (type_specializations
),
21961 (long) htab_elements (type_specializations
),
21962 htab_collisions (type_specializations
));
21965 #include "gt-cp-pt.h"