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 (parm
== error_mark_node
)
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
;
465 decl
= (CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
466 ? CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (decl
))
469 if (inline_needs_template_parms (decl
, nsdmi
))
471 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
472 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
474 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
477 parms
= TREE_CHAIN (parms
);
480 push_inline_template_parms_recursive (parms
, levels
);
483 /* Remember how many levels of template parameters we pushed so that
484 we can pop them later. */
485 inline_parm_levels
.safe_push (levels
);
488 /* Undo the effects of maybe_begin_member_template_processing. */
491 maybe_end_member_template_processing (void)
496 if (inline_parm_levels
.length () == 0)
499 last
= inline_parm_levels
.pop ();
500 for (i
= 0; i
< last
; ++i
)
502 --processing_template_decl
;
503 current_template_parms
= TREE_CHAIN (current_template_parms
);
508 /* Return a new template argument vector which contains all of ARGS,
509 but has as its innermost set of arguments the EXTRA_ARGS. */
512 add_to_template_args (tree args
, tree extra_args
)
519 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
522 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
523 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
525 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
526 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
528 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
529 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
534 /* Like add_to_template_args, but only the outermost ARGS are added to
535 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
536 (EXTRA_ARGS) levels are added. This function is used to combine
537 the template arguments from a partial instantiation with the
538 template arguments used to attain the full instantiation from the
539 partial instantiation. */
542 add_outermost_template_args (tree args
, tree extra_args
)
546 /* If there are more levels of EXTRA_ARGS than there are ARGS,
547 something very fishy is going on. */
548 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
550 /* If *all* the new arguments will be the EXTRA_ARGS, just return
552 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
555 /* For the moment, we make ARGS look like it contains fewer levels. */
556 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
558 new_args
= add_to_template_args (args
, extra_args
);
560 /* Now, we restore ARGS to its full dimensions. */
561 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
566 /* Return the N levels of innermost template arguments from the ARGS. */
569 get_innermost_template_args (tree args
, int n
)
577 /* If N is 1, just return the innermost set of template arguments. */
579 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
581 /* If we're not removing anything, just return the arguments we were
583 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
584 gcc_assert (extra_levels
>= 0);
585 if (extra_levels
== 0)
588 /* Make a new set of arguments, not containing the outer arguments. */
589 new_args
= make_tree_vec (n
);
590 for (i
= 1; i
<= n
; ++i
)
591 SET_TMPL_ARGS_LEVEL (new_args
, i
,
592 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
597 /* The inverse of get_innermost_template_args: Return all but the innermost
598 EXTRA_LEVELS levels of template arguments from the ARGS. */
601 strip_innermost_template_args (tree args
, int extra_levels
)
604 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
609 /* If N is 1, just return the outermost set of template arguments. */
611 return TMPL_ARGS_LEVEL (args
, 1);
613 /* If we're not removing anything, just return the arguments we were
615 gcc_assert (extra_levels
>= 0);
616 if (extra_levels
== 0)
619 /* Make a new set of arguments, not containing the inner arguments. */
620 new_args
= make_tree_vec (n
);
621 for (i
= 1; i
<= n
; ++i
)
622 SET_TMPL_ARGS_LEVEL (new_args
, i
,
623 TMPL_ARGS_LEVEL (args
, i
));
628 /* We've got a template header coming up; push to a new level for storing
632 begin_template_parm_list (void)
634 /* We use a non-tag-transparent scope here, which causes pushtag to
635 put tags in this scope, rather than in the enclosing class or
636 namespace scope. This is the right thing, since we want
637 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
638 global template class, push_template_decl handles putting the
639 TEMPLATE_DECL into top-level scope. For a nested template class,
642 template <class T> struct S1 {
643 template <class T> struct S2 {};
646 pushtag contains special code to call pushdecl_with_scope on the
647 TEMPLATE_DECL for S2. */
648 begin_scope (sk_template_parms
, NULL
);
649 ++processing_template_decl
;
650 ++processing_template_parmlist
;
651 note_template_header (0);
654 /* This routine is called when a specialization is declared. If it is
655 invalid to declare a specialization here, an error is reported and
656 false is returned, otherwise this routine will return true. */
659 check_specialization_scope (void)
661 tree scope
= current_scope ();
665 An explicit specialization shall be declared in the namespace of
666 which the template is a member, or, for member templates, in the
667 namespace of which the enclosing class or enclosing class
668 template is a member. An explicit specialization of a member
669 function, member class or static data member of a class template
670 shall be declared in the namespace of which the class template
672 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
674 error ("explicit specialization in non-namespace scope %qD", scope
);
680 In an explicit specialization declaration for a member of a class
681 template or a member template that appears in namespace scope,
682 the member template and some of its enclosing class templates may
683 remain unspecialized, except that the declaration shall not
684 explicitly specialize a class member template if its enclosing
685 class templates are not explicitly specialized as well. */
686 if (current_template_parms
)
688 error ("enclosing class templates are not explicitly specialized");
695 /* We've just seen template <>. */
698 begin_specialization (void)
700 begin_scope (sk_template_spec
, NULL
);
701 note_template_header (1);
702 return check_specialization_scope ();
705 /* Called at then end of processing a declaration preceded by
709 end_specialization (void)
712 reset_specialization ();
715 /* Any template <>'s that we have seen thus far are not referring to a
716 function specialization. */
719 reset_specialization (void)
721 processing_specialization
= 0;
722 template_header_count
= 0;
725 /* We've just seen a template header. If SPECIALIZATION is nonzero,
726 it was of the form template <>. */
729 note_template_header (int specialization
)
731 processing_specialization
= specialization
;
732 template_header_count
++;
735 /* We're beginning an explicit instantiation. */
738 begin_explicit_instantiation (void)
740 gcc_assert (!processing_explicit_instantiation
);
741 processing_explicit_instantiation
= true;
746 end_explicit_instantiation (void)
748 gcc_assert (processing_explicit_instantiation
);
749 processing_explicit_instantiation
= false;
752 /* An explicit specialization or partial specialization of TMPL is being
753 declared. Check that the namespace in which the specialization is
754 occurring is permissible. Returns false iff it is invalid to
755 specialize TMPL in the current namespace. */
758 check_specialization_namespace (tree tmpl
)
760 tree tpl_ns
= decl_namespace_context (tmpl
);
764 An explicit specialization shall be declared in the namespace of
765 which the template is a member, or, for member templates, in the
766 namespace of which the enclosing class or enclosing class
767 template is a member. An explicit specialization of a member
768 function, member class or static data member of a class template
769 shall be declared in the namespace of which the class template is
771 if (current_scope() != DECL_CONTEXT (tmpl
)
772 && !at_namespace_scope_p ())
774 error ("specialization of %qD must appear at namespace scope", tmpl
);
777 if (is_associated_namespace (current_namespace
, tpl_ns
))
778 /* Same or super-using namespace. */
782 permerror (input_location
, "specialization of %qD in different namespace", tmpl
);
783 permerror (input_location
, " from definition of %q+#D", tmpl
);
788 /* SPEC is an explicit instantiation. Check that it is valid to
789 perform this explicit instantiation in the current namespace. */
792 check_explicit_instantiation_namespace (tree spec
)
796 /* DR 275: An explicit instantiation shall appear in an enclosing
797 namespace of its template. */
798 ns
= decl_namespace_context (spec
);
799 if (!is_ancestor (current_namespace
, ns
))
800 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
801 "(which does not enclose namespace %qD)",
802 spec
, current_namespace
, ns
);
805 /* The TYPE is being declared. If it is a template type, that means it
806 is a partial specialization. Do appropriate error-checking. */
809 maybe_process_partial_specialization (tree type
)
813 if (type
== error_mark_node
)
814 return error_mark_node
;
816 /* A lambda that appears in specialization context is not itself a
818 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
821 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
823 error ("name of class shadows template template parameter %qD",
825 return error_mark_node
;
828 context
= TYPE_CONTEXT (type
);
830 if (TYPE_ALIAS_P (type
))
832 if (TYPE_TEMPLATE_INFO (type
)
833 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type
)))
834 error ("specialization of alias template %qD",
835 TYPE_TI_TEMPLATE (type
));
837 error ("explicit specialization of non-template %qT", type
);
838 return error_mark_node
;
840 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
842 /* This is for ordinary explicit specialization and partial
843 specialization of a template class such as:
845 template <> class C<int>;
849 template <class T> class C<T*>;
851 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
853 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
854 && !COMPLETE_TYPE_P (type
))
856 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type
))
857 && !at_namespace_scope_p ())
858 return error_mark_node
;
859 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
860 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
861 if (processing_template_decl
)
863 if (push_template_decl (TYPE_MAIN_DECL (type
))
865 return error_mark_node
;
868 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
869 error ("specialization of %qT after instantiation", type
);
870 else if (errorcount
&& !processing_specialization
871 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
872 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
873 /* Trying to define a specialization either without a template<> header
874 or in an inappropriate place. We've already given an error, so just
875 bail now so we don't actually define the specialization. */
876 return error_mark_node
;
878 else if (CLASS_TYPE_P (type
)
879 && !CLASSTYPE_USE_TEMPLATE (type
)
880 && CLASSTYPE_TEMPLATE_INFO (type
)
881 && context
&& CLASS_TYPE_P (context
)
882 && CLASSTYPE_TEMPLATE_INFO (context
))
884 /* This is for an explicit specialization of member class
885 template according to [temp.expl.spec/18]:
887 template <> template <class U> class C<int>::D;
889 The context `C<int>' must be an implicit instantiation.
890 Otherwise this is just a member class template declared
893 template <> class C<int> { template <class U> class D; };
894 template <> template <class U> class C<int>::D;
896 In the first case, `C<int>::D' is a specialization of `C<T>::D'
897 while in the second case, `C<int>::D' is a primary template
898 and `C<T>::D' may not exist. */
900 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
901 && !COMPLETE_TYPE_P (type
))
904 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
906 if (current_namespace
907 != decl_namespace_context (tmpl
))
909 permerror (input_location
, "specializing %q#T in different namespace", type
);
910 permerror (input_location
, " from definition of %q+#D", tmpl
);
913 /* Check for invalid specialization after instantiation:
915 template <> template <> class C<int>::D<int>;
916 template <> template <class U> class C<int>::D; */
918 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
919 t
; t
= TREE_CHAIN (t
))
921 tree inst
= TREE_VALUE (t
);
922 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
923 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
925 /* We already have a full specialization of this partial
926 instantiation, or a full specialization has been
927 looked up but not instantiated. Reassign it to the
928 new member specialization template. */
933 elt
.tmpl
= most_general_template (tmpl
);
934 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
937 htab_remove_elt (type_specializations
, &elt
);
940 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
942 slot
= htab_find_slot (type_specializations
, &elt
, INSERT
);
943 entry
= ggc_alloc_spec_entry ();
948 /* But if we've had an implicit instantiation, that's a
949 problem ([temp.expl.spec]/6). */
950 error ("specialization %qT after instantiation %qT",
954 /* Mark TYPE as a specialization. And as a result, we only
955 have one level of template argument for the innermost
957 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
958 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
959 CLASSTYPE_TI_ARGS (type
)
960 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
963 else if (processing_specialization
)
965 /* Someday C++0x may allow for enum template specialization. */
966 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
967 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
968 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
969 "of %qD not allowed by ISO C++", type
);
972 error ("explicit specialization of non-template %qT", type
);
973 return error_mark_node
;
980 /* Returns nonzero if we can optimize the retrieval of specializations
981 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
982 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
985 optimize_specialization_lookup_p (tree tmpl
)
987 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
988 && DECL_CLASS_SCOPE_P (tmpl
)
989 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
991 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
992 /* The optimized lookup depends on the fact that the
993 template arguments for the member function template apply
994 purely to the containing class, which is not true if the
995 containing class is an explicit or partial
997 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
998 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
999 && !DECL_CONV_FN_P (tmpl
)
1000 /* It is possible to have a template that is not a member
1001 template and is not a member of a template class:
1003 template <typename T>
1004 struct S { friend A::f(); };
1006 Here, the friend function is a template, but the context does
1007 not have template information. The optimized lookup relies
1008 on having ARGS be the template arguments for both the class
1009 and the function template. */
1010 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1013 /* Retrieve the specialization (in the sense of [temp.spec] - a
1014 specialization is either an instantiation or an explicit
1015 specialization) of TMPL for the given template ARGS. If there is
1016 no such specialization, return NULL_TREE. The ARGS are a vector of
1017 arguments, or a vector of vectors of arguments, in the case of
1018 templates with more than one level of parameters.
1020 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1021 then we search for a partial specialization matching ARGS. This
1022 parameter is ignored if TMPL is not a class template.
1024 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1025 result is a NONTYPE_ARGUMENT_PACK. */
1028 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1030 if (tmpl
== NULL_TREE
)
1033 if (args
== error_mark_node
)
1036 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1037 || TREE_CODE (tmpl
) == FIELD_DECL
);
1039 /* There should be as many levels of arguments as there are
1040 levels of parameters. */
1041 gcc_assert (TMPL_ARGS_DEPTH (args
)
1042 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1043 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1044 : template_class_depth (DECL_CONTEXT (tmpl
))));
1046 if (optimize_specialization_lookup_p (tmpl
))
1048 tree class_template
;
1049 tree class_specialization
;
1050 vec
<tree
, va_gc
> *methods
;
1054 /* The template arguments actually apply to the containing
1055 class. Find the class specialization with those
1057 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1058 class_specialization
1059 = retrieve_specialization (class_template
, args
, 0);
1060 if (!class_specialization
)
1062 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1063 for the specialization. */
1064 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
1067 /* Iterate through the methods with the indicated name, looking
1068 for the one that has an instance of TMPL. */
1069 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
1070 for (fns
= (*methods
)[idx
]; fns
; fns
= OVL_NEXT (fns
))
1072 tree fn
= OVL_CURRENT (fns
);
1073 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1074 /* using-declarations can add base methods to the method vec,
1075 and we don't want those here. */
1076 && DECL_CONTEXT (fn
) == class_specialization
)
1085 htab_t specializations
;
1089 elt
.spec
= NULL_TREE
;
1091 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1092 specializations
= type_specializations
;
1094 specializations
= decl_specializations
;
1097 hash
= hash_specialization (&elt
);
1098 found
= (spec_entry
*) htab_find_with_hash (specializations
, &elt
, hash
);
1106 /* Like retrieve_specialization, but for local declarations. */
1109 retrieve_local_specialization (tree tmpl
)
1113 if (local_specializations
== NULL
)
1116 slot
= pointer_map_contains (local_specializations
, tmpl
);
1117 return slot
? (tree
) *slot
: NULL_TREE
;
1120 /* Returns nonzero iff DECL is a specialization of TMPL. */
1123 is_specialization_of (tree decl
, tree tmpl
)
1127 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1131 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1137 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1139 for (t
= TREE_TYPE (decl
);
1141 t
= CLASSTYPE_USE_TEMPLATE (t
)
1142 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1143 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1150 /* Returns nonzero iff DECL is a specialization of friend declaration
1151 FRIEND_DECL according to [temp.friend]. */
1154 is_specialization_of_friend (tree decl
, tree friend_decl
)
1156 bool need_template
= true;
1159 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1160 || TREE_CODE (decl
) == TYPE_DECL
);
1162 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1163 of a template class, we want to check if DECL is a specialization
1165 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1166 && DECL_TEMPLATE_INFO (friend_decl
)
1167 && !DECL_USE_TEMPLATE (friend_decl
))
1169 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1170 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1171 need_template
= false;
1173 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1174 && !PRIMARY_TEMPLATE_P (friend_decl
))
1175 need_template
= false;
1177 /* There is nothing to do if this is not a template friend. */
1178 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1181 if (is_specialization_of (decl
, friend_decl
))
1185 A member of a class template may be declared to be a friend of a
1186 non-template class. In this case, the corresponding member of
1187 every specialization of the class template is a friend of the
1188 class granting friendship.
1190 For example, given a template friend declaration
1192 template <class T> friend void A<T>::f();
1194 the member function below is considered a friend
1196 template <> struct A<int> {
1200 For this type of template friend, TEMPLATE_DEPTH below will be
1201 nonzero. To determine if DECL is a friend of FRIEND, we first
1202 check if the enclosing class is a specialization of another. */
1204 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1206 && DECL_CLASS_SCOPE_P (decl
)
1207 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1208 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1210 /* Next, we check the members themselves. In order to handle
1211 a few tricky cases, such as when FRIEND_DECL's are
1213 template <class T> friend void A<T>::g(T t);
1214 template <class T> template <T t> friend void A<T>::h();
1218 void A<int>::g(int);
1219 template <int> void A<int>::h();
1221 we need to figure out ARGS, the template arguments from
1222 the context of DECL. This is required for template substitution
1223 of `T' in the function parameter of `g' and template parameter
1224 of `h' in the above examples. Here ARGS corresponds to `int'. */
1226 tree context
= DECL_CONTEXT (decl
);
1227 tree args
= NULL_TREE
;
1228 int current_depth
= 0;
1230 while (current_depth
< template_depth
)
1232 if (CLASSTYPE_TEMPLATE_INFO (context
))
1234 if (current_depth
== 0)
1235 args
= TYPE_TI_ARGS (context
);
1237 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1240 context
= TYPE_CONTEXT (context
);
1243 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1248 tree friend_args_type
;
1249 tree decl_args_type
;
1251 /* Make sure that both DECL and FRIEND_DECL are templates or
1253 is_template
= DECL_TEMPLATE_INFO (decl
)
1254 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1255 if (need_template
^ is_template
)
1257 else if (is_template
)
1259 /* If both are templates, check template parameter list. */
1261 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1263 if (!comp_template_parms
1264 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1268 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1271 decl_type
= TREE_TYPE (decl
);
1273 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1274 tf_none
, NULL_TREE
);
1275 if (friend_type
== error_mark_node
)
1278 /* Check if return types match. */
1279 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1282 /* Check if function parameter types match, ignoring the
1283 `this' parameter. */
1284 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1285 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1286 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1287 friend_args_type
= TREE_CHAIN (friend_args_type
);
1288 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1289 decl_args_type
= TREE_CHAIN (decl_args_type
);
1291 return compparms (decl_args_type
, friend_args_type
);
1295 /* DECL is a TYPE_DECL */
1297 tree decl_type
= TREE_TYPE (decl
);
1299 /* Make sure that both DECL and FRIEND_DECL are templates or
1302 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1303 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1305 if (need_template
^ is_template
)
1307 else if (is_template
)
1310 /* If both are templates, check the name of the two
1311 TEMPLATE_DECL's first because is_friend didn't. */
1312 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1313 != DECL_NAME (friend_decl
))
1316 /* Now check template parameter list. */
1318 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1320 return comp_template_parms
1321 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1325 return (DECL_NAME (decl
)
1326 == DECL_NAME (friend_decl
));
1332 /* Register the specialization SPEC as a specialization of TMPL with
1333 the indicated ARGS. IS_FRIEND indicates whether the specialization
1334 is actually just a friend declaration. Returns SPEC, or an
1335 equivalent prior declaration, if available.
1337 We also store instantiations of field packs in the hash table, even
1338 though they are not themselves templates, to make lookup easier. */
1341 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1348 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1349 || (TREE_CODE (tmpl
) == FIELD_DECL
1350 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1352 if (TREE_CODE (spec
) == FUNCTION_DECL
1353 && uses_template_parms (DECL_TI_ARGS (spec
)))
1354 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1355 register it; we want the corresponding TEMPLATE_DECL instead.
1356 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1357 the more obvious `uses_template_parms (spec)' to avoid problems
1358 with default function arguments. In particular, given
1359 something like this:
1361 template <class T> void f(T t1, T t = T())
1363 the default argument expression is not substituted for in an
1364 instantiation unless and until it is actually needed. */
1367 if (optimize_specialization_lookup_p (tmpl
))
1368 /* We don't put these specializations in the hash table, but we might
1369 want to give an error about a mismatch. */
1370 fn
= retrieve_specialization (tmpl
, args
, 0);
1378 hash
= hash_specialization (&elt
);
1381 htab_find_slot_with_hash (decl_specializations
, &elt
, hash
, INSERT
);
1383 fn
= ((spec_entry
*) *slot
)->spec
;
1388 /* We can sometimes try to re-register a specialization that we've
1389 already got. In particular, regenerate_decl_from_template calls
1390 duplicate_decls which will update the specialization list. But,
1391 we'll still get called again here anyhow. It's more convenient
1392 to simply allow this than to try to prevent it. */
1395 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1397 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1399 if (DECL_ODR_USED (fn
)
1400 || DECL_EXPLICIT_INSTANTIATION (fn
))
1402 error ("specialization of %qD after instantiation",
1404 return error_mark_node
;
1409 /* This situation should occur only if the first
1410 specialization is an implicit instantiation, the
1411 second is an explicit specialization, and the
1412 implicit instantiation has not yet been used. That
1413 situation can occur if we have implicitly
1414 instantiated a member function and then specialized
1417 We can also wind up here if a friend declaration that
1418 looked like an instantiation turns out to be a
1421 template <class T> void foo(T);
1422 class S { friend void foo<>(int) };
1423 template <> void foo(int);
1425 We transform the existing DECL in place so that any
1426 pointers to it become pointers to the updated
1429 If there was a definition for the template, but not
1430 for the specialization, we want this to look as if
1431 there were no definition, and vice versa. */
1432 DECL_INITIAL (fn
) = NULL_TREE
;
1433 duplicate_decls (spec
, fn
, is_friend
);
1434 /* The call to duplicate_decls will have applied
1437 An explicit specialization of a function template
1438 is inline only if it is explicitly declared to be,
1439 and independently of whether its function template
1442 to the primary function; now copy the inline bits to
1443 the various clones. */
1444 FOR_EACH_CLONE (clone
, fn
)
1446 DECL_DECLARED_INLINE_P (clone
)
1447 = DECL_DECLARED_INLINE_P (fn
);
1448 DECL_SOURCE_LOCATION (clone
)
1449 = DECL_SOURCE_LOCATION (fn
);
1450 DECL_DELETED_FN (clone
)
1451 = DECL_DELETED_FN (fn
);
1453 check_specialization_namespace (tmpl
);
1458 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1460 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1461 /* Dup decl failed, but this is a new definition. Set the
1462 line number so any errors match this new
1464 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1470 return duplicate_decls (spec
, fn
, is_friend
);
1472 /* A specialization must be declared in the same namespace as the
1473 template it is specializing. */
1474 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1475 && !check_specialization_namespace (tmpl
))
1476 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1478 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1480 spec_entry
*entry
= ggc_alloc_spec_entry ();
1481 gcc_assert (tmpl
&& args
&& spec
);
1484 if (TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1485 && PRIMARY_TEMPLATE_P (tmpl
)
1486 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1487 /* TMPL is a forward declaration of a template function; keep a list
1488 of all specializations in case we need to reassign them to a friend
1489 template later in tsubst_friend_function. */
1490 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1491 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1497 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1498 TMPL and ARGS members, ignores SPEC. */
1500 int comparing_specializations
;
1503 eq_specializations (const void *p1
, const void *p2
)
1505 const spec_entry
*e1
= (const spec_entry
*)p1
;
1506 const spec_entry
*e2
= (const spec_entry
*)p2
;
1509 ++comparing_specializations
;
1510 equal
= (e1
->tmpl
== e2
->tmpl
1511 && comp_template_args (e1
->args
, e2
->args
));
1512 --comparing_specializations
;
1517 /* Returns a hash for a template TMPL and template arguments ARGS. */
1520 hash_tmpl_and_args (tree tmpl
, tree args
)
1522 hashval_t val
= DECL_UID (tmpl
);
1523 return iterative_hash_template_arg (args
, val
);
1526 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1530 hash_specialization (const void *p
)
1532 const spec_entry
*e
= (const spec_entry
*)p
;
1533 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1536 /* Recursively calculate a hash value for a template argument ARG, for use
1537 in the hash tables of template specializations. */
1540 iterative_hash_template_arg (tree arg
, hashval_t val
)
1542 unsigned HOST_WIDE_INT i
;
1543 enum tree_code code
;
1546 if (arg
== NULL_TREE
)
1547 return iterative_hash_object (arg
, val
);
1552 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1553 /* We can get one of these when re-hashing a previous entry in the middle
1554 of substituting into a pack expansion. Just look through it. */
1555 arg
= ARGUMENT_PACK_SELECT_FROM_PACK (arg
);
1557 code
= TREE_CODE (arg
);
1558 tclass
= TREE_CODE_CLASS (code
);
1560 val
= iterative_hash_object (code
, val
);
1567 case IDENTIFIER_NODE
:
1568 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1572 int i
, len
= TREE_VEC_LENGTH (arg
);
1573 for (i
= 0; i
< len
; ++i
)
1574 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1578 case TYPE_PACK_EXPANSION
:
1579 case EXPR_PACK_EXPANSION
:
1580 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1581 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1583 case TYPE_ARGUMENT_PACK
:
1584 case NONTYPE_ARGUMENT_PACK
:
1585 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1588 for (; arg
; arg
= TREE_CHAIN (arg
))
1589 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1593 for (; arg
; arg
= OVL_NEXT (arg
))
1594 val
= iterative_hash_template_arg (OVL_CURRENT (arg
), val
);
1600 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1602 val
= iterative_hash_template_arg (field
, val
);
1603 val
= iterative_hash_template_arg (value
, val
);
1609 if (!DECL_ARTIFICIAL (arg
))
1611 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1612 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1614 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1617 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1620 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1621 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1623 case TEMPLATE_PARM_INDEX
:
1624 val
= iterative_hash_template_arg
1625 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1626 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1627 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1630 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1631 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1632 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1635 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1637 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1641 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1642 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1643 val
= iterative_hash_object (code
, val
);
1644 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1647 /* A lambda can't appear in a template arg, but don't crash on
1649 gcc_assert (seen_error ());
1653 case IMPLICIT_CONV_EXPR
:
1654 case STATIC_CAST_EXPR
:
1655 case REINTERPRET_CAST_EXPR
:
1656 case CONST_CAST_EXPR
:
1657 case DYNAMIC_CAST_EXPR
:
1659 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1660 /* Now hash operands as usual. */
1670 if (TYPE_CANONICAL (arg
))
1671 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1673 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1674 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1675 /* Otherwise just compare the types during lookup. */
1678 case tcc_declaration
:
1680 return iterative_hash_expr (arg
, val
);
1683 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1685 unsigned n
= cp_tree_operand_length (arg
);
1686 for (i
= 0; i
< n
; ++i
)
1687 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1695 /* Unregister the specialization SPEC as a specialization of TMPL.
1696 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1697 if the SPEC was listed as a specialization of TMPL.
1699 Note that SPEC has been ggc_freed, so we can't look inside it. */
1702 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1707 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1708 elt
.args
= TI_ARGS (tinfo
);
1709 elt
.spec
= NULL_TREE
;
1711 entry
= (spec_entry
*) htab_find (decl_specializations
, &elt
);
1714 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1715 gcc_assert (new_spec
!= NULL_TREE
);
1716 entry
->spec
= new_spec
;
1723 /* Like register_specialization, but for local declarations. We are
1724 registering SPEC, an instantiation of TMPL. */
1727 register_local_specialization (tree spec
, tree tmpl
)
1731 slot
= pointer_map_insert (local_specializations
, tmpl
);
1735 /* TYPE is a class type. Returns true if TYPE is an explicitly
1736 specialized class. */
1739 explicit_class_specialization_p (tree type
)
1741 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1743 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1746 /* Print the list of functions at FNS, going through all the overloads
1747 for each element of the list. Alternatively, FNS can not be a
1748 TREE_LIST, in which case it will be printed together with all the
1751 MORE and *STR should respectively be FALSE and NULL when the function
1752 is called from the outside. They are used internally on recursive
1753 calls. print_candidates manages the two parameters and leaves NULL
1754 in *STR when it ends. */
1757 print_candidates_1 (tree fns
, bool more
, const char **str
)
1760 char *spaces
= NULL
;
1762 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
1763 if (TREE_CODE (fn
) == TREE_LIST
)
1765 for (fn2
= fn
; fn2
!= NULL_TREE
; fn2
= TREE_CHAIN (fn2
))
1766 print_candidates_1 (TREE_VALUE (fn2
),
1767 TREE_CHAIN (fn2
) || more
, str
);
1771 tree cand
= OVL_CURRENT (fn
);
1774 /* Pick the prefix string. */
1775 if (!more
&& !OVL_NEXT (fns
))
1777 inform (DECL_SOURCE_LOCATION (cand
),
1778 "candidate is: %#D", cand
);
1782 *str
= _("candidates are:");
1783 spaces
= get_spaces (*str
);
1785 inform (DECL_SOURCE_LOCATION (cand
), "%s %#D", *str
, cand
);
1786 *str
= spaces
? spaces
: *str
;
1796 /* Print the list of candidate FNS in an error message. FNS can also
1797 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1800 print_candidates (tree fns
)
1802 const char *str
= NULL
;
1803 print_candidates_1 (fns
, false, &str
);
1804 gcc_assert (str
== NULL
);
1807 /* Returns the template (one of the functions given by TEMPLATE_ID)
1808 which can be specialized to match the indicated DECL with the
1809 explicit template args given in TEMPLATE_ID. The DECL may be
1810 NULL_TREE if none is available. In that case, the functions in
1811 TEMPLATE_ID are non-members.
1813 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1814 specialization of a member template.
1816 The TEMPLATE_COUNT is the number of references to qualifying
1817 template classes that appeared in the name of the function. See
1818 check_explicit_specialization for a more accurate description.
1820 TSK indicates what kind of template declaration (if any) is being
1821 declared. TSK_TEMPLATE indicates that the declaration given by
1822 DECL, though a FUNCTION_DECL, has template parameters, and is
1823 therefore a template function.
1825 The template args (those explicitly specified and those deduced)
1826 are output in a newly created vector *TARGS_OUT.
1828 If it is impossible to determine the result, an error message is
1829 issued. The error_mark_node is returned to indicate failure. */
1832 determine_specialization (tree template_id
,
1835 int need_member_template
,
1841 tree explicit_targs
;
1842 tree candidates
= NULL_TREE
;
1843 /* A TREE_LIST of templates of which DECL may be a specialization.
1844 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1845 corresponding TREE_PURPOSE is the set of template arguments that,
1846 when used to instantiate the template, would produce a function
1847 with the signature of DECL. */
1848 tree templates
= NULL_TREE
;
1850 cp_binding_level
*b
;
1852 *targs_out
= NULL_TREE
;
1854 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
1855 return error_mark_node
;
1857 /* We shouldn't be specializing a member template of an
1858 unspecialized class template; we already gave an error in
1859 check_specialization_scope, now avoid crashing. */
1860 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
1861 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
1863 gcc_assert (errorcount
);
1864 return error_mark_node
;
1867 fns
= TREE_OPERAND (template_id
, 0);
1868 explicit_targs
= TREE_OPERAND (template_id
, 1);
1870 if (fns
== error_mark_node
)
1871 return error_mark_node
;
1873 /* Check for baselinks. */
1874 if (BASELINK_P (fns
))
1875 fns
= BASELINK_FUNCTIONS (fns
);
1877 if (!is_overloaded_fn (fns
))
1879 error ("%qD is not a function template", fns
);
1880 return error_mark_node
;
1883 /* Count the number of template headers specified for this
1886 for (b
= current_binding_level
;
1887 b
->kind
== sk_template_parms
;
1891 for (; fns
; fns
= OVL_NEXT (fns
))
1893 tree fn
= OVL_CURRENT (fns
);
1895 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1897 tree decl_arg_types
;
1901 /* In case of explicit specialization, we need to check if
1902 the number of template headers appearing in the specialization
1903 is correct. This is usually done in check_explicit_specialization,
1904 but the check done there cannot be exhaustive when specializing
1905 member functions. Consider the following code:
1907 template <> void A<int>::f(int);
1908 template <> template <> void A<int>::f(int);
1910 Assuming that A<int> is not itself an explicit specialization
1911 already, the first line specializes "f" which is a non-template
1912 member function, whilst the second line specializes "f" which
1913 is a template member function. So both lines are syntactically
1914 correct, and check_explicit_specialization does not reject
1917 Here, we can do better, as we are matching the specialization
1918 against the declarations. We count the number of template
1919 headers, and we check if they match TEMPLATE_COUNT + 1
1920 (TEMPLATE_COUNT is the number of qualifying template classes,
1921 plus there must be another header for the member template
1924 Notice that if header_count is zero, this is not a
1925 specialization but rather a template instantiation, so there
1926 is no check we can perform here. */
1927 if (header_count
&& header_count
!= template_count
+ 1)
1930 /* Check that the number of template arguments at the
1931 innermost level for DECL is the same as for FN. */
1932 if (current_binding_level
->kind
== sk_template_parms
1933 && !current_binding_level
->explicit_spec_p
1934 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
1935 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1936 (current_template_parms
))))
1939 /* DECL might be a specialization of FN. */
1940 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1941 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1943 /* For a non-static member function, we need to make sure
1944 that the const qualification is the same. Since
1945 get_bindings does not try to merge the "this" parameter,
1946 we must do the comparison explicitly. */
1947 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1948 && !same_type_p (TREE_VALUE (fn_arg_types
),
1949 TREE_VALUE (decl_arg_types
)))
1952 /* Skip the "this" parameter and, for constructors of
1953 classes with virtual bases, the VTT parameter. A
1954 full specialization of a constructor will have a VTT
1955 parameter, but a template never will. */
1957 = skip_artificial_parms_for (decl
, decl_arg_types
);
1959 = skip_artificial_parms_for (fn
, fn_arg_types
);
1961 /* Function templates cannot be specializations; there are
1962 no partial specializations of functions. Therefore, if
1963 the type of DECL does not match FN, there is no
1965 if (tsk
== tsk_template
)
1967 if (compparms (fn_arg_types
, decl_arg_types
))
1968 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1972 /* See whether this function might be a specialization of this
1973 template. Suppress access control because we might be trying
1974 to make this specialization a friend, and we have already done
1975 access control for the declaration of the specialization. */
1976 push_deferring_access_checks (dk_no_check
);
1977 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
1978 pop_deferring_access_checks ();
1981 /* We cannot deduce template arguments that when used to
1982 specialize TMPL will produce DECL. */
1985 /* Make sure that the deduced arguments actually work. */
1986 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
);
1987 if (insttype
== error_mark_node
)
1990 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
1991 if (!compparms (fn_arg_types
, decl_arg_types
))
1994 /* Save this template, and the arguments deduced. */
1995 templates
= tree_cons (targs
, fn
, templates
);
1997 else if (need_member_template
)
1998 /* FN is an ordinary member function, and we need a
1999 specialization of a member template. */
2001 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2002 /* We can get IDENTIFIER_NODEs here in certain erroneous
2005 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2006 /* This is just an ordinary non-member function. Nothing can
2007 be a specialization of that. */
2009 else if (DECL_ARTIFICIAL (fn
))
2010 /* Cannot specialize functions that are created implicitly. */
2014 tree decl_arg_types
;
2016 /* This is an ordinary member function. However, since
2017 we're here, we can assume its enclosing class is a
2018 template class. For example,
2020 template <typename T> struct S { void f(); };
2021 template <> void S<int>::f() {}
2023 Here, S<int>::f is a non-template, but S<int> is a
2024 template class. If FN has the same type as DECL, we
2025 might be in business. */
2027 if (!DECL_TEMPLATE_INFO (fn
))
2028 /* Its enclosing class is an explicit specialization
2029 of a template class. This is not a candidate. */
2032 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2033 TREE_TYPE (TREE_TYPE (fn
))))
2034 /* The return types differ. */
2037 /* Adjust the type of DECL in case FN is a static member. */
2038 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2039 if (DECL_STATIC_FUNCTION_P (fn
)
2040 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2041 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2043 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2046 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2050 if (templates
&& TREE_CHAIN (templates
))
2056 It is possible for a specialization with a given function
2057 signature to be instantiated from more than one function
2058 template. In such cases, explicit specification of the
2059 template arguments must be used to uniquely identify the
2060 function template specialization being specialized.
2062 Note that here, there's no suggestion that we're supposed to
2063 determine which of the candidate templates is most
2064 specialized. However, we, also have:
2068 Partial ordering of overloaded function template
2069 declarations is used in the following contexts to select
2070 the function template to which a function template
2071 specialization refers:
2073 -- when an explicit specialization refers to a function
2076 So, we do use the partial ordering rules, at least for now.
2077 This extension can only serve to make invalid programs valid,
2078 so it's safe. And, there is strong anecdotal evidence that
2079 the committee intended the partial ordering rules to apply;
2080 the EDG front end has that behavior, and John Spicer claims
2081 that the committee simply forgot to delete the wording in
2082 [temp.expl.spec]. */
2083 tree tmpl
= most_specialized_instantiation (templates
);
2084 if (tmpl
!= error_mark_node
)
2087 TREE_CHAIN (templates
) = NULL_TREE
;
2091 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2093 error ("template-id %qD for %q+D does not match any template "
2094 "declaration", template_id
, decl
);
2095 if (header_count
&& header_count
!= template_count
+ 1)
2096 inform (input_location
, "saw %d %<template<>%>, need %d for "
2097 "specializing a member function template",
2098 header_count
, template_count
+ 1);
2099 return error_mark_node
;
2101 else if ((templates
&& TREE_CHAIN (templates
))
2102 || (candidates
&& TREE_CHAIN (candidates
))
2103 || (templates
&& candidates
))
2105 error ("ambiguous template specialization %qD for %q+D",
2107 candidates
= chainon (candidates
, templates
);
2108 print_candidates (candidates
);
2109 return error_mark_node
;
2112 /* We have one, and exactly one, match. */
2115 tree fn
= TREE_VALUE (candidates
);
2116 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2117 /* DECL is a re-declaration or partial instantiation of a template
2119 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2121 /* It was a specialization of an ordinary member function in a
2123 return DECL_TI_TEMPLATE (fn
);
2126 /* It was a specialization of a template. */
2127 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2128 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2130 *targs_out
= copy_node (targs
);
2131 SET_TMPL_ARGS_LEVEL (*targs_out
,
2132 TMPL_ARGS_DEPTH (*targs_out
),
2133 TREE_PURPOSE (templates
));
2136 *targs_out
= TREE_PURPOSE (templates
);
2137 return TREE_VALUE (templates
);
2140 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2141 but with the default argument values filled in from those in the
2145 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2148 tree new_spec_types
;
2153 if (spec_types
== void_list_node
)
2154 return void_list_node
;
2156 /* Substitute into the rest of the list. */
2158 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2159 TREE_CHAIN (tmpl_types
));
2161 /* Add the default argument for this parameter. */
2162 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2163 TREE_VALUE (spec_types
),
2167 /* DECL is an explicit specialization. Replicate default arguments
2168 from the template it specializes. (That way, code like:
2170 template <class T> void f(T = 3);
2171 template <> void f(double);
2174 works, as required.) An alternative approach would be to look up
2175 the correct default arguments at the call-site, but this approach
2176 is consistent with how implicit instantiations are handled. */
2179 copy_default_args_to_explicit_spec (tree decl
)
2184 tree new_spec_types
;
2188 tree object_type
= NULL_TREE
;
2189 tree in_charge
= NULL_TREE
;
2190 tree vtt
= NULL_TREE
;
2192 /* See if there's anything we need to do. */
2193 tmpl
= DECL_TI_TEMPLATE (decl
);
2194 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2195 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2196 if (TREE_PURPOSE (t
))
2201 old_type
= TREE_TYPE (decl
);
2202 spec_types
= TYPE_ARG_TYPES (old_type
);
2204 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2206 /* Remove the this pointer, but remember the object's type for
2208 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2209 spec_types
= TREE_CHAIN (spec_types
);
2210 tmpl_types
= TREE_CHAIN (tmpl_types
);
2212 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2214 /* DECL may contain more parameters than TMPL due to the extra
2215 in-charge parameter in constructors and destructors. */
2216 in_charge
= spec_types
;
2217 spec_types
= TREE_CHAIN (spec_types
);
2219 if (DECL_HAS_VTT_PARM_P (decl
))
2222 spec_types
= TREE_CHAIN (spec_types
);
2226 /* Compute the merged default arguments. */
2228 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2230 /* Compute the new FUNCTION_TYPE. */
2234 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2239 /* Put the in-charge parameter back. */
2240 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2241 TREE_VALUE (in_charge
),
2244 new_type
= build_method_type_directly (object_type
,
2245 TREE_TYPE (old_type
),
2249 new_type
= build_function_type (TREE_TYPE (old_type
),
2251 new_type
= cp_build_type_attribute_variant (new_type
,
2252 TYPE_ATTRIBUTES (old_type
));
2253 new_type
= build_exception_variant (new_type
,
2254 TYPE_RAISES_EXCEPTIONS (old_type
));
2255 TREE_TYPE (decl
) = new_type
;
2258 /* Return the number of template headers we expect to see for a definition
2259 or specialization of CTYPE or one of its non-template members. */
2262 num_template_headers_for_class (tree ctype
)
2264 int num_templates
= 0;
2266 while (ctype
&& CLASS_TYPE_P (ctype
))
2268 /* You're supposed to have one `template <...>' for every
2269 template class, but you don't need one for a full
2270 specialization. For example:
2272 template <class T> struct S{};
2273 template <> struct S<int> { void f(); };
2274 void S<int>::f () {}
2276 is correct; there shouldn't be a `template <>' for the
2277 definition of `S<int>::f'. */
2278 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2279 /* If CTYPE does not have template information of any
2280 kind, then it is not a template, nor is it nested
2281 within a template. */
2283 if (explicit_class_specialization_p (ctype
))
2285 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2288 ctype
= TYPE_CONTEXT (ctype
);
2291 return num_templates
;
2294 /* Do a simple sanity check on the template headers that precede the
2295 variable declaration DECL. */
2298 check_template_variable (tree decl
)
2300 tree ctx
= CP_DECL_CONTEXT (decl
);
2301 int wanted
= num_template_headers_for_class (ctx
);
2302 if (!TYPE_P (ctx
) || !CLASSTYPE_TEMPLATE_INFO (ctx
))
2303 permerror (DECL_SOURCE_LOCATION (decl
),
2304 "%qD is not a static data member of a class template", decl
);
2305 else if (template_header_count
> wanted
)
2307 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2308 "too many template headers for %D (should be %d)",
2310 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2311 inform (DECL_SOURCE_LOCATION (decl
),
2312 "members of an explicitly specialized class are defined "
2313 "without a template header");
2317 /* Check to see if the function just declared, as indicated in
2318 DECLARATOR, and in DECL, is a specialization of a function
2319 template. We may also discover that the declaration is an explicit
2320 instantiation at this point.
2322 Returns DECL, or an equivalent declaration that should be used
2323 instead if all goes well. Issues an error message if something is
2324 amiss. Returns error_mark_node if the error is not easily
2327 FLAGS is a bitmask consisting of the following flags:
2329 2: The function has a definition.
2330 4: The function is a friend.
2332 The TEMPLATE_COUNT is the number of references to qualifying
2333 template classes that appeared in the name of the function. For
2336 template <class T> struct S { void f(); };
2339 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2340 classes are not counted in the TEMPLATE_COUNT, so that in
2342 template <class T> struct S {};
2343 template <> struct S<int> { void f(); }
2344 template <> void S<int>::f();
2346 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2347 invalid; there should be no template <>.)
2349 If the function is a specialization, it is marked as such via
2350 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2351 is set up correctly, and it is added to the list of specializations
2352 for that template. */
2355 check_explicit_specialization (tree declarator
,
2360 int have_def
= flags
& 2;
2361 int is_friend
= flags
& 4;
2362 int specialization
= 0;
2363 int explicit_instantiation
= 0;
2364 int member_specialization
= 0;
2365 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2366 tree dname
= DECL_NAME (decl
);
2371 if (!processing_specialization
)
2374 tsk
= tsk_excessive_parms
;
2377 tsk
= current_tmpl_spec_kind (template_count
);
2382 if (processing_specialization
)
2385 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2387 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2390 /* This could be something like:
2392 template <class T> void f(T);
2393 class S { friend void f<>(int); } */
2397 /* This case handles bogus declarations like template <>
2398 template <class T> void f<int>(); */
2400 error ("template-id %qD in declaration of primary template",
2407 case tsk_invalid_member_spec
:
2408 /* The error has already been reported in
2409 check_specialization_scope. */
2410 return error_mark_node
;
2412 case tsk_invalid_expl_inst
:
2413 error ("template parameter list used in explicit instantiation");
2419 error ("definition provided for explicit instantiation");
2421 explicit_instantiation
= 1;
2424 case tsk_excessive_parms
:
2425 case tsk_insufficient_parms
:
2426 if (tsk
== tsk_excessive_parms
)
2427 error ("too many template parameter lists in declaration of %qD",
2429 else if (template_header_count
)
2430 error("too few template parameter lists in declaration of %qD", decl
);
2432 error("explicit specialization of %qD must be introduced by "
2433 "%<template <>%>", decl
);
2437 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2439 member_specialization
= 1;
2445 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2447 /* This case handles bogus declarations like template <>
2448 template <class T> void f<int>(); */
2450 if (uses_template_parms (declarator
))
2451 error ("function template partial specialization %qD "
2452 "is not allowed", declarator
);
2454 error ("template-id %qD in declaration of primary template",
2459 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2460 /* This is a specialization of a member template, without
2461 specialization the containing class. Something like:
2463 template <class T> struct S {
2464 template <class U> void f (U);
2466 template <> template <class U> void S<int>::f(U) {}
2468 That's a specialization -- but of the entire template. */
2476 if (specialization
|| member_specialization
)
2478 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2479 for (; t
; t
= TREE_CHAIN (t
))
2480 if (TREE_PURPOSE (t
))
2482 permerror (input_location
,
2483 "default argument specified in explicit specialization");
2488 if (specialization
|| member_specialization
|| explicit_instantiation
)
2490 tree tmpl
= NULL_TREE
;
2491 tree targs
= NULL_TREE
;
2493 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2494 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2498 gcc_assert (identifier_p (declarator
));
2503 /* If there is no class context, the explicit instantiation
2504 must be at namespace scope. */
2505 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2507 /* Find the namespace binding, using the declaration
2509 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2511 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2513 error ("%qD is not a template function", dname
);
2514 fns
= error_mark_node
;
2518 tree fn
= OVL_CURRENT (fns
);
2519 if (!is_associated_namespace (CP_DECL_CONTEXT (decl
),
2520 CP_DECL_CONTEXT (fn
)))
2521 error ("%qD is not declared in %qD",
2522 decl
, current_namespace
);
2526 declarator
= lookup_template_function (fns
, NULL_TREE
);
2529 if (declarator
== error_mark_node
)
2530 return error_mark_node
;
2532 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2534 if (!explicit_instantiation
)
2535 /* A specialization in class scope. This is invalid,
2536 but the error will already have been flagged by
2537 check_specialization_scope. */
2538 return error_mark_node
;
2541 /* It's not valid to write an explicit instantiation in
2544 class C { template void f(); }
2546 This case is caught by the parser. However, on
2549 template class C { void f(); };
2551 (which is invalid) we can get here. The error will be
2558 else if (ctype
!= NULL_TREE
2559 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2561 /* Find the list of functions in ctype that have the same
2562 name as the declared function. */
2563 tree name
= TREE_OPERAND (declarator
, 0);
2564 tree fns
= NULL_TREE
;
2567 if (constructor_name_p (name
, ctype
))
2569 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2571 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2572 : !CLASSTYPE_DESTRUCTORS (ctype
))
2574 /* From [temp.expl.spec]:
2576 If such an explicit specialization for the member
2577 of a class template names an implicitly-declared
2578 special member function (clause _special_), the
2579 program is ill-formed.
2581 Similar language is found in [temp.explicit]. */
2582 error ("specialization of implicitly-declared special member function");
2583 return error_mark_node
;
2586 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2589 if (!DECL_CONV_FN_P (decl
))
2591 idx
= lookup_fnfields_1 (ctype
, name
);
2593 fns
= (*CLASSTYPE_METHOD_VEC (ctype
))[idx
];
2597 vec
<tree
, va_gc
> *methods
;
2600 /* For a type-conversion operator, we cannot do a
2601 name-based lookup. We might be looking for `operator
2602 int' which will be a specialization of `operator T'.
2603 So, we find *all* the conversion operators, and then
2604 select from them. */
2607 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2609 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2610 methods
->iterate (idx
, &ovl
);
2613 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2614 /* There are no more conversion functions. */
2617 /* Glue all these conversion functions together
2618 with those we already have. */
2619 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2620 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2624 if (fns
== NULL_TREE
)
2626 error ("no member function %qD declared in %qT", name
, ctype
);
2627 return error_mark_node
;
2630 TREE_OPERAND (declarator
, 0) = fns
;
2633 /* Figure out what exactly is being specialized at this point.
2634 Note that for an explicit instantiation, even one for a
2635 member function, we cannot tell apriori whether the
2636 instantiation is for a member template, or just a member
2637 function of a template class. Even if a member template is
2638 being instantiated, the member template arguments may be
2639 elided if they can be deduced from the rest of the
2641 tmpl
= determine_specialization (declarator
, decl
,
2643 member_specialization
,
2647 if (!tmpl
|| tmpl
== error_mark_node
)
2648 /* We couldn't figure out what this declaration was
2650 return error_mark_node
;
2653 tree gen_tmpl
= most_general_template (tmpl
);
2655 if (explicit_instantiation
)
2657 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2658 is done by do_decl_instantiation later. */
2660 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2661 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2663 if (arg_depth
> parm_depth
)
2665 /* If TMPL is not the most general template (for
2666 example, if TMPL is a friend template that is
2667 injected into namespace scope), then there will
2668 be too many levels of TARGS. Remove some of them
2673 new_targs
= make_tree_vec (parm_depth
);
2674 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2675 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2676 = TREE_VEC_ELT (targs
, i
);
2680 return instantiate_template (tmpl
, targs
, tf_error
);
2683 /* If we thought that the DECL was a member function, but it
2684 turns out to be specializing a static member function,
2685 make DECL a static member function as well. */
2686 if (DECL_STATIC_FUNCTION_P (tmpl
)
2687 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2688 revert_static_member_fn (decl
);
2690 /* If this is a specialization of a member template of a
2691 template class, we want to return the TEMPLATE_DECL, not
2692 the specialization of it. */
2693 if (tsk
== tsk_template
)
2695 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
2696 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2697 DECL_INITIAL (result
) = NULL_TREE
;
2701 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2702 DECL_SOURCE_LOCATION (result
)
2703 = DECL_SOURCE_LOCATION (decl
);
2704 /* We want to use the argument list specified in the
2705 definition, not in the original declaration. */
2706 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
2707 for (parm
= DECL_ARGUMENTS (result
); parm
;
2708 parm
= DECL_CHAIN (parm
))
2709 DECL_CONTEXT (parm
) = result
;
2711 return register_specialization (tmpl
, gen_tmpl
, targs
,
2715 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2716 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
2718 /* Inherit default function arguments from the template
2719 DECL is specializing. */
2720 copy_default_args_to_explicit_spec (decl
);
2722 /* This specialization has the same protection as the
2723 template it specializes. */
2724 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
2725 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
2727 /* 7.1.1-1 [dcl.stc]
2729 A storage-class-specifier shall not be specified in an
2730 explicit specialization...
2732 The parser rejects these, so unless action is taken here,
2733 explicit function specializations will always appear with
2736 The action recommended by the C++ CWG in response to C++
2737 defect report 605 is to make the storage class and linkage
2738 of the explicit specialization match the templated function:
2740 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2742 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
2744 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
2745 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
2747 /* This specialization has the same linkage and visibility as
2748 the function template it specializes. */
2749 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
2750 if (! TREE_PUBLIC (decl
))
2752 DECL_INTERFACE_KNOWN (decl
) = 1;
2753 DECL_NOT_REALLY_EXTERN (decl
) = 1;
2755 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
2756 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
2758 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
2759 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
2763 /* If DECL is a friend declaration, declared using an
2764 unqualified name, the namespace associated with DECL may
2765 have been set incorrectly. For example, in:
2767 template <typename T> void f(T);
2769 struct S { friend void f<int>(int); }
2772 we will have set the DECL_CONTEXT for the friend
2773 declaration to N, rather than to the global namespace. */
2774 if (DECL_NAMESPACE_SCOPE_P (decl
))
2775 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
2777 if (is_friend
&& !have_def
)
2778 /* This is not really a declaration of a specialization.
2779 It's just the name of an instantiation. But, it's not
2780 a request for an instantiation, either. */
2781 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
2783 /* Register this specialization so that we can find it
2785 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
, 0);
2787 /* A 'structor should already have clones. */
2788 gcc_assert (decl
== error_mark_node
2789 || !(DECL_CONSTRUCTOR_P (decl
)
2790 || DECL_DESTRUCTOR_P (decl
))
2791 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
2798 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2799 parameters. These are represented in the same format used for
2800 DECL_TEMPLATE_PARMS. */
2803 comp_template_parms (const_tree parms1
, const_tree parms2
)
2808 if (parms1
== parms2
)
2811 for (p1
= parms1
, p2
= parms2
;
2812 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2813 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2815 tree t1
= TREE_VALUE (p1
);
2816 tree t2
= TREE_VALUE (p2
);
2819 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2820 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2822 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2825 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2827 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2828 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2830 /* If either of the template parameters are invalid, assume
2831 they match for the sake of error recovery. */
2832 if (parm1
== error_mark_node
|| parm2
== error_mark_node
)
2835 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2838 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2839 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2840 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2842 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2847 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2848 /* One set of parameters has more parameters lists than the
2855 /* Determine whether PARM is a parameter pack. */
2858 template_parameter_pack_p (const_tree parm
)
2860 /* Determine if we have a non-type template parameter pack. */
2861 if (TREE_CODE (parm
) == PARM_DECL
)
2862 return (DECL_TEMPLATE_PARM_P (parm
)
2863 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2864 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
2865 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
2867 /* If this is a list of template parameters, we could get a
2868 TYPE_DECL or a TEMPLATE_DECL. */
2869 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2870 parm
= TREE_TYPE (parm
);
2872 /* Otherwise it must be a type template parameter. */
2873 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2874 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2875 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2878 /* Determine if T is a function parameter pack. */
2881 function_parameter_pack_p (const_tree t
)
2883 if (t
&& TREE_CODE (t
) == PARM_DECL
)
2884 return DECL_PACK_P (t
);
2888 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2889 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2892 get_function_template_decl (const_tree primary_func_tmpl_inst
)
2894 if (! primary_func_tmpl_inst
2895 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
2896 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
2899 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
2902 /* Return true iff the function parameter PARAM_DECL was expanded
2903 from the function parameter pack PACK. */
2906 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
2908 if (DECL_ARTIFICIAL (param_decl
)
2909 || !function_parameter_pack_p (pack
))
2912 /* The parameter pack and its pack arguments have the same
2914 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
2917 /* Determine whether ARGS describes a variadic template args list,
2918 i.e., one that is terminated by a template argument pack. */
2921 template_args_variadic_p (tree args
)
2926 if (args
== NULL_TREE
)
2929 args
= INNERMOST_TEMPLATE_ARGS (args
);
2930 nargs
= TREE_VEC_LENGTH (args
);
2935 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
2937 return ARGUMENT_PACK_P (last_parm
);
2940 /* Generate a new name for the parameter pack name NAME (an
2941 IDENTIFIER_NODE) that incorporates its */
2944 make_ith_pack_parameter_name (tree name
, int i
)
2946 /* Munge the name to include the parameter index. */
2947 #define NUMBUF_LEN 128
2948 char numbuf
[NUMBUF_LEN
];
2952 if (name
== NULL_TREE
)
2954 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
2955 newname_len
= IDENTIFIER_LENGTH (name
)
2956 + strlen (numbuf
) + 2;
2957 newname
= (char*)alloca (newname_len
);
2958 snprintf (newname
, newname_len
,
2959 "%s#%i", IDENTIFIER_POINTER (name
), i
);
2960 return get_identifier (newname
);
2963 /* Return true if T is a primary function, class or alias template
2967 primary_template_instantiation_p (const_tree t
)
2972 if (TREE_CODE (t
) == FUNCTION_DECL
)
2973 return DECL_LANG_SPECIFIC (t
)
2974 && DECL_TEMPLATE_INSTANTIATION (t
)
2975 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
2976 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
2977 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
2978 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
2979 else if (alias_template_specialization_p (t
))
2984 /* Return true if PARM is a template template parameter. */
2987 template_template_parameter_p (const_tree parm
)
2989 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
2992 /* Return true iff PARM is a DECL representing a type template
2996 template_type_parameter_p (const_tree parm
)
2999 && (TREE_CODE (parm
) == TYPE_DECL
3000 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3001 && DECL_TEMPLATE_PARM_P (parm
));
3004 /* Return the template parameters of T if T is a
3005 primary template instantiation, NULL otherwise. */
3008 get_primary_template_innermost_parameters (const_tree t
)
3010 tree parms
= NULL
, template_info
= NULL
;
3012 if ((template_info
= get_template_info (t
))
3013 && primary_template_instantiation_p (t
))
3014 parms
= INNERMOST_TEMPLATE_PARMS
3015 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3020 /* Return the template parameters of the LEVELth level from the full list
3021 of template parameters PARMS. */
3024 get_template_parms_at_level (tree parms
, int level
)
3028 || TREE_CODE (parms
) != TREE_LIST
3029 || level
> TMPL_PARMS_DEPTH (parms
))
3032 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3033 if (TMPL_PARMS_DEPTH (p
) == level
)
3039 /* Returns the template arguments of T if T is a template instantiation,
3043 get_template_innermost_arguments (const_tree t
)
3045 tree args
= NULL
, template_info
= NULL
;
3047 if ((template_info
= get_template_info (t
))
3048 && TI_ARGS (template_info
))
3049 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3054 /* Return the argument pack elements of T if T is a template argument pack,
3058 get_template_argument_pack_elems (const_tree t
)
3060 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3061 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3064 return ARGUMENT_PACK_ARGS (t
);
3067 /* Structure used to track the progress of find_parameter_packs_r. */
3068 struct find_parameter_pack_data
3070 /* TREE_LIST that will contain all of the parameter packs found by
3072 tree
* parameter_packs
;
3074 /* Set of AST nodes that have been visited by the traversal. */
3075 struct pointer_set_t
*visited
;
3078 /* Identifies all of the argument packs that occur in a template
3079 argument and appends them to the TREE_LIST inside DATA, which is a
3080 find_parameter_pack_data structure. This is a subroutine of
3081 make_pack_expansion and uses_parameter_packs. */
3083 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3086 struct find_parameter_pack_data
* ppd
=
3087 (struct find_parameter_pack_data
*)data
;
3088 bool parameter_pack_p
= false;
3090 /* Handle type aliases/typedefs. */
3091 if (TYPE_ALIAS_P (t
))
3093 if (TYPE_TEMPLATE_INFO (t
))
3094 cp_walk_tree (&TYPE_TI_ARGS (t
),
3095 &find_parameter_packs_r
,
3101 /* Identify whether this is a parameter pack or not. */
3102 switch (TREE_CODE (t
))
3104 case TEMPLATE_PARM_INDEX
:
3105 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3106 parameter_pack_p
= true;
3109 case TEMPLATE_TYPE_PARM
:
3110 t
= TYPE_MAIN_VARIANT (t
);
3111 case TEMPLATE_TEMPLATE_PARM
:
3112 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3113 parameter_pack_p
= true;
3118 if (DECL_PACK_P (t
))
3120 /* We don't want to walk into the type of a PARM_DECL,
3121 because we don't want to see the type parameter pack. */
3123 parameter_pack_p
= true;
3127 /* Look through a lambda capture proxy to the field pack. */
3129 if (DECL_HAS_VALUE_EXPR_P (t
))
3131 tree v
= DECL_VALUE_EXPR (t
);
3133 &find_parameter_packs_r
,
3140 parameter_pack_p
= true;
3143 /* Not a parameter pack. */
3147 if (parameter_pack_p
)
3149 /* Add this parameter pack to the list. */
3150 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3154 cp_walk_tree (&TYPE_CONTEXT (t
),
3155 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3157 /* This switch statement will return immediately if we don't find a
3159 switch (TREE_CODE (t
))
3161 case TEMPLATE_PARM_INDEX
:
3164 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3165 /* Check the template itself. */
3166 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3167 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3168 /* Check the template arguments. */
3169 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3174 case TEMPLATE_TYPE_PARM
:
3175 case TEMPLATE_TEMPLATE_PARM
:
3182 if (TYPE_PTRMEMFUNC_P (t
))
3188 if (TYPE_TEMPLATE_INFO (t
))
3189 cp_walk_tree (&TYPE_TI_ARGS (t
),
3190 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3197 cp_walk_tree (&TREE_TYPE (t
),
3198 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3202 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3207 case TYPE_PACK_EXPANSION
:
3208 case EXPR_PACK_EXPANSION
:
3213 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3218 case IDENTIFIER_NODE
:
3219 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3231 /* Determines if the expression or type T uses any parameter packs. */
3233 uses_parameter_packs (tree t
)
3235 tree parameter_packs
= NULL_TREE
;
3236 struct find_parameter_pack_data ppd
;
3237 ppd
.parameter_packs
= ¶meter_packs
;
3238 ppd
.visited
= pointer_set_create ();
3239 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3240 pointer_set_destroy (ppd
.visited
);
3241 return parameter_packs
!= NULL_TREE
;
3244 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3245 representation a base-class initializer into a parameter pack
3246 expansion. If all goes well, the resulting node will be an
3247 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3250 make_pack_expansion (tree arg
)
3253 tree parameter_packs
= NULL_TREE
;
3254 bool for_types
= false;
3255 struct find_parameter_pack_data ppd
;
3257 if (!arg
|| arg
== error_mark_node
)
3260 if (TREE_CODE (arg
) == TREE_LIST
)
3262 /* The only time we will see a TREE_LIST here is for a base
3263 class initializer. In this case, the TREE_PURPOSE will be a
3264 _TYPE node (representing the base class expansion we're
3265 initializing) and the TREE_VALUE will be a TREE_LIST
3266 containing the initialization arguments.
3268 The resulting expansion looks somewhat different from most
3269 expansions. Rather than returning just one _EXPANSION, we
3270 return a TREE_LIST whose TREE_PURPOSE is a
3271 TYPE_PACK_EXPANSION containing the bases that will be
3272 initialized. The TREE_VALUE will be identical to the
3273 original TREE_VALUE, which is a list of arguments that will
3274 be passed to each base. We do not introduce any new pack
3275 expansion nodes into the TREE_VALUE (although it is possible
3276 that some already exist), because the TREE_PURPOSE and
3277 TREE_VALUE all need to be expanded together with the same
3278 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3279 resulting TREE_PURPOSE will mention the parameter packs in
3280 both the bases and the arguments to the bases. */
3283 tree parameter_packs
= NULL_TREE
;
3285 /* Determine which parameter packs will be used by the base
3287 ppd
.visited
= pointer_set_create ();
3288 ppd
.parameter_packs
= ¶meter_packs
;
3289 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3292 if (parameter_packs
== NULL_TREE
)
3294 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3295 pointer_set_destroy (ppd
.visited
);
3296 return error_mark_node
;
3299 if (TREE_VALUE (arg
) != void_type_node
)
3301 /* Collect the sets of parameter packs used in each of the
3302 initialization arguments. */
3303 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3305 /* Determine which parameter packs will be expanded in this
3307 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3312 pointer_set_destroy (ppd
.visited
);
3314 /* Create the pack expansion type for the base type. */
3315 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3316 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3317 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3319 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3320 they will rarely be compared to anything. */
3321 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3323 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3326 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3329 /* Build the PACK_EXPANSION_* node. */
3331 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3332 : make_node (EXPR_PACK_EXPANSION
);
3333 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3334 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3336 /* Propagate type and const-expression information. */
3337 TREE_TYPE (result
) = TREE_TYPE (arg
);
3338 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3341 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3342 they will rarely be compared to anything. */
3343 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3345 /* Determine which parameter packs will be expanded. */
3346 ppd
.parameter_packs
= ¶meter_packs
;
3347 ppd
.visited
= pointer_set_create ();
3348 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3349 pointer_set_destroy (ppd
.visited
);
3351 /* Make sure we found some parameter packs. */
3352 if (parameter_packs
== NULL_TREE
)
3355 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3357 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3358 return error_mark_node
;
3360 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3362 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3367 /* Checks T for any "bare" parameter packs, which have not yet been
3368 expanded, and issues an error if any are found. This operation can
3369 only be done on full expressions or types (e.g., an expression
3370 statement, "if" condition, etc.), because we could have expressions like:
3372 foo(f(g(h(args)))...)
3374 where "args" is a parameter pack. check_for_bare_parameter_packs
3375 should not be called for the subexpressions args, h(args),
3376 g(h(args)), or f(g(h(args))), because we would produce erroneous
3379 Returns TRUE and emits an error if there were bare parameter packs,
3380 returns FALSE otherwise. */
3382 check_for_bare_parameter_packs (tree t
)
3384 tree parameter_packs
= NULL_TREE
;
3385 struct find_parameter_pack_data ppd
;
3387 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3390 if (TREE_CODE (t
) == TYPE_DECL
)
3393 ppd
.parameter_packs
= ¶meter_packs
;
3394 ppd
.visited
= pointer_set_create ();
3395 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3396 pointer_set_destroy (ppd
.visited
);
3398 if (parameter_packs
)
3400 error ("parameter packs not expanded with %<...%>:");
3401 while (parameter_packs
)
3403 tree pack
= TREE_VALUE (parameter_packs
);
3404 tree name
= NULL_TREE
;
3406 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3407 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3408 name
= TYPE_NAME (pack
);
3409 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3410 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3412 name
= DECL_NAME (pack
);
3415 inform (input_location
, " %qD", name
);
3417 inform (input_location
, " <anonymous>");
3419 parameter_packs
= TREE_CHAIN (parameter_packs
);
3428 /* Expand any parameter packs that occur in the template arguments in
3431 expand_template_argument_pack (tree args
)
3433 tree result_args
= NULL_TREE
;
3434 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3435 int num_result_args
= -1;
3436 int non_default_args_count
= -1;
3438 /* First, determine if we need to expand anything, and the number of
3439 slots we'll need. */
3440 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3442 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3443 if (arg
== NULL_TREE
)
3445 if (ARGUMENT_PACK_P (arg
))
3447 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3448 if (num_result_args
< 0)
3449 num_result_args
= in_arg
+ num_packed
;
3451 num_result_args
+= num_packed
;
3455 if (num_result_args
>= 0)
3460 /* If no expansion is necessary, we're done. */
3461 if (num_result_args
< 0)
3464 /* Expand arguments. */
3465 result_args
= make_tree_vec (num_result_args
);
3466 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3467 non_default_args_count
=
3468 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3469 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3471 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3472 if (ARGUMENT_PACK_P (arg
))
3474 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3475 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3476 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3477 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3478 if (non_default_args_count
> 0)
3479 non_default_args_count
+= num_packed
- 1;
3483 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3487 if (non_default_args_count
>= 0)
3488 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3492 /* Checks if DECL shadows a template parameter.
3494 [temp.local]: A template-parameter shall not be redeclared within its
3495 scope (including nested scopes).
3497 Emits an error and returns TRUE if the DECL shadows a parameter,
3498 returns FALSE otherwise. */
3501 check_template_shadow (tree decl
)
3505 /* If we're not in a template, we can't possibly shadow a template
3507 if (!current_template_parms
)
3510 /* Figure out what we're shadowing. */
3511 if (TREE_CODE (decl
) == OVERLOAD
)
3512 decl
= OVL_CURRENT (decl
);
3513 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3515 /* If there's no previous binding for this name, we're not shadowing
3516 anything, let alone a template parameter. */
3520 /* If we're not shadowing a template parameter, we're done. Note
3521 that OLDDECL might be an OVERLOAD (or perhaps even an
3522 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3524 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3527 /* We check for decl != olddecl to avoid bogus errors for using a
3528 name inside a class. We check TPFI to avoid duplicate errors for
3529 inline member templates. */
3531 || (DECL_TEMPLATE_PARM_P (decl
)
3532 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
3535 /* Don't complain about the injected class name, as we've already
3536 complained about the class itself. */
3537 if (DECL_SELF_REFERENCE_P (decl
))
3540 error ("declaration of %q+#D", decl
);
3541 error (" shadows template parm %q+#D", olddecl
);
3545 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3546 ORIG_LEVEL, DECL, and TYPE. */
3549 build_template_parm_index (int index
,
3555 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3556 TEMPLATE_PARM_IDX (t
) = index
;
3557 TEMPLATE_PARM_LEVEL (t
) = level
;
3558 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3559 TEMPLATE_PARM_DECL (t
) = decl
;
3560 TREE_TYPE (t
) = type
;
3561 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3562 TREE_READONLY (t
) = TREE_READONLY (decl
);
3567 /* Find the canonical type parameter for the given template type
3568 parameter. Returns the canonical type parameter, which may be TYPE
3569 if no such parameter existed. */
3572 canonical_type_parameter (tree type
)
3575 int idx
= TEMPLATE_TYPE_IDX (type
);
3576 if (!canonical_template_parms
)
3577 vec_alloc (canonical_template_parms
, idx
+1);
3579 while (canonical_template_parms
->length () <= (unsigned)idx
)
3580 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3582 list
= (*canonical_template_parms
)[idx
];
3583 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3584 list
= TREE_CHAIN (list
);
3587 return TREE_VALUE (list
);
3590 (*canonical_template_parms
)[idx
]
3591 = tree_cons (NULL_TREE
, type
,
3592 (*canonical_template_parms
)[idx
]);
3597 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3598 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3599 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3600 new one is created. */
3603 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3604 tsubst_flags_t complain
)
3606 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3607 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3608 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3609 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3611 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3614 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3615 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3616 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3617 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3618 DECL_ARTIFICIAL (decl
) = 1;
3619 SET_DECL_TEMPLATE_PARM_P (decl
);
3621 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3622 TEMPLATE_PARM_LEVEL (index
) - levels
,
3623 TEMPLATE_PARM_ORIG_LEVEL (index
),
3625 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3626 TEMPLATE_PARM_PARAMETER_PACK (t
)
3627 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3629 /* Template template parameters need this. */
3630 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3631 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3632 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
)),
3636 return TEMPLATE_PARM_DESCENDANTS (index
);
3639 /* Process information from new template parameter PARM and append it
3640 to the LIST being built. This new parameter is a non-type
3641 parameter iff IS_NON_TYPE is true. This new parameter is a
3642 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3643 is in PARM_LOC. NUM_TEMPLATE_PARMS is the size of the template
3644 parameter list PARM belongs to. This is used used to create a
3645 proper canonical type for the type of PARM that is to be created,
3646 iff PARM is a type. If the size is not known, this parameter shall
3650 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
3651 bool is_non_type
, bool is_parameter_pack
)
3658 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
3659 defval
= TREE_PURPOSE (parm
);
3663 tree p
= tree_last (list
);
3665 if (p
&& TREE_VALUE (p
) != error_mark_node
)
3668 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
3669 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
3671 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
3681 parm
= TREE_VALUE (parm
);
3683 SET_DECL_TEMPLATE_PARM_P (parm
);
3685 if (TREE_TYPE (parm
) == error_mark_node
)
3687 err_parm_list
= build_tree_list (defval
, parm
);
3688 TREE_VALUE (err_parm_list
) = error_mark_node
;
3689 return chainon (list
, err_parm_list
);
3695 The top-level cv-qualifiers on the template-parameter are
3696 ignored when determining its type. */
3697 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
3698 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
3700 err_parm_list
= build_tree_list (defval
, parm
);
3701 TREE_VALUE (err_parm_list
) = error_mark_node
;
3702 return chainon (list
, err_parm_list
);
3705 if (uses_parameter_packs (TREE_TYPE (parm
)) && !is_parameter_pack
3706 /* If we're in a nested template parameter list, the template
3707 template parameter could be a parameter pack. */
3708 && processing_template_parmlist
== 1)
3710 /* This template parameter is not a parameter pack, but it
3711 should be. Complain about "bare" parameter packs. */
3712 check_for_bare_parameter_packs (TREE_TYPE (parm
));
3714 /* Recover by calling this a parameter pack. */
3715 is_parameter_pack
= true;
3719 /* A template parameter is not modifiable. */
3720 TREE_CONSTANT (parm
) = 1;
3721 TREE_READONLY (parm
) = 1;
3722 decl
= build_decl (parm_loc
,
3723 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
3724 TREE_CONSTANT (decl
) = 1;
3725 TREE_READONLY (decl
) = 1;
3726 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
3727 = build_template_parm_index (idx
, processing_template_decl
,
3728 processing_template_decl
,
3729 decl
, TREE_TYPE (parm
));
3731 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
3732 = is_parameter_pack
;
3737 parm
= TREE_VALUE (TREE_VALUE (parm
));
3739 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
3741 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
3742 /* This is for distinguishing between real templates and template
3743 template parameters */
3744 TREE_TYPE (parm
) = t
;
3745 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
3750 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
3751 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3752 decl
= build_decl (parm_loc
,
3753 TYPE_DECL
, parm
, t
);
3756 TYPE_NAME (t
) = decl
;
3757 TYPE_STUB_DECL (t
) = decl
;
3759 TEMPLATE_TYPE_PARM_INDEX (t
)
3760 = build_template_parm_index (idx
, processing_template_decl
,
3761 processing_template_decl
,
3762 decl
, TREE_TYPE (parm
));
3763 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
3764 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
3766 DECL_ARTIFICIAL (decl
) = 1;
3767 SET_DECL_TEMPLATE_PARM_P (decl
);
3769 parm
= build_tree_list (defval
, parm
);
3770 return chainon (list
, parm
);
3773 /* The end of a template parameter list has been reached. Process the
3774 tree list into a parameter vector, converting each parameter into a more
3775 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3779 end_template_parm_list (tree parms
)
3783 tree saved_parmlist
= make_tree_vec (list_length (parms
));
3785 current_template_parms
3786 = tree_cons (size_int (processing_template_decl
),
3787 saved_parmlist
, current_template_parms
);
3789 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3791 next
= TREE_CHAIN (parm
);
3792 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3793 TREE_CHAIN (parm
) = NULL_TREE
;
3796 --processing_template_parmlist
;
3798 return saved_parmlist
;
3801 /* end_template_decl is called after a template declaration is seen. */
3804 end_template_decl (void)
3806 reset_specialization ();
3808 if (! processing_template_decl
)
3811 /* This matches the pushlevel in begin_template_parm_list. */
3814 --processing_template_decl
;
3815 current_template_parms
= TREE_CHAIN (current_template_parms
);
3818 /* Takes a TREE_LIST representing a template parameter and convert it
3819 into an argument suitable to be passed to the type substitution
3820 functions. Note that If the TREE_LIST contains an error_mark
3821 node, the returned argument is error_mark_node. */
3824 template_parm_to_arg (tree t
)
3828 || TREE_CODE (t
) != TREE_LIST
)
3831 if (error_operand_p (TREE_VALUE (t
)))
3832 return error_mark_node
;
3836 if (TREE_CODE (t
) == TYPE_DECL
3837 || TREE_CODE (t
) == TEMPLATE_DECL
)
3841 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3843 /* Turn this argument into a TYPE_ARGUMENT_PACK
3844 with a single element, which expands T. */
3845 tree vec
= make_tree_vec (1);
3846 #ifdef ENABLE_CHECKING
3847 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3848 (vec
, TREE_VEC_LENGTH (vec
));
3850 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3852 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
3853 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3858 t
= DECL_INITIAL (t
);
3860 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3862 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3863 with a single element, which expands T. */
3864 tree vec
= make_tree_vec (1);
3865 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3866 #ifdef ENABLE_CHECKING
3867 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3868 (vec
, TREE_VEC_LENGTH (vec
));
3870 t
= convert_from_reference (t
);
3871 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3873 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3874 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3875 TREE_TYPE (t
) = type
;
3878 t
= convert_from_reference (t
);
3883 /* Given a set of template parameters, return them as a set of template
3884 arguments. The template parameters are represented as a TREE_VEC, in
3885 the form documented in cp-tree.h for template arguments. */
3888 template_parms_to_args (tree parms
)
3891 tree args
= NULL_TREE
;
3892 int length
= TMPL_PARMS_DEPTH (parms
);
3895 /* If there is only one level of template parameters, we do not
3896 create a TREE_VEC of TREE_VECs. Instead, we return a single
3897 TREE_VEC containing the arguments. */
3899 args
= make_tree_vec (length
);
3901 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
3903 tree a
= copy_node (TREE_VALUE (header
));
3906 TREE_TYPE (a
) = NULL_TREE
;
3907 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
3908 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
3910 #ifdef ENABLE_CHECKING
3911 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
3915 TREE_VEC_ELT (args
, --l
) = a
;
3920 if (length
> 1 && TREE_VEC_ELT (args
, 0) == NULL_TREE
)
3921 /* This can happen for template parms of a template template
3924 template<template<class T, class U> class TT> struct S;
3926 Consider the level of the parms of TT; T and U both have
3927 level 2; TT has no template parm of level 1. So in this case
3928 the first element of full_template_args is NULL_TREE. If we
3929 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
3930 of 2. This will make tsubst wrongly consider that T and U
3931 have level 1. Instead, let's create a dummy vector as the
3932 first element of full_template_args so that TMPL_ARGS_DEPTH
3933 returns the correct depth for args. */
3934 TREE_VEC_ELT (args
, 0) = make_tree_vec (1);
3938 /* Within the declaration of a template, return the currently active
3939 template parameters as an argument TREE_VEC. */
3942 current_template_args (void)
3944 return template_parms_to_args (current_template_parms
);
3947 /* Update the declared TYPE by doing any lookups which were thought to be
3948 dependent, but are not now that we know the SCOPE of the declarator. */
3951 maybe_update_decl_type (tree orig_type
, tree scope
)
3953 tree type
= orig_type
;
3955 if (type
== NULL_TREE
)
3958 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3959 type
= TREE_TYPE (type
);
3961 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
3962 && dependent_type_p (type
)
3963 /* Don't bother building up the args in this case. */
3964 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
3966 /* tsubst in the args corresponding to the template parameters,
3967 including auto if present. Most things will be unchanged, but
3968 make_typename_type and tsubst_qualified_id will resolve
3969 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3970 tree args
= current_template_args ();
3971 tree auto_node
= type_uses_auto (type
);
3975 tree auto_vec
= make_tree_vec (1);
3976 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
3977 args
= add_to_template_args (args
, auto_vec
);
3979 pushed
= push_scope (scope
);
3980 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
3985 if (type
== error_mark_node
)
3988 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3990 if (same_type_p (type
, TREE_TYPE (orig_type
)))
3993 type
= TYPE_NAME (type
);
3998 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3999 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
4000 a member template. Used by push_template_decl below. */
4003 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4005 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4006 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4007 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4008 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4009 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4014 struct template_parm_data
4016 /* The level of the template parameters we are currently
4020 /* The index of the specialization argument we are currently
4024 /* An array whose size is the number of template parameters. The
4025 elements are nonzero if the parameter has been used in any one
4026 of the arguments processed so far. */
4029 /* An array whose size is the number of template arguments. The
4030 elements are nonzero if the argument makes use of template
4031 parameters of this level. */
4032 int* arg_uses_template_parms
;
4035 /* Subroutine of push_template_decl used to see if each template
4036 parameter in a partial specialization is used in the explicit
4037 argument list. If T is of the LEVEL given in DATA (which is
4038 treated as a template_parm_data*), then DATA->PARMS is marked
4042 mark_template_parm (tree t
, void* data
)
4046 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4048 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4050 level
= TEMPLATE_PARM_LEVEL (t
);
4051 idx
= TEMPLATE_PARM_IDX (t
);
4055 level
= TEMPLATE_TYPE_LEVEL (t
);
4056 idx
= TEMPLATE_TYPE_IDX (t
);
4059 if (level
== tpd
->level
)
4061 tpd
->parms
[idx
] = 1;
4062 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4065 /* Return zero so that for_each_template_parm will continue the
4066 traversal of the tree; we want to mark *every* template parm. */
4070 /* Process the partial specialization DECL. */
4073 process_partial_specialization (tree decl
)
4075 tree type
= TREE_TYPE (decl
);
4076 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
4077 tree specargs
= CLASSTYPE_TI_ARGS (type
);
4078 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4079 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4082 int nargs
= TREE_VEC_LENGTH (inner_args
);
4085 bool did_error_intro
= false;
4086 struct template_parm_data tpd
;
4087 struct template_parm_data tpd2
;
4089 gcc_assert (current_template_parms
);
4091 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4092 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4094 /* We check that each of the template parameters given in the
4095 partial specialization is used in the argument list to the
4096 specialization. For example:
4098 template <class T> struct S;
4099 template <class T> struct S<T*>;
4101 The second declaration is OK because `T*' uses the template
4102 parameter T, whereas
4104 template <class T> struct S<int>;
4106 is no good. Even trickier is:
4117 The S2<T> declaration is actually invalid; it is a
4118 full-specialization. Of course,
4121 struct S2<T (*)(U)>;
4123 or some such would have been OK. */
4124 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4125 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4126 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4128 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4129 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4130 for (i
= 0; i
< nargs
; ++i
)
4132 tpd
.current_arg
= i
;
4133 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4134 &mark_template_parm
,
4137 /*include_nondeduced_p=*/false);
4139 for (i
= 0; i
< ntparms
; ++i
)
4140 if (tpd
.parms
[i
] == 0)
4142 /* One of the template parms was not used in the
4144 if (!did_error_intro
)
4146 error ("template parameters not used in partial specialization:");
4147 did_error_intro
= true;
4150 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4153 if (did_error_intro
)
4154 return error_mark_node
;
4156 /* [temp.class.spec]
4158 The argument list of the specialization shall not be identical to
4159 the implicit argument list of the primary template. */
4160 if (comp_template_args
4162 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
4164 error ("partial specialization %qT does not specialize any template arguments", type
);
4166 /* A partial specialization that replaces multiple parameters of the
4167 primary template with a pack expansion is less specialized for those
4169 if (nargs
< DECL_NTPARMS (maintmpl
))
4171 error ("partial specialization is not more specialized than the "
4172 "primary template because it replaces multiple parameters "
4173 "with a pack expansion");
4174 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4178 /* [temp.class.spec]
4180 A partially specialized non-type argument expression shall not
4181 involve template parameters of the partial specialization except
4182 when the argument expression is a simple identifier.
4184 The type of a template parameter corresponding to a specialized
4185 non-type argument shall not be dependent on a parameter of the
4188 Also, we verify that pack expansions only occur at the
4189 end of the argument list. */
4190 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4192 for (i
= 0; i
< nargs
; ++i
)
4194 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4195 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4196 tree packed_args
= NULL_TREE
;
4199 if (ARGUMENT_PACK_P (arg
))
4201 /* Extract the arguments from the argument pack. We'll be
4202 iterating over these in the following loop. */
4203 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4204 len
= TREE_VEC_LENGTH (packed_args
);
4207 for (j
= 0; j
< len
; j
++)
4210 /* Get the Jth argument in the parameter pack. */
4211 arg
= TREE_VEC_ELT (packed_args
, j
);
4213 if (PACK_EXPANSION_P (arg
))
4215 /* Pack expansions must come at the end of the
4217 if ((packed_args
&& j
< len
- 1)
4218 || (!packed_args
&& i
< nargs
- 1))
4220 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4221 error ("parameter pack argument %qE must be at the "
4222 "end of the template argument list", arg
);
4224 error ("parameter pack argument %qT must be at the "
4225 "end of the template argument list", arg
);
4229 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4230 /* We only care about the pattern. */
4231 arg
= PACK_EXPANSION_PATTERN (arg
);
4233 if (/* These first two lines are the `non-type' bit. */
4235 && TREE_CODE (arg
) != TEMPLATE_DECL
4236 /* This next two lines are the `argument expression is not just a
4237 simple identifier' condition and also the `specialized
4238 non-type argument' bit. */
4239 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4240 && !(REFERENCE_REF_P (arg
)
4241 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4243 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4244 || (packed_args
&& uses_template_parms (arg
)))
4245 error ("template argument %qE involves template parameter(s)",
4249 /* Look at the corresponding template parameter,
4250 marking which template parameters its type depends
4252 tree type
= TREE_TYPE (parm
);
4256 /* We haven't yet initialized TPD2. Do so now. */
4257 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4258 /* The number of parameters here is the number in the
4259 main template, which, as checked in the assertion
4261 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4263 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4266 /* Mark the template parameters. But this time, we're
4267 looking for the template parameters of the main
4268 template, not in the specialization. */
4269 tpd2
.current_arg
= i
;
4270 tpd2
.arg_uses_template_parms
[i
] = 0;
4271 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4272 for_each_template_parm (type
,
4273 &mark_template_parm
,
4276 /*include_nondeduced_p=*/false);
4278 if (tpd2
.arg_uses_template_parms
[i
])
4280 /* The type depended on some template parameters.
4281 If they are fully specialized in the
4282 specialization, that's OK. */
4285 for (j
= 0; j
< nargs
; ++j
)
4286 if (tpd2
.parms
[j
] != 0
4287 && tpd
.arg_uses_template_parms
[j
])
4290 error_n (input_location
, count
,
4291 "type %qT of template argument %qE depends "
4292 "on a template parameter",
4293 "type %qT of template argument %qE depends "
4294 "on template parameters",
4303 /* We should only get here once. */
4304 gcc_assert (!COMPLETE_TYPE_P (type
));
4306 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4307 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4308 TREE_TYPE (tmpl
) = type
;
4309 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4310 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4311 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4312 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4314 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4315 = tree_cons (specargs
, tmpl
,
4316 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4317 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4319 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4320 inst
= TREE_CHAIN (inst
))
4322 tree inst_type
= TREE_VALUE (inst
);
4323 if (COMPLETE_TYPE_P (inst_type
)
4324 && CLASSTYPE_IMPLICIT_INSTANTIATION (inst_type
))
4326 tree spec
= most_specialized_class (inst_type
, tf_none
);
4327 if (spec
&& TREE_TYPE (spec
) == type
)
4328 permerror (input_location
,
4329 "partial specialization of %qT after instantiation "
4330 "of %qT", type
, inst_type
);
4337 /* PARM is a template parameter of some form; return the corresponding
4338 TEMPLATE_PARM_INDEX. */
4341 get_template_parm_index (tree parm
)
4343 if (TREE_CODE (parm
) == PARM_DECL
4344 || TREE_CODE (parm
) == CONST_DECL
)
4345 parm
= DECL_INITIAL (parm
);
4346 else if (TREE_CODE (parm
) == TYPE_DECL
4347 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4348 parm
= TREE_TYPE (parm
);
4349 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4350 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4351 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4352 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4356 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4357 parameter packs used by the template parameter PARM. */
4360 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4362 /* A type parm can't refer to another parm. */
4363 if (TREE_CODE (parm
) == TYPE_DECL
)
4365 else if (TREE_CODE (parm
) == PARM_DECL
)
4367 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4372 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4374 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4375 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4376 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4379 /* PARM is a template parameter pack. Return any parameter packs used in
4380 its type or the type of any of its template parameters. If there are
4381 any such packs, it will be instantiated into a fixed template parameter
4382 list by partial instantiation rather than be fully deduced. */
4385 fixed_parameter_pack_p (tree parm
)
4387 /* This can only be true in a member template. */
4388 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4390 /* This can only be true for a parameter pack. */
4391 if (!template_parameter_pack_p (parm
))
4393 /* A type parm can't refer to another parm. */
4394 if (TREE_CODE (parm
) == TYPE_DECL
)
4397 tree parameter_packs
= NULL_TREE
;
4398 struct find_parameter_pack_data ppd
;
4399 ppd
.parameter_packs
= ¶meter_packs
;
4400 ppd
.visited
= pointer_set_create ();
4402 fixed_parameter_pack_p_1 (parm
, &ppd
);
4404 pointer_set_destroy (ppd
.visited
);
4405 return parameter_packs
;
4408 /* Check that a template declaration's use of default arguments and
4409 parameter packs is not invalid. Here, PARMS are the template
4410 parameters. IS_PRIMARY is true if DECL is the thing declared by
4411 a primary template. IS_PARTIAL is true if DECL is a partial
4414 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4415 declaration (but not a definition); 1 indicates a declaration, 2
4416 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4417 emitted for extraneous default arguments.
4419 Returns TRUE if there were no errors found, FALSE otherwise. */
4422 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4423 bool is_partial
, int is_friend_decl
)
4426 int last_level_to_check
;
4428 bool no_errors
= true;
4432 A default template-argument shall not be specified in a
4433 function template declaration or a function template definition, nor
4434 in the template-parameter-list of the definition of a member of a
4437 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
4438 /* You can't have a function template declaration in a local
4439 scope, nor you can you define a member of a class template in a
4443 if (TREE_CODE (decl
) == TYPE_DECL
4445 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4446 /* A lambda doesn't have an explicit declaration; don't complain
4447 about the parms of the enclosing class. */
4450 if (current_class_type
4451 && !TYPE_BEING_DEFINED (current_class_type
)
4452 && DECL_LANG_SPECIFIC (decl
)
4453 && DECL_DECLARES_FUNCTION_P (decl
)
4454 /* If this is either a friend defined in the scope of the class
4455 or a member function. */
4456 && (DECL_FUNCTION_MEMBER_P (decl
)
4457 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4458 : DECL_FRIEND_CONTEXT (decl
)
4459 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4461 /* And, if it was a member function, it really was defined in
4462 the scope of the class. */
4463 && (!DECL_FUNCTION_MEMBER_P (decl
)
4464 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4465 /* We already checked these parameters when the template was
4466 declared, so there's no need to do it again now. This function
4467 was defined in class scope, but we're processing its body now
4468 that the class is complete. */
4471 /* Core issue 226 (C++0x only): the following only applies to class
4474 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4478 If a template-parameter has a default template-argument, all
4479 subsequent template-parameters shall have a default
4480 template-argument supplied. */
4481 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4483 tree inner_parms
= TREE_VALUE (parm_level
);
4484 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4485 int seen_def_arg_p
= 0;
4488 for (i
= 0; i
< ntparms
; ++i
)
4490 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4492 if (parm
== error_mark_node
)
4495 if (TREE_PURPOSE (parm
))
4497 else if (seen_def_arg_p
4498 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4500 error ("no default argument for %qD", TREE_VALUE (parm
));
4501 /* For better subsequent error-recovery, we indicate that
4502 there should have been a default argument. */
4503 TREE_PURPOSE (parm
) = error_mark_node
;
4506 else if (!is_partial
4508 /* Don't complain about an enclosing partial
4510 && parm_level
== parms
4511 && TREE_CODE (decl
) == TYPE_DECL
4513 && template_parameter_pack_p (TREE_VALUE (parm
))
4514 /* A fixed parameter pack will be partially
4515 instantiated into a fixed length list. */
4516 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4518 /* A primary class template can only have one
4519 parameter pack, at the end of the template
4522 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
4523 error ("parameter pack %qE must be at the end of the"
4524 " template parameter list", TREE_VALUE (parm
));
4526 error ("parameter pack %qT must be at the end of the"
4527 " template parameter list",
4528 TREE_TYPE (TREE_VALUE (parm
)));
4530 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4538 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4542 /* For an ordinary class template, default template arguments are
4543 allowed at the innermost level, e.g.:
4544 template <class T = int>
4546 but, in a partial specialization, they're not allowed even
4547 there, as we have in [temp.class.spec]:
4549 The template parameter list of a specialization shall not
4550 contain default template argument values.
4552 So, for a partial specialization, or for a function template
4553 (in C++98/C++03), we look at all of them. */
4556 /* But, for a primary class template that is not a partial
4557 specialization we look at all template parameters except the
4559 parms
= TREE_CHAIN (parms
);
4561 /* Figure out what error message to issue. */
4562 if (is_friend_decl
== 2)
4563 msg
= G_("default template arguments may not be used in function template "
4564 "friend re-declaration");
4565 else if (is_friend_decl
)
4566 msg
= G_("default template arguments may not be used in function template "
4567 "friend declarations");
4568 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4569 msg
= G_("default template arguments may not be used in function templates "
4570 "without -std=c++11 or -std=gnu++11");
4571 else if (is_partial
)
4572 msg
= G_("default template arguments may not be used in "
4573 "partial specializations");
4575 msg
= G_("default argument for template parameter for class enclosing %qD");
4577 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4578 /* If we're inside a class definition, there's no need to
4579 examine the parameters to the class itself. On the one
4580 hand, they will be checked when the class is defined, and,
4581 on the other, default arguments are valid in things like:
4582 template <class T = double>
4583 struct S { template <class U> void f(U); };
4584 Here the default argument for `S' has no bearing on the
4585 declaration of `f'. */
4586 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4588 /* Check everything. */
4589 last_level_to_check
= 0;
4591 for (parm_level
= parms
;
4592 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4593 parm_level
= TREE_CHAIN (parm_level
))
4595 tree inner_parms
= TREE_VALUE (parm_level
);
4599 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4600 for (i
= 0; i
< ntparms
; ++i
)
4602 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4605 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4610 if (is_friend_decl
== 2)
4617 /* Clear out the default argument so that we are not
4619 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
4623 /* At this point, if we're still interested in issuing messages,
4624 they must apply to classes surrounding the object declared. */
4626 msg
= G_("default argument for template parameter for class "
4633 /* Worker for push_template_decl_real, called via
4634 for_each_template_parm. DATA is really an int, indicating the
4635 level of the parameters we are interested in. If T is a template
4636 parameter of that level, return nonzero. */
4639 template_parm_this_level_p (tree t
, void* data
)
4641 int this_level
= *(int *)data
;
4644 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4645 level
= TEMPLATE_PARM_LEVEL (t
);
4647 level
= TEMPLATE_TYPE_LEVEL (t
);
4648 return level
== this_level
;
4651 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4652 parameters given by current_template_args, or reuses a
4653 previously existing one, if appropriate. Returns the DECL, or an
4654 equivalent one, if it is replaced via a call to duplicate_decls.
4656 If IS_FRIEND is true, DECL is a friend declaration. */
4659 push_template_decl_real (tree decl
, bool is_friend
)
4667 int new_template_p
= 0;
4668 /* True if the template is a member template, in the sense of
4670 bool member_template_p
= false;
4672 if (decl
== error_mark_node
|| !current_template_parms
)
4673 return error_mark_node
;
4675 /* See if this is a partial specialization. */
4676 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
4677 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
4678 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
4680 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
4684 /* For a friend, we want the context of the friend function, not
4685 the type of which it is a friend. */
4686 ctx
= CP_DECL_CONTEXT (decl
);
4687 else if (CP_DECL_CONTEXT (decl
)
4688 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4689 /* In the case of a virtual function, we want the class in which
4691 ctx
= CP_DECL_CONTEXT (decl
);
4693 /* Otherwise, if we're currently defining some class, the DECL
4694 is assumed to be a member of the class. */
4695 ctx
= current_scope ();
4697 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
4700 if (!DECL_CONTEXT (decl
))
4701 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
4703 /* See if this is a primary template. */
4704 if (is_friend
&& ctx
4705 && uses_template_parms_level (ctx
, processing_template_decl
))
4706 /* A friend template that specifies a class context, i.e.
4707 template <typename T> friend void A<T>::f();
4711 is_primary
= template_parm_scope_p ();
4715 if (DECL_CLASS_SCOPE_P (decl
))
4716 member_template_p
= true;
4717 if (TREE_CODE (decl
) == TYPE_DECL
4718 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
4720 error ("template class without a name");
4721 return error_mark_node
;
4723 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
4725 if (DECL_DESTRUCTOR_P (decl
))
4729 A destructor shall not be a member template. */
4730 error ("destructor %qD declared as member template", decl
);
4731 return error_mark_node
;
4733 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
4734 && (!prototype_p (TREE_TYPE (decl
))
4735 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
4736 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
4737 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
4738 == void_list_node
)))
4740 /* [basic.stc.dynamic.allocation]
4742 An allocation function can be a function
4743 template. ... Template allocation functions shall
4744 have two or more parameters. */
4745 error ("invalid template declaration of %qD", decl
);
4746 return error_mark_node
;
4749 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4750 && CLASS_TYPE_P (TREE_TYPE (decl
)))
4752 else if (TREE_CODE (decl
) == TYPE_DECL
4753 && TYPE_DECL_ALIAS_P (decl
))
4754 /* alias-declaration */
4755 gcc_assert (!DECL_ARTIFICIAL (decl
));
4758 error ("template declaration of %q#D", decl
);
4759 return error_mark_node
;
4763 /* Check to see that the rules regarding the use of default
4764 arguments are not being violated. */
4765 check_default_tmpl_args (decl
, current_template_parms
,
4766 is_primary
, is_partial
, /*is_friend_decl=*/0);
4768 /* Ensure that there are no parameter packs in the type of this
4769 declaration that have not been expanded. */
4770 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4772 /* Check each of the arguments individually to see if there are
4773 any bare parameter packs. */
4774 tree type
= TREE_TYPE (decl
);
4775 tree arg
= DECL_ARGUMENTS (decl
);
4776 tree argtype
= TYPE_ARG_TYPES (type
);
4778 while (arg
&& argtype
)
4780 if (!DECL_PACK_P (arg
)
4781 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
4783 /* This is a PARM_DECL that contains unexpanded parameter
4784 packs. We have already complained about this in the
4785 check_for_bare_parameter_packs call, so just replace
4786 these types with ERROR_MARK_NODE. */
4787 TREE_TYPE (arg
) = error_mark_node
;
4788 TREE_VALUE (argtype
) = error_mark_node
;
4791 arg
= DECL_CHAIN (arg
);
4792 argtype
= TREE_CHAIN (argtype
);
4795 /* Check for bare parameter packs in the return type and the
4796 exception specifiers. */
4797 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
4798 /* Errors were already issued, set return type to int
4799 as the frontend doesn't expect error_mark_node as
4801 TREE_TYPE (type
) = integer_type_node
;
4802 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
4803 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
4805 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
4806 && TYPE_DECL_ALIAS_P (decl
))
4807 ? DECL_ORIGINAL_TYPE (decl
)
4808 : TREE_TYPE (decl
)))
4810 TREE_TYPE (decl
) = error_mark_node
;
4811 return error_mark_node
;
4815 return process_partial_specialization (decl
);
4817 args
= current_template_args ();
4820 || TREE_CODE (ctx
) == FUNCTION_DECL
4821 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
4822 || (TREE_CODE (decl
) == TYPE_DECL
4823 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4824 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
4826 if (DECL_LANG_SPECIFIC (decl
)
4827 && DECL_TEMPLATE_INFO (decl
)
4828 && DECL_TI_TEMPLATE (decl
))
4829 tmpl
= DECL_TI_TEMPLATE (decl
);
4830 /* If DECL is a TYPE_DECL for a class-template, then there won't
4831 be DECL_LANG_SPECIFIC. The information equivalent to
4832 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4833 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4834 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
4835 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
4837 /* Since a template declaration already existed for this
4838 class-type, we must be redeclaring it here. Make sure
4839 that the redeclaration is valid. */
4840 redeclare_class_template (TREE_TYPE (decl
),
4841 current_template_parms
);
4842 /* We don't need to create a new TEMPLATE_DECL; just use the
4843 one we already had. */
4844 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
4848 tmpl
= build_template_decl (decl
, current_template_parms
,
4852 if (DECL_LANG_SPECIFIC (decl
)
4853 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4855 /* A specialization of a member template of a template
4857 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4858 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
4859 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
4865 tree a
, t
, current
, parms
;
4867 tree tinfo
= get_template_info (decl
);
4871 error ("template definition of non-template %q#D", decl
);
4872 return error_mark_node
;
4875 tmpl
= TI_TEMPLATE (tinfo
);
4877 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
4878 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
4879 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4880 && DECL_MEMBER_TEMPLATE_P (tmpl
))
4884 /* The declaration is a specialization of a member
4885 template, declared outside the class. Therefore, the
4886 innermost template arguments will be NULL, so we
4887 replace them with the arguments determined by the
4888 earlier call to check_explicit_specialization. */
4889 args
= DECL_TI_ARGS (decl
);
4892 = build_template_decl (decl
, current_template_parms
,
4894 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
4895 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
4896 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
4897 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
4898 DECL_TEMPLATE_INFO (new_tmpl
)
4899 = build_template_info (tmpl
, args
);
4901 register_specialization (new_tmpl
,
4902 most_general_template (tmpl
),
4908 /* Make sure the template headers we got make sense. */
4910 parms
= DECL_TEMPLATE_PARMS (tmpl
);
4911 i
= TMPL_PARMS_DEPTH (parms
);
4912 if (TMPL_ARGS_DEPTH (args
) != i
)
4914 error ("expected %d levels of template parms for %q#D, got %d",
4915 i
, decl
, TMPL_ARGS_DEPTH (args
));
4916 DECL_INTERFACE_KNOWN (decl
) = 1;
4917 return error_mark_node
;
4920 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
4922 a
= TMPL_ARGS_LEVEL (args
, i
);
4923 t
= INNERMOST_TEMPLATE_PARMS (parms
);
4925 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
4927 if (current
== decl
)
4928 error ("got %d template parameters for %q#D",
4929 TREE_VEC_LENGTH (a
), decl
);
4931 error ("got %d template parameters for %q#T",
4932 TREE_VEC_LENGTH (a
), current
);
4933 error (" but %d required", TREE_VEC_LENGTH (t
));
4934 /* Avoid crash in import_export_decl. */
4935 DECL_INTERFACE_KNOWN (decl
) = 1;
4936 return error_mark_node
;
4939 if (current
== decl
)
4941 else if (current
== NULL_TREE
)
4942 /* Can happen in erroneous input. */
4945 current
= get_containing_scope (current
);
4948 /* Check that the parms are used in the appropriate qualifying scopes
4949 in the declarator. */
4950 if (!comp_template_args
4952 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
4955 template arguments to %qD do not match original template %qD",
4956 decl
, DECL_TEMPLATE_RESULT (tmpl
));
4957 if (!uses_template_parms (TI_ARGS (tinfo
)))
4958 inform (input_location
, "use template<> for an explicit specialization");
4959 /* Avoid crash in import_export_decl. */
4960 DECL_INTERFACE_KNOWN (decl
) = 1;
4961 return error_mark_node
;
4965 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4966 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
4968 /* Push template declarations for global functions and types. Note
4969 that we do not try to push a global template friend declared in a
4970 template class; such a thing may well depend on the template
4971 parameters of the class. */
4972 if (new_template_p
&& !ctx
4973 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
4975 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
4976 if (tmpl
== error_mark_node
)
4977 return error_mark_node
;
4979 /* Hide template friend classes that haven't been declared yet. */
4980 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
4982 DECL_ANTICIPATED (tmpl
) = 1;
4983 DECL_FRIEND_P (tmpl
) = 1;
4989 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
4992 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
4993 if (DECL_CONV_FN_P (tmpl
))
4995 int depth
= TMPL_PARMS_DEPTH (parms
);
4997 /* It is a conversion operator. See if the type converted to
4998 depends on innermost template operands. */
5000 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
5002 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
5005 /* Give template template parms a DECL_CONTEXT of the template
5006 for which they are a parameter. */
5007 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5008 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5010 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5011 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5012 DECL_CONTEXT (parm
) = tmpl
;
5016 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5017 back to its most general template. If TMPL is a specialization,
5018 ARGS may only have the innermost set of arguments. Add the missing
5019 argument levels if necessary. */
5020 if (DECL_TEMPLATE_INFO (tmpl
))
5021 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5023 info
= build_template_info (tmpl
, args
);
5025 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5026 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5029 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5030 retrofit_lang_decl (decl
);
5031 if (DECL_LANG_SPECIFIC (decl
))
5032 DECL_TEMPLATE_INFO (decl
) = info
;
5035 return DECL_TEMPLATE_RESULT (tmpl
);
5039 push_template_decl (tree decl
)
5041 return push_template_decl_real (decl
, false);
5044 /* FN is an inheriting constructor that inherits from the constructor
5045 template INHERITED; turn FN into a constructor template with a matching
5049 add_inherited_template_parms (tree fn
, tree inherited
)
5052 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5053 inner_parms
= copy_node (inner_parms
);
5055 = tree_cons (size_int (processing_template_decl
+ 1),
5056 inner_parms
, current_template_parms
);
5057 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5058 tree args
= template_parms_to_args (parms
);
5059 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5060 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5061 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5062 DECL_ARTIFICIAL (tmpl
) = true;
5063 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5067 /* Called when a class template TYPE is redeclared with the indicated
5068 template PARMS, e.g.:
5070 template <class T> struct S;
5071 template <class T> struct S {}; */
5074 redeclare_class_template (tree type
, tree parms
)
5080 if (!TYPE_TEMPLATE_INFO (type
))
5082 error ("%qT is not a template type", type
);
5086 tmpl
= TYPE_TI_TEMPLATE (type
);
5087 if (!PRIMARY_TEMPLATE_P (tmpl
))
5088 /* The type is nested in some template class. Nothing to worry
5089 about here; there are no new template parameters for the nested
5095 error ("template specifiers not specified in declaration of %qD",
5100 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5101 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5103 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5105 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5106 "redeclared with %d template parameter",
5107 "redeclared with %d template parameters",
5108 TREE_VEC_LENGTH (parms
));
5109 inform_n (input_location
, TREE_VEC_LENGTH (tmpl_parms
),
5110 "previous declaration %q+D used %d template parameter",
5111 "previous declaration %q+D used %d template parameters",
5112 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5116 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5123 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5124 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5127 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5128 if (tmpl_parm
== error_mark_node
)
5131 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5132 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5133 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5135 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5137 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5138 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5139 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5140 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5141 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5142 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5143 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5144 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5145 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5147 error ("template parameter %q+#D", tmpl_parm
);
5148 error ("redeclared here as %q#D", parm
);
5152 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5154 /* We have in [temp.param]:
5156 A template-parameter may not be given default arguments
5157 by two different declarations in the same scope. */
5158 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5159 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5160 "original definition appeared here");
5164 if (parm_default
!= NULL_TREE
)
5165 /* Update the previous template parameters (which are the ones
5166 that will really count) with the new default value. */
5167 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5168 else if (tmpl_default
!= NULL_TREE
)
5169 /* Update the new parameters, too; they'll be used as the
5170 parameters for any members. */
5171 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5177 /* Simplify EXPR if it is a non-dependent expression. Returns the
5178 (possibly simplified) expression. */
5181 fold_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5183 if (expr
== NULL_TREE
)
5186 /* If we're in a template, but EXPR isn't value dependent, simplify
5187 it. We're supposed to treat:
5189 template <typename T> void f(T[1 + 1]);
5190 template <typename T> void f(T[2]);
5192 as two declarations of the same function, for example. */
5193 if (processing_template_decl
5194 && !instantiation_dependent_expression_p (expr
)
5195 && potential_constant_expression (expr
))
5197 HOST_WIDE_INT saved_processing_template_decl
;
5199 saved_processing_template_decl
= processing_template_decl
;
5200 processing_template_decl
= 0;
5201 expr
= tsubst_copy_and_build (expr
,
5204 /*in_decl=*/NULL_TREE
,
5205 /*function_p=*/false,
5206 /*integral_constant_expression_p=*/true);
5207 processing_template_decl
= saved_processing_template_decl
;
5213 fold_non_dependent_expr (tree expr
)
5215 return fold_non_dependent_expr_sfinae (expr
, tf_error
);
5218 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5219 template declaration, or a TYPE_DECL for an alias declaration. */
5222 alias_type_or_template_p (tree t
)
5226 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5229 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5230 || DECL_ALIAS_TEMPLATE_P (t
));
5233 /* Return TRUE iff is a specialization of an alias template. */
5236 alias_template_specialization_p (const_tree t
)
5242 && TYPE_TEMPLATE_INFO (t
)
5243 && PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (t
))
5244 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (t
)));
5247 /* Return the number of innermost template parameters in TMPL. */
5250 num_innermost_template_parms (tree tmpl
)
5252 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5253 return TREE_VEC_LENGTH (parms
);
5256 /* Return either TMPL or another template that it is equivalent to under DR
5257 1286: An alias that just changes the name of a template is equivalent to
5258 the other template. */
5261 get_underlying_template (tree tmpl
)
5263 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5264 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5266 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5267 if (TYPE_TEMPLATE_INFO (result
))
5269 tree sub
= TYPE_TI_TEMPLATE (result
);
5270 if (PRIMARY_TEMPLATE_P (sub
)
5271 && (num_innermost_template_parms (tmpl
)
5272 == num_innermost_template_parms (sub
)))
5274 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5275 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5276 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5278 /* The alias type is equivalent to the pattern of the
5279 underlying template, so strip the alias. */
5289 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5290 must be a function or a pointer-to-function type, as specified
5291 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5292 and check that the resulting function has external linkage. */
5295 convert_nontype_argument_function (tree type
, tree expr
)
5299 linkage_kind linkage
;
5301 fn
= instantiate_type (type
, fns
, tf_none
);
5302 if (fn
== error_mark_node
)
5303 return error_mark_node
;
5306 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5307 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5308 if (BASELINK_P (fn_no_ptr
))
5309 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5311 /* [temp.arg.nontype]/1
5313 A template-argument for a non-type, non-template template-parameter
5316 -- the address of an object or function with external [C++11: or
5317 internal] linkage. */
5319 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5321 error ("%qE is not a valid template argument for type %qT", expr
, type
);
5322 if (TYPE_PTR_P (type
))
5323 error ("it must be the address of a function with external linkage");
5325 error ("it must be the name of a function with external linkage");
5329 linkage
= decl_linkage (fn_no_ptr
);
5330 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5332 if (cxx_dialect
>= cxx11
)
5333 error ("%qE is not a valid template argument for type %qT "
5334 "because %qD has no linkage",
5335 expr
, type
, fn_no_ptr
);
5337 error ("%qE is not a valid template argument for type %qT "
5338 "because %qD does not have external linkage",
5339 expr
, type
, fn_no_ptr
);
5346 /* Subroutine of convert_nontype_argument.
5347 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5348 Emit an error otherwise. */
5351 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5352 tsubst_flags_t complain
)
5355 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5357 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5359 if (complain
& tf_error
)
5361 error ("%qE is not a valid template argument for type %qT",
5363 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5368 /* Returns TRUE iff the address of OP is value-dependent.
5370 14.6.2.4 [temp.dep.temp]:
5371 A non-integral non-type template-argument is dependent if its type is
5372 dependent or it has either of the following forms
5375 and contains a nested-name-specifier which specifies a class-name that
5376 names a dependent type.
5378 We generalize this to just say that the address of a member of a
5379 dependent class is value-dependent; the above doesn't cover the
5380 address of a static data member named with an unqualified-id. */
5383 has_value_dependent_address (tree op
)
5385 /* We could use get_inner_reference here, but there's no need;
5386 this is only relevant for template non-type arguments, which
5387 can only be expressed as &id-expression. */
5390 tree ctx
= CP_DECL_CONTEXT (op
);
5391 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5398 /* The next set of functions are used for providing helpful explanatory
5399 diagnostics for failed overload resolution. Their messages should be
5400 indented by two spaces for consistency with the messages in
5404 unify_success (bool /*explain_p*/)
5410 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5413 inform (input_location
,
5414 " couldn't deduce template parameter %qD", parm
);
5419 unify_invalid (bool /*explain_p*/)
5425 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5428 inform (input_location
,
5429 " types %qT and %qT have incompatible cv-qualifiers",
5435 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5438 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5443 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5446 inform (input_location
,
5447 " template parameter %qD is not a parameter pack, but "
5454 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5457 inform (input_location
,
5458 " template argument %qE does not match "
5459 "pointer-to-member constant %qE",
5465 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5468 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5473 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5476 inform (input_location
,
5477 " inconsistent parameter pack deduction with %qT and %qT",
5483 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5488 inform (input_location
,
5489 " deduced conflicting types for parameter %qT (%qT and %qT)",
5490 parm
, first
, second
);
5492 inform (input_location
,
5493 " deduced conflicting values for non-type parameter "
5494 "%qE (%qE and %qE)", parm
, first
, second
);
5500 unify_vla_arg (bool explain_p
, tree arg
)
5503 inform (input_location
,
5504 " variable-sized array type %qT is not "
5505 "a valid template argument",
5511 unify_method_type_error (bool explain_p
, tree arg
)
5514 inform (input_location
,
5515 " member function type %qT is not a valid template argument",
5521 unify_arity (bool explain_p
, int have
, int wanted
)
5524 inform_n (input_location
, wanted
,
5525 " candidate expects %d argument, %d provided",
5526 " candidate expects %d arguments, %d provided",
5532 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5534 return unify_arity (explain_p
, have
, wanted
);
5538 unify_too_few_arguments (bool explain_p
, int have
, int wanted
)
5540 return unify_arity (explain_p
, have
, wanted
);
5544 unify_arg_conversion (bool explain_p
, tree to_type
,
5545 tree from_type
, tree arg
)
5548 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5549 " cannot convert %qE (type %qT) to type %qT",
5550 arg
, from_type
, to_type
);
5555 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5556 tree parm
, tree arg
)
5561 case tbr_ambiguous_baseclass
:
5562 inform (input_location
, " %qT is an ambiguous base class of %qT",
5566 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5573 unify_inconsistent_template_template_parameters (bool explain_p
)
5576 inform (input_location
,
5577 " template parameters of a template template argument are "
5578 "inconsistent with other deduced template arguments");
5583 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5586 inform (input_location
,
5587 " can't deduce a template for %qT from non-template type %qT",
5593 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5596 inform (input_location
,
5597 " template argument %qE does not match %qD", arg
, parm
);
5602 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5605 inform (input_location
,
5606 " could not resolve address from overloaded function %qE",
5611 /* Attempt to convert the non-type template parameter EXPR to the
5612 indicated TYPE. If the conversion is successful, return the
5613 converted value. If the conversion is unsuccessful, return
5614 NULL_TREE if we issued an error message, or error_mark_node if we
5615 did not. We issue error messages for out-and-out bad template
5616 parameters, but not simply because the conversion failed, since we
5617 might be just trying to do argument deduction. Both TYPE and EXPR
5618 must be non-dependent.
5620 The conversion follows the special rules described in
5621 [temp.arg.nontype], and it is much more strict than an implicit
5624 This function is called twice for each template argument (see
5625 lookup_template_class for a more accurate description of this
5626 problem). This means that we need to handle expressions which
5627 are not valid in a C++ source, but can be created from the
5628 first call (for instance, casts to perform conversions). These
5629 hacks can go away after we fix the double coercion problem. */
5632 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5636 /* Detect immediately string literals as invalid non-type argument.
5637 This special-case is not needed for correctness (we would easily
5638 catch this later), but only to provide better diagnostic for this
5639 common user mistake. As suggested by DR 100, we do not mention
5640 linkage issues in the diagnostic as this is not the point. */
5641 /* FIXME we're making this OK. */
5642 if (TREE_CODE (expr
) == STRING_CST
)
5644 if (complain
& tf_error
)
5645 error ("%qE is not a valid template argument for type %qT "
5646 "because string literals can never be used in this context",
5651 /* Add the ADDR_EXPR now for the benefit of
5652 value_dependent_expression_p. */
5653 if (TYPE_PTROBV_P (type
)
5654 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5656 expr
= decay_conversion (expr
, complain
);
5657 if (expr
== error_mark_node
)
5658 return error_mark_node
;
5661 /* If we are in a template, EXPR may be non-dependent, but still
5662 have a syntactic, rather than semantic, form. For example, EXPR
5663 might be a SCOPE_REF, rather than the VAR_DECL to which the
5664 SCOPE_REF refers. Preserving the qualifying scope is necessary
5665 so that access checking can be performed when the template is
5666 instantiated -- but here we need the resolved form so that we can
5667 convert the argument. */
5668 if (TYPE_REF_OBJ_P (type
)
5669 && has_value_dependent_address (expr
))
5670 /* If we want the address and it's value-dependent, don't fold. */;
5671 else if (!type_unknown_p (expr
))
5672 expr
= fold_non_dependent_expr_sfinae (expr
, complain
);
5673 if (error_operand_p (expr
))
5674 return error_mark_node
;
5675 expr_type
= TREE_TYPE (expr
);
5676 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5677 expr
= mark_lvalue_use (expr
);
5679 expr
= mark_rvalue_use (expr
);
5681 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5682 to a non-type argument of "nullptr". */
5683 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5684 expr
= convert (type
, expr
);
5686 /* In C++11, integral or enumeration non-type template arguments can be
5687 arbitrary constant expressions. Pointer and pointer to
5688 member arguments can be general constant expressions that evaluate
5689 to a null value, but otherwise still need to be of a specific form. */
5690 if (cxx_dialect
>= cxx11
)
5692 if (TREE_CODE (expr
) == PTRMEM_CST
)
5693 /* A PTRMEM_CST is already constant, and a valid template
5694 argument for a parameter of pointer to member type, we just want
5695 to leave it in that form rather than lower it to a
5697 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5698 expr
= maybe_constant_value (expr
);
5699 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5701 tree folded
= maybe_constant_value (expr
);
5702 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5703 : null_member_pointer_value_p (folded
))
5708 /* HACK: Due to double coercion, we can get a
5709 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5710 which is the tree that we built on the first call (see
5711 below when coercing to reference to object or to reference to
5712 function). We just strip everything and get to the arg.
5713 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5715 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5717 tree probe_type
, probe
= expr
;
5718 if (REFERENCE_REF_P (probe
))
5719 probe
= TREE_OPERAND (probe
, 0);
5720 probe_type
= TREE_TYPE (probe
);
5721 if (TREE_CODE (probe
) == NOP_EXPR
)
5723 /* ??? Maybe we could use convert_from_reference here, but we
5724 would need to relax its constraints because the NOP_EXPR
5725 could actually change the type to something more cv-qualified,
5726 and this is not folded by convert_from_reference. */
5727 tree addr
= TREE_OPERAND (probe
, 0);
5728 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5729 && TREE_CODE (addr
) == ADDR_EXPR
5730 && TYPE_PTR_P (TREE_TYPE (addr
))
5731 && (same_type_ignoring_top_level_qualifiers_p
5732 (TREE_TYPE (probe_type
),
5733 TREE_TYPE (TREE_TYPE (addr
)))))
5735 expr
= TREE_OPERAND (addr
, 0);
5736 expr_type
= TREE_TYPE (probe_type
);
5741 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5742 parameter is a pointer to object, through decay and
5743 qualification conversion. Let's strip everything. */
5744 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5748 if (TREE_CODE (probe
) == ADDR_EXPR
5749 && TYPE_PTR_P (TREE_TYPE (probe
)))
5751 /* Skip the ADDR_EXPR only if it is part of the decay for
5752 an array. Otherwise, it is part of the original argument
5753 in the source code. */
5754 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5755 probe
= TREE_OPERAND (probe
, 0);
5757 expr_type
= TREE_TYPE (expr
);
5761 /* [temp.arg.nontype]/5, bullet 1
5763 For a non-type template-parameter of integral or enumeration type,
5764 integral promotions (_conv.prom_) and integral conversions
5765 (_conv.integral_) are applied. */
5766 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5768 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5769 t
= maybe_constant_value (t
);
5770 if (t
!= error_mark_node
)
5773 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5774 return error_mark_node
;
5776 /* Notice that there are constant expressions like '4 % 0' which
5777 do not fold into integer constants. */
5778 if (TREE_CODE (expr
) != INTEGER_CST
)
5780 if (complain
& tf_error
)
5782 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
5783 if (processing_template_decl
5784 && !require_potential_constant_expression (expr
))
5786 expr
= cxx_constant_value (expr
);
5787 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
5788 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
5789 "in template argument for type %qT ", type
);
5790 if (expr
== error_mark_node
)
5792 /* else cxx_constant_value complained but gave us
5793 a real constant, so go ahead. */
5794 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
5800 /* Avoid typedef problems. */
5801 if (TREE_TYPE (expr
) != type
)
5802 expr
= fold_convert (type
, expr
);
5804 /* [temp.arg.nontype]/5, bullet 2
5806 For a non-type template-parameter of type pointer to object,
5807 qualification conversions (_conv.qual_) and the array-to-pointer
5808 conversion (_conv.array_) are applied. */
5809 else if (TYPE_PTROBV_P (type
))
5811 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5813 A template-argument for a non-type, non-template template-parameter
5814 shall be one of: [...]
5816 -- the name of a non-type template-parameter;
5817 -- the address of an object or function with external linkage, [...]
5818 expressed as "& id-expression" where the & is optional if the name
5819 refers to a function or array, or if the corresponding
5820 template-parameter is a reference.
5822 Here, we do not care about functions, as they are invalid anyway
5823 for a parameter of type pointer-to-object. */
5825 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
5826 /* Non-type template parameters are OK. */
5828 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5829 /* Null pointer values are OK in C++11. */;
5830 else if (TREE_CODE (expr
) != ADDR_EXPR
5831 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
5835 error ("%qD is not a valid template argument "
5836 "because %qD is a variable, not the address of "
5841 if (POINTER_TYPE_P (expr_type
))
5843 error ("%qE is not a valid template argument for %qT "
5844 "because it is not the address of a variable",
5848 /* Other values, like integer constants, might be valid
5849 non-type arguments of some other type. */
5850 return error_mark_node
;
5856 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
5857 ? TREE_OPERAND (expr
, 0) : expr
);
5860 error ("%qE is not a valid template argument of type %qT "
5861 "because %qE is not a variable",
5865 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
5867 error ("%qE is not a valid template argument of type %qT "
5868 "because %qD does not have external linkage",
5872 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
5874 error ("%qE is not a valid template argument of type %qT "
5875 "because %qD has no linkage",
5881 expr
= decay_conversion (expr
, complain
);
5882 if (expr
== error_mark_node
)
5883 return error_mark_node
;
5885 expr
= perform_qualification_conversions (type
, expr
);
5886 if (expr
== error_mark_node
)
5887 return error_mark_node
;
5889 /* [temp.arg.nontype]/5, bullet 3
5891 For a non-type template-parameter of type reference to object, no
5892 conversions apply. The type referred to by the reference may be more
5893 cv-qualified than the (otherwise identical) type of the
5894 template-argument. The template-parameter is bound directly to the
5895 template-argument, which must be an lvalue. */
5896 else if (TYPE_REF_OBJ_P (type
))
5898 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
5900 return error_mark_node
;
5902 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
5904 error ("%qE is not a valid template argument for type %qT "
5905 "because of conflicts in cv-qualification", expr
, type
);
5909 if (!real_lvalue_p (expr
))
5911 error ("%qE is not a valid template argument for type %qT "
5912 "because it is not an lvalue", expr
, type
);
5916 /* [temp.arg.nontype]/1
5918 A template-argument for a non-type, non-template template-parameter
5919 shall be one of: [...]
5921 -- the address of an object or function with external linkage. */
5922 if (INDIRECT_REF_P (expr
)
5923 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
5925 expr
= TREE_OPERAND (expr
, 0);
5928 error ("%q#D is not a valid template argument for type %qT "
5929 "because a reference variable does not have a constant "
5930 "address", expr
, type
);
5937 error ("%qE is not a valid template argument for type %qT "
5938 "because it is not an object with external linkage",
5943 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
5945 error ("%qE is not a valid template argument for type %qT "
5946 "because object %qD has not external linkage",
5951 expr
= build_nop (type
, build_address (expr
));
5953 /* [temp.arg.nontype]/5, bullet 4
5955 For a non-type template-parameter of type pointer to function, only
5956 the function-to-pointer conversion (_conv.func_) is applied. If the
5957 template-argument represents a set of overloaded functions (or a
5958 pointer to such), the matching function is selected from the set
5960 else if (TYPE_PTRFN_P (type
))
5962 /* If the argument is a template-id, we might not have enough
5963 context information to decay the pointer. */
5964 if (!type_unknown_p (expr_type
))
5966 expr
= decay_conversion (expr
, complain
);
5967 if (expr
== error_mark_node
)
5968 return error_mark_node
;
5971 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5972 /* Null pointer values are OK in C++11. */
5973 return perform_qualification_conversions (type
, expr
);
5975 expr
= convert_nontype_argument_function (type
, expr
);
5976 if (!expr
|| expr
== error_mark_node
)
5979 /* [temp.arg.nontype]/5, bullet 5
5981 For a non-type template-parameter of type reference to function, no
5982 conversions apply. If the template-argument represents a set of
5983 overloaded functions, the matching function is selected from the set
5985 else if (TYPE_REFFN_P (type
))
5987 if (TREE_CODE (expr
) == ADDR_EXPR
)
5989 error ("%qE is not a valid template argument for type %qT "
5990 "because it is a pointer", expr
, type
);
5991 inform (input_location
, "try using %qE instead", TREE_OPERAND (expr
, 0));
5995 expr
= convert_nontype_argument_function (type
, expr
);
5996 if (!expr
|| expr
== error_mark_node
)
5999 expr
= build_nop (type
, build_address (expr
));
6001 /* [temp.arg.nontype]/5, bullet 6
6003 For a non-type template-parameter of type pointer to member function,
6004 no conversions apply. If the template-argument represents a set of
6005 overloaded member functions, the matching member function is selected
6006 from the set (_over.over_). */
6007 else if (TYPE_PTRMEMFUNC_P (type
))
6009 expr
= instantiate_type (type
, expr
, tf_none
);
6010 if (expr
== error_mark_node
)
6011 return error_mark_node
;
6013 /* [temp.arg.nontype] bullet 1 says the pointer to member
6014 expression must be a pointer-to-member constant. */
6015 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6016 return error_mark_node
;
6018 /* There is no way to disable standard conversions in
6019 resolve_address_of_overloaded_function (called by
6020 instantiate_type). It is possible that the call succeeded by
6021 converting &B::I to &D::I (where B is a base of D), so we need
6022 to reject this conversion here.
6024 Actually, even if there was a way to disable standard conversions,
6025 it would still be better to reject them here so that we can
6026 provide a superior diagnostic. */
6027 if (!same_type_p (TREE_TYPE (expr
), type
))
6029 error ("%qE is not a valid template argument for type %qT "
6030 "because it is of type %qT", expr
, type
,
6032 /* If we are just one standard conversion off, explain. */
6033 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6034 inform (input_location
,
6035 "standard conversions are not allowed in this context");
6039 /* [temp.arg.nontype]/5, bullet 7
6041 For a non-type template-parameter of type pointer to data member,
6042 qualification conversions (_conv.qual_) are applied. */
6043 else if (TYPE_PTRDATAMEM_P (type
))
6045 /* [temp.arg.nontype] bullet 1 says the pointer to member
6046 expression must be a pointer-to-member constant. */
6047 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6048 return error_mark_node
;
6050 expr
= perform_qualification_conversions (type
, expr
);
6051 if (expr
== error_mark_node
)
6054 else if (NULLPTR_TYPE_P (type
))
6056 if (expr
!= nullptr_node
)
6058 error ("%qE is not a valid template argument for type %qT "
6059 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6064 /* A template non-type parameter must be one of the above. */
6068 /* Sanity check: did we actually convert the argument to the
6070 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6071 (type
, TREE_TYPE (expr
)));
6075 /* Subroutine of coerce_template_template_parms, which returns 1 if
6076 PARM_PARM and ARG_PARM match using the rule for the template
6077 parameters of template template parameters. Both PARM and ARG are
6078 template parameters; the rest of the arguments are the same as for
6079 coerce_template_template_parms.
6082 coerce_template_template_parm (tree parm
,
6084 tsubst_flags_t complain
,
6088 if (arg
== NULL_TREE
|| arg
== error_mark_node
6089 || parm
== NULL_TREE
|| parm
== error_mark_node
)
6092 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6095 switch (TREE_CODE (parm
))
6098 /* We encounter instantiations of templates like
6099 template <template <template <class> class> class TT>
6102 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6103 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6105 if (!coerce_template_template_parms
6106 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6112 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6113 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6114 /* Argument is a parameter pack but parameter is not. */
6119 /* The tsubst call is used to handle cases such as
6121 template <int> class C {};
6122 template <class T, template <T> class TT> class D {};
6125 i.e. the parameter list of TT depends on earlier parameters. */
6126 if (!uses_template_parms (TREE_TYPE (arg
))
6128 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6132 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6133 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6134 /* Argument is a parameter pack but parameter is not. */
6147 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6148 template template parameters. Both PARM_PARMS and ARG_PARMS are
6149 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6152 Consider the example:
6153 template <class T> class A;
6154 template<template <class U> class TT> class B;
6156 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6157 the parameters to A, and OUTER_ARGS contains A. */
6160 coerce_template_template_parms (tree parm_parms
,
6162 tsubst_flags_t complain
,
6166 int nparms
, nargs
, i
;
6170 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6171 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6173 nparms
= TREE_VEC_LENGTH (parm_parms
);
6174 nargs
= TREE_VEC_LENGTH (arg_parms
);
6176 /* Determine whether we have a parameter pack at the end of the
6177 template template parameter's template parameter list. */
6178 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6180 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6182 if (parm
== error_mark_node
)
6185 switch (TREE_CODE (parm
))
6189 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6194 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6204 && !(variadic_p
&& nargs
>= nparms
- 1))
6207 /* Check all of the template parameters except the parameter pack at
6208 the end (if any). */
6209 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6211 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6212 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6215 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6216 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6218 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6226 /* Check each of the template parameters in the template
6227 argument against the template parameter pack at the end of
6228 the template template parameter. */
6229 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6232 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6234 for (; i
< nargs
; ++i
)
6236 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6239 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6241 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6250 /* Verifies that the deduced template arguments (in TARGS) for the
6251 template template parameters (in TPARMS) represent valid bindings,
6252 by comparing the template parameter list of each template argument
6253 to the template parameter list of its corresponding template
6254 template parameter, in accordance with DR150. This
6255 routine can only be called after all template arguments have been
6256 deduced. It will return TRUE if all of the template template
6257 parameter bindings are okay, FALSE otherwise. */
6259 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6261 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6264 /* We're dealing with template parms in this process. */
6265 ++processing_template_decl
;
6267 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6269 for (i
= 0; i
< ntparms
; ++i
)
6271 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6272 tree targ
= TREE_VEC_ELT (targs
, i
);
6274 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6276 tree packed_args
= NULL_TREE
;
6279 if (ARGUMENT_PACK_P (targ
))
6281 /* Look inside the argument pack. */
6282 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6283 len
= TREE_VEC_LENGTH (packed_args
);
6286 for (idx
= 0; idx
< len
; ++idx
)
6288 tree targ_parms
= NULL_TREE
;
6291 /* Extract the next argument from the argument
6293 targ
= TREE_VEC_ELT (packed_args
, idx
);
6295 if (PACK_EXPANSION_P (targ
))
6296 /* Look at the pattern of the pack expansion. */
6297 targ
= PACK_EXPANSION_PATTERN (targ
);
6299 /* Extract the template parameters from the template
6301 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6302 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6303 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6304 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6306 /* Verify that we can coerce the template template
6307 parameters from the template argument to the template
6308 parameter. This requires an exact match. */
6310 && !coerce_template_template_parms
6311 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6326 --processing_template_decl
;
6330 /* Since type attributes aren't mangled, we need to strip them from
6331 template type arguments. */
6334 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6337 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6339 mv
= TYPE_MAIN_VARIANT (arg
);
6340 arg
= strip_typedefs (arg
);
6341 if (TYPE_ALIGN (arg
) != TYPE_ALIGN (mv
)
6342 || TYPE_ATTRIBUTES (arg
) != TYPE_ATTRIBUTES (mv
))
6344 if (complain
& tf_warning
)
6345 warning (0, "ignoring attributes on template argument %qT", arg
);
6346 arg
= build_aligned_type (arg
, TYPE_ALIGN (mv
));
6347 arg
= cp_build_type_attribute_variant (arg
, TYPE_ATTRIBUTES (mv
));
6352 /* Convert the indicated template ARG as necessary to match the
6353 indicated template PARM. Returns the converted ARG, or
6354 error_mark_node if the conversion was unsuccessful. Error and
6355 warning messages are issued under control of COMPLAIN. This
6356 conversion is for the Ith parameter in the parameter list. ARGS is
6357 the full set of template arguments deduced so far. */
6360 convert_template_argument (tree parm
,
6363 tsubst_flags_t complain
,
6369 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6371 if (TREE_CODE (arg
) == TREE_LIST
6372 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6374 /* The template argument was the name of some
6375 member function. That's usually
6376 invalid, but static members are OK. In any
6377 case, grab the underlying fields/functions
6378 and issue an error later if required. */
6379 orig_arg
= TREE_VALUE (arg
);
6380 TREE_TYPE (arg
) = unknown_type_node
;
6385 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6386 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6387 || requires_tmpl_type
);
6389 /* When determining whether an argument pack expansion is a template,
6390 look at the pattern. */
6391 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6392 arg
= PACK_EXPANSION_PATTERN (arg
);
6394 /* Deal with an injected-class-name used as a template template arg. */
6395 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6397 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6398 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6400 if (cxx_dialect
>= cxx11
)
6401 /* OK under DR 1004. */;
6402 else if (complain
& tf_warning_or_error
)
6403 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6404 " used as template template argument", TYPE_NAME (arg
));
6405 else if (flag_pedantic_errors
)
6413 ((TREE_CODE (arg
) == TEMPLATE_DECL
6414 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6415 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6416 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6417 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6420 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6421 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6422 arg
= TYPE_STUB_DECL (arg
);
6424 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6426 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6427 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6429 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6431 if (complain
& tf_error
)
6432 error ("invalid use of destructor %qE as a type", orig_arg
);
6433 return error_mark_node
;
6436 permerror (input_location
,
6437 "to refer to a type member of a template parameter, "
6438 "use %<typename %E%>", orig_arg
);
6440 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6441 TREE_OPERAND (arg
, 1),
6447 if (is_type
!= requires_type
)
6451 if (complain
& tf_error
)
6453 error ("type/value mismatch at argument %d in template "
6454 "parameter list for %qD",
6457 error (" expected a constant of type %qT, got %qT",
6459 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6460 else if (requires_tmpl_type
)
6461 error (" expected a class template, got %qE", orig_arg
);
6463 error (" expected a type, got %qE", orig_arg
);
6466 return error_mark_node
;
6468 if (is_tmpl_type
^ requires_tmpl_type
)
6470 if (in_decl
&& (complain
& tf_error
))
6472 error ("type/value mismatch at argument %d in template "
6473 "parameter list for %qD",
6476 error (" expected a type, got %qT", DECL_NAME (arg
));
6478 error (" expected a class template, got %qT", orig_arg
);
6480 return error_mark_node
;
6485 if (requires_tmpl_type
)
6487 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6489 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6490 /* The number of argument required is not known yet.
6491 Just accept it for now. */
6492 val
= TREE_TYPE (arg
);
6495 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6498 /* Strip alias templates that are equivalent to another
6500 arg
= get_underlying_template (arg
);
6501 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6503 if (coerce_template_template_parms (parmparm
, argparm
,
6509 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6511 if (val
!= error_mark_node
)
6513 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6514 val
= TREE_TYPE (val
);
6515 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6516 val
= make_pack_expansion (val
);
6521 if (in_decl
&& (complain
& tf_error
))
6523 error ("type/value mismatch at argument %d in "
6524 "template parameter list for %qD",
6526 error (" expected a template of type %qD, got %qT",
6530 val
= error_mark_node
;
6536 /* We only form one instance of each template specialization.
6537 Therefore, if we use a non-canonical variant (i.e., a
6538 typedef), any future messages referring to the type will use
6539 the typedef, which is confusing if those future uses do not
6540 themselves also use the typedef. */
6542 val
= canonicalize_type_argument (val
, complain
);
6546 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6548 if (invalid_nontype_parm_type_p (t
, complain
))
6549 return error_mark_node
;
6551 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6553 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6557 /* Not sure if this is reachable, but it doesn't hurt
6559 error ("type mismatch in nontype parameter pack");
6560 val
= error_mark_node
;
6563 else if (!dependent_template_arg_p (orig_arg
)
6564 && !uses_template_parms (t
))
6565 /* We used to call digest_init here. However, digest_init
6566 will report errors, which we don't want when complain
6567 is zero. More importantly, digest_init will try too
6568 hard to convert things: for example, `0' should not be
6569 converted to pointer type at this point according to
6570 the standard. Accepting this is not merely an
6571 extension, since deciding whether or not these
6572 conversions can occur is part of determining which
6573 function template to call, or whether a given explicit
6574 argument specification is valid. */
6575 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6577 val
= strip_typedefs_expr (orig_arg
);
6579 if (val
== NULL_TREE
)
6580 val
= error_mark_node
;
6581 else if (val
== error_mark_node
&& (complain
& tf_error
))
6582 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6584 if (TREE_CODE (val
) == SCOPE_REF
)
6586 /* Strip typedefs from the SCOPE_REF. */
6587 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6588 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6590 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6591 QUALIFIED_NAME_IS_TEMPLATE (val
));
6598 /* Coerces the remaining template arguments in INNER_ARGS (from
6599 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6600 Returns the coerced argument pack. PARM_IDX is the position of this
6601 parameter in the template parameter list. ARGS is the original
6602 template argument list. */
6604 coerce_template_parameter_pack (tree parms
,
6612 tsubst_flags_t complain
)
6614 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6615 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6618 tree packed_parms
= NULL_TREE
;
6620 if (arg_idx
> nargs
)
6623 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6625 /* When the template parameter is a non-type template parameter pack
6626 or template template parameter pack whose type or template
6627 parameters use parameter packs, we know exactly how many arguments
6628 we are looking for. Build a vector of the instantiated decls for
6629 these template parameters in PACKED_PARMS. */
6630 /* We can't use make_pack_expansion here because it would interpret a
6631 _DECL as a use rather than a declaration. */
6632 tree decl
= TREE_VALUE (parm
);
6633 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6634 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6635 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6636 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6638 TREE_VEC_LENGTH (args
)--;
6639 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6640 TREE_VEC_LENGTH (args
)++;
6642 if (packed_parms
== error_mark_node
)
6643 return error_mark_node
;
6645 /* If we're doing a partial instantiation of a member template,
6646 verify that all of the types used for the non-type
6647 template parameter pack are, in fact, valid for non-type
6648 template parameters. */
6650 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6652 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6653 for (j
= 0; j
< len
; ++j
)
6655 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6656 if (invalid_nontype_parm_type_p (t
, complain
))
6657 return error_mark_node
;
6661 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6664 packed_args
= make_tree_vec (nargs
- arg_idx
);
6666 /* Convert the remaining arguments, which will be a part of the
6667 parameter pack "parm". */
6668 for (; arg_idx
< nargs
; ++arg_idx
)
6670 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6671 tree actual_parm
= TREE_VALUE (parm
);
6672 int pack_idx
= arg_idx
- parm_idx
;
6676 /* Once we've packed as many args as we have types, stop. */
6677 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6679 else if (PACK_EXPANSION_P (arg
))
6680 /* We don't know how many args we have yet, just
6681 use the unconverted ones for now. */
6684 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6687 if (arg
== error_mark_node
)
6689 if (complain
& tf_error
)
6690 error ("template argument %d is invalid", arg_idx
+ 1);
6693 arg
= convert_template_argument (actual_parm
,
6694 arg
, new_args
, complain
, parm_idx
,
6696 if (arg
== error_mark_node
)
6698 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6701 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6702 && TREE_VEC_LENGTH (packed_args
) > 0)
6704 error ("wrong number of template arguments (%d, should be %d)",
6705 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6706 return error_mark_node
;
6709 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6710 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6711 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6714 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6715 TREE_TYPE (argument_pack
)
6716 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6717 TREE_CONSTANT (argument_pack
) = 1;
6720 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6721 #ifdef ENABLE_CHECKING
6722 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6723 TREE_VEC_LENGTH (packed_args
));
6725 return argument_pack
;
6728 /* Returns the number of pack expansions in the template argument vector
6732 pack_expansion_args_count (tree args
)
6737 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6739 tree elt
= TREE_VEC_ELT (args
, i
);
6740 if (elt
&& PACK_EXPANSION_P (elt
))
6746 /* Convert all template arguments to their appropriate types, and
6747 return a vector containing the innermost resulting template
6748 arguments. If any error occurs, return error_mark_node. Error and
6749 warning messages are issued under control of COMPLAIN.
6751 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6752 for arguments not specified in ARGS. Otherwise, if
6753 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6754 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6755 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6759 coerce_template_parms (tree parms
,
6762 tsubst_flags_t complain
,
6763 bool require_all_args
,
6764 bool use_default_args
)
6766 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6767 tree orig_inner_args
;
6770 tree new_inner_args
;
6771 int saved_unevaluated_operand
;
6772 int saved_inhibit_evaluation_warnings
;
6774 /* When used as a boolean value, indicates whether this is a
6775 variadic template parameter list. Since it's an int, we can also
6776 subtract it from nparms to get the number of non-variadic
6779 int variadic_args_p
= 0;
6780 int post_variadic_parms
= 0;
6782 if (args
== error_mark_node
)
6783 return error_mark_node
;
6785 nparms
= TREE_VEC_LENGTH (parms
);
6787 /* Determine if there are any parameter packs. */
6788 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
6790 tree tparm
= TREE_VALUE (TREE_VEC_ELT (parms
, parm_idx
));
6792 ++post_variadic_parms
;
6793 if (template_parameter_pack_p (tparm
))
6797 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
6798 /* If there are no parameters that follow a parameter pack, we need to
6799 expand any argument packs so that we can deduce a parameter pack from
6800 some non-packed args followed by an argument pack, as in variadic85.C.
6801 If there are such parameters, we need to leave argument packs intact
6802 so the arguments are assigned properly. This can happen when dealing
6803 with a nested class inside a partial specialization of a class
6804 template, as in variadic92.C, or when deducing a template parameter pack
6805 from a sub-declarator, as in variadic114.C. */
6806 if (!post_variadic_parms
)
6807 inner_args
= expand_template_argument_pack (inner_args
);
6809 /* Count any pack expansion args. */
6810 variadic_args_p
= pack_expansion_args_count (inner_args
);
6812 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6813 if ((nargs
> nparms
&& !variadic_p
)
6814 || (nargs
< nparms
- variadic_p
6817 && (!use_default_args
6818 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
6819 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
6821 if (complain
& tf_error
)
6825 nparms
-= variadic_p
;
6826 error ("wrong number of template arguments "
6827 "(%d, should be %d or more)", nargs
, nparms
);
6830 error ("wrong number of template arguments "
6831 "(%d, should be %d)", nargs
, nparms
);
6834 error ("provided for %q+D", in_decl
);
6837 return error_mark_node
;
6839 /* We can't pass a pack expansion to a non-pack parameter of an alias
6840 template (DR 1430). */
6841 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
6843 && nargs
- variadic_args_p
< nparms
- variadic_p
)
6845 if (complain
& tf_error
)
6847 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
6849 tree arg
= TREE_VEC_ELT (inner_args
, i
);
6850 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
6852 if (PACK_EXPANSION_P (arg
)
6853 && !template_parameter_pack_p (parm
))
6855 error ("pack expansion argument for non-pack parameter "
6856 "%qD of alias template %qD", parm
, in_decl
);
6857 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
6864 return error_mark_node
;
6867 /* We need to evaluate the template arguments, even though this
6868 template-id may be nested within a "sizeof". */
6869 saved_unevaluated_operand
= cp_unevaluated_operand
;
6870 cp_unevaluated_operand
= 0;
6871 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6872 c_inhibit_evaluation_warnings
= 0;
6873 new_inner_args
= make_tree_vec (nparms
);
6874 new_args
= add_outermost_template_args (args
, new_inner_args
);
6875 int pack_adjust
= 0;
6876 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
6881 /* Get the Ith template parameter. */
6882 parm
= TREE_VEC_ELT (parms
, parm_idx
);
6884 if (parm
== error_mark_node
)
6886 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
6890 /* Calculate the next argument. */
6891 if (arg_idx
< nargs
)
6892 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6896 if (template_parameter_pack_p (TREE_VALUE (parm
))
6897 && !(arg
&& ARGUMENT_PACK_P (arg
)))
6899 /* Some arguments will be placed in the
6900 template parameter pack PARM. */
6901 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
6902 inner_args
, arg_idx
,
6906 if (arg
== NULL_TREE
)
6908 /* We don't know how many args we have yet, just use the
6909 unconverted (and still packed) ones for now. */
6910 new_inner_args
= orig_inner_args
;
6915 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
6917 /* Store this argument. */
6918 if (arg
== error_mark_node
)
6921 /* We are done with all of the arguments. */
6926 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
6927 arg_idx
+= pack_adjust
;
6934 if (PACK_EXPANSION_P (arg
))
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 late-specified
12637 return type of a local lambda. Just make a dummy decl
12638 since it's only used for its type. */
12639 if (cp_unevaluated_operand
)
12640 return tsubst_decl (t
, args
, complain
);
12641 gcc_assert (errorcount
|| sorrycount
);
12642 return error_mark_node
;
12651 case NAMESPACE_DECL
:
12655 /* An OVERLOAD will always be a non-dependent overload set; an
12656 overload set from function scope will just be represented with an
12657 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12658 gcc_assert (!uses_template_parms (t
));
12662 return tsubst_baselink (t
, current_nonlambda_class_type (),
12663 args
, complain
, in_decl
);
12665 case TEMPLATE_DECL
:
12666 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12667 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
12668 args
, complain
, in_decl
);
12669 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
12670 return tsubst (t
, args
, complain
, in_decl
);
12671 else if (DECL_CLASS_SCOPE_P (t
)
12672 && uses_template_parms (DECL_CONTEXT (t
)))
12674 /* Template template argument like the following example need
12677 template <template <class> class TT> struct C {};
12678 template <class T> struct D {
12679 template <class U> struct E {};
12684 We are processing the template argument `E' in #1 for
12685 the template instantiation #2. Originally, `E' is a
12686 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12687 have to substitute this with one having context `D<int>'. */
12689 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
12690 return lookup_field (context
, DECL_NAME(t
), 0, false);
12693 /* Ordinary template template argument. */
12697 case REINTERPRET_CAST_EXPR
:
12698 case CONST_CAST_EXPR
:
12699 case STATIC_CAST_EXPR
:
12700 case DYNAMIC_CAST_EXPR
:
12701 case IMPLICIT_CONV_EXPR
:
12705 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
12706 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
12709 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
12712 tree expanded
, op
= TREE_OPERAND (t
, 0);
12715 if (SIZEOF_EXPR_TYPE_P (t
))
12716 op
= TREE_TYPE (op
);
12718 ++cp_unevaluated_operand
;
12719 ++c_inhibit_evaluation_warnings
;
12720 /* We only want to compute the number of arguments. */
12721 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
12722 --cp_unevaluated_operand
;
12723 --c_inhibit_evaluation_warnings
;
12725 if (TREE_CODE (expanded
) == TREE_VEC
)
12726 len
= TREE_VEC_LENGTH (expanded
);
12728 if (expanded
== error_mark_node
)
12729 return error_mark_node
;
12730 else if (PACK_EXPANSION_P (expanded
)
12731 || (TREE_CODE (expanded
) == TREE_VEC
12733 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
12735 if (TREE_CODE (expanded
) == TREE_VEC
)
12736 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
12738 if (TYPE_P (expanded
))
12739 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
12740 complain
& tf_error
);
12742 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
12743 complain
& tf_error
);
12746 return build_int_cst (size_type_node
, len
);
12748 if (SIZEOF_EXPR_TYPE_P (t
))
12750 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
12751 args
, complain
, in_decl
);
12752 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
12753 r
= build1 (SIZEOF_EXPR
,
12754 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
12755 SIZEOF_EXPR_TYPE_P (r
) = 1;
12762 case TRUTH_NOT_EXPR
:
12765 case UNARY_PLUS_EXPR
: /* Unary + */
12767 case AT_ENCODE_EXPR
:
12771 case REALPART_EXPR
:
12772 case IMAGPART_EXPR
:
12775 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
12776 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
12778 case COMPONENT_REF
:
12783 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12784 name
= TREE_OPERAND (t
, 1);
12785 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
12787 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12788 complain
, in_decl
);
12789 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12791 else if (TREE_CODE (name
) == SCOPE_REF
12792 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
12794 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12795 complain
, in_decl
);
12796 name
= TREE_OPERAND (name
, 1);
12797 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12798 complain
, in_decl
);
12799 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12800 name
= build_qualified_name (/*type=*/NULL_TREE
,
12802 /*template_p=*/false);
12804 else if (BASELINK_P (name
))
12805 name
= tsubst_baselink (name
,
12806 non_reference (TREE_TYPE (object
)),
12810 name
= tsubst_copy (name
, args
, complain
, in_decl
);
12811 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
12817 case TRUNC_DIV_EXPR
:
12818 case CEIL_DIV_EXPR
:
12819 case FLOOR_DIV_EXPR
:
12820 case ROUND_DIV_EXPR
:
12821 case EXACT_DIV_EXPR
:
12825 case TRUNC_MOD_EXPR
:
12826 case FLOOR_MOD_EXPR
:
12827 case TRUTH_ANDIF_EXPR
:
12828 case TRUTH_ORIF_EXPR
:
12829 case TRUTH_AND_EXPR
:
12830 case TRUTH_OR_EXPR
:
12843 case COMPOUND_EXPR
:
12846 case PREDECREMENT_EXPR
:
12847 case PREINCREMENT_EXPR
:
12848 case POSTDECREMENT_EXPR
:
12849 case POSTINCREMENT_EXPR
:
12851 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12852 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
12855 return build_qualified_name (/*type=*/NULL_TREE
,
12856 tsubst_copy (TREE_OPERAND (t
, 0),
12857 args
, complain
, in_decl
),
12858 tsubst_copy (TREE_OPERAND (t
, 1),
12859 args
, complain
, in_decl
),
12860 QUALIFIED_NAME_IS_TEMPLATE (t
));
12865 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12866 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12867 NULL_TREE
, NULL_TREE
);
12871 int n
= VL_EXP_OPERAND_LENGTH (t
);
12872 tree result
= build_vl_exp (CALL_EXPR
, n
);
12874 for (i
= 0; i
< n
; i
++)
12875 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
12876 complain
, in_decl
);
12882 case PSEUDO_DTOR_EXPR
:
12883 case VEC_PERM_EXPR
:
12886 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12887 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12888 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
12889 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
12896 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12897 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12898 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
12899 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
12906 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12907 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
12908 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
12909 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
12913 case TEMPLATE_ID_EXPR
:
12915 /* Substituted template arguments */
12916 tree fn
= TREE_OPERAND (t
, 0);
12917 tree targs
= TREE_OPERAND (t
, 1);
12919 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
12921 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
12923 return lookup_template_function (fn
, targs
);
12928 tree purpose
, value
, chain
;
12930 if (t
== void_list_node
)
12933 purpose
= TREE_PURPOSE (t
);
12935 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
12936 value
= TREE_VALUE (t
);
12938 value
= tsubst_copy (value
, args
, complain
, in_decl
);
12939 chain
= TREE_CHAIN (t
);
12940 if (chain
&& chain
!= void_type_node
)
12941 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
12942 if (purpose
== TREE_PURPOSE (t
)
12943 && value
== TREE_VALUE (t
)
12944 && chain
== TREE_CHAIN (t
))
12946 return tree_cons (purpose
, value
, chain
);
12951 case ENUMERAL_TYPE
:
12953 case TEMPLATE_TYPE_PARM
:
12954 case TEMPLATE_TEMPLATE_PARM
:
12955 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12956 case TEMPLATE_PARM_INDEX
:
12958 case REFERENCE_TYPE
:
12960 case FUNCTION_TYPE
:
12963 case TYPENAME_TYPE
:
12964 case UNBOUND_CLASS_TEMPLATE
:
12966 case DECLTYPE_TYPE
:
12968 return tsubst (t
, args
, complain
, in_decl
);
12972 /* Fall through. */
12973 case IDENTIFIER_NODE
:
12974 if (IDENTIFIER_TYPENAME_P (t
))
12976 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12977 return mangle_conv_op_name_for_type (new_type
);
12983 /* This is handled by tsubst_copy_and_build. */
12984 gcc_unreachable ();
12987 return build_x_va_arg (EXPR_LOCATION (t
),
12988 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
,
12990 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
12992 case CLEANUP_POINT_EXPR
:
12993 /* We shouldn't have built any of these during initial template
12994 generation. Instead, they should be built during instantiation
12995 in response to the saved STMT_IS_FULL_EXPR_P setting. */
12996 gcc_unreachable ();
13000 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
13001 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
13002 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
13003 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13004 mark_used (TREE_OPERAND (r
, 1));
13007 case EXPR_PACK_EXPANSION
:
13008 error ("invalid use of pack expansion expression");
13009 return error_mark_node
;
13011 case NONTYPE_ARGUMENT_PACK
:
13012 error ("use %<...%> to expand argument pack");
13013 return error_mark_node
;
13020 /* Instantiate any typedefs in the type. */
13021 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13022 r
= fold_convert (type
, t
);
13023 gcc_assert (TREE_CODE (r
) == code
);
13028 /* These can sometimes show up in a partial instantiation, but never
13029 involve template parms. */
13030 gcc_assert (!uses_template_parms (t
));
13034 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13035 gcc_checking_assert (false);
13040 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13043 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13044 tree args
, tsubst_flags_t complain
, tree in_decl
)
13046 tree new_clauses
= NULL
, nc
, oc
;
13048 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13050 nc
= copy_node (oc
);
13051 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13054 switch (OMP_CLAUSE_CODE (nc
))
13056 case OMP_CLAUSE_LASTPRIVATE
:
13057 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13059 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13060 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13061 in_decl
, /*integral_constant_expression_p=*/false);
13062 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13063 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13066 case OMP_CLAUSE_PRIVATE
:
13067 case OMP_CLAUSE_SHARED
:
13068 case OMP_CLAUSE_FIRSTPRIVATE
:
13069 case OMP_CLAUSE_COPYIN
:
13070 case OMP_CLAUSE_COPYPRIVATE
:
13071 case OMP_CLAUSE_IF
:
13072 case OMP_CLAUSE_NUM_THREADS
:
13073 case OMP_CLAUSE_SCHEDULE
:
13074 case OMP_CLAUSE_COLLAPSE
:
13075 case OMP_CLAUSE_FINAL
:
13076 case OMP_CLAUSE_DEPEND
:
13077 case OMP_CLAUSE_FROM
:
13078 case OMP_CLAUSE_TO
:
13079 case OMP_CLAUSE_UNIFORM
:
13080 case OMP_CLAUSE_MAP
:
13081 case OMP_CLAUSE_DEVICE
:
13082 case OMP_CLAUSE_DIST_SCHEDULE
:
13083 case OMP_CLAUSE_NUM_TEAMS
:
13084 case OMP_CLAUSE_THREAD_LIMIT
:
13085 case OMP_CLAUSE_SAFELEN
:
13086 case OMP_CLAUSE_SIMDLEN
:
13087 OMP_CLAUSE_OPERAND (nc
, 0)
13088 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13089 in_decl
, /*integral_constant_expression_p=*/false);
13091 case OMP_CLAUSE_REDUCTION
:
13092 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13094 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13095 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13097 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13098 complain
, in_decl
);
13099 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13100 = build_qualified_name (NULL_TREE
, scope
,
13101 TREE_OPERAND (placeholder
, 1),
13105 gcc_assert (identifier_p (placeholder
));
13107 OMP_CLAUSE_OPERAND (nc
, 0)
13108 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13109 in_decl
, /*integral_constant_expression_p=*/false);
13111 case OMP_CLAUSE_LINEAR
:
13112 case OMP_CLAUSE_ALIGNED
:
13113 OMP_CLAUSE_OPERAND (nc
, 0)
13114 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13115 in_decl
, /*integral_constant_expression_p=*/false);
13116 OMP_CLAUSE_OPERAND (nc
, 1)
13117 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13118 in_decl
, /*integral_constant_expression_p=*/false);
13121 case OMP_CLAUSE_NOWAIT
:
13122 case OMP_CLAUSE_ORDERED
:
13123 case OMP_CLAUSE_DEFAULT
:
13124 case OMP_CLAUSE_UNTIED
:
13125 case OMP_CLAUSE_MERGEABLE
:
13126 case OMP_CLAUSE_INBRANCH
:
13127 case OMP_CLAUSE_NOTINBRANCH
:
13128 case OMP_CLAUSE_PROC_BIND
:
13129 case OMP_CLAUSE_FOR
:
13130 case OMP_CLAUSE_PARALLEL
:
13131 case OMP_CLAUSE_SECTIONS
:
13132 case OMP_CLAUSE_TASKGROUP
:
13135 gcc_unreachable ();
13139 new_clauses
= nreverse (new_clauses
);
13141 new_clauses
= finish_omp_clauses (new_clauses
);
13142 return new_clauses
;
13145 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13148 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13151 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13153 tree purpose
, value
, chain
;
13158 if (TREE_CODE (t
) != TREE_LIST
)
13159 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13160 /*function_p=*/false,
13161 /*integral_constant_expression_p=*/false);
13163 if (t
== void_list_node
)
13166 purpose
= TREE_PURPOSE (t
);
13168 purpose
= RECUR (purpose
);
13169 value
= TREE_VALUE (t
);
13172 if (TREE_CODE (value
) != LABEL_DECL
)
13173 value
= RECUR (value
);
13176 value
= lookup_label (DECL_NAME (value
));
13177 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13178 TREE_USED (value
) = 1;
13181 chain
= TREE_CHAIN (t
);
13182 if (chain
&& chain
!= void_type_node
)
13183 chain
= RECUR (chain
);
13184 return tree_cons (purpose
, value
, chain
);
13188 /* Substitute one OMP_FOR iterator. */
13191 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13192 tree condv
, tree incrv
, tree
*clauses
,
13193 tree args
, tsubst_flags_t complain
, tree in_decl
,
13194 bool integral_constant_expression_p
)
13196 #define RECUR(NODE) \
13197 tsubst_expr ((NODE), args, complain, in_decl, \
13198 integral_constant_expression_p)
13199 tree decl
, init
, cond
, incr
;
13201 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13202 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13203 decl
= TREE_OPERAND (init
, 0);
13204 init
= TREE_OPERAND (init
, 1);
13205 tree decl_expr
= NULL_TREE
;
13206 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13208 /* We need to jump through some hoops to handle declarations in the
13209 for-init-statement, since we might need to handle auto deduction,
13210 but we need to keep control of initialization. */
13212 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13213 decl
= tsubst_decl (decl
, args
, complain
);
13216 decl
= RECUR (decl
);
13217 init
= RECUR (init
);
13219 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13220 if (auto_node
&& init
)
13222 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13224 gcc_assert (!type_dependent_expression_p (decl
));
13226 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13230 /* Declare the variable, but don't let that initialize it. */
13231 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13232 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13234 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13237 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13238 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13239 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13240 incr
= build_x_modify_expr (EXPR_LOCATION (incr
),
13241 RECUR (TREE_OPERAND (incr
, 0)), NOP_EXPR
,
13242 RECUR (TREE_OPERAND (incr
, 1)),
13245 incr
= RECUR (incr
);
13246 TREE_VEC_ELT (declv
, i
) = decl
;
13247 TREE_VEC_ELT (initv
, i
) = init
;
13248 TREE_VEC_ELT (condv
, i
) = cond
;
13249 TREE_VEC_ELT (incrv
, i
) = incr
;
13255 /* Declare and initialize the variable. */
13262 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13264 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13265 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13266 && OMP_CLAUSE_DECL (c
) == decl
)
13268 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13269 && OMP_CLAUSE_DECL (c
) == decl
)
13270 error ("iteration variable %qD should not be firstprivate", decl
);
13271 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13272 && OMP_CLAUSE_DECL (c
) == decl
)
13273 error ("iteration variable %qD should not be reduction", decl
);
13277 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13278 OMP_CLAUSE_DECL (c
) = decl
;
13279 c
= finish_omp_clauses (c
);
13282 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13287 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13288 if (COMPARISON_CLASS_P (cond
))
13289 cond
= build2 (TREE_CODE (cond
), boolean_type_node
,
13290 RECUR (TREE_OPERAND (cond
, 0)),
13291 RECUR (TREE_OPERAND (cond
, 1)));
13293 cond
= RECUR (cond
);
13294 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13295 switch (TREE_CODE (incr
))
13297 case PREINCREMENT_EXPR
:
13298 case PREDECREMENT_EXPR
:
13299 case POSTINCREMENT_EXPR
:
13300 case POSTDECREMENT_EXPR
:
13301 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13302 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13305 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13306 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13308 tree rhs
= TREE_OPERAND (incr
, 1);
13309 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
),
13310 RECUR (TREE_OPERAND (incr
, 0)),
13311 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13312 RECUR (TREE_OPERAND (rhs
, 0)),
13313 RECUR (TREE_OPERAND (rhs
, 1))));
13316 incr
= RECUR (incr
);
13319 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13320 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13322 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13323 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13324 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13325 TREE_TYPE (decl
), lhs
,
13326 RECUR (TREE_OPERAND (incr
, 2))));
13328 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13329 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13330 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13332 tree rhs
= TREE_OPERAND (incr
, 2);
13333 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
),
13334 RECUR (TREE_OPERAND (incr
, 0)),
13335 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13336 RECUR (TREE_OPERAND (rhs
, 0)),
13337 RECUR (TREE_OPERAND (rhs
, 1))));
13340 incr
= RECUR (incr
);
13343 incr
= RECUR (incr
);
13347 TREE_VEC_ELT (declv
, i
) = decl
;
13348 TREE_VEC_ELT (initv
, i
) = init
;
13349 TREE_VEC_ELT (condv
, i
) = cond
;
13350 TREE_VEC_ELT (incrv
, i
) = incr
;
13354 /* Like tsubst_copy for expressions, etc. but also does semantic
13358 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13359 bool integral_constant_expression_p
)
13361 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13362 #define RECUR(NODE) \
13363 tsubst_expr ((NODE), args, complain, in_decl, \
13364 integral_constant_expression_p)
13370 if (t
== NULL_TREE
|| t
== error_mark_node
)
13373 loc
= input_location
;
13374 if (EXPR_HAS_LOCATION (t
))
13375 input_location
= EXPR_LOCATION (t
);
13376 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13377 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13379 switch (TREE_CODE (t
))
13381 case STATEMENT_LIST
:
13383 tree_stmt_iterator i
;
13384 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13385 RECUR (tsi_stmt (i
));
13389 case CTOR_INITIALIZER
:
13390 finish_mem_initializers (tsubst_initializer_list
13391 (TREE_OPERAND (t
, 0), args
));
13395 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13399 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13400 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13401 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13403 finish_expr_stmt (tmp
);
13407 do_using_directive (USING_STMT_NAMESPACE (t
));
13412 tree decl
, pattern_decl
;
13415 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13416 if (TREE_CODE (decl
) == LABEL_DECL
)
13417 finish_label_decl (DECL_NAME (decl
));
13418 else if (TREE_CODE (decl
) == USING_DECL
)
13420 tree scope
= USING_DECL_SCOPE (decl
);
13421 tree name
= DECL_NAME (decl
);
13424 scope
= tsubst (scope
, args
, complain
, in_decl
);
13425 decl
= lookup_qualified_name (scope
, name
,
13426 /*is_type_p=*/false,
13427 /*complain=*/false);
13428 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13429 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13431 do_local_using_decl (decl
, scope
, name
);
13433 else if (DECL_PACK_P (decl
))
13435 /* Don't build up decls for a variadic capture proxy, we'll
13436 instantiate the elements directly as needed. */
13441 init
= DECL_INITIAL (decl
);
13442 decl
= tsubst (decl
, args
, complain
, in_decl
);
13443 if (decl
!= error_mark_node
)
13445 /* By marking the declaration as instantiated, we avoid
13446 trying to instantiate it. Since instantiate_decl can't
13447 handle local variables, and since we've already done
13448 all that needs to be done, that's the right thing to
13451 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13453 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13454 /* Anonymous aggregates are a special case. */
13455 finish_anon_union (decl
);
13456 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13458 DECL_CONTEXT (decl
) = current_function_decl
;
13459 if (DECL_NAME (decl
) == this_identifier
)
13461 tree lam
= DECL_CONTEXT (current_function_decl
);
13462 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13463 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13465 insert_capture_proxy (decl
);
13467 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13468 /* We already did a pushtag. */;
13469 else if (TREE_CODE (decl
) == FUNCTION_DECL
13470 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13471 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13473 DECL_CONTEXT (decl
) = NULL_TREE
;
13475 DECL_CONTEXT (decl
) = current_function_decl
;
13476 cp_check_omp_declare_reduction (decl
);
13480 int const_init
= false;
13481 maybe_push_decl (decl
);
13483 && DECL_PRETTY_FUNCTION_P (decl
))
13485 /* For __PRETTY_FUNCTION__ we have to adjust the
13487 const char *const name
13488 = cxx_printable_name (current_function_decl
, 2);
13489 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13493 tree t
= RECUR (init
);
13497 /* If we had an initializer but it
13498 instantiated to nothing,
13499 value-initialize the object. This will
13500 only occur when the initializer was a
13501 pack expansion where the parameter packs
13502 used in that expansion were of length
13504 init
= build_value_init (TREE_TYPE (decl
),
13506 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
13507 init
= get_target_expr_sfinae (init
, complain
);
13514 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13516 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13525 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13526 RECUR (FOR_INIT_STMT (t
));
13527 finish_for_init_stmt (stmt
);
13528 tmp
= RECUR (FOR_COND (t
));
13529 finish_for_cond (tmp
, stmt
, false);
13530 tmp
= RECUR (FOR_EXPR (t
));
13531 finish_for_expr (tmp
, stmt
);
13532 RECUR (FOR_BODY (t
));
13533 finish_for_stmt (stmt
);
13536 case RANGE_FOR_STMT
:
13539 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13540 decl
= RANGE_FOR_DECL (t
);
13541 decl
= tsubst (decl
, args
, complain
, in_decl
);
13542 maybe_push_decl (decl
);
13543 expr
= RECUR (RANGE_FOR_EXPR (t
));
13544 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13545 RECUR (RANGE_FOR_BODY (t
));
13546 finish_for_stmt (stmt
);
13551 stmt
= begin_while_stmt ();
13552 tmp
= RECUR (WHILE_COND (t
));
13553 finish_while_stmt_cond (tmp
, stmt
, false);
13554 RECUR (WHILE_BODY (t
));
13555 finish_while_stmt (stmt
);
13559 stmt
= begin_do_stmt ();
13560 RECUR (DO_BODY (t
));
13561 finish_do_body (stmt
);
13562 tmp
= RECUR (DO_COND (t
));
13563 finish_do_stmt (tmp
, stmt
, false);
13567 stmt
= begin_if_stmt ();
13568 tmp
= RECUR (IF_COND (t
));
13569 finish_if_stmt_cond (tmp
, stmt
);
13570 RECUR (THEN_CLAUSE (t
));
13571 finish_then_clause (stmt
);
13573 if (ELSE_CLAUSE (t
))
13575 begin_else_clause (stmt
);
13576 RECUR (ELSE_CLAUSE (t
));
13577 finish_else_clause (stmt
);
13580 finish_if_stmt (stmt
);
13584 if (BIND_EXPR_BODY_BLOCK (t
))
13585 stmt
= begin_function_body ();
13587 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
13588 ? BCS_TRY_BLOCK
: 0);
13590 RECUR (BIND_EXPR_BODY (t
));
13592 if (BIND_EXPR_BODY_BLOCK (t
))
13593 finish_function_body (stmt
);
13595 finish_compound_stmt (stmt
);
13599 finish_break_stmt ();
13602 case CONTINUE_STMT
:
13603 finish_continue_stmt ();
13607 stmt
= begin_switch_stmt ();
13608 tmp
= RECUR (SWITCH_STMT_COND (t
));
13609 finish_switch_cond (tmp
, stmt
);
13610 RECUR (SWITCH_STMT_BODY (t
));
13611 finish_switch_stmt (stmt
);
13614 case CASE_LABEL_EXPR
:
13615 finish_case_label (EXPR_LOCATION (t
),
13616 RECUR (CASE_LOW (t
)),
13617 RECUR (CASE_HIGH (t
)));
13622 tree decl
= LABEL_EXPR_LABEL (t
);
13625 label
= finish_label_stmt (DECL_NAME (decl
));
13626 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13627 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13632 tmp
= GOTO_DESTINATION (t
);
13633 if (TREE_CODE (tmp
) != LABEL_DECL
)
13634 /* Computed goto's must be tsubst'd into. On the other hand,
13635 non-computed gotos must not be; the identifier in question
13636 will have no binding. */
13639 tmp
= DECL_NAME (tmp
);
13640 finish_goto_stmt (tmp
);
13644 tmp
= finish_asm_stmt
13645 (ASM_VOLATILE_P (t
),
13646 RECUR (ASM_STRING (t
)),
13647 tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
, complain
, in_decl
),
13648 tsubst_copy_asm_operands (ASM_INPUTS (t
), args
, complain
, in_decl
),
13649 tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
, complain
, in_decl
),
13650 tsubst_copy_asm_operands (ASM_LABELS (t
), args
, complain
, in_decl
));
13652 tree asm_expr
= tmp
;
13653 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
13654 asm_expr
= TREE_OPERAND (asm_expr
, 0);
13655 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
13662 stmt
= begin_try_block ();
13663 RECUR (TRY_STMTS (t
));
13664 finish_cleanup_try_block (stmt
);
13665 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
13669 tree compound_stmt
= NULL_TREE
;
13671 if (FN_TRY_BLOCK_P (t
))
13672 stmt
= begin_function_try_block (&compound_stmt
);
13674 stmt
= begin_try_block ();
13676 RECUR (TRY_STMTS (t
));
13678 if (FN_TRY_BLOCK_P (t
))
13679 finish_function_try_block (stmt
);
13681 finish_try_block (stmt
);
13683 RECUR (TRY_HANDLERS (t
));
13684 if (FN_TRY_BLOCK_P (t
))
13685 finish_function_handler_sequence (stmt
, compound_stmt
);
13687 finish_handler_sequence (stmt
);
13693 tree decl
= HANDLER_PARMS (t
);
13697 decl
= tsubst (decl
, args
, complain
, in_decl
);
13698 /* Prevent instantiate_decl from trying to instantiate
13699 this variable. We've already done all that needs to be
13701 if (decl
!= error_mark_node
)
13702 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13704 stmt
= begin_handler ();
13705 finish_handler_parms (decl
, stmt
);
13706 RECUR (HANDLER_BODY (t
));
13707 finish_handler (stmt
);
13712 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
13713 if (CLASS_TYPE_P (tmp
))
13715 /* Local classes are not independent templates; they are
13716 instantiated along with their containing function. And this
13717 way we don't have to deal with pushing out of one local class
13718 to instantiate a member of another local class. */
13720 /* Closures are handled by the LAMBDA_EXPR. */
13721 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
13722 complete_type (tmp
);
13723 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
13724 if (!DECL_ARTIFICIAL (fn
))
13725 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
13729 case STATIC_ASSERT
:
13733 ++c_inhibit_evaluation_warnings
;
13735 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
13738 /*integral_constant_expression_p=*/true);
13739 --c_inhibit_evaluation_warnings
;
13741 finish_static_assert (condition
,
13742 STATIC_ASSERT_MESSAGE (t
),
13743 STATIC_ASSERT_SOURCE_LOCATION (t
),
13744 /*member_p=*/false);
13749 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
13750 args
, complain
, in_decl
);
13751 stmt
= begin_omp_parallel ();
13752 RECUR (OMP_PARALLEL_BODY (t
));
13753 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
13754 = OMP_PARALLEL_COMBINED (t
);
13758 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
13759 args
, complain
, in_decl
);
13760 stmt
= begin_omp_task ();
13761 RECUR (OMP_TASK_BODY (t
));
13762 finish_omp_task (tmp
, stmt
);
13768 case OMP_DISTRIBUTE
:
13770 tree clauses
, body
, pre_body
;
13771 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
13772 tree incrv
= NULL_TREE
;
13775 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
13776 args
, complain
, in_decl
);
13777 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13779 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13780 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13781 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13782 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13785 stmt
= begin_omp_structured_block ();
13787 pre_body
= push_stmt_list ();
13788 RECUR (OMP_FOR_PRE_BODY (t
));
13789 pre_body
= pop_stmt_list (pre_body
);
13791 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13792 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
13793 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
13794 &clauses
, args
, complain
, in_decl
,
13795 integral_constant_expression_p
);
13797 body
= push_stmt_list ();
13798 RECUR (OMP_FOR_BODY (t
));
13799 body
= pop_stmt_list (body
);
13801 if (OMP_FOR_INIT (t
) != NULL_TREE
)
13802 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
13803 condv
, incrv
, body
, pre_body
, clauses
);
13806 t
= make_node (TREE_CODE (t
));
13807 TREE_TYPE (t
) = void_type_node
;
13808 OMP_FOR_BODY (t
) = body
;
13809 OMP_FOR_PRE_BODY (t
) = pre_body
;
13810 OMP_FOR_CLAUSES (t
) = clauses
;
13811 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
13815 add_stmt (finish_omp_structured_block (stmt
));
13822 case OMP_TARGET_DATA
:
13824 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
13825 args
, complain
, in_decl
);
13826 stmt
= push_stmt_list ();
13827 RECUR (OMP_BODY (t
));
13828 stmt
= pop_stmt_list (stmt
);
13831 OMP_BODY (t
) = stmt
;
13832 OMP_CLAUSES (t
) = tmp
;
13836 case OMP_TARGET_UPDATE
:
13837 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
13838 args
, complain
, in_decl
);
13840 OMP_CLAUSES (t
) = tmp
;
13847 case OMP_TASKGROUP
:
13849 stmt
= push_stmt_list ();
13850 RECUR (OMP_BODY (t
));
13851 stmt
= pop_stmt_list (stmt
);
13854 OMP_BODY (t
) = stmt
;
13859 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
13860 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
13862 tree op1
= TREE_OPERAND (t
, 1);
13863 tree rhs1
= NULL_TREE
;
13865 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
13867 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
13868 op1
= TREE_OPERAND (op1
, 1);
13870 lhs
= RECUR (TREE_OPERAND (op1
, 0));
13871 rhs
= RECUR (TREE_OPERAND (op1
, 1));
13872 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
13873 NULL_TREE
, NULL_TREE
, rhs1
,
13874 OMP_ATOMIC_SEQ_CST (t
));
13878 tree op1
= TREE_OPERAND (t
, 1);
13879 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
13880 tree rhs1
= NULL_TREE
;
13881 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
13882 enum tree_code opcode
= NOP_EXPR
;
13883 if (code
== OMP_ATOMIC_READ
)
13885 v
= RECUR (TREE_OPERAND (op1
, 0));
13886 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
13888 else if (code
== OMP_ATOMIC_CAPTURE_OLD
13889 || code
== OMP_ATOMIC_CAPTURE_NEW
)
13891 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
13892 v
= RECUR (TREE_OPERAND (op1
, 0));
13893 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
13894 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
13896 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
13897 op11
= TREE_OPERAND (op11
, 1);
13899 lhs
= RECUR (TREE_OPERAND (op11
, 0));
13900 rhs
= RECUR (TREE_OPERAND (op11
, 1));
13901 opcode
= TREE_CODE (op11
);
13902 if (opcode
== MODIFY_EXPR
)
13908 lhs
= RECUR (TREE_OPERAND (op1
, 0));
13909 rhs
= RECUR (TREE_OPERAND (op1
, 1));
13911 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
13912 OMP_ATOMIC_SEQ_CST (t
));
13916 case TRANSACTION_EXPR
:
13919 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
13920 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
13922 if (TRANSACTION_EXPR_IS_STMT (t
))
13924 tree body
= TRANSACTION_EXPR_BODY (t
);
13925 tree noex
= NULL_TREE
;
13926 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
13928 noex
= MUST_NOT_THROW_COND (body
);
13929 if (noex
== NULL_TREE
)
13930 noex
= boolean_true_node
;
13931 body
= TREE_OPERAND (body
, 0);
13933 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
13935 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
13939 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
13940 RECUR (TRANSACTION_EXPR_BODY (t
)),
13947 case MUST_NOT_THROW_EXPR
:
13948 RETURN (build_must_not_throw_expr (RECUR (TREE_OPERAND (t
, 0)),
13949 RECUR (MUST_NOT_THROW_COND (t
))));
13951 case EXPR_PACK_EXPANSION
:
13952 error ("invalid use of pack expansion expression");
13953 RETURN (error_mark_node
);
13955 case NONTYPE_ARGUMENT_PACK
:
13956 error ("use %<...%> to expand argument pack");
13957 RETURN (error_mark_node
);
13959 case CILK_SPAWN_STMT
:
13960 cfun
->calls_cilk_spawn
= 1;
13961 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
13963 case CILK_SYNC_STMT
:
13964 RETURN (build_cilk_sync ());
13966 case COMPOUND_EXPR
:
13967 tmp
= RECUR (TREE_OPERAND (t
, 0));
13968 if (tmp
== NULL_TREE
)
13969 /* If the first operand was a statement, we're done with it. */
13970 RETURN (RECUR (TREE_OPERAND (t
, 1)));
13971 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
13972 RECUR (TREE_OPERAND (t
, 1)),
13975 case ANNOTATE_EXPR
:
13976 tmp
= RECUR (TREE_OPERAND (t
, 0));
13977 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
13978 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
13981 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
13983 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13984 /*function_p=*/false,
13985 integral_constant_expression_p
));
13988 RETURN (NULL_TREE
);
13990 input_location
= loc
;
13996 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
13997 function. For description of the body see comment above
13998 cp_parser_omp_declare_reduction_exprs. */
14001 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14003 if (t
== NULL_TREE
|| t
== error_mark_node
)
14006 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14008 tree_stmt_iterator tsi
;
14011 memset (stmts
, 0, sizeof stmts
);
14012 for (i
= 0, tsi
= tsi_start (t
);
14013 i
< 7 && !tsi_end_p (tsi
);
14014 i
++, tsi_next (&tsi
))
14015 stmts
[i
] = tsi_stmt (tsi
);
14016 gcc_assert (tsi_end_p (tsi
));
14020 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14021 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14022 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14023 args
, complain
, in_decl
);
14024 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14025 args
, complain
, in_decl
);
14026 DECL_CONTEXT (omp_out
) = current_function_decl
;
14027 DECL_CONTEXT (omp_in
) = current_function_decl
;
14028 keep_next_level (true);
14029 tree block
= begin_omp_structured_block ();
14030 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14031 block
= finish_omp_structured_block (block
);
14032 block
= maybe_cleanup_point_expr_void (block
);
14033 add_decl_expr (omp_out
);
14034 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14035 TREE_NO_WARNING (omp_out
) = 1;
14036 add_decl_expr (omp_in
);
14037 finish_expr_stmt (block
);
14041 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14042 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14043 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14044 args
, complain
, in_decl
);
14045 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14046 args
, complain
, in_decl
);
14047 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14048 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14049 keep_next_level (true);
14050 tree block
= begin_omp_structured_block ();
14051 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14052 block
= finish_omp_structured_block (block
);
14053 block
= maybe_cleanup_point_expr_void (block
);
14054 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14055 add_decl_expr (omp_priv
);
14056 add_decl_expr (omp_orig
);
14057 finish_expr_stmt (block
);
14059 add_decl_expr (omp_orig
);
14063 /* T is a postfix-expression that is not being used in a function
14064 call. Return the substituted version of T. */
14067 tsubst_non_call_postfix_expression (tree t
, tree args
,
14068 tsubst_flags_t complain
,
14071 if (TREE_CODE (t
) == SCOPE_REF
)
14072 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14073 /*done=*/false, /*address_p=*/false);
14075 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14076 /*function_p=*/false,
14077 /*integral_constant_expression_p=*/false);
14082 /* Sentinel to disable certain warnings during template substitution. */
14084 struct warning_sentinel
{
14087 warning_sentinel(int& flag
, bool suppress
=true)
14088 : flag(flag
), val(flag
) { if (suppress
) flag
= 0; }
14089 ~warning_sentinel() { flag
= val
; }
14092 /* Like tsubst but deals with expressions and performs semantic
14093 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14096 tsubst_copy_and_build (tree t
,
14098 tsubst_flags_t complain
,
14101 bool integral_constant_expression_p
)
14103 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14104 #define RECUR(NODE) \
14105 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14106 /*function_p=*/false, \
14107 integral_constant_expression_p)
14112 if (t
== NULL_TREE
|| t
== error_mark_node
)
14115 loc
= input_location
;
14116 if (EXPR_HAS_LOCATION (t
))
14117 input_location
= EXPR_LOCATION (t
);
14119 /* N3276 decltype magic only applies to calls at the top level or on the
14120 right side of a comma. */
14121 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14122 complain
&= ~tf_decltype
;
14124 switch (TREE_CODE (t
))
14128 /* Fall through. */
14129 case IDENTIFIER_NODE
:
14133 bool non_integral_constant_expression_p
;
14134 const char *error_msg
;
14136 if (IDENTIFIER_TYPENAME_P (t
))
14138 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14139 t
= mangle_conv_op_name_for_type (new_type
);
14142 /* Look up the name. */
14143 decl
= lookup_name (t
);
14145 /* By convention, expressions use ERROR_MARK_NODE to indicate
14146 failure, not NULL_TREE. */
14147 if (decl
== NULL_TREE
)
14148 decl
= error_mark_node
;
14150 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14152 integral_constant_expression_p
,
14153 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14154 &non_integral_constant_expression_p
,
14155 /*template_p=*/false,
14157 /*address_p=*/false,
14158 /*template_arg_p=*/false,
14163 if (!function_p
&& identifier_p (decl
))
14165 if (complain
& tf_error
)
14166 unqualified_name_lookup_error (decl
);
14167 decl
= error_mark_node
;
14172 case TEMPLATE_ID_EXPR
:
14175 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14176 tree targs
= TREE_OPERAND (t
, 1);
14179 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14181 if (TREE_CODE (templ
) == COMPONENT_REF
)
14183 object
= TREE_OPERAND (templ
, 0);
14184 templ
= TREE_OPERAND (templ
, 1);
14187 object
= NULL_TREE
;
14188 templ
= lookup_template_function (templ
, targs
);
14191 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14192 object
, templ
, NULL_TREE
));
14194 RETURN (baselink_for_fns (templ
));
14199 tree r
= RECUR (TREE_OPERAND (t
, 0));
14201 if (REFERENCE_REF_P (t
))
14203 /* A type conversion to reference type will be enclosed in
14204 such an indirect ref, but the substitution of the cast
14205 will have also added such an indirect ref. */
14206 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14207 r
= convert_from_reference (r
);
14210 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14211 complain
|decltype_flag
);
14217 (tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
14218 RECUR (TREE_OPERAND (t
, 0))));
14220 case IMPLICIT_CONV_EXPR
:
14222 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14223 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14224 int flags
= LOOKUP_IMPLICIT
;
14225 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14226 flags
= LOOKUP_NORMAL
;
14227 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14234 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
14235 RECUR (TREE_OPERAND (t
, 0))));
14238 case REINTERPRET_CAST_EXPR
:
14239 case CONST_CAST_EXPR
:
14240 case DYNAMIC_CAST_EXPR
:
14241 case STATIC_CAST_EXPR
:
14244 tree op
, r
= NULL_TREE
;
14246 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14247 if (integral_constant_expression_p
14248 && !cast_valid_in_integral_constant_expression_p (type
))
14250 if (complain
& tf_error
)
14251 error ("a cast to a type other than an integral or "
14252 "enumeration type cannot appear in a constant-expression");
14253 RETURN (error_mark_node
);
14256 op
= RECUR (TREE_OPERAND (t
, 0));
14258 warning_sentinel
s(warn_useless_cast
);
14259 switch (TREE_CODE (t
))
14262 r
= build_functional_cast (type
, op
, complain
);
14264 case REINTERPRET_CAST_EXPR
:
14265 r
= build_reinterpret_cast (type
, op
, complain
);
14267 case CONST_CAST_EXPR
:
14268 r
= build_const_cast (type
, op
, complain
);
14270 case DYNAMIC_CAST_EXPR
:
14271 r
= build_dynamic_cast (type
, op
, complain
);
14273 case STATIC_CAST_EXPR
:
14274 r
= build_static_cast (type
, op
, complain
);
14277 gcc_unreachable ();
14283 case POSTDECREMENT_EXPR
:
14284 case POSTINCREMENT_EXPR
:
14285 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14286 args
, complain
, in_decl
);
14287 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14288 complain
|decltype_flag
));
14290 case PREDECREMENT_EXPR
:
14291 case PREINCREMENT_EXPR
:
14295 case TRUTH_NOT_EXPR
:
14296 case UNARY_PLUS_EXPR
: /* Unary + */
14297 case REALPART_EXPR
:
14298 case IMAGPART_EXPR
:
14299 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14300 RECUR (TREE_OPERAND (t
, 0)),
14301 complain
|decltype_flag
));
14303 case FIX_TRUNC_EXPR
:
14304 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14308 op1
= TREE_OPERAND (t
, 0);
14309 if (TREE_CODE (op1
) == LABEL_DECL
)
14310 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14311 EXPR_LOCATION (op1
)));
14312 if (TREE_CODE (op1
) == SCOPE_REF
)
14313 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14314 /*done=*/true, /*address_p=*/true);
14316 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14318 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14319 complain
|decltype_flag
));
14324 case TRUNC_DIV_EXPR
:
14325 case CEIL_DIV_EXPR
:
14326 case FLOOR_DIV_EXPR
:
14327 case ROUND_DIV_EXPR
:
14328 case EXACT_DIV_EXPR
:
14332 case TRUNC_MOD_EXPR
:
14333 case FLOOR_MOD_EXPR
:
14334 case TRUTH_ANDIF_EXPR
:
14335 case TRUTH_ORIF_EXPR
:
14336 case TRUTH_AND_EXPR
:
14337 case TRUTH_OR_EXPR
:
14353 warning_sentinel
s1(warn_type_limits
);
14354 warning_sentinel
s2(warn_div_by_zero
);
14355 tree r
= build_x_binary_op
14356 (input_location
, TREE_CODE (t
),
14357 RECUR (TREE_OPERAND (t
, 0)),
14358 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14360 : TREE_CODE (TREE_OPERAND (t
, 0))),
14361 RECUR (TREE_OPERAND (t
, 1)),
14362 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14364 : TREE_CODE (TREE_OPERAND (t
, 1))),
14366 complain
|decltype_flag
);
14367 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14368 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14373 case POINTER_PLUS_EXPR
:
14374 return fold_build_pointer_plus (RECUR (TREE_OPERAND (t
, 0)),
14375 RECUR (TREE_OPERAND (t
, 1)));
14378 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14379 /*address_p=*/false));
14381 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14382 args
, complain
, in_decl
);
14383 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14384 RECUR (TREE_OPERAND (t
, 1)),
14385 complain
|decltype_flag
));
14387 case ARRAY_NOTATION_REF
:
14389 tree start_index
, length
, stride
;
14390 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14391 args
, complain
, in_decl
);
14392 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14393 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14394 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14395 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14396 length
, stride
, TREE_TYPE (op1
)));
14399 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14400 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14407 op1
= TREE_OPERAND (t
, 0);
14408 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14409 op1
= TREE_TYPE (op1
);
14412 /* When there are no ARGS, we are trying to evaluate a
14413 non-dependent expression from the parser. Trying to do
14414 the substitutions may not work. */
14416 op1
= TREE_TYPE (op1
);
14420 ++cp_unevaluated_operand
;
14421 ++c_inhibit_evaluation_warnings
;
14423 op1
= tsubst (op1
, args
, complain
, in_decl
);
14425 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14426 /*function_p=*/false,
14427 /*integral_constant_expression_p=*/
14429 --cp_unevaluated_operand
;
14430 --c_inhibit_evaluation_warnings
;
14433 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14434 complain
& tf_error
);
14436 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14437 complain
& tf_error
);
14438 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14440 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14442 if (!processing_template_decl
&& TYPE_P (op1
))
14444 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14445 build1 (NOP_EXPR
, op1
, error_mark_node
));
14446 SIZEOF_EXPR_TYPE_P (r
) = 1;
14449 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14450 TREE_SIDE_EFFECTS (r
) = 0;
14451 TREE_READONLY (r
) = 1;
14453 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14458 case AT_ENCODE_EXPR
:
14460 op1
= TREE_OPERAND (t
, 0);
14461 ++cp_unevaluated_operand
;
14462 ++c_inhibit_evaluation_warnings
;
14463 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14464 /*function_p=*/false,
14465 /*integral_constant_expression_p=*/false);
14466 --cp_unevaluated_operand
;
14467 --c_inhibit_evaluation_warnings
;
14468 RETURN (objc_build_encode_expr (op1
));
14471 case NOEXCEPT_EXPR
:
14472 op1
= TREE_OPERAND (t
, 0);
14473 ++cp_unevaluated_operand
;
14474 ++c_inhibit_evaluation_warnings
;
14475 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14476 /*function_p=*/false,
14477 /*integral_constant_expression_p=*/false);
14478 --cp_unevaluated_operand
;
14479 --c_inhibit_evaluation_warnings
;
14480 RETURN (finish_noexcept_expr (op1
, complain
));
14484 warning_sentinel
s(warn_div_by_zero
);
14485 tree r
= build_x_modify_expr
14486 (EXPR_LOCATION (t
),
14487 RECUR (TREE_OPERAND (t
, 0)),
14488 TREE_CODE (TREE_OPERAND (t
, 1)),
14489 RECUR (TREE_OPERAND (t
, 2)),
14490 complain
|decltype_flag
);
14491 /* TREE_NO_WARNING must be set if either the expression was
14492 parenthesized or it uses an operator such as >>= rather
14493 than plain assignment. In the former case, it was already
14494 set and must be copied. In the latter case,
14495 build_x_modify_expr sets it and it must not be reset
14497 if (TREE_NO_WARNING (t
))
14498 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14504 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14505 args
, complain
, in_decl
);
14506 /* Remember that there was a reference to this entity. */
14509 RETURN (build_x_arrow (input_location
, op1
, complain
));
14513 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14514 tree init
= RECUR (TREE_OPERAND (t
, 3));
14515 vec
<tree
, va_gc
> *placement_vec
;
14516 vec
<tree
, va_gc
> *init_vec
;
14519 if (placement
== NULL_TREE
)
14520 placement_vec
= NULL
;
14523 placement_vec
= make_tree_vector ();
14524 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14525 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14528 /* If there was an initializer in the original tree, but it
14529 instantiated to an empty list, then we should pass a
14530 non-NULL empty vector to tell build_new that it was an
14531 empty initializer() rather than no initializer. This can
14532 only happen when the initializer is a pack expansion whose
14533 parameter packs are of length zero. */
14534 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
14538 init_vec
= make_tree_vector ();
14539 if (init
== void_zero_node
)
14540 gcc_assert (init_vec
!= NULL
);
14543 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
14544 vec_safe_push (init_vec
, TREE_VALUE (init
));
14548 ret
= build_new (&placement_vec
,
14549 tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
14550 RECUR (TREE_OPERAND (t
, 2)),
14552 NEW_EXPR_USE_GLOBAL (t
),
14555 if (placement_vec
!= NULL
)
14556 release_tree_vector (placement_vec
);
14557 if (init_vec
!= NULL
)
14558 release_tree_vector (init_vec
);
14564 RETURN (delete_sanity
14565 (RECUR (TREE_OPERAND (t
, 0)),
14566 RECUR (TREE_OPERAND (t
, 1)),
14567 DELETE_EXPR_USE_VEC (t
),
14568 DELETE_EXPR_USE_GLOBAL (t
),
14571 case COMPOUND_EXPR
:
14573 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
14574 complain
& ~tf_decltype
, in_decl
,
14575 /*function_p=*/false,
14576 integral_constant_expression_p
);
14577 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
14579 RECUR (TREE_OPERAND (t
, 1)),
14580 complain
|decltype_flag
));
14586 vec
<tree
, va_gc
> *call_args
;
14587 unsigned int nargs
, i
;
14592 function
= CALL_EXPR_FN (t
);
14593 /* When we parsed the expression, we determined whether or
14594 not Koenig lookup should be performed. */
14595 koenig_p
= KOENIG_LOOKUP_P (t
);
14596 if (TREE_CODE (function
) == SCOPE_REF
)
14598 qualified_p
= true;
14599 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
14601 /*address_p=*/false);
14603 else if (koenig_p
&& identifier_p (function
))
14605 /* Do nothing; calling tsubst_copy_and_build on an identifier
14606 would incorrectly perform unqualified lookup again.
14608 Note that we can also have an IDENTIFIER_NODE if the earlier
14609 unqualified lookup found a member function; in that case
14610 koenig_p will be false and we do want to do the lookup
14611 again to find the instantiated member function.
14613 FIXME but doing that causes c++/15272, so we need to stop
14614 using IDENTIFIER_NODE in that situation. */
14615 qualified_p
= false;
14619 if (TREE_CODE (function
) == COMPONENT_REF
)
14621 tree op
= TREE_OPERAND (function
, 1);
14623 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
14624 || (BASELINK_P (op
)
14625 && BASELINK_QUALIFIED_P (op
)));
14628 qualified_p
= false;
14630 if (TREE_CODE (function
) == ADDR_EXPR
14631 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
14632 /* Avoid error about taking the address of a constructor. */
14633 function
= TREE_OPERAND (function
, 0);
14635 function
= tsubst_copy_and_build (function
, args
, complain
,
14638 integral_constant_expression_p
);
14640 if (BASELINK_P (function
))
14641 qualified_p
= true;
14644 nargs
= call_expr_nargs (t
);
14645 call_args
= make_tree_vector ();
14646 for (i
= 0; i
< nargs
; ++i
)
14648 tree arg
= CALL_EXPR_ARG (t
, i
);
14650 if (!PACK_EXPANSION_P (arg
))
14651 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
14654 /* Expand the pack expansion and push each entry onto
14656 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
14657 if (TREE_CODE (arg
) == TREE_VEC
)
14659 unsigned int len
, j
;
14661 len
= TREE_VEC_LENGTH (arg
);
14662 for (j
= 0; j
< len
; ++j
)
14664 tree value
= TREE_VEC_ELT (arg
, j
);
14665 if (value
!= NULL_TREE
)
14666 value
= convert_from_reference (value
);
14667 vec_safe_push (call_args
, value
);
14672 /* A partial substitution. Add one entry. */
14673 vec_safe_push (call_args
, arg
);
14678 /* We do not perform argument-dependent lookup if normal
14679 lookup finds a non-function, in accordance with the
14680 expected resolution of DR 218. */
14682 && ((is_overloaded_fn (function
)
14683 /* If lookup found a member function, the Koenig lookup is
14684 not appropriate, even if an unqualified-name was used
14685 to denote the function. */
14686 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
14687 || identifier_p (function
))
14688 /* Only do this when substitution turns a dependent call
14689 into a non-dependent call. */
14690 && type_dependent_expression_p_push (t
)
14691 && !any_type_dependent_arguments_p (call_args
))
14692 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
14694 if (identifier_p (function
)
14695 && !any_type_dependent_arguments_p (call_args
))
14697 if (koenig_p
&& (complain
& tf_warning_or_error
))
14699 /* For backwards compatibility and good diagnostics, try
14700 the unqualified lookup again if we aren't in SFINAE
14702 tree unq
= (tsubst_copy_and_build
14703 (function
, args
, complain
, in_decl
, true,
14704 integral_constant_expression_p
));
14705 if (unq
== error_mark_node
)
14706 RETURN (error_mark_node
);
14708 if (unq
!= function
)
14711 if (INDIRECT_REF_P (fn
))
14712 fn
= TREE_OPERAND (fn
, 0);
14713 if (TREE_CODE (fn
) == COMPONENT_REF
)
14714 fn
= TREE_OPERAND (fn
, 1);
14715 if (is_overloaded_fn (fn
))
14716 fn
= get_first_fn (fn
);
14717 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
14718 "%qD was not declared in this scope, "
14719 "and no declarations were found by "
14720 "argument-dependent lookup at the point "
14721 "of instantiation", function
))
14724 /* Can't say anything more. */;
14725 else if (DECL_CLASS_SCOPE_P (fn
))
14727 location_t loc
= EXPR_LOC_OR_LOC (t
,
14730 "declarations in dependent base %qT are "
14731 "not found by unqualified lookup",
14732 DECL_CLASS_CONTEXT (fn
));
14733 if (current_class_ptr
)
14735 "use %<this->%D%> instead", function
);
14738 "use %<%T::%D%> instead",
14739 current_class_name
, function
);
14742 inform (0, "%q+D declared here, later in the "
14743 "translation unit", fn
);
14748 if (identifier_p (function
))
14750 if (complain
& tf_error
)
14751 unqualified_name_lookup_error (function
);
14752 release_tree_vector (call_args
);
14753 RETURN (error_mark_node
);
14757 /* Remember that there was a reference to this entity. */
14758 if (DECL_P (function
))
14759 mark_used (function
);
14761 /* Put back tf_decltype for the actual call. */
14762 complain
|= decltype_flag
;
14764 if (TREE_CODE (function
) == OFFSET_REF
)
14765 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
14767 else if (TREE_CODE (function
) == COMPONENT_REF
)
14769 tree instance
= TREE_OPERAND (function
, 0);
14770 tree fn
= TREE_OPERAND (function
, 1);
14772 if (processing_template_decl
14773 && (type_dependent_expression_p (instance
)
14774 || (!BASELINK_P (fn
)
14775 && TREE_CODE (fn
) != FIELD_DECL
)
14776 || type_dependent_expression_p (fn
)
14777 || any_type_dependent_arguments_p (call_args
)))
14778 ret
= build_nt_call_vec (function
, call_args
);
14779 else if (!BASELINK_P (fn
))
14780 ret
= finish_call_expr (function
, &call_args
,
14781 /*disallow_virtual=*/false,
14782 /*koenig_p=*/false,
14785 ret
= (build_new_method_call
14787 &call_args
, NULL_TREE
,
14788 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
14793 ret
= finish_call_expr (function
, &call_args
,
14794 /*disallow_virtual=*/qualified_p
,
14798 release_tree_vector (call_args
);
14805 tree cond
= RECUR (TREE_OPERAND (t
, 0));
14808 if (TREE_CODE (cond
) == INTEGER_CST
)
14810 if (integer_zerop (cond
))
14812 ++c_inhibit_evaluation_warnings
;
14813 exp1
= RECUR (TREE_OPERAND (t
, 1));
14814 --c_inhibit_evaluation_warnings
;
14815 exp2
= RECUR (TREE_OPERAND (t
, 2));
14819 exp1
= RECUR (TREE_OPERAND (t
, 1));
14820 ++c_inhibit_evaluation_warnings
;
14821 exp2
= RECUR (TREE_OPERAND (t
, 2));
14822 --c_inhibit_evaluation_warnings
;
14827 exp1
= RECUR (TREE_OPERAND (t
, 1));
14828 exp2
= RECUR (TREE_OPERAND (t
, 2));
14831 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
14832 cond
, exp1
, exp2
, complain
));
14835 case PSEUDO_DTOR_EXPR
:
14836 RETURN (finish_pseudo_destructor_expr
14837 (RECUR (TREE_OPERAND (t
, 0)),
14838 RECUR (TREE_OPERAND (t
, 1)),
14839 tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
),
14844 tree purpose
, value
, chain
;
14846 if (t
== void_list_node
)
14849 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
14850 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
14852 /* We have pack expansions, so expand those and
14853 create a new list out of it. */
14854 tree purposevec
= NULL_TREE
;
14855 tree valuevec
= NULL_TREE
;
14859 /* Expand the argument expressions. */
14860 if (TREE_PURPOSE (t
))
14861 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
14862 complain
, in_decl
);
14863 if (TREE_VALUE (t
))
14864 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
14865 complain
, in_decl
);
14867 /* Build the rest of the list. */
14868 chain
= TREE_CHAIN (t
);
14869 if (chain
&& chain
!= void_type_node
)
14870 chain
= RECUR (chain
);
14872 /* Determine the number of arguments. */
14873 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
14875 len
= TREE_VEC_LENGTH (purposevec
);
14876 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
14878 else if (TREE_CODE (valuevec
) == TREE_VEC
)
14879 len
= TREE_VEC_LENGTH (valuevec
);
14882 /* Since we only performed a partial substitution into
14883 the argument pack, we only RETURN (a single list
14885 if (purposevec
== TREE_PURPOSE (t
)
14886 && valuevec
== TREE_VALUE (t
)
14887 && chain
== TREE_CHAIN (t
))
14890 RETURN (tree_cons (purposevec
, valuevec
, chain
));
14893 /* Convert the argument vectors into a TREE_LIST */
14897 /* Grab the Ith values. */
14899 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
14902 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
14905 /* Build the list (backwards). */
14906 chain
= tree_cons (purpose
, value
, chain
);
14912 purpose
= TREE_PURPOSE (t
);
14914 purpose
= RECUR (purpose
);
14915 value
= TREE_VALUE (t
);
14917 value
= RECUR (value
);
14918 chain
= TREE_CHAIN (t
);
14919 if (chain
&& chain
!= void_type_node
)
14920 chain
= RECUR (chain
);
14921 if (purpose
== TREE_PURPOSE (t
)
14922 && value
== TREE_VALUE (t
)
14923 && chain
== TREE_CHAIN (t
))
14925 RETURN (tree_cons (purpose
, value
, chain
));
14928 case COMPONENT_REF
:
14935 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14936 args
, complain
, in_decl
);
14937 /* Remember that there was a reference to this entity. */
14938 if (DECL_P (object
))
14939 mark_used (object
);
14940 object_type
= TREE_TYPE (object
);
14942 member
= TREE_OPERAND (t
, 1);
14943 if (BASELINK_P (member
))
14944 member
= tsubst_baselink (member
,
14945 non_reference (TREE_TYPE (object
)),
14946 args
, complain
, in_decl
);
14948 member
= tsubst_copy (member
, args
, complain
, in_decl
);
14949 if (member
== error_mark_node
)
14950 RETURN (error_mark_node
);
14952 if (type_dependent_expression_p (object
))
14953 /* We can't do much here. */;
14954 else if (!CLASS_TYPE_P (object_type
))
14956 if (scalarish_type_p (object_type
))
14958 tree s
= NULL_TREE
;
14959 tree dtor
= member
;
14961 if (TREE_CODE (dtor
) == SCOPE_REF
)
14963 s
= TREE_OPERAND (dtor
, 0);
14964 dtor
= TREE_OPERAND (dtor
, 1);
14966 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
14968 dtor
= TREE_OPERAND (dtor
, 0);
14970 RETURN (finish_pseudo_destructor_expr
14971 (object
, s
, dtor
, input_location
));
14975 else if (TREE_CODE (member
) == SCOPE_REF
14976 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
14978 /* Lookup the template functions now that we know what the
14980 tree scope
= TREE_OPERAND (member
, 0);
14981 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
14982 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
14983 member
= lookup_qualified_name (scope
, tmpl
,
14984 /*is_type_p=*/false,
14985 /*complain=*/false);
14986 if (BASELINK_P (member
))
14988 BASELINK_FUNCTIONS (member
)
14989 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
14991 member
= (adjust_result_of_qualified_name_lookup
14992 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
14997 qualified_name_lookup_error (scope
, tmpl
, member
,
14999 RETURN (error_mark_node
);
15002 else if (TREE_CODE (member
) == SCOPE_REF
15003 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15004 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15006 if (complain
& tf_error
)
15008 if (TYPE_P (TREE_OPERAND (member
, 0)))
15009 error ("%qT is not a class or namespace",
15010 TREE_OPERAND (member
, 0));
15012 error ("%qD is not a class or namespace",
15013 TREE_OPERAND (member
, 0));
15015 RETURN (error_mark_node
);
15017 else if (TREE_CODE (member
) == FIELD_DECL
)
15019 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15020 if (TREE_CODE (r
) == COMPONENT_REF
)
15021 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15025 r
= finish_class_member_access_expr (object
, member
,
15026 /*template_p=*/false,
15028 if (TREE_CODE (r
) == COMPONENT_REF
)
15029 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15034 RETURN (build_throw
15035 (RECUR (TREE_OPERAND (t
, 0))));
15039 vec
<constructor_elt
, va_gc
> *n
;
15040 constructor_elt
*ce
;
15041 unsigned HOST_WIDE_INT idx
;
15042 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15043 bool process_index_p
;
15045 bool need_copy_p
= false;
15048 if (type
== error_mark_node
)
15049 RETURN (error_mark_node
);
15051 /* digest_init will do the wrong thing if we let it. */
15052 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15055 /* We do not want to process the index of aggregate
15056 initializers as they are identifier nodes which will be
15057 looked up by digest_init. */
15058 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15060 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15061 newlen
= vec_safe_length (n
);
15062 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15064 if (ce
->index
&& process_index_p
15065 /* An identifier index is looked up in the type
15066 being initialized, not the current scope. */
15067 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15068 ce
->index
= RECUR (ce
->index
);
15070 if (PACK_EXPANSION_P (ce
->value
))
15072 /* Substitute into the pack expansion. */
15073 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15076 if (ce
->value
== error_mark_node
15077 || PACK_EXPANSION_P (ce
->value
))
15079 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15080 /* Just move the argument into place. */
15081 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15084 /* Update the length of the final CONSTRUCTOR
15085 arguments vector, and note that we will need to
15087 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15088 need_copy_p
= true;
15092 ce
->value
= RECUR (ce
->value
);
15097 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15099 vec_alloc (n
, newlen
);
15100 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15102 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15104 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15105 for (i
= 0; i
< len
; ++i
)
15106 CONSTRUCTOR_APPEND_ELT (n
, 0,
15107 TREE_VEC_ELT (ce
->value
, i
));
15110 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15114 r
= build_constructor (init_list_type_node
, n
);
15115 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15117 if (TREE_HAS_CONSTRUCTOR (t
))
15118 RETURN (finish_compound_literal (type
, r
, complain
));
15120 TREE_TYPE (r
) = type
;
15126 tree operand_0
= TREE_OPERAND (t
, 0);
15127 if (TYPE_P (operand_0
))
15129 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15130 RETURN (get_typeid (operand_0
, complain
));
15134 operand_0
= RECUR (operand_0
);
15135 RETURN (build_typeid (operand_0
, complain
));
15142 else if (DECL_PACK_P (t
))
15144 /* We don't build decls for an instantiation of a
15145 variadic capture proxy, we instantiate the elements
15147 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15148 return RECUR (DECL_VALUE_EXPR (t
));
15154 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15156 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15157 /* If the original type was a reference, we'll be wrapped in
15158 the appropriate INDIRECT_REF. */
15159 r
= convert_from_reference (r
);
15164 RETURN (build_x_va_arg (EXPR_LOCATION (t
),
15165 RECUR (TREE_OPERAND (t
, 0)),
15166 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
)));
15168 case OFFSETOF_EXPR
:
15169 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0))));
15173 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15174 complain
, in_decl
);
15176 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15178 type2
= tsubst (type2
, args
, complain
, in_decl
);
15180 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15185 tree old_stmt_expr
= cur_stmt_expr
;
15186 tree stmt_expr
= begin_stmt_expr ();
15188 cur_stmt_expr
= stmt_expr
;
15189 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15190 integral_constant_expression_p
);
15191 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15192 cur_stmt_expr
= old_stmt_expr
;
15194 /* If the resulting list of expression statement is empty,
15195 fold it further into void_zero_node. */
15196 if (empty_expr_stmt_p (stmt_expr
))
15197 stmt_expr
= void_zero_node
;
15199 RETURN (stmt_expr
);
15204 tree r
= build_lambda_expr ();
15206 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15207 LAMBDA_EXPR_CLOSURE (r
) = type
;
15208 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15210 LAMBDA_EXPR_LOCATION (r
)
15211 = LAMBDA_EXPR_LOCATION (t
);
15212 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15213 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15214 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15215 LAMBDA_EXPR_DISCRIMINATOR (r
)
15216 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15217 /* For a function scope, we want to use tsubst so that we don't
15218 complain about referring to an auto function before its return
15219 type has been deduced. Otherwise, we want to use tsubst_copy so
15220 that we look up the existing field/parameter/variable rather
15221 than build a new one. */
15222 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15223 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15224 scope
= tsubst (scope
, args
, complain
, in_decl
);
15225 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15227 /* Look up the parameter we want directly, as tsubst_copy
15228 doesn't do what we need. */
15229 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15230 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15231 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15232 parm
= DECL_CHAIN (parm
);
15234 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15235 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15236 DECL_CONTEXT (scope
) = fn
;
15239 scope
= RECUR (scope
);
15240 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15241 LAMBDA_EXPR_RETURN_TYPE (r
)
15242 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15244 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15245 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15247 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15248 determine_visibility (TYPE_NAME (type
));
15249 /* Now that we know visibility, instantiate the type so we have a
15250 declaration of the op() for later calls to lambda_function. */
15251 complete_type (type
);
15253 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15255 RETURN (build_lambda_object (r
));
15259 /* We can get here for a constant initializer of non-dependent type.
15260 FIXME stop folding in cp_parser_initializer_clause. */
15262 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15267 case TRANSACTION_EXPR
:
15268 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15269 integral_constant_expression_p
));
15272 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15274 case VEC_PERM_EXPR
:
15275 RETURN (build_x_vec_perm_expr (input_location
,
15276 RECUR (TREE_OPERAND (t
, 0)),
15277 RECUR (TREE_OPERAND (t
, 1)),
15278 RECUR (TREE_OPERAND (t
, 2)),
15282 /* Handle Objective-C++ constructs, if appropriate. */
15285 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15286 in_decl
, /*function_p=*/false);
15290 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15296 input_location
= loc
;
15300 /* Verify that the instantiated ARGS are valid. For type arguments,
15301 make sure that the type's linkage is ok. For non-type arguments,
15302 make sure they are constants if they are integral or enumerations.
15303 Emit an error under control of COMPLAIN, and return TRUE on error. */
15306 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15308 if (dependent_template_arg_p (t
))
15310 if (ARGUMENT_PACK_P (t
))
15312 tree vec
= ARGUMENT_PACK_ARGS (t
);
15313 int len
= TREE_VEC_LENGTH (vec
);
15314 bool result
= false;
15317 for (i
= 0; i
< len
; ++i
)
15318 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15322 else if (TYPE_P (t
))
15324 /* [basic.link]: A name with no linkage (notably, the name
15325 of a class or enumeration declared in a local scope)
15326 shall not be used to declare an entity with linkage.
15327 This implies that names with no linkage cannot be used as
15330 DR 757 relaxes this restriction for C++0x. */
15331 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15332 : no_linkage_check (t
, /*relaxed_p=*/false));
15336 /* DR 488 makes use of a type with no linkage cause
15337 type deduction to fail. */
15338 if (complain
& tf_error
)
15340 if (TYPE_ANONYMOUS_P (nt
))
15341 error ("%qT is/uses anonymous type", t
);
15343 error ("template argument for %qD uses local type %qT",
15348 /* In order to avoid all sorts of complications, we do not
15349 allow variably-modified types as template arguments. */
15350 else if (variably_modified_type_p (t
, NULL_TREE
))
15352 if (complain
& tf_error
)
15353 error ("%qT is a variably modified type", t
);
15357 /* Class template and alias template arguments should be OK. */
15358 else if (DECL_TYPE_TEMPLATE_P (t
))
15360 /* A non-type argument of integral or enumerated type must be a
15362 else if (TREE_TYPE (t
)
15363 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15364 && !TREE_CONSTANT (t
))
15366 if (complain
& tf_error
)
15367 error ("integral expression %qE is not constant", t
);
15374 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15376 int ix
, len
= DECL_NTPARMS (tmpl
);
15377 bool result
= false;
15379 for (ix
= 0; ix
!= len
; ix
++)
15381 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15384 if (result
&& (complain
& tf_error
))
15385 error (" trying to instantiate %qD", tmpl
);
15389 /* We're out of SFINAE context now, so generate diagnostics for the access
15390 errors we saw earlier when instantiating D from TMPL and ARGS. */
15393 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15395 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15396 tree type
= TREE_TYPE (pattern
);
15397 location_t loc
= input_location
;
15399 push_access_scope (d
);
15400 push_deferring_access_checks (dk_no_deferred
);
15401 input_location
= DECL_SOURCE_LOCATION (pattern
);
15402 tsubst (type
, args
, tf_warning_or_error
, d
);
15403 input_location
= loc
;
15404 pop_deferring_access_checks ();
15405 pop_access_scope (d
);
15408 /* Instantiate the indicated variable, function, or alias template TMPL with
15409 the template arguments in TARG_PTR. */
15412 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15414 tree targ_ptr
= orig_args
;
15418 bool access_ok
= true;
15420 if (tmpl
== error_mark_node
)
15421 return error_mark_node
;
15423 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15425 /* If this function is a clone, handle it specially. */
15426 if (DECL_CLONED_FUNCTION_P (tmpl
))
15431 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15432 DECL_CLONED_FUNCTION. */
15433 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15434 targ_ptr
, complain
);
15435 if (spec
== error_mark_node
)
15436 return error_mark_node
;
15438 /* Look for the clone. */
15439 FOR_EACH_CLONE (clone
, spec
)
15440 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15442 /* We should always have found the clone by now. */
15443 gcc_unreachable ();
15447 if (targ_ptr
== error_mark_node
)
15448 return error_mark_node
;
15450 /* Check to see if we already have this specialization. */
15451 gen_tmpl
= most_general_template (tmpl
);
15452 if (tmpl
!= gen_tmpl
)
15453 /* The TMPL is a partial instantiation. To get a full set of
15454 arguments we must add the arguments used to perform the
15455 partial instantiation. */
15456 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15459 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15460 but it doesn't seem to be on the hot path. */
15461 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15463 gcc_assert (tmpl
== gen_tmpl
15464 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15466 || fndecl
== NULL_TREE
);
15468 if (spec
!= NULL_TREE
)
15470 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15472 if (complain
& tf_error
)
15473 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15474 return error_mark_node
;
15479 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15481 return error_mark_node
;
15483 /* We are building a FUNCTION_DECL, during which the access of its
15484 parameters and return types have to be checked. However this
15485 FUNCTION_DECL which is the desired context for access checking
15486 is not built yet. We solve this chicken-and-egg problem by
15487 deferring all checks until we have the FUNCTION_DECL. */
15488 push_deferring_access_checks (dk_deferred
);
15490 /* Instantiation of the function happens in the context of the function
15491 template, not the context of the overload resolution we're doing. */
15492 push_to_top_level ();
15493 /* If there are dependent arguments, e.g. because we're doing partial
15494 ordering, make sure processing_template_decl stays set. */
15495 if (uses_template_parms (targ_ptr
))
15496 ++processing_template_decl
;
15497 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15499 tree ctx
= tsubst (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15500 complain
, gen_tmpl
);
15501 push_nested_class (ctx
);
15503 /* Substitute template parameters to obtain the specialization. */
15504 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
15505 targ_ptr
, complain
, gen_tmpl
);
15506 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15507 pop_nested_class ();
15508 pop_from_top_level ();
15510 if (fndecl
== error_mark_node
)
15512 pop_deferring_access_checks ();
15513 return error_mark_node
;
15516 /* The DECL_TI_TEMPLATE should always be the immediate parent
15517 template, not the most general template. */
15518 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
15520 /* Now we know the specialization, compute access previously
15522 push_access_scope (fndecl
);
15523 if (!perform_deferred_access_checks (complain
))
15525 pop_access_scope (fndecl
);
15526 pop_deferring_access_checks ();
15528 /* If we've just instantiated the main entry point for a function,
15529 instantiate all the alternate entry points as well. We do this
15530 by cloning the instantiation of the main entry point, not by
15531 instantiating the template clones. */
15532 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
15533 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
15537 if (!(complain
& tf_error
))
15539 /* Remember to reinstantiate when we're out of SFINAE so the user
15540 can see the errors. */
15541 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
15543 return error_mark_node
;
15548 /* Wrapper for instantiate_template_1. */
15551 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15554 timevar_push (TV_TEMPLATE_INST
);
15555 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
15556 timevar_pop (TV_TEMPLATE_INST
);
15560 /* Instantiate the alias template TMPL with ARGS. Also push a template
15561 instantiation level, which instantiate_template doesn't do because
15562 functions and variables have sufficient context established by the
15566 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
15568 struct pending_template
*old_last_pend
= last_pending_template
;
15569 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15570 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
15571 return error_mark_node
;
15572 tree tinst
= build_tree_list (tmpl
, args
);
15573 if (!push_tinst_level (tinst
))
15576 return error_mark_node
;
15580 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
15581 args
, tmpl
, complain
,
15582 /*require_all_args=*/true,
15583 /*use_default_args=*/true);
15585 tree r
= instantiate_template (tmpl
, args
, complain
);
15586 pop_tinst_level ();
15587 /* We can't free this if a pending_template entry or last_error_tinst_level
15588 is pointing at it. */
15589 if (last_pending_template
== old_last_pend
15590 && last_error_tinst_level
== old_error_tinst
)
15596 /* PARM is a template parameter pack for FN. Returns true iff
15597 PARM is used in a deducible way in the argument list of FN. */
15600 pack_deducible_p (tree parm
, tree fn
)
15602 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
15603 for (; t
; t
= TREE_CHAIN (t
))
15605 tree type
= TREE_VALUE (t
);
15607 if (!PACK_EXPANSION_P (type
))
15609 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
15610 packs
; packs
= TREE_CHAIN (packs
))
15611 if (TREE_VALUE (packs
) == parm
)
15613 /* The template parameter pack is used in a function parameter
15614 pack. If this is the end of the parameter list, the
15615 template parameter pack is deducible. */
15616 if (TREE_CHAIN (t
) == void_list_node
)
15619 /* Otherwise, not. Well, it could be deduced from
15620 a non-pack parameter, but doing so would end up with
15621 a deduction mismatch, so don't bother. */
15625 /* The template parameter pack isn't used in any function parameter
15626 packs, but it might be used deeper, e.g. tuple<Args...>. */
15630 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
15631 NARGS elements of the arguments that are being used when calling
15632 it. TARGS is a vector into which the deduced template arguments
15635 Returns either a FUNCTION_DECL for the matching specialization of FN or
15636 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
15637 true, diagnostics will be printed to explain why it failed.
15639 If FN is a conversion operator, or we are trying to produce a specific
15640 specialization, RETURN_TYPE is the return type desired.
15642 The EXPLICIT_TARGS are explicit template arguments provided via a
15645 The parameter STRICT is one of:
15648 We are deducing arguments for a function call, as in
15649 [temp.deduct.call].
15652 We are deducing arguments for a conversion function, as in
15653 [temp.deduct.conv].
15656 We are deducing arguments when doing an explicit instantiation
15657 as in [temp.explicit], when determining an explicit specialization
15658 as in [temp.expl.spec], or when taking the address of a function
15659 template, as in [temp.deduct.funcaddr]. */
15662 fn_type_unification (tree fn
,
15663 tree explicit_targs
,
15666 unsigned int nargs
,
15668 unification_kind_t strict
,
15675 tree decl
= NULL_TREE
;
15676 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
15678 static int deduction_depth
;
15679 struct pending_template
*old_last_pend
= last_pending_template
;
15680 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15681 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
15683 tree r
= error_mark_node
;
15686 complain
|= tf_decltype
;
15688 /* In C++0x, it's possible to have a function template whose type depends
15689 on itself recursively. This is most obvious with decltype, but can also
15690 occur with enumeration scope (c++/48969). So we need to catch infinite
15691 recursion and reject the substitution at deduction time; this function
15692 will return error_mark_node for any repeated substitution.
15694 This also catches excessive recursion such as when f<N> depends on
15695 f<N-1> across all integers, and returns error_mark_node for all the
15696 substitutions back up to the initial one.
15698 This is, of course, not reentrant. */
15699 if (excessive_deduction_depth
)
15700 return error_mark_node
;
15701 tinst
= build_tree_list (fn
, NULL_TREE
);
15704 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
15706 fntype
= TREE_TYPE (fn
);
15707 if (explicit_targs
)
15711 The specified template arguments must match the template
15712 parameters in kind (i.e., type, nontype, template), and there
15713 must not be more arguments than there are parameters;
15714 otherwise type deduction fails.
15716 Nontype arguments must match the types of the corresponding
15717 nontype template parameters, or must be convertible to the
15718 types of the corresponding nontype parameters as specified in
15719 _temp.arg.nontype_, otherwise type deduction fails.
15721 All references in the function type of the function template
15722 to the corresponding template parameters are replaced by the
15723 specified template argument values. If a substitution in a
15724 template parameter or in the function type of the function
15725 template results in an invalid type, type deduction fails. */
15726 int i
, len
= TREE_VEC_LENGTH (tparms
);
15727 location_t loc
= input_location
;
15728 bool incomplete
= false;
15730 /* Adjust any explicit template arguments before entering the
15731 substitution context. */
15733 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
15735 /*require_all_args=*/false,
15736 /*use_default_args=*/false));
15737 if (explicit_targs
== error_mark_node
)
15740 /* Substitute the explicit args into the function type. This is
15741 necessary so that, for instance, explicitly declared function
15742 arguments can match null pointed constants. If we were given
15743 an incomplete set of explicit args, we must not do semantic
15744 processing during substitution as we could create partial
15746 for (i
= 0; i
< len
; i
++)
15748 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
15749 bool parameter_pack
= false;
15750 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
15752 /* Dig out the actual parm. */
15753 if (TREE_CODE (parm
) == TYPE_DECL
15754 || TREE_CODE (parm
) == TEMPLATE_DECL
)
15756 parm
= TREE_TYPE (parm
);
15757 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
15759 else if (TREE_CODE (parm
) == PARM_DECL
)
15761 parm
= DECL_INITIAL (parm
);
15762 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
15765 if (!parameter_pack
&& targ
== NULL_TREE
)
15766 /* No explicit argument for this template parameter. */
15769 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
15771 /* Mark the argument pack as "incomplete". We could
15772 still deduce more arguments during unification.
15773 We remove this mark in type_unification_real. */
15776 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
15777 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
15778 = ARGUMENT_PACK_ARGS (targ
);
15781 /* We have some incomplete argument packs. */
15786 TREE_VALUE (tinst
) = explicit_targs
;
15787 if (!push_tinst_level (tinst
))
15789 excessive_deduction_depth
= true;
15792 processing_template_decl
+= incomplete
;
15793 input_location
= DECL_SOURCE_LOCATION (fn
);
15794 /* Ignore any access checks; we'll see them again in
15795 instantiate_template and they might have the wrong
15796 access path at this point. */
15797 push_deferring_access_checks (dk_deferred
);
15798 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
15799 complain
| tf_partial
, NULL_TREE
);
15800 pop_deferring_access_checks ();
15801 input_location
= loc
;
15802 processing_template_decl
-= incomplete
;
15803 pop_tinst_level ();
15805 if (fntype
== error_mark_node
)
15808 /* Place the explicitly specified arguments in TARGS. */
15809 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
15810 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
15813 /* Never do unification on the 'this' parameter. */
15814 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
15820 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
15821 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
15822 new_args
[0] = return_type
;
15823 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
15828 /* We allow incomplete unification without an error message here
15829 because the standard doesn't seem to explicitly prohibit it. Our
15830 callers must be ready to deal with unification failures in any
15833 TREE_VALUE (tinst
) = targs
;
15834 /* If we aren't explaining yet, push tinst context so we can see where
15835 any errors (e.g. from class instantiations triggered by instantiation
15836 of default template arguments) come from. If we are explaining, this
15837 context is redundant. */
15838 if (!explain_p
&& !push_tinst_level (tinst
))
15840 excessive_deduction_depth
= true;
15844 /* type_unification_real will pass back any access checks from default
15845 template argument substitution. */
15846 vec
<deferred_access_check
, va_gc
> *checks
;
15849 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
15850 targs
, parms
, args
, nargs
, /*subr=*/0,
15851 strict
, flags
, &checks
, explain_p
);
15853 pop_tinst_level ();
15857 /* Now that we have bindings for all of the template arguments,
15858 ensure that the arguments deduced for the template template
15859 parameters have compatible template parameter lists. We cannot
15860 check this property before we have deduced all template
15861 arguments, because the template parameter types of a template
15862 template parameter might depend on prior template parameters
15863 deduced after the template template parameter. The following
15864 ill-formed example illustrates this issue:
15866 template<typename T, template<T> class C> void f(C<5>, T);
15868 template<int N> struct X {};
15871 f(X<5>(), 5l); // error: template argument deduction fails
15874 The template parameter list of 'C' depends on the template type
15875 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
15876 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
15877 time that we deduce 'C'. */
15878 if (!template_template_parm_bindings_ok_p
15879 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
15881 unify_inconsistent_template_template_parameters (explain_p
);
15885 /* All is well so far. Now, check:
15889 When all template arguments have been deduced, all uses of
15890 template parameters in nondeduced contexts are replaced with
15891 the corresponding deduced argument values. If the
15892 substitution results in an invalid type, as described above,
15893 type deduction fails. */
15894 TREE_VALUE (tinst
) = targs
;
15895 if (!push_tinst_level (tinst
))
15897 excessive_deduction_depth
= true;
15901 /* Also collect access checks from the instantiation. */
15902 reopen_deferring_access_checks (checks
);
15904 decl
= instantiate_template (fn
, targs
, complain
);
15906 checks
= get_deferred_access_checks ();
15907 pop_deferring_access_checks ();
15909 pop_tinst_level ();
15911 if (decl
== error_mark_node
)
15914 /* Now perform any access checks encountered during substitution. */
15915 push_access_scope (decl
);
15916 ok
= perform_access_checks (checks
, complain
);
15917 pop_access_scope (decl
);
15921 /* If we're looking for an exact match, check that what we got
15922 is indeed an exact match. It might not be if some template
15923 parameters are used in non-deduced contexts. But don't check
15924 for an exact match if we have dependent template arguments;
15925 in that case we're doing partial ordering, and we already know
15926 that we have two candidates that will provide the actual type. */
15927 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
15929 tree substed
= TREE_TYPE (decl
);
15933 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
15935 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
15936 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
15937 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
15939 unify_type_mismatch (explain_p
, args
[i
],
15940 TREE_VALUE (sarg
));
15949 if (excessive_deduction_depth
)
15951 if (deduction_depth
== 0)
15952 /* Reset once we're all the way out. */
15953 excessive_deduction_depth
= false;
15956 /* We can't free this if a pending_template entry or last_error_tinst_level
15957 is pointing at it. */
15958 if (last_pending_template
== old_last_pend
15959 && last_error_tinst_level
== old_error_tinst
)
15965 /* Adjust types before performing type deduction, as described in
15966 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
15967 sections are symmetric. PARM is the type of a function parameter
15968 or the return type of the conversion function. ARG is the type of
15969 the argument passed to the call, or the type of the value
15970 initialized with the result of the conversion function.
15971 ARG_EXPR is the original argument expression, which may be null. */
15974 maybe_adjust_types_for_deduction (unification_kind_t strict
,
15988 /* Swap PARM and ARG throughout the remainder of this
15989 function; the handling is precisely symmetric since PARM
15990 will initialize ARG rather than vice versa. */
15998 /* Core issue #873: Do the DR606 thing (see below) for these cases,
15999 too, but here handle it by stripping the reference from PARM
16000 rather than by adding it to ARG. */
16001 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16002 && TYPE_REF_IS_RVALUE (*parm
)
16003 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16004 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16005 && TREE_CODE (*arg
) == REFERENCE_TYPE
16006 && !TYPE_REF_IS_RVALUE (*arg
))
16007 *parm
= TREE_TYPE (*parm
);
16008 /* Nothing else to do in this case. */
16012 gcc_unreachable ();
16015 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16017 /* [temp.deduct.call]
16019 If P is not a reference type:
16021 --If A is an array type, the pointer type produced by the
16022 array-to-pointer standard conversion (_conv.array_) is
16023 used in place of A for type deduction; otherwise,
16025 --If A is a function type, the pointer type produced by
16026 the function-to-pointer standard conversion
16027 (_conv.func_) is used in place of A for type deduction;
16030 --If A is a cv-qualified type, the top level
16031 cv-qualifiers of A's type are ignored for type
16033 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16034 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16035 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16036 *arg
= build_pointer_type (*arg
);
16038 *arg
= TYPE_MAIN_VARIANT (*arg
);
16041 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16042 of the form T&&, where T is a template parameter, and the argument
16043 is an lvalue, T is deduced as A& */
16044 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16045 && TYPE_REF_IS_RVALUE (*parm
)
16046 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16047 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16048 && (arg_expr
? real_lvalue_p (arg_expr
)
16049 /* try_one_overload doesn't provide an arg_expr, but
16050 functions are always lvalues. */
16051 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16052 *arg
= build_reference_type (*arg
);
16054 /* [temp.deduct.call]
16056 If P is a cv-qualified type, the top level cv-qualifiers
16057 of P's type are ignored for type deduction. If P is a
16058 reference type, the type referred to by P is used for
16060 *parm
= TYPE_MAIN_VARIANT (*parm
);
16061 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16063 *parm
= TREE_TYPE (*parm
);
16064 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16067 /* DR 322. For conversion deduction, remove a reference type on parm
16068 too (which has been swapped into ARG). */
16069 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16070 *arg
= TREE_TYPE (*arg
);
16075 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16076 template which does contain any deducible template parameters; check if
16077 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16078 unify_one_argument. */
16081 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16082 int flags
, bool explain_p
)
16087 type
= TREE_TYPE (arg
);
16091 if (same_type_p (parm
, type
))
16092 return unify_success (explain_p
);
16094 if (strict
== DEDUCE_CONV
)
16096 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16097 explain_p
? tf_warning_or_error
: tf_none
))
16098 return unify_success (explain_p
);
16100 else if (strict
!= DEDUCE_EXACT
)
16102 if (can_convert_arg (parm
, type
,
16103 TYPE_P (arg
) ? NULL_TREE
: arg
,
16104 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16105 return unify_success (explain_p
);
16108 if (strict
== DEDUCE_EXACT
)
16109 return unify_type_mismatch (explain_p
, parm
, arg
);
16111 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16114 static bool uses_deducible_template_parms (tree type
);
16116 /* Returns true iff the expression EXPR is one from which a template
16117 argument can be deduced. In other words, if it's an undecorated
16118 use of a template non-type parameter. */
16121 deducible_expression (tree expr
)
16123 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16126 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16127 deducible way; that is, if it has a max value of <PARM> - 1. */
16130 deducible_array_bound (tree domain
)
16132 if (domain
== NULL_TREE
)
16135 tree max
= TYPE_MAX_VALUE (domain
);
16136 if (TREE_CODE (max
) != MINUS_EXPR
)
16139 return deducible_expression (TREE_OPERAND (max
, 0));
16142 /* Returns true iff the template arguments ARGS use a template parameter
16143 in a deducible way. */
16146 deducible_template_args (tree args
)
16148 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16151 tree elt
= TREE_VEC_ELT (args
, i
);
16152 if (ARGUMENT_PACK_P (elt
))
16153 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16156 if (PACK_EXPANSION_P (elt
))
16157 elt
= PACK_EXPANSION_PATTERN (elt
);
16158 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16160 else if (TYPE_P (elt
))
16161 deducible
= uses_deducible_template_parms (elt
);
16163 deducible
= deducible_expression (elt
);
16171 /* Returns true iff TYPE contains any deducible references to template
16172 parameters, as per 14.8.2.5. */
16175 uses_deducible_template_parms (tree type
)
16177 if (PACK_EXPANSION_P (type
))
16178 type
= PACK_EXPANSION_PATTERN (type
);
16185 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16186 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16192 if (POINTER_TYPE_P (type
))
16193 return uses_deducible_template_parms (TREE_TYPE (type
));
16195 /* T[integer-constant ]
16197 if (TREE_CODE (type
) == ARRAY_TYPE
)
16198 return (uses_deducible_template_parms (TREE_TYPE (type
))
16199 || deducible_array_bound (TYPE_DOMAIN (type
)));
16211 if (TYPE_PTRMEM_P (type
))
16212 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16213 || (uses_deducible_template_parms
16214 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16216 /* template-name <T> (where template-name refers to a class template)
16217 template-name <i> (where template-name refers to a class template) */
16218 if (CLASS_TYPE_P (type
)
16219 && CLASSTYPE_TEMPLATE_INFO (type
)
16220 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16221 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16222 (CLASSTYPE_TI_ARGS (type
)));
16227 if (TREE_CODE (type
) == FUNCTION_TYPE
16228 || TREE_CODE (type
) == METHOD_TYPE
)
16230 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16232 tree parm
= TYPE_ARG_TYPES (type
);
16233 if (TREE_CODE (type
) == METHOD_TYPE
)
16234 parm
= TREE_CHAIN (parm
);
16235 for (; parm
; parm
= TREE_CHAIN (parm
))
16236 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16243 /* Subroutine of type_unification_real and unify_pack_expansion to
16244 handle unification of a single P/A pair. Parameters are as
16245 for those functions. */
16248 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16249 int subr
, unification_kind_t strict
, int flags
,
16252 tree arg_expr
= NULL_TREE
;
16255 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16256 return unify_invalid (explain_p
);
16257 if (arg
== unknown_type_node
)
16258 /* We can't deduce anything from this, but we might get all the
16259 template args from other function args. */
16260 return unify_success (explain_p
);
16262 /* Implicit conversions (Clause 4) will be performed on a function
16263 argument to convert it to the type of the corresponding function
16264 parameter if the parameter type contains no template-parameters that
16265 participate in template argument deduction. */
16266 if (TYPE_P (parm
) && !uses_template_parms (parm
))
16267 /* For function parameters that contain no template-parameters at all,
16268 we have historically checked for convertibility in order to shortcut
16269 consideration of this candidate. */
16270 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
16272 else if (strict
== DEDUCE_CALL
16273 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16274 /* For function parameters with only non-deducible template parameters,
16276 return unify_success (explain_p
);
16281 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16282 | UNIFY_ALLOW_MORE_CV_QUAL
16283 | UNIFY_ALLOW_DERIVED
);
16287 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16291 arg_strict
= UNIFY_ALLOW_NONE
;
16295 gcc_unreachable ();
16298 /* We only do these transformations if this is the top-level
16299 parameter_type_list in a call or declaration matching; in other
16300 situations (nested function declarators, template argument lists) we
16301 won't be comparing a type to an expression, and we don't do any type
16307 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16308 if (type_unknown_p (arg
))
16310 /* [temp.deduct.type] A template-argument can be
16311 deduced from a pointer to function or pointer
16312 to member function argument if the set of
16313 overloaded functions does not contain function
16314 templates and at most one of a set of
16315 overloaded functions provides a unique
16318 if (resolve_overloaded_unification
16319 (tparms
, targs
, parm
, arg
, strict
,
16320 arg_strict
, explain_p
))
16321 return unify_success (explain_p
);
16322 return unify_overload_resolution_failure (explain_p
, arg
);
16326 arg
= unlowered_expr_type (arg
);
16327 if (arg
== error_mark_node
)
16328 return unify_invalid (explain_p
);
16332 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16335 gcc_assert ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16336 == (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
));
16338 /* For deduction from an init-list we need the actual list. */
16339 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16341 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16344 /* Most parms like fn_type_unification.
16346 If SUBR is 1, we're being called recursively (to unify the
16347 arguments of a function or method parameter of a function
16350 CHECKS is a pointer to a vector of access checks encountered while
16351 substituting default template arguments. */
16354 type_unification_real (tree tparms
,
16358 unsigned int xnargs
,
16360 unification_kind_t strict
,
16362 vec
<deferred_access_check
, va_gc
> **checks
,
16367 int ntparms
= TREE_VEC_LENGTH (tparms
);
16368 int saw_undeduced
= 0;
16371 unsigned int nargs
;
16374 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16375 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16376 gcc_assert (ntparms
> 0);
16378 /* Reset the number of non-defaulted template arguments contained
16380 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16388 while (parms
&& parms
!= void_list_node
16391 parm
= TREE_VALUE (parms
);
16393 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16394 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16395 /* For a function parameter pack that occurs at the end of the
16396 parameter-declaration-list, the type A of each remaining
16397 argument of the call is compared with the type P of the
16398 declarator-id of the function parameter pack. */
16401 parms
= TREE_CHAIN (parms
);
16403 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16404 /* For a function parameter pack that does not occur at the
16405 end of the parameter-declaration-list, the type of the
16406 parameter pack is a non-deduced context. */
16412 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16418 && parms
!= void_list_node
16419 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16421 /* Unify the remaining arguments with the pack expansion type. */
16423 tree parmvec
= make_tree_vec (1);
16425 /* Allocate a TREE_VEC and copy in all of the arguments */
16426 argvec
= make_tree_vec (nargs
- ia
);
16427 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16428 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16430 /* Copy the parameter into parmvec. */
16431 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16432 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16433 /*subr=*/subr
, explain_p
))
16436 /* Advance to the end of the list of parameters. */
16437 parms
= TREE_CHAIN (parms
);
16440 /* Fail if we've reached the end of the parm list, and more args
16441 are present, and the parm list isn't variadic. */
16442 if (ia
< nargs
&& parms
== void_list_node
)
16443 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16444 /* Fail if parms are left and they don't have default values. */
16445 if (parms
&& parms
!= void_list_node
16446 && TREE_PURPOSE (parms
) == NULL_TREE
)
16448 unsigned int count
= nargs
;
16450 while (p
&& p
!= void_list_node
)
16453 p
= TREE_CHAIN (p
);
16455 return unify_too_few_arguments (explain_p
, ia
, count
);
16460 tsubst_flags_t complain
= (explain_p
16461 ? tf_warning_or_error
16464 for (i
= 0; i
< ntparms
; i
++)
16466 tree targ
= TREE_VEC_ELT (targs
, i
);
16467 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16469 /* Clear the "incomplete" flags on all argument packs now so that
16470 substituting them into later default arguments works. */
16471 if (targ
&& ARGUMENT_PACK_P (targ
))
16473 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16474 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16477 if (targ
|| tparm
== error_mark_node
)
16479 tparm
= TREE_VALUE (tparm
);
16481 /* If this is an undeduced nontype parameter that depends on
16482 a type parameter, try another pass; its type may have been
16483 deduced from a later argument than the one from which
16484 this parameter can be deduced. */
16485 if (TREE_CODE (tparm
) == PARM_DECL
16486 && uses_template_parms (TREE_TYPE (tparm
))
16487 && !saw_undeduced
++)
16490 /* Core issue #226 (C++0x) [temp.deduct]:
16492 If a template argument has not been deduced, its
16493 default template argument, if any, is used.
16495 When we are in C++98 mode, TREE_PURPOSE will either
16496 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16497 to explicitly check cxx_dialect here. */
16498 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
16500 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16501 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
16502 reopen_deferring_access_checks (*checks
);
16503 location_t save_loc
= input_location
;
16505 input_location
= DECL_SOURCE_LOCATION (parm
);
16506 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
16507 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
16509 input_location
= save_loc
;
16510 *checks
= get_deferred_access_checks ();
16511 pop_deferring_access_checks ();
16512 if (arg
== error_mark_node
)
16516 TREE_VEC_ELT (targs
, i
) = arg
;
16517 /* The position of the first default template argument,
16518 is also the number of non-defaulted arguments in TARGS.
16520 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16521 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
16526 /* If the type parameter is a parameter pack, then it will
16527 be deduced to an empty parameter pack. */
16528 if (template_parameter_pack_p (tparm
))
16532 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
16534 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
16535 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
16536 TREE_CONSTANT (arg
) = 1;
16539 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16541 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
16543 TREE_VEC_ELT (targs
, i
) = arg
;
16547 return unify_parameter_deduction_failure (explain_p
, tparm
);
16550 #ifdef ENABLE_CHECKING
16551 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16552 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
16555 return unify_success (explain_p
);
16558 /* Subroutine of type_unification_real. Args are like the variables
16559 at the call site. ARG is an overloaded function (or template-id);
16560 we try deducing template args from each of the overloads, and if
16561 only one succeeds, we go with that. Modifies TARGS and returns
16562 true on success. */
16565 resolve_overloaded_unification (tree tparms
,
16569 unification_kind_t strict
,
16573 tree tempargs
= copy_node (targs
);
16575 tree goodfn
= NULL_TREE
;
16578 if (TREE_CODE (arg
) == ADDR_EXPR
)
16580 arg
= TREE_OPERAND (arg
, 0);
16586 if (TREE_CODE (arg
) == COMPONENT_REF
)
16587 /* Handle `&x' where `x' is some static or non-static member
16589 arg
= TREE_OPERAND (arg
, 1);
16591 if (TREE_CODE (arg
) == OFFSET_REF
)
16592 arg
= TREE_OPERAND (arg
, 1);
16594 /* Strip baselink information. */
16595 if (BASELINK_P (arg
))
16596 arg
= BASELINK_FUNCTIONS (arg
);
16598 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
16600 /* If we got some explicit template args, we need to plug them into
16601 the affected templates before we try to unify, in case the
16602 explicit args will completely resolve the templates in question. */
16605 tree expl_subargs
= TREE_OPERAND (arg
, 1);
16606 arg
= TREE_OPERAND (arg
, 0);
16608 for (; arg
; arg
= OVL_NEXT (arg
))
16610 tree fn
= OVL_CURRENT (arg
);
16611 tree subargs
, elem
;
16613 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16616 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16617 expl_subargs
, NULL_TREE
, tf_none
,
16618 /*require_all_args=*/true,
16619 /*use_default_args=*/true);
16620 if (subargs
!= error_mark_node
16621 && !any_dependent_template_arguments_p (subargs
))
16623 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
16624 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16625 elem
, strict
, sub_strict
, addr_p
, explain_p
)
16626 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
16635 /* If no templates (or more than one) are fully resolved by the
16636 explicit arguments, this template-id is a non-deduced context; it
16637 could still be OK if we deduce all template arguments for the
16638 enclosing call through other arguments. */
16642 else if (TREE_CODE (arg
) != OVERLOAD
16643 && TREE_CODE (arg
) != FUNCTION_DECL
)
16644 /* If ARG is, for example, "(0, &f)" then its type will be unknown
16645 -- but the deduction does not succeed because the expression is
16646 not just the function on its own. */
16649 for (; arg
; arg
= OVL_NEXT (arg
))
16650 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16651 TREE_TYPE (OVL_CURRENT (arg
)),
16652 strict
, sub_strict
, addr_p
, explain_p
)
16653 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
16655 goodfn
= OVL_CURRENT (arg
);
16659 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16660 to function or pointer to member function argument if the set of
16661 overloaded functions does not contain function templates and at most
16662 one of a set of overloaded functions provides a unique match.
16664 So if we found multiple possibilities, we return success but don't
16665 deduce anything. */
16669 int i
= TREE_VEC_LENGTH (targs
);
16671 if (TREE_VEC_ELT (tempargs
, i
))
16672 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
16680 /* Core DR 115: In contexts where deduction is done and fails, or in
16681 contexts where deduction is not done, if a template argument list is
16682 specified and it, along with any default template arguments, identifies
16683 a single function template specialization, then the template-id is an
16684 lvalue for the function template specialization. */
16687 resolve_nondeduced_context (tree orig_expr
)
16689 tree expr
, offset
, baselink
;
16692 if (!type_unknown_p (orig_expr
))
16697 offset
= NULL_TREE
;
16698 baselink
= NULL_TREE
;
16700 if (TREE_CODE (expr
) == ADDR_EXPR
)
16702 expr
= TREE_OPERAND (expr
, 0);
16705 if (TREE_CODE (expr
) == OFFSET_REF
)
16708 expr
= TREE_OPERAND (expr
, 1);
16710 if (BASELINK_P (expr
))
16713 expr
= BASELINK_FUNCTIONS (expr
);
16716 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
16719 tree goodfn
= NULL_TREE
;
16721 /* If we got some explicit template args, we need to plug them into
16722 the affected templates before we try to unify, in case the
16723 explicit args will completely resolve the templates in question. */
16725 tree expl_subargs
= TREE_OPERAND (expr
, 1);
16726 tree arg
= TREE_OPERAND (expr
, 0);
16727 tree badfn
= NULL_TREE
;
16728 tree badargs
= NULL_TREE
;
16730 for (; arg
; arg
= OVL_NEXT (arg
))
16732 tree fn
= OVL_CURRENT (arg
);
16733 tree subargs
, elem
;
16735 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16738 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16739 expl_subargs
, NULL_TREE
, tf_none
,
16740 /*require_all_args=*/true,
16741 /*use_default_args=*/true);
16742 if (subargs
!= error_mark_node
16743 && !any_dependent_template_arguments_p (subargs
))
16745 elem
= instantiate_template (fn
, subargs
, tf_none
);
16746 if (elem
== error_mark_node
)
16751 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
16760 mark_used (goodfn
);
16763 expr
= build_baselink (BASELINK_BINFO (baselink
),
16764 BASELINK_ACCESS_BINFO (baselink
),
16765 expr
, BASELINK_OPTYPE (baselink
));
16769 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
16770 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
16773 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
16776 else if (good
== 0 && badargs
)
16777 /* There were no good options and at least one bad one, so let the
16778 user know what the problem is. */
16779 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
16784 /* Subroutine of resolve_overloaded_unification; does deduction for a single
16785 overload. Fills TARGS with any deduced arguments, or error_mark_node if
16786 different overloads deduce different arguments for a given parm.
16787 ADDR_P is true if the expression for which deduction is being
16788 performed was of the form "& fn" rather than simply "fn".
16790 Returns 1 on success. */
16793 try_one_overload (tree tparms
,
16798 unification_kind_t strict
,
16807 if (arg
== error_mark_node
)
16810 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16811 to function or pointer to member function argument if the set of
16812 overloaded functions does not contain function templates and at most
16813 one of a set of overloaded functions provides a unique match.
16815 So if this is a template, just return success. */
16817 if (uses_template_parms (arg
))
16820 if (TREE_CODE (arg
) == METHOD_TYPE
)
16821 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
16823 arg
= build_pointer_type (arg
);
16825 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
16827 /* We don't copy orig_targs for this because if we have already deduced
16828 some template args from previous args, unify would complain when we
16829 try to deduce a template parameter for the same argument, even though
16830 there isn't really a conflict. */
16831 nargs
= TREE_VEC_LENGTH (targs
);
16832 tempargs
= make_tree_vec (nargs
);
16834 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
16837 /* First make sure we didn't deduce anything that conflicts with
16838 explicitly specified args. */
16839 for (i
= nargs
; i
--; )
16841 tree elt
= TREE_VEC_ELT (tempargs
, i
);
16842 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
16846 else if (uses_template_parms (elt
))
16847 /* Since we're unifying against ourselves, we will fill in
16848 template args used in the function parm list with our own
16849 template parms. Discard them. */
16850 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
16851 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
16855 for (i
= nargs
; i
--; )
16857 tree elt
= TREE_VEC_ELT (tempargs
, i
);
16860 TREE_VEC_ELT (targs
, i
) = elt
;
16866 /* PARM is a template class (perhaps with unbound template
16867 parameters). ARG is a fully instantiated type. If ARG can be
16868 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
16869 TARGS are as for unify. */
16872 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
16875 tree copy_of_targs
;
16877 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
16878 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
16879 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
16882 /* We need to make a new template argument vector for the call to
16883 unify. If we used TARGS, we'd clutter it up with the result of
16884 the attempted unification, even if this class didn't work out.
16885 We also don't want to commit ourselves to all the unifications
16886 we've already done, since unification is supposed to be done on
16887 an argument-by-argument basis. In other words, consider the
16888 following pathological case:
16890 template <int I, int J, int K>
16893 template <int I, int J>
16894 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
16896 template <int I, int J, int K>
16897 void f(S<I, J, K>, S<I, I, I>);
16906 Now, by the time we consider the unification involving `s2', we
16907 already know that we must have `f<0, 0, 0>'. But, even though
16908 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
16909 because there are two ways to unify base classes of S<0, 1, 2>
16910 with S<I, I, I>. If we kept the already deduced knowledge, we
16911 would reject the possibility I=1. */
16912 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
16914 /* If unification failed, we're done. */
16915 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
16916 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
16922 /* Given a template type PARM and a class type ARG, find the unique
16923 base type in ARG that is an instance of PARM. We do not examine
16924 ARG itself; only its base-classes. If there is not exactly one
16925 appropriate base class, return NULL_TREE. PARM may be the type of
16926 a partial specialization, as well as a plain template type. Used
16929 static enum template_base_result
16930 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
16931 bool explain_p
, tree
*result
)
16933 tree rval
= NULL_TREE
;
16936 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
16938 binfo
= TYPE_BINFO (complete_type (arg
));
16941 /* The type could not be completed. */
16942 *result
= NULL_TREE
;
16943 return tbr_incomplete_type
;
16946 /* Walk in inheritance graph order. The search order is not
16947 important, and this avoids multiple walks of virtual bases. */
16948 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
16950 tree r
= try_class_unification (tparms
, targs
, parm
,
16951 BINFO_TYPE (binfo
), explain_p
);
16955 /* If there is more than one satisfactory baseclass, then:
16959 If they yield more than one possible deduced A, the type
16963 if (rval
&& !same_type_p (r
, rval
))
16965 *result
= NULL_TREE
;
16966 return tbr_ambiguous_baseclass
;
16974 return tbr_success
;
16977 /* Returns the level of DECL, which declares a template parameter. */
16980 template_decl_level (tree decl
)
16982 switch (TREE_CODE (decl
))
16985 case TEMPLATE_DECL
:
16986 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
16989 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
16992 gcc_unreachable ();
16997 /* Decide whether ARG can be unified with PARM, considering only the
16998 cv-qualifiers of each type, given STRICT as documented for unify.
16999 Returns nonzero iff the unification is OK on that basis. */
17002 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17004 int arg_quals
= cp_type_quals (arg
);
17005 int parm_quals
= cp_type_quals (parm
);
17007 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17008 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17010 /* Although a CVR qualifier is ignored when being applied to a
17011 substituted template parameter ([8.3.2]/1 for example), that
17012 does not allow us to unify "const T" with "int&" because both
17013 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17014 It is ok when we're allowing additional CV qualifiers
17015 at the outer level [14.8.2.1]/3,1st bullet. */
17016 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17017 || TREE_CODE (arg
) == FUNCTION_TYPE
17018 || TREE_CODE (arg
) == METHOD_TYPE
)
17019 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17022 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17023 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17027 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17028 && (arg_quals
& parm_quals
) != parm_quals
)
17031 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17032 && (parm_quals
& arg_quals
) != arg_quals
)
17038 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17040 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17042 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17043 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17044 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17046 *index
= TEMPLATE_TYPE_IDX (parm
);
17047 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17051 *index
= TEMPLATE_PARM_IDX (parm
);
17052 *level
= TEMPLATE_PARM_LEVEL (parm
);
17056 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17058 if (unify (TP, TA, P, A, S, EP)) \
17062 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17063 expansion at the end of PACKED_PARMS. Returns 0 if the type
17064 deduction succeeds, 1 otherwise. STRICT is the same as in
17065 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17066 call argument list. We'll need to adjust the arguments to make them
17067 types. SUBR tells us if this is from a recursive call to
17068 type_unification_real, or for comparing two template argument
17072 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17073 tree packed_args
, unification_kind_t strict
,
17074 bool subr
, bool explain_p
)
17077 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17078 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17079 tree pack
, packs
= NULL_TREE
;
17080 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17082 packed_args
= expand_template_argument_pack (packed_args
);
17084 int len
= TREE_VEC_LENGTH (packed_args
);
17086 /* Determine the parameter packs we will be deducing from the
17087 pattern, and record their current deductions. */
17088 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17089 pack
; pack
= TREE_CHAIN (pack
))
17091 tree parm_pack
= TREE_VALUE (pack
);
17094 /* Determine the index and level of this parameter pack. */
17095 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17097 /* Keep track of the parameter packs and their corresponding
17099 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17100 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17103 /* Loop through all of the arguments that have not yet been
17104 unified and unify each with the pattern. */
17105 for (i
= start
; i
< len
; i
++)
17108 bool any_explicit
= false;
17109 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17111 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17112 or the element of its argument pack at the current index if
17113 this argument was explicitly specified. */
17114 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17118 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17121 if (TREE_VALUE (pack
)
17122 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17123 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17125 any_explicit
= true;
17126 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17128 TMPL_ARG (targs
, level
, idx
) = arg
;
17131 /* If we had explicit template arguments, substitute them into the
17132 pattern before deduction. */
17135 /* Some arguments might still be unspecified or dependent. */
17137 ++processing_template_decl
;
17138 dependent
= any_dependent_template_arguments_p (targs
);
17140 --processing_template_decl
;
17141 parm
= tsubst (pattern
, targs
,
17142 explain_p
? tf_warning_or_error
: tf_none
,
17145 --processing_template_decl
;
17146 if (parm
== error_mark_node
)
17152 /* Unify the pattern with the current argument. */
17153 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17154 LOOKUP_IMPLICIT
, explain_p
))
17157 /* For each parameter pack, collect the deduced value. */
17158 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17161 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17163 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17164 TMPL_ARG (targs
, level
, idx
);
17168 /* Verify that the results of unification with the parameter packs
17169 produce results consistent with what we've seen before, and make
17170 the deduced argument packs available. */
17171 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17173 tree old_pack
= TREE_VALUE (pack
);
17174 tree new_args
= TREE_TYPE (pack
);
17175 int i
, len
= TREE_VEC_LENGTH (new_args
);
17177 bool nondeduced_p
= false;
17179 /* By default keep the original deduced argument pack.
17180 If necessary, more specific code is going to update the
17181 resulting deduced argument later down in this function. */
17182 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17183 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17185 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17186 actually deduce anything. */
17187 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17188 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17189 nondeduced_p
= true;
17193 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17195 /* If we had fewer function args than explicit template args,
17196 just use the explicits. */
17197 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17198 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17199 if (len
< explicit_len
)
17200 new_args
= explicit_args
;
17206 /* Build the deduced *_ARGUMENT_PACK. */
17207 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17209 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17210 TREE_TYPE (result
) =
17211 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17212 TREE_CONSTANT (result
) = 1;
17215 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17217 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17219 /* Note the deduced argument packs for this parameter
17221 TMPL_ARG (targs
, level
, idx
) = result
;
17223 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17224 && (ARGUMENT_PACK_ARGS (old_pack
)
17225 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17227 /* We only had the explicitly-provided arguments before, but
17228 now we have a complete set of arguments. */
17229 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17231 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17232 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17233 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17237 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17238 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17240 if (!comp_template_args_with_info (old_args
, new_args
,
17241 &bad_old_arg
, &bad_new_arg
))
17242 /* Inconsistent unification of this parameter pack. */
17243 return unify_parameter_pack_inconsistent (explain_p
,
17249 return unify_success (explain_p
);
17252 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17253 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17254 parameters and return value are as for unify. */
17257 unify_array_domain (tree tparms
, tree targs
,
17258 tree parm_dom
, tree arg_dom
,
17266 /* Our representation of array types uses "N - 1" as the
17267 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17268 not an integer constant. We cannot unify arbitrarily
17269 complex expressions, so we eliminate the MINUS_EXPRs
17271 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17272 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17275 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17276 parm_max
= TREE_OPERAND (parm_max
, 0);
17278 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17279 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17282 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17283 trying to unify the type of a variable with the type
17284 of a template parameter. For example:
17286 template <unsigned int N>
17287 void f (char (&) [N]);
17294 Here, the type of the ARG will be "int [g(i)]", and
17295 may be a SAVE_EXPR, etc. */
17296 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17297 return unify_vla_arg (explain_p
, arg_dom
);
17298 arg_max
= TREE_OPERAND (arg_max
, 0);
17301 /* If only one of the bounds used a MINUS_EXPR, compensate
17302 by adding one to the other bound. */
17303 if (parm_cst
&& !arg_cst
)
17304 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17308 else if (arg_cst
&& !parm_cst
)
17309 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17314 return unify (tparms
, targs
, parm_max
, arg_max
,
17315 UNIFY_ALLOW_INTEGER
, explain_p
);
17318 /* Deduce the value of template parameters. TPARMS is the (innermost)
17319 set of template parameters to a template. TARGS is the bindings
17320 for those template parameters, as determined thus far; TARGS may
17321 include template arguments for outer levels of template parameters
17322 as well. PARM is a parameter to a template function, or a
17323 subcomponent of that parameter; ARG is the corresponding argument.
17324 This function attempts to match PARM with ARG in a manner
17325 consistent with the existing assignments in TARGS. If more values
17326 are deduced, then TARGS is updated.
17328 Returns 0 if the type deduction succeeds, 1 otherwise. The
17329 parameter STRICT is a bitwise or of the following flags:
17332 Require an exact match between PARM and ARG.
17333 UNIFY_ALLOW_MORE_CV_QUAL:
17334 Allow the deduced ARG to be more cv-qualified (by qualification
17335 conversion) than ARG.
17336 UNIFY_ALLOW_LESS_CV_QUAL:
17337 Allow the deduced ARG to be less cv-qualified than ARG.
17338 UNIFY_ALLOW_DERIVED:
17339 Allow the deduced ARG to be a template base class of ARG,
17340 or a pointer to a template base class of the type pointed to by
17342 UNIFY_ALLOW_INTEGER:
17343 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17344 case for more information.
17345 UNIFY_ALLOW_OUTER_LEVEL:
17346 This is the outermost level of a deduction. Used to determine validity
17347 of qualification conversions. A valid qualification conversion must
17348 have const qualified pointers leading up to the inner type which
17349 requires additional CV quals, except at the outer level, where const
17350 is not required [conv.qual]. It would be normal to set this flag in
17351 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17352 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17353 This is the outermost level of a deduction, and PARM can be more CV
17354 qualified at this point.
17355 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17356 This is the outermost level of a deduction, and PARM can be less CV
17357 qualified at this point. */
17360 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17366 int strict_in
= strict
;
17368 /* I don't think this will do the right thing with respect to types.
17369 But the only case I've seen it in so far has been array bounds, where
17370 signedness is the only information lost, and I think that will be
17372 while (TREE_CODE (parm
) == NOP_EXPR
)
17373 parm
= TREE_OPERAND (parm
, 0);
17375 if (arg
== error_mark_node
)
17376 return unify_invalid (explain_p
);
17377 if (arg
== unknown_type_node
17378 || arg
== init_list_type_node
)
17379 /* We can't deduce anything from this, but we might get all the
17380 template args from other function args. */
17381 return unify_success (explain_p
);
17383 /* If PARM uses template parameters, then we can't bail out here,
17384 even if ARG == PARM, since we won't record unifications for the
17385 template parameters. We might need them if we're trying to
17386 figure out which of two things is more specialized. */
17387 if (arg
== parm
&& !uses_template_parms (parm
))
17388 return unify_success (explain_p
);
17390 /* Handle init lists early, so the rest of the function can assume
17391 we're dealing with a type. */
17392 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17396 tree orig_parm
= parm
;
17398 /* Replace T with std::initializer_list<T> for deduction. */
17399 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17400 && flag_deduce_init_list
)
17401 parm
= listify (parm
);
17403 if (!is_std_init_list (parm
)
17404 && TREE_CODE (parm
) != ARRAY_TYPE
)
17405 /* We can only deduce from an initializer list argument if the
17406 parameter is std::initializer_list or an array; otherwise this
17407 is a non-deduced context. */
17408 return unify_success (explain_p
);
17410 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17411 elttype
= TREE_TYPE (parm
);
17413 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17415 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
17417 int elt_strict
= strict
;
17419 if (elt
== error_mark_node
)
17420 return unify_invalid (explain_p
);
17422 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
17424 tree type
= TREE_TYPE (elt
);
17425 /* It should only be possible to get here for a call. */
17426 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
17427 elt_strict
|= maybe_adjust_types_for_deduction
17428 (DEDUCE_CALL
, &elttype
, &type
, elt
);
17432 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
17436 if (TREE_CODE (parm
) == ARRAY_TYPE
17437 && deducible_array_bound (TYPE_DOMAIN (parm
)))
17439 /* Also deduce from the length of the initializer list. */
17440 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
17441 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
17442 if (idx
== error_mark_node
)
17443 return unify_invalid (explain_p
);
17444 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17448 /* If the std::initializer_list<T> deduction worked, replace the
17449 deduced A with std::initializer_list<A>. */
17450 if (orig_parm
!= parm
)
17452 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
17453 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17454 targ
= listify (targ
);
17455 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
17457 return unify_success (explain_p
);
17460 /* Immediately reject some pairs that won't unify because of
17461 cv-qualification mismatches. */
17462 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17464 /* It is the elements of the array which hold the cv quals of an array
17465 type, and the elements might be template type parms. We'll check
17466 when we recurse. */
17467 && TREE_CODE (arg
) != ARRAY_TYPE
17468 /* We check the cv-qualifiers when unifying with template type
17469 parameters below. We want to allow ARG `const T' to unify with
17470 PARM `T' for example, when computing which of two templates
17471 is more specialized, for example. */
17472 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
17473 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
17474 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17476 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
17477 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
17478 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
17479 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
17480 strict
&= ~UNIFY_ALLOW_DERIVED
;
17481 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17482 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
17484 switch (TREE_CODE (parm
))
17486 case TYPENAME_TYPE
:
17488 case UNBOUND_CLASS_TEMPLATE
:
17489 /* In a type which contains a nested-name-specifier, template
17490 argument values cannot be deduced for template parameters used
17491 within the nested-name-specifier. */
17492 return unify_success (explain_p
);
17494 case TEMPLATE_TYPE_PARM
:
17495 case TEMPLATE_TEMPLATE_PARM
:
17496 case BOUND_TEMPLATE_TEMPLATE_PARM
:
17497 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17498 if (tparm
== error_mark_node
)
17499 return unify_invalid (explain_p
);
17501 if (TEMPLATE_TYPE_LEVEL (parm
)
17502 != template_decl_level (tparm
))
17503 /* The PARM is not one we're trying to unify. Just check
17504 to see if it matches ARG. */
17506 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17507 && (is_auto (parm
) ? is_auto (arg
)
17508 : same_type_p (parm
, arg
)))
17509 return unify_success (explain_p
);
17511 return unify_type_mismatch (explain_p
, parm
, arg
);
17513 idx
= TEMPLATE_TYPE_IDX (parm
);
17514 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17515 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
17516 if (tparm
== error_mark_node
)
17517 return unify_invalid (explain_p
);
17519 /* Check for mixed types and values. */
17520 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17521 && TREE_CODE (tparm
) != TYPE_DECL
)
17522 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17523 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
17524 gcc_unreachable ();
17526 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17528 /* ARG must be constructed from a template class or a template
17529 template parameter. */
17530 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
17531 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
17532 return unify_template_deduction_failure (explain_p
, parm
, arg
);
17534 tree parmvec
= TYPE_TI_ARGS (parm
);
17535 /* An alias template name is never deduced. */
17536 if (TYPE_ALIAS_P (arg
))
17537 arg
= strip_typedefs (arg
);
17538 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
17539 tree full_argvec
= add_to_template_args (targs
, argvec
);
17541 = DECL_INNERMOST_TEMPLATE_PARMS
17542 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
17544 int parm_variadic_p
= 0;
17546 /* The resolution to DR150 makes clear that default
17547 arguments for an N-argument may not be used to bind T
17548 to a template template parameter with fewer than N
17549 parameters. It is not safe to permit the binding of
17550 default arguments as an extension, as that may change
17551 the meaning of a conforming program. Consider:
17553 struct Dense { static const unsigned int dim = 1; };
17555 template <template <typename> class View,
17557 void operator+(float, View<Block> const&);
17559 template <typename Block,
17560 unsigned int Dim = Block::dim>
17561 struct Lvalue_proxy { operator float() const; };
17565 Lvalue_proxy<Dense> p;
17570 Here, if Lvalue_proxy is permitted to bind to View, then
17571 the global operator+ will be used; if they are not, the
17572 Lvalue_proxy will be converted to float. */
17573 if (coerce_template_parms (parm_parms
,
17575 TYPE_TI_TEMPLATE (parm
),
17577 ? tf_warning_or_error
17579 /*require_all_args=*/true,
17580 /*use_default_args=*/false)
17581 == error_mark_node
)
17584 /* Deduce arguments T, i from TT<T> or TT<i>.
17585 We check each element of PARMVEC and ARGVEC individually
17586 rather than the whole TREE_VEC since they can have
17587 different number of elements. */
17589 parmvec
= expand_template_argument_pack (parmvec
);
17590 argvec
= expand_template_argument_pack (argvec
);
17592 len
= TREE_VEC_LENGTH (parmvec
);
17594 /* Check if the parameters end in a pack, making them
17597 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
17598 parm_variadic_p
= 1;
17600 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17601 /* If the template argument list of P contains a pack
17602 expansion that is not the last template argument, the
17603 entire template argument list is a non-deduced
17605 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
17606 return unify_success (explain_p
);
17608 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
17609 return unify_too_few_arguments (explain_p
,
17610 TREE_VEC_LENGTH (argvec
), len
);
17612 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17614 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17615 TREE_VEC_ELT (parmvec
, i
),
17616 TREE_VEC_ELT (argvec
, i
),
17617 UNIFY_ALLOW_NONE
, explain_p
);
17620 if (parm_variadic_p
17621 && unify_pack_expansion (tparms
, targs
,
17624 /*subr=*/true, explain_p
))
17627 arg
= TYPE_TI_TEMPLATE (arg
);
17629 /* Fall through to deduce template name. */
17632 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17633 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17635 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
17637 /* Simple cases: Value already set, does match or doesn't. */
17638 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
17639 return unify_success (explain_p
);
17641 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17645 /* If PARM is `const T' and ARG is only `int', we don't have
17646 a match unless we are allowing additional qualification.
17647 If ARG is `const int' and PARM is just `T' that's OK;
17648 that binds `const int' to `T'. */
17649 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
17651 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17653 /* Consider the case where ARG is `const volatile int' and
17654 PARM is `const T'. Then, T should be `volatile int'. */
17655 arg
= cp_build_qualified_type_real
17656 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
17657 if (arg
== error_mark_node
)
17658 return unify_invalid (explain_p
);
17660 /* Simple cases: Value already set, does match or doesn't. */
17661 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
17662 return unify_success (explain_p
);
17664 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17666 /* Make sure that ARG is not a variable-sized array. (Note
17667 that were talking about variable-sized arrays (like
17668 `int[n]'), rather than arrays of unknown size (like
17669 `int[]').) We'll get very confused by such a type since
17670 the bound of the array is not constant, and therefore
17671 not mangleable. Besides, such types are not allowed in
17672 ISO C++, so we can do as we please here. We do allow
17673 them for 'auto' deduction, since that isn't ABI-exposed. */
17674 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
17675 return unify_vla_arg (explain_p
, arg
);
17677 /* Strip typedefs as in convert_template_argument. */
17678 arg
= canonicalize_type_argument (arg
, tf_none
);
17681 /* If ARG is a parameter pack or an expansion, we cannot unify
17682 against it unless PARM is also a parameter pack. */
17683 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17684 && !template_parameter_pack_p (parm
))
17685 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17687 /* If the argument deduction results is a METHOD_TYPE,
17688 then there is a problem.
17689 METHOD_TYPE doesn't map to any real C++ type the result of
17690 the deduction can not be of that type. */
17691 if (TREE_CODE (arg
) == METHOD_TYPE
)
17692 return unify_method_type_error (explain_p
, arg
);
17694 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17695 return unify_success (explain_p
);
17697 case TEMPLATE_PARM_INDEX
:
17698 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17699 if (tparm
== error_mark_node
)
17700 return unify_invalid (explain_p
);
17702 if (TEMPLATE_PARM_LEVEL (parm
)
17703 != template_decl_level (tparm
))
17705 /* The PARM is not one we're trying to unify. Just check
17706 to see if it matches ARG. */
17707 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
17708 && cp_tree_equal (parm
, arg
));
17710 unify_expression_unequal (explain_p
, parm
, arg
);
17714 idx
= TEMPLATE_PARM_IDX (parm
);
17715 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17719 int x
= !cp_tree_equal (targ
, arg
);
17721 unify_inconsistency (explain_p
, parm
, targ
, arg
);
17725 /* [temp.deduct.type] If, in the declaration of a function template
17726 with a non-type template-parameter, the non-type
17727 template-parameter is used in an expression in the function
17728 parameter-list and, if the corresponding template-argument is
17729 deduced, the template-argument type shall match the type of the
17730 template-parameter exactly, except that a template-argument
17731 deduced from an array bound may be of any integral type.
17732 The non-type parameter might use already deduced type parameters. */
17733 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
17734 if (!TREE_TYPE (arg
))
17735 /* Template-parameter dependent expression. Just accept it for now.
17736 It will later be processed in convert_template_argument. */
17738 else if (same_type_p (TREE_TYPE (arg
), tparm
))
17740 else if ((strict
& UNIFY_ALLOW_INTEGER
)
17741 && CP_INTEGRAL_TYPE_P (tparm
))
17742 /* Convert the ARG to the type of PARM; the deduced non-type
17743 template argument must exactly match the types of the
17744 corresponding parameter. */
17745 arg
= fold (build_nop (tparm
, arg
));
17746 else if (uses_template_parms (tparm
))
17747 /* We haven't deduced the type of this parameter yet. Try again
17749 return unify_success (explain_p
);
17751 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
17753 /* If ARG is a parameter pack or an expansion, we cannot unify
17754 against it unless PARM is also a parameter pack. */
17755 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17756 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
17757 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17759 arg
= strip_typedefs_expr (arg
);
17760 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17761 return unify_success (explain_p
);
17765 /* A pointer-to-member constant can be unified only with
17766 another constant. */
17767 if (TREE_CODE (arg
) != PTRMEM_CST
)
17768 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
17770 /* Just unify the class member. It would be useless (and possibly
17771 wrong, depending on the strict flags) to unify also
17772 PTRMEM_CST_CLASS, because we want to be sure that both parm and
17773 arg refer to the same variable, even if through different
17774 classes. For instance:
17776 struct A { int x; };
17779 Unification of &A::x and &B::x must succeed. */
17780 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
17781 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
17786 if (!TYPE_PTR_P (arg
))
17787 return unify_type_mismatch (explain_p
, parm
, arg
);
17789 /* [temp.deduct.call]
17791 A can be another pointer or pointer to member type that can
17792 be converted to the deduced A via a qualification
17793 conversion (_conv.qual_).
17795 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
17796 This will allow for additional cv-qualification of the
17797 pointed-to types if appropriate. */
17799 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
17800 /* The derived-to-base conversion only persists through one
17801 level of pointers. */
17802 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
17804 return unify (tparms
, targs
, TREE_TYPE (parm
),
17805 TREE_TYPE (arg
), strict
, explain_p
);
17808 case REFERENCE_TYPE
:
17809 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
17810 return unify_type_mismatch (explain_p
, parm
, arg
);
17811 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
17812 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
17815 if (TREE_CODE (arg
) != ARRAY_TYPE
)
17816 return unify_type_mismatch (explain_p
, parm
, arg
);
17817 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
17818 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
17819 return unify_type_mismatch (explain_p
, parm
, arg
);
17820 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
17821 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
17822 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
17823 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17824 TYPE_DOMAIN (arg
), explain_p
);
17825 return unify_success (explain_p
);
17832 case ENUMERAL_TYPE
:
17835 if (TREE_CODE (arg
) != TREE_CODE (parm
))
17836 return unify_type_mismatch (explain_p
, parm
, arg
);
17838 /* We have already checked cv-qualification at the top of the
17840 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
17841 return unify_type_mismatch (explain_p
, parm
, arg
);
17843 /* As far as unification is concerned, this wins. Later checks
17844 will invalidate it if necessary. */
17845 return unify_success (explain_p
);
17847 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
17848 /* Type INTEGER_CST can come from ordinary constant template args. */
17850 while (TREE_CODE (arg
) == NOP_EXPR
)
17851 arg
= TREE_OPERAND (arg
, 0);
17853 if (TREE_CODE (arg
) != INTEGER_CST
)
17854 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
17855 return (tree_int_cst_equal (parm
, arg
)
17856 ? unify_success (explain_p
)
17857 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
17861 int i
, len
, argslen
;
17862 int parm_variadic_p
= 0;
17864 if (TREE_CODE (arg
) != TREE_VEC
)
17865 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
17867 len
= TREE_VEC_LENGTH (parm
);
17868 argslen
= TREE_VEC_LENGTH (arg
);
17870 /* Check for pack expansions in the parameters. */
17871 for (i
= 0; i
< len
; ++i
)
17873 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
17876 /* We can unify against something with a trailing
17878 parm_variadic_p
= 1;
17880 /* [temp.deduct.type]/9: If the template argument list of
17881 P contains a pack expansion that is not the last
17882 template argument, the entire template argument list
17883 is a non-deduced context. */
17884 return unify_success (explain_p
);
17888 /* If we don't have enough arguments to satisfy the parameters
17889 (not counting the pack expression at the end), or we have
17890 too many arguments for a parameter list that doesn't end in
17891 a pack expression, we can't unify. */
17892 if (parm_variadic_p
17893 ? argslen
< len
- parm_variadic_p
17895 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
17897 /* Unify all of the parameters that precede the (optional)
17898 pack expression. */
17899 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17901 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17902 TREE_VEC_ELT (parm
, i
),
17903 TREE_VEC_ELT (arg
, i
),
17904 UNIFY_ALLOW_NONE
, explain_p
);
17906 if (parm_variadic_p
)
17907 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
17909 /*subr=*/true, explain_p
);
17910 return unify_success (explain_p
);
17915 if (TREE_CODE (arg
) != TREE_CODE (parm
))
17916 return unify_type_mismatch (explain_p
, parm
, arg
);
17918 if (TYPE_PTRMEMFUNC_P (parm
))
17920 if (!TYPE_PTRMEMFUNC_P (arg
))
17921 return unify_type_mismatch (explain_p
, parm
, arg
);
17923 return unify (tparms
, targs
,
17924 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
17925 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
17926 strict
, explain_p
);
17929 if (CLASSTYPE_TEMPLATE_INFO (parm
))
17931 tree t
= NULL_TREE
;
17933 if (strict_in
& UNIFY_ALLOW_DERIVED
)
17935 /* First, we try to unify the PARM and ARG directly. */
17936 t
= try_class_unification (tparms
, targs
,
17937 parm
, arg
, explain_p
);
17941 /* Fallback to the special case allowed in
17942 [temp.deduct.call]:
17944 If P is a class, and P has the form
17945 template-id, then A can be a derived class of
17946 the deduced A. Likewise, if P is a pointer to
17947 a class of the form template-id, A can be a
17948 pointer to a derived class pointed to by the
17950 enum template_base_result r
;
17951 r
= get_template_base (tparms
, targs
, parm
, arg
,
17955 return unify_no_common_base (explain_p
, r
, parm
, arg
);
17958 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
17959 && (CLASSTYPE_TI_TEMPLATE (parm
)
17960 == CLASSTYPE_TI_TEMPLATE (arg
)))
17961 /* Perhaps PARM is something like S<U> and ARG is S<int>.
17962 Then, we should unify `int' and `U'. */
17965 /* There's no chance of unification succeeding. */
17966 return unify_type_mismatch (explain_p
, parm
, arg
);
17968 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
17969 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
17971 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
17972 return unify_type_mismatch (explain_p
, parm
, arg
);
17973 return unify_success (explain_p
);
17976 case FUNCTION_TYPE
:
17978 unsigned int nargs
;
17983 if (TREE_CODE (arg
) != TREE_CODE (parm
))
17984 return unify_type_mismatch (explain_p
, parm
, arg
);
17986 /* CV qualifications for methods can never be deduced, they must
17987 match exactly. We need to check them explicitly here,
17988 because type_unification_real treats them as any other
17989 cv-qualified parameter. */
17990 if (TREE_CODE (parm
) == METHOD_TYPE
17991 && (!check_cv_quals_for_unify
17993 class_of_this_parm (arg
),
17994 class_of_this_parm (parm
))))
17995 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17997 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
17998 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18000 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18001 args
= XALLOCAVEC (tree
, nargs
);
18002 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18003 a
!= NULL_TREE
&& a
!= void_list_node
;
18004 a
= TREE_CHAIN (a
), ++i
)
18005 args
[i
] = TREE_VALUE (a
);
18008 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18009 args
, nargs
, 1, DEDUCE_EXACT
,
18010 LOOKUP_NORMAL
, NULL
, explain_p
);
18014 /* Unify a pointer to member with a pointer to member function, which
18015 deduces the type of the member as a function type. */
18016 if (TYPE_PTRMEMFUNC_P (arg
))
18018 /* Check top-level cv qualifiers */
18019 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18020 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18022 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18023 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18024 UNIFY_ALLOW_NONE
, explain_p
);
18026 /* Determine the type of the function we are unifying against. */
18027 tree fntype
= static_fn_type (arg
);
18029 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18032 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18033 return unify_type_mismatch (explain_p
, parm
, arg
);
18034 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18035 TYPE_OFFSET_BASETYPE (arg
),
18036 UNIFY_ALLOW_NONE
, explain_p
);
18037 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18038 strict
, explain_p
);
18041 if (DECL_TEMPLATE_PARM_P (parm
))
18042 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18043 if (arg
!= integral_constant_value (parm
))
18044 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18045 return unify_success (explain_p
);
18048 case TEMPLATE_DECL
:
18049 /* Matched cases are handled by the ARG == PARM test above. */
18050 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18053 /* A non-type template parameter that is a variable should be a
18054 an integral constant, in which case, it whould have been
18055 folded into its (constant) value. So we should not be getting
18056 a variable here. */
18057 gcc_unreachable ();
18059 case TYPE_ARGUMENT_PACK
:
18060 case NONTYPE_ARGUMENT_PACK
:
18061 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18062 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18065 case DECLTYPE_TYPE
:
18066 case UNDERLYING_TYPE
:
18067 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18068 or UNDERLYING_TYPE nodes. */
18069 return unify_success (explain_p
);
18072 /* Unification fails if we hit an error node. */
18073 return unify_invalid (explain_p
);
18076 if (REFERENCE_REF_P (parm
))
18077 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18078 strict
, explain_p
);
18082 /* An unresolved overload is a nondeduced context. */
18083 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18084 return unify_success (explain_p
);
18085 gcc_assert (EXPR_P (parm
));
18087 /* We must be looking at an expression. This can happen with
18091 void foo(S<I>, S<I + 2>);
18093 This is a "nondeduced context":
18097 The nondeduced contexts are:
18099 --A type that is a template-id in which one or more of
18100 the template-arguments is an expression that references
18101 a template-parameter.
18103 In these cases, we assume deduction succeeded, but don't
18104 actually infer any unifications. */
18106 if (!uses_template_parms (parm
)
18107 && !template_args_equal (parm
, arg
))
18108 return unify_expression_unequal (explain_p
, parm
, arg
);
18110 return unify_success (explain_p
);
18113 #undef RECUR_AND_CHECK_FAILURE
18115 /* Note that DECL can be defined in this translation unit, if
18119 mark_definable (tree decl
)
18122 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18123 FOR_EACH_CLONE (clone
, decl
)
18124 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18127 /* Called if RESULT is explicitly instantiated, or is a member of an
18128 explicitly instantiated class. */
18131 mark_decl_instantiated (tree result
, int extern_p
)
18133 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18135 /* If this entity has already been written out, it's too late to
18136 make any modifications. */
18137 if (TREE_ASM_WRITTEN (result
))
18140 /* For anonymous namespace we don't need to do anything. */
18141 if (decl_anon_ns_mem_p (result
))
18143 gcc_assert (!TREE_PUBLIC (result
));
18147 if (TREE_CODE (result
) != FUNCTION_DECL
)
18148 /* The TREE_PUBLIC flag for function declarations will have been
18149 set correctly by tsubst. */
18150 TREE_PUBLIC (result
) = 1;
18152 /* This might have been set by an earlier implicit instantiation. */
18153 DECL_COMDAT (result
) = 0;
18156 DECL_NOT_REALLY_EXTERN (result
) = 0;
18159 mark_definable (result
);
18160 mark_needed (result
);
18161 /* Always make artificials weak. */
18162 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18163 comdat_linkage (result
);
18164 /* For WIN32 we also want to put explicit instantiations in
18165 linkonce sections. */
18166 else if (TREE_PUBLIC (result
))
18167 maybe_make_one_only (result
);
18170 /* If EXTERN_P, then this function will not be emitted -- unless
18171 followed by an explicit instantiation, at which point its linkage
18172 will be adjusted. If !EXTERN_P, then this function will be
18173 emitted here. In neither circumstance do we want
18174 import_export_decl to adjust the linkage. */
18175 DECL_INTERFACE_KNOWN (result
) = 1;
18178 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18179 important template arguments. If any are missing, we check whether
18180 they're important by using error_mark_node for substituting into any
18181 args that were used for partial ordering (the ones between ARGS and END)
18182 and seeing if it bubbles up. */
18185 check_undeduced_parms (tree targs
, tree args
, tree end
)
18187 bool found
= false;
18189 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18190 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18193 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18197 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18198 if (substed
== error_mark_node
)
18204 /* Given two function templates PAT1 and PAT2, return:
18206 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18207 -1 if PAT2 is more specialized than PAT1.
18208 0 if neither is more specialized.
18210 LEN indicates the number of parameters we should consider
18211 (defaulted parameters should not be considered).
18213 The 1998 std underspecified function template partial ordering, and
18214 DR214 addresses the issue. We take pairs of arguments, one from
18215 each of the templates, and deduce them against each other. One of
18216 the templates will be more specialized if all the *other*
18217 template's arguments deduce against its arguments and at least one
18218 of its arguments *does* *not* deduce against the other template's
18219 corresponding argument. Deduction is done as for class templates.
18220 The arguments used in deduction have reference and top level cv
18221 qualifiers removed. Iff both arguments were originally reference
18222 types *and* deduction succeeds in both directions, an lvalue reference
18223 wins against an rvalue reference and otherwise the template
18224 with the more cv-qualified argument wins for that pairing (if
18225 neither is more cv-qualified, they both are equal). Unlike regular
18226 deduction, after all the arguments have been deduced in this way,
18227 we do *not* verify the deduced template argument values can be
18228 substituted into non-deduced contexts.
18230 The logic can be a bit confusing here, because we look at deduce1 and
18231 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18232 can find template arguments for pat1 to make arg1 look like arg2, that
18233 means that arg2 is at least as specialized as arg1. */
18236 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18238 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18239 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18240 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18241 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18242 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18243 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18244 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18245 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18246 tree origs1
, origs2
;
18247 bool lose1
= false;
18248 bool lose2
= false;
18250 /* Remove the this parameter from non-static member functions. If
18251 one is a non-static member function and the other is not a static
18252 member function, remove the first parameter from that function
18253 also. This situation occurs for operator functions where we
18254 locate both a member function (with this pointer) and non-member
18255 operator (with explicit first operand). */
18256 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18258 len
--; /* LEN is the number of significant arguments for DECL1 */
18259 args1
= TREE_CHAIN (args1
);
18260 if (!DECL_STATIC_FUNCTION_P (decl2
))
18261 args2
= TREE_CHAIN (args2
);
18263 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18265 args2
= TREE_CHAIN (args2
);
18266 if (!DECL_STATIC_FUNCTION_P (decl1
))
18269 args1
= TREE_CHAIN (args1
);
18273 /* If only one is a conversion operator, they are unordered. */
18274 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18277 /* Consider the return type for a conversion function */
18278 if (DECL_CONV_FN_P (decl1
))
18280 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18281 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18285 processing_template_decl
++;
18291 /* Stop when an ellipsis is seen. */
18292 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18294 tree arg1
= TREE_VALUE (args1
);
18295 tree arg2
= TREE_VALUE (args2
);
18296 int deduce1
, deduce2
;
18302 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18303 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18305 /* When both arguments are pack expansions, we need only
18306 unify the patterns themselves. */
18307 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18308 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18310 /* This is the last comparison we need to do. */
18314 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18316 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18317 arg1
= TREE_TYPE (arg1
);
18318 quals1
= cp_type_quals (arg1
);
18321 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18323 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18324 arg2
= TREE_TYPE (arg2
);
18325 quals2
= cp_type_quals (arg2
);
18328 arg1
= TYPE_MAIN_VARIANT (arg1
);
18329 arg2
= TYPE_MAIN_VARIANT (arg2
);
18331 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18333 int i
, len2
= list_length (args2
);
18334 tree parmvec
= make_tree_vec (1);
18335 tree argvec
= make_tree_vec (len2
);
18338 /* Setup the parameter vector, which contains only ARG1. */
18339 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18341 /* Setup the argument vector, which contains the remaining
18343 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18344 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18346 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18347 argvec
, DEDUCE_EXACT
,
18348 /*subr=*/true, /*explain_p=*/false)
18351 /* We cannot deduce in the other direction, because ARG1 is
18352 a pack expansion but ARG2 is not. */
18355 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18357 int i
, len1
= list_length (args1
);
18358 tree parmvec
= make_tree_vec (1);
18359 tree argvec
= make_tree_vec (len1
);
18362 /* Setup the parameter vector, which contains only ARG1. */
18363 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18365 /* Setup the argument vector, which contains the remaining
18367 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18368 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18370 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18371 argvec
, DEDUCE_EXACT
,
18372 /*subr=*/true, /*explain_p=*/false)
18375 /* We cannot deduce in the other direction, because ARG2 is
18376 a pack expansion but ARG1 is not.*/
18382 /* The normal case, where neither argument is a pack
18384 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18385 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18387 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18388 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18392 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18393 arg2, then arg2 is not as specialized as arg1. */
18399 /* "If, for a given type, deduction succeeds in both directions
18400 (i.e., the types are identical after the transformations above)
18401 and both P and A were reference types (before being replaced with
18402 the type referred to above):
18403 - if the type from the argument template was an lvalue reference and
18404 the type from the parameter template was not, the argument type is
18405 considered to be more specialized than the other; otherwise,
18406 - if the type from the argument template is more cv-qualified
18407 than the type from the parameter template (as described above),
18408 the argument type is considered to be more specialized than the other;
18410 - neither type is more specialized than the other." */
18412 if (deduce1
&& deduce2
)
18414 if (ref1
&& ref2
&& ref1
!= ref2
)
18421 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
18423 if ((quals1
& quals2
) == quals2
)
18425 if ((quals1
& quals2
) == quals1
)
18430 if (lose1
&& lose2
)
18431 /* We've failed to deduce something in either direction.
18432 These must be unordered. */
18435 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18436 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18437 /* We have already processed all of the arguments in our
18438 handing of the pack expansion type. */
18441 args1
= TREE_CHAIN (args1
);
18442 args2
= TREE_CHAIN (args2
);
18445 /* "In most cases, all template parameters must have values in order for
18446 deduction to succeed, but for partial ordering purposes a template
18447 parameter may remain without a value provided it is not used in the
18448 types being used for partial ordering."
18450 Thus, if we are missing any of the targs1 we need to substitute into
18451 origs1, then pat2 is not as specialized as pat1. This can happen when
18452 there is a nondeduced context. */
18453 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
18455 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
18458 processing_template_decl
--;
18460 /* All things being equal, if the next argument is a pack expansion
18461 for one function but not for the other, prefer the
18462 non-variadic function. FIXME this is bogus; see c++/41958. */
18464 && args1
&& TREE_VALUE (args1
)
18465 && args2
&& TREE_VALUE (args2
))
18467 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
18468 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
18471 if (lose1
== lose2
)
18479 /* Determine which of two partial specializations of TMPL is more
18482 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18483 to the first partial specialization. The TREE_VALUE is the
18484 innermost set of template parameters for the partial
18485 specialization. PAT2 is similar, but for the second template.
18487 Return 1 if the first partial specialization is more specialized;
18488 -1 if the second is more specialized; 0 if neither is more
18491 See [temp.class.order] for information about determining which of
18492 two templates is more specialized. */
18495 more_specialized_class (tree tmpl
, tree pat1
, tree pat2
)
18500 bool any_deductions
= false;
18502 tmpl1
= TREE_TYPE (pat1
);
18503 tmpl2
= TREE_TYPE (pat2
);
18505 /* Just like what happens for functions, if we are ordering between
18506 different class template specializations, we may encounter dependent
18507 types in the arguments, and we need our dependency check functions
18508 to behave correctly. */
18509 ++processing_template_decl
;
18510 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat1
),
18511 CLASSTYPE_TI_ARGS (tmpl1
),
18512 CLASSTYPE_TI_ARGS (tmpl2
));
18516 any_deductions
= true;
18519 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat2
),
18520 CLASSTYPE_TI_ARGS (tmpl2
),
18521 CLASSTYPE_TI_ARGS (tmpl1
));
18525 any_deductions
= true;
18527 --processing_template_decl
;
18529 /* In the case of a tie where at least one of the class templates
18530 has a parameter pack at the end, the template with the most
18531 non-packed parameters wins. */
18534 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
18535 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
18537 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
18538 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
18539 int len1
= TREE_VEC_LENGTH (args1
);
18540 int len2
= TREE_VEC_LENGTH (args2
);
18542 /* We don't count the pack expansion at the end. */
18543 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
18545 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
18550 else if (len1
< len2
)
18557 /* Return the template arguments that will produce the function signature
18558 DECL from the function template FN, with the explicit template
18559 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18560 also match. Return NULL_TREE if no satisfactory arguments could be
18564 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
18566 int ntparms
= DECL_NTPARMS (fn
);
18567 tree targs
= make_tree_vec (ntparms
);
18568 tree decl_type
= TREE_TYPE (decl
);
18569 tree decl_arg_types
;
18571 unsigned int nargs
, ix
;
18574 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
18576 /* Never do unification on the 'this' parameter. */
18577 decl_arg_types
= skip_artificial_parms_for (decl
,
18578 TYPE_ARG_TYPES (decl_type
));
18580 nargs
= list_length (decl_arg_types
);
18581 args
= XALLOCAVEC (tree
, nargs
);
18582 for (arg
= decl_arg_types
, ix
= 0;
18583 arg
!= NULL_TREE
&& arg
!= void_list_node
;
18584 arg
= TREE_CHAIN (arg
), ++ix
)
18585 args
[ix
] = TREE_VALUE (arg
);
18587 if (fn_type_unification (fn
, explicit_args
, targs
,
18589 (check_rettype
|| DECL_CONV_FN_P (fn
)
18590 ? TREE_TYPE (decl_type
) : NULL_TREE
),
18591 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
18593 == error_mark_node
)
18599 /* Return the innermost template arguments that, when applied to a partial
18600 specialization of TMPL whose innermost template parameters are
18601 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
18604 For example, suppose we have:
18606 template <class T, class U> struct S {};
18607 template <class T> struct S<T*, int> {};
18609 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
18610 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
18611 int}. The resulting vector will be {double}, indicating that `T'
18612 is bound to `double'. */
18615 get_class_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
18617 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
18619 tree innermost_deduced_args
;
18621 innermost_deduced_args
= make_tree_vec (ntparms
);
18622 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18624 deduced_args
= copy_node (args
);
18625 SET_TMPL_ARGS_LEVEL (deduced_args
,
18626 TMPL_ARGS_DEPTH (deduced_args
),
18627 innermost_deduced_args
);
18630 deduced_args
= innermost_deduced_args
;
18632 if (unify (tparms
, deduced_args
,
18633 INNERMOST_TEMPLATE_ARGS (spec_args
),
18634 INNERMOST_TEMPLATE_ARGS (args
),
18635 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
18638 for (i
= 0; i
< ntparms
; ++i
)
18639 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
18642 /* Verify that nondeduced template arguments agree with the type
18643 obtained from argument deduction.
18647 struct A { typedef int X; };
18648 template <class T, class U> struct C {};
18649 template <class T> struct C<T, typename T::X> {};
18651 Then with the instantiation `C<A, int>', we can deduce that
18652 `T' is `A' but unify () does not check whether `typename T::X'
18654 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
18655 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
18657 tf_none
, false, false);
18658 if (spec_args
== error_mark_node
18659 /* We only need to check the innermost arguments; the other
18660 arguments will always agree. */
18661 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
18662 INNERMOST_TEMPLATE_ARGS (args
)))
18665 /* Now that we have bindings for all of the template arguments,
18666 ensure that the arguments deduced for the template template
18667 parameters have compatible template parameter lists. See the use
18668 of template_template_parm_bindings_ok_p in fn_type_unification
18669 for more information. */
18670 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
18673 return deduced_args
;
18676 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
18677 Return the TREE_LIST node with the most specialized template, if
18678 any. If there is no most specialized template, the error_mark_node
18681 Note that this function does not look at, or modify, the
18682 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
18683 returned is one of the elements of INSTANTIATIONS, callers may
18684 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
18685 and retrieve it from the value returned. */
18688 most_specialized_instantiation (tree templates
)
18692 ++processing_template_decl
;
18695 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
18699 if (get_bindings (TREE_VALUE (champ
),
18700 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18701 NULL_TREE
, /*check_ret=*/true))
18704 if (get_bindings (TREE_VALUE (fn
),
18705 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18706 NULL_TREE
, /*check_ret=*/true))
18713 /* Equally specialized, move to next function. If there
18714 is no next function, nothing's most specialized. */
18715 fn
= TREE_CHAIN (fn
);
18723 /* Now verify that champ is better than everything earlier in the
18724 instantiation list. */
18725 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
18726 if (get_bindings (TREE_VALUE (champ
),
18727 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18728 NULL_TREE
, /*check_ret=*/true)
18729 || !get_bindings (TREE_VALUE (fn
),
18730 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18731 NULL_TREE
, /*check_ret=*/true))
18737 processing_template_decl
--;
18740 return error_mark_node
;
18745 /* If DECL is a specialization of some template, return the most
18746 general such template. Otherwise, returns NULL_TREE.
18748 For example, given:
18750 template <class T> struct S { template <class U> void f(U); };
18752 if TMPL is `template <class U> void S<int>::f(U)' this will return
18753 the full template. This function will not trace past partial
18754 specializations, however. For example, given in addition:
18756 template <class T> struct S<T*> { template <class U> void f(U); };
18758 if TMPL is `template <class U> void S<int*>::f(U)' this will return
18759 `template <class T> template <class U> S<T*>::f(U)'. */
18762 most_general_template (tree decl
)
18764 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18766 if (tree tinfo
= get_template_info (decl
))
18767 decl
= TI_TEMPLATE (tinfo
);
18768 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
18769 template friend, or a FIELD_DECL for a capture pack. */
18770 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
18774 /* Look for more and more general templates. */
18775 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
18777 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
18778 (See cp-tree.h for details.) */
18779 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
18782 if (CLASS_TYPE_P (TREE_TYPE (decl
))
18783 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
18786 /* Stop if we run into an explicitly specialized class template. */
18787 if (!DECL_NAMESPACE_SCOPE_P (decl
)
18788 && DECL_CONTEXT (decl
)
18789 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
18792 decl
= DECL_TI_TEMPLATE (decl
);
18798 /* Return the most specialized of the class template partial
18799 specializations which can produce TYPE, a specialization of some class
18800 template. The value returned is actually a TREE_LIST; the TREE_TYPE is
18801 a _TYPE node corresponding to the partial specialization, while the
18802 TREE_PURPOSE is the set of template arguments that must be
18803 substituted into the TREE_TYPE in order to generate TYPE.
18805 If the choice of partial specialization is ambiguous, a diagnostic
18806 is issued, and the error_mark_node is returned. If there are no
18807 partial specializations matching TYPE, then NULL_TREE is
18808 returned, indicating that the primary template should be used. */
18811 most_specialized_class (tree type
, tsubst_flags_t complain
)
18813 tree list
= NULL_TREE
;
18818 tree outer_args
= NULL_TREE
;
18820 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
18821 tree main_tmpl
= most_general_template (tmpl
);
18822 tree args
= CLASSTYPE_TI_ARGS (type
);
18824 /* For determining which partial specialization to use, only the
18825 innermost args are interesting. */
18826 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18828 outer_args
= strip_innermost_template_args (args
, 1);
18829 args
= INNERMOST_TEMPLATE_ARGS (args
);
18832 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
18834 tree partial_spec_args
;
18836 tree spec_tmpl
= TREE_VALUE (t
);
18837 tree orig_parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
18839 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
18841 ++processing_template_decl
;
18845 /* Discard the outer levels of args, and then substitute in the
18846 template args from the enclosing class. */
18847 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
18848 partial_spec_args
= tsubst_template_args
18849 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
18851 /* And the same for the partial specialization TEMPLATE_DECL. */
18852 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
18855 partial_spec_args
=
18856 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
18859 /*require_all_args=*/true,
18860 /*use_default_args=*/true);
18862 --processing_template_decl
;
18864 if (partial_spec_args
== error_mark_node
)
18865 return error_mark_node
;
18866 if (spec_tmpl
== error_mark_node
)
18867 return error_mark_node
;
18869 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
18870 spec_args
= get_class_bindings (tmpl
, parms
,
18876 spec_args
= add_to_template_args (outer_args
, spec_args
);
18877 list
= tree_cons (spec_args
, orig_parms
, list
);
18878 TREE_TYPE (list
) = TREE_TYPE (t
);
18885 ambiguous_p
= false;
18888 t
= TREE_CHAIN (t
);
18889 for (; t
; t
= TREE_CHAIN (t
))
18891 fate
= more_specialized_class (tmpl
, champ
, t
);
18898 t
= TREE_CHAIN (t
);
18901 ambiguous_p
= true;
18910 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
18912 fate
= more_specialized_class (tmpl
, champ
, t
);
18915 ambiguous_p
= true;
18923 char *spaces
= NULL
;
18924 if (!(complain
& tf_error
))
18925 return error_mark_node
;
18926 error ("ambiguous class template instantiation for %q#T", type
);
18927 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
18928 for (t
= list
; t
; t
= TREE_CHAIN (t
))
18930 error ("%s %+#T", spaces
? spaces
: str
, TREE_TYPE (t
));
18931 spaces
= spaces
? spaces
: get_spaces (str
);
18934 return error_mark_node
;
18940 /* Explicitly instantiate DECL. */
18943 do_decl_instantiation (tree decl
, tree storage
)
18945 tree result
= NULL_TREE
;
18948 if (!decl
|| decl
== error_mark_node
)
18949 /* An error occurred, for which grokdeclarator has already issued
18950 an appropriate message. */
18952 else if (! DECL_LANG_SPECIFIC (decl
))
18954 error ("explicit instantiation of non-template %q#D", decl
);
18957 else if (VAR_P (decl
))
18959 /* There is an asymmetry here in the way VAR_DECLs and
18960 FUNCTION_DECLs are handled by grokdeclarator. In the case of
18961 the latter, the DECL we get back will be marked as a
18962 template instantiation, and the appropriate
18963 DECL_TEMPLATE_INFO will be set up. This does not happen for
18964 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
18965 should handle VAR_DECLs as it currently handles
18967 if (!DECL_CLASS_SCOPE_P (decl
))
18969 error ("%qD is not a static data member of a class template", decl
);
18972 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
18973 if (!result
|| !VAR_P (result
))
18975 error ("no matching template for %qD found", decl
);
18978 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
18980 error ("type %qT for explicit instantiation %qD does not match "
18981 "declared type %qT", TREE_TYPE (result
), decl
,
18986 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
18988 error ("explicit instantiation of %q#D", decl
);
18994 /* Check for various error cases. Note that if the explicit
18995 instantiation is valid the RESULT will currently be marked as an
18996 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
18997 until we get here. */
18999 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19001 /* DR 259 [temp.spec].
19003 Both an explicit instantiation and a declaration of an explicit
19004 specialization shall not appear in a program unless the explicit
19005 instantiation follows a declaration of the explicit specialization.
19007 For a given set of template parameters, if an explicit
19008 instantiation of a template appears after a declaration of an
19009 explicit specialization for that template, the explicit
19010 instantiation has no effect. */
19013 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19017 No program shall explicitly instantiate any template more
19020 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19021 the first instantiation was `extern' and the second is not,
19022 and EXTERN_P for the opposite case. */
19023 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19024 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19025 /* If an "extern" explicit instantiation follows an ordinary
19026 explicit instantiation, the template is instantiated. */
19030 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19032 error ("no matching template for %qD found", result
);
19035 else if (!DECL_TEMPLATE_INFO (result
))
19037 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19041 if (storage
== NULL_TREE
)
19043 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19045 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19046 pedwarn (input_location
, OPT_Wpedantic
,
19047 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19052 error ("storage class %qD applied to template instantiation", storage
);
19054 check_explicit_instantiation_namespace (result
);
19055 mark_decl_instantiated (result
, extern_p
);
19057 instantiate_decl (result
, /*defer_ok=*/1,
19058 /*expl_inst_class_mem_p=*/false);
19062 mark_class_instantiated (tree t
, int extern_p
)
19064 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19065 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19066 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19067 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19070 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19071 rest_of_type_compilation (t
, 1);
19075 /* Called from do_type_instantiation through binding_table_foreach to
19076 do recursive instantiation for the type bound in ENTRY. */
19078 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19080 tree storage
= *(tree
*) data
;
19082 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19083 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19084 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19087 /* Called from do_type_instantiation to instantiate a member
19088 (a member function or a static member variable) of an
19089 explicitly instantiated class template. */
19091 instantiate_class_member (tree decl
, int extern_p
)
19093 mark_decl_instantiated (decl
, extern_p
);
19095 instantiate_decl (decl
, /*defer_ok=*/1,
19096 /*expl_inst_class_mem_p=*/true);
19099 /* Perform an explicit instantiation of template class T. STORAGE, if
19100 non-null, is the RID for extern, inline or static. COMPLAIN is
19101 nonzero if this is called from the parser, zero if called recursively,
19102 since the standard is unclear (as detailed below). */
19105 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19110 int previous_instantiation_extern_p
= 0;
19112 if (TREE_CODE (t
) == TYPE_DECL
)
19115 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19118 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19120 error ("explicit instantiation of non-class template %qD", tmpl
);
19122 error ("explicit instantiation of non-template type %qT", t
);
19128 if (!COMPLETE_TYPE_P (t
))
19130 if (complain
& tf_error
)
19131 error ("explicit instantiation of %q#T before definition of template",
19136 if (storage
!= NULL_TREE
)
19138 if (!in_system_header_at (input_location
))
19140 if (storage
== ridpointers
[(int) RID_EXTERN
])
19142 if (cxx_dialect
== cxx98
)
19143 pedwarn (input_location
, OPT_Wpedantic
,
19144 "ISO C++ 1998 forbids the use of %<extern%> on "
19145 "explicit instantiations");
19148 pedwarn (input_location
, OPT_Wpedantic
,
19149 "ISO C++ forbids the use of %qE"
19150 " on explicit instantiations", storage
);
19153 if (storage
== ridpointers
[(int) RID_INLINE
])
19155 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19157 else if (storage
== ridpointers
[(int) RID_STATIC
])
19161 error ("storage class %qD applied to template instantiation",
19167 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19169 /* DR 259 [temp.spec].
19171 Both an explicit instantiation and a declaration of an explicit
19172 specialization shall not appear in a program unless the explicit
19173 instantiation follows a declaration of the explicit specialization.
19175 For a given set of template parameters, if an explicit
19176 instantiation of a template appears after a declaration of an
19177 explicit specialization for that template, the explicit
19178 instantiation has no effect. */
19181 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19185 No program shall explicitly instantiate any template more
19188 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19189 instantiation was `extern'. If EXTERN_P then the second is.
19190 These cases are OK. */
19191 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19193 if (!previous_instantiation_extern_p
&& !extern_p
19194 && (complain
& tf_error
))
19195 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19197 /* If we've already instantiated the template, just return now. */
19198 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19202 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19203 mark_class_instantiated (t
, extern_p
);
19211 /* In contrast to implicit instantiation, where only the
19212 declarations, and not the definitions, of members are
19213 instantiated, we have here:
19217 The explicit instantiation of a class template specialization
19218 implies the instantiation of all of its members not
19219 previously explicitly specialized in the translation unit
19220 containing the explicit instantiation.
19222 Of course, we can't instantiate member template classes, since
19223 we don't have any arguments for them. Note that the standard
19224 is unclear on whether the instantiation of the members are
19225 *explicit* instantiations or not. However, the most natural
19226 interpretation is that it should be an explicit instantiation. */
19229 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19230 if (TREE_CODE (tmp
) == FUNCTION_DECL
19231 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19232 instantiate_class_member (tmp
, extern_p
);
19234 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19235 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19236 instantiate_class_member (tmp
, extern_p
);
19238 if (CLASSTYPE_NESTED_UTDS (t
))
19239 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19240 bt_instantiate_type_proc
, &storage
);
19244 /* Given a function DECL, which is a specialization of TMPL, modify
19245 DECL to be a re-instantiation of TMPL with the same template
19246 arguments. TMPL should be the template into which tsubst'ing
19247 should occur for DECL, not the most general template.
19249 One reason for doing this is a scenario like this:
19252 void f(const T&, int i);
19254 void g() { f(3, 7); }
19257 void f(const T& t, const int i) { }
19259 Note that when the template is first instantiated, with
19260 instantiate_template, the resulting DECL will have no name for the
19261 first parameter, and the wrong type for the second. So, when we go
19262 to instantiate the DECL, we regenerate it. */
19265 regenerate_decl_from_template (tree decl
, tree tmpl
)
19267 /* The arguments used to instantiate DECL, from the most general
19272 args
= DECL_TI_ARGS (decl
);
19273 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19275 /* Make sure that we can see identifiers, and compute access
19277 push_access_scope (decl
);
19279 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19287 args_depth
= TMPL_ARGS_DEPTH (args
);
19288 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19289 if (args_depth
> parms_depth
)
19290 args
= get_innermost_template_args (args
, parms_depth
);
19292 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19293 args
, tf_error
, NULL_TREE
,
19294 /*defer_ok*/false);
19295 if (specs
&& specs
!= error_mark_node
)
19296 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19299 /* Merge parameter declarations. */
19300 decl_parm
= skip_artificial_parms_for (decl
,
19301 DECL_ARGUMENTS (decl
));
19303 = skip_artificial_parms_for (code_pattern
,
19304 DECL_ARGUMENTS (code_pattern
));
19305 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19310 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19311 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19312 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19314 parm_type
= type_decays_to (parm_type
);
19315 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19316 TREE_TYPE (decl_parm
) = parm_type
;
19317 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19318 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19320 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19321 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19323 decl_parm
= DECL_CHAIN (decl_parm
);
19324 pattern_parm
= DECL_CHAIN (pattern_parm
);
19326 /* Merge any parameters that match with the function parameter
19328 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19331 tree expanded_types
;
19332 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19333 the parameters in this function parameter pack. */
19334 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19335 args
, tf_error
, NULL_TREE
);
19336 len
= TREE_VEC_LENGTH (expanded_types
);
19337 for (i
= 0; i
< len
; i
++)
19342 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19343 /* Rename the parameter to include the index. */
19344 DECL_NAME (decl_parm
) =
19345 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19346 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19347 parm_type
= type_decays_to (parm_type
);
19348 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19349 TREE_TYPE (decl_parm
) = parm_type
;
19350 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19351 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19353 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19354 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19356 decl_parm
= DECL_CHAIN (decl_parm
);
19359 /* Merge additional specifiers from the CODE_PATTERN. */
19360 if (DECL_DECLARED_INLINE_P (code_pattern
)
19361 && !DECL_DECLARED_INLINE_P (decl
))
19362 DECL_DECLARED_INLINE_P (decl
) = 1;
19364 else if (VAR_P (decl
))
19366 DECL_INITIAL (decl
) =
19367 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19368 tf_error
, DECL_TI_TEMPLATE (decl
),
19369 /*integral_constant_expression_p=*/false);
19370 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19371 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19372 tf_error
, DECL_TI_TEMPLATE (decl
));
19375 gcc_unreachable ();
19377 pop_access_scope (decl
);
19380 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19381 substituted to get DECL. */
19384 template_for_substitution (tree decl
)
19386 tree tmpl
= DECL_TI_TEMPLATE (decl
);
19388 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19389 for the instantiation. This is not always the most general
19390 template. Consider, for example:
19393 struct S { template <class U> void f();
19394 template <> void f<int>(); };
19396 and an instantiation of S<double>::f<int>. We want TD to be the
19397 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19398 while (/* An instantiation cannot have a definition, so we need a
19399 more general template. */
19400 DECL_TEMPLATE_INSTANTIATION (tmpl
)
19401 /* We must also deal with friend templates. Given:
19403 template <class T> struct S {
19404 template <class U> friend void f() {};
19407 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19408 so far as the language is concerned, but that's still
19409 where we get the pattern for the instantiation from. On
19410 other hand, if the definition comes outside the class, say:
19412 template <class T> struct S {
19413 template <class U> friend void f();
19415 template <class U> friend void f() {}
19417 we don't need to look any further. That's what the check for
19418 DECL_INITIAL is for. */
19419 || (TREE_CODE (decl
) == FUNCTION_DECL
19420 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
19421 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
19423 /* The present template, TD, should not be a definition. If it
19424 were a definition, we should be using it! Note that we
19425 cannot restructure the loop to just keep going until we find
19426 a template with a definition, since that might go too far if
19427 a specialization was declared, but not defined. */
19428 gcc_assert (!VAR_P (decl
)
19429 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl
)));
19431 /* Fetch the more general template. */
19432 tmpl
= DECL_TI_TEMPLATE (tmpl
);
19438 /* Returns true if we need to instantiate this template instance even if we
19439 know we aren't going to emit it.. */
19442 always_instantiate_p (tree decl
)
19444 /* We always instantiate inline functions so that we can inline them. An
19445 explicit instantiation declaration prohibits implicit instantiation of
19446 non-inline functions. With high levels of optimization, we would
19447 normally inline non-inline functions -- but we're not allowed to do
19448 that for "extern template" functions. Therefore, we check
19449 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19450 return ((TREE_CODE (decl
) == FUNCTION_DECL
19451 && (DECL_DECLARED_INLINE_P (decl
)
19452 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
19453 /* And we need to instantiate static data members so that
19454 their initializers are available in integral constant
19457 && decl_maybe_constant_var_p (decl
)));
19460 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19461 instantiate it now, modifying TREE_TYPE (fn). */
19464 maybe_instantiate_noexcept (tree fn
)
19466 tree fntype
, spec
, noex
, clone
;
19468 /* Don't instantiate a noexcept-specification from template context. */
19469 if (processing_template_decl
)
19472 if (DECL_CLONED_FUNCTION_P (fn
))
19473 fn
= DECL_CLONED_FUNCTION (fn
);
19474 fntype
= TREE_TYPE (fn
);
19475 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
19477 if (!DEFERRED_NOEXCEPT_SPEC_P (spec
))
19480 noex
= TREE_PURPOSE (spec
);
19482 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
19484 if (push_tinst_level (fn
))
19486 push_access_scope (fn
);
19487 push_deferring_access_checks (dk_no_deferred
);
19488 input_location
= DECL_SOURCE_LOCATION (fn
);
19489 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
19490 DEFERRED_NOEXCEPT_ARGS (noex
),
19491 tf_warning_or_error
, fn
,
19492 /*function_p=*/false,
19493 /*integral_constant_expression_p=*/true);
19494 pop_deferring_access_checks ();
19495 pop_access_scope (fn
);
19496 pop_tinst_level ();
19497 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
19498 if (spec
== error_mark_node
)
19499 spec
= noexcept_false_spec
;
19502 spec
= noexcept_false_spec
;
19506 /* This is an implicitly declared function, so NOEX is a list of
19507 other functions to evaluate and merge. */
19509 spec
= noexcept_true_spec
;
19510 for (elt
= noex
; elt
; elt
= OVL_NEXT (elt
))
19512 tree fn
= OVL_CURRENT (elt
);
19514 maybe_instantiate_noexcept (fn
);
19515 subspec
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
19516 spec
= merge_exception_specifiers (spec
, subspec
, NULL_TREE
);
19520 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
19522 FOR_EACH_CLONE (clone
, fn
)
19524 if (TREE_TYPE (clone
) == fntype
)
19525 TREE_TYPE (clone
) = TREE_TYPE (fn
);
19527 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
19531 /* Produce the definition of D, a _DECL generated from a template. If
19532 DEFER_OK is nonzero, then we don't have to actually do the
19533 instantiation now; we just have to do it sometime. Normally it is
19534 an error if this is an explicit instantiation but D is undefined.
19535 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19536 explicitly instantiated class template. */
19539 instantiate_decl (tree d
, int defer_ok
,
19540 bool expl_inst_class_mem_p
)
19542 tree tmpl
= DECL_TI_TEMPLATE (d
);
19549 bool pattern_defined
;
19550 location_t saved_loc
= input_location
;
19551 int saved_unevaluated_operand
= cp_unevaluated_operand
;
19552 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
19557 /* This function should only be used to instantiate templates for
19558 functions and static member variables. */
19559 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
19561 /* Variables are never deferred; if instantiation is required, they
19562 are instantiated right away. That allows for better code in the
19563 case that an expression refers to the value of the variable --
19564 if the variable has a constant value the referring expression can
19565 take advantage of that fact. */
19567 || DECL_DECLARED_CONSTEXPR_P (d
))
19570 /* Don't instantiate cloned functions. Instead, instantiate the
19571 functions they cloned. */
19572 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
19573 d
= DECL_CLONED_FUNCTION (d
);
19575 if (DECL_TEMPLATE_INSTANTIATED (d
)
19576 || (TREE_CODE (d
) == FUNCTION_DECL
19577 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
19578 || DECL_TEMPLATE_SPECIALIZATION (d
))
19579 /* D has already been instantiated or explicitly specialized, so
19580 there's nothing for us to do here.
19582 It might seem reasonable to check whether or not D is an explicit
19583 instantiation, and, if so, stop here. But when an explicit
19584 instantiation is deferred until the end of the compilation,
19585 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
19586 the instantiation. */
19589 /* Check to see whether we know that this template will be
19590 instantiated in some other file, as with "extern template"
19592 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
19594 /* In general, we do not instantiate such templates. */
19595 if (external_p
&& !always_instantiate_p (d
))
19598 gen_tmpl
= most_general_template (tmpl
);
19599 gen_args
= DECL_TI_ARGS (d
);
19601 if (tmpl
!= gen_tmpl
)
19602 /* We should already have the extra args. */
19603 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
19604 == TMPL_ARGS_DEPTH (gen_args
));
19605 /* And what's in the hash table should match D. */
19606 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
19607 || spec
== NULL_TREE
);
19609 /* This needs to happen before any tsubsting. */
19610 if (! push_tinst_level (d
))
19613 timevar_push (TV_TEMPLATE_INST
);
19615 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
19616 for the instantiation. */
19617 td
= template_for_substitution (d
);
19618 code_pattern
= DECL_TEMPLATE_RESULT (td
);
19620 /* We should never be trying to instantiate a member of a class
19621 template or partial specialization. */
19622 gcc_assert (d
!= code_pattern
);
19624 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
19625 || DECL_TEMPLATE_SPECIALIZATION (td
))
19626 /* In the case of a friend template whose definition is provided
19627 outside the class, we may have too many arguments. Drop the
19628 ones we don't need. The same is true for specializations. */
19629 args
= get_innermost_template_args
19630 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
19634 if (TREE_CODE (d
) == FUNCTION_DECL
)
19635 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
19636 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
));
19638 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
19640 /* We may be in the middle of deferred access check. Disable it now. */
19641 push_deferring_access_checks (dk_no_deferred
);
19643 /* Unless an explicit instantiation directive has already determined
19644 the linkage of D, remember that a definition is available for
19646 if (pattern_defined
19647 && !DECL_INTERFACE_KNOWN (d
)
19648 && !DECL_NOT_REALLY_EXTERN (d
))
19649 mark_definable (d
);
19651 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
19652 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
19653 input_location
= DECL_SOURCE_LOCATION (d
);
19655 /* If D is a member of an explicitly instantiated class template,
19656 and no definition is available, treat it like an implicit
19658 if (!pattern_defined
&& expl_inst_class_mem_p
19659 && DECL_EXPLICIT_INSTANTIATION (d
))
19661 /* Leave linkage flags alone on instantiations with anonymous
19663 if (TREE_PUBLIC (d
))
19665 DECL_NOT_REALLY_EXTERN (d
) = 0;
19666 DECL_INTERFACE_KNOWN (d
) = 0;
19668 SET_DECL_IMPLICIT_INSTANTIATION (d
);
19671 if (TREE_CODE (d
) == FUNCTION_DECL
)
19672 maybe_instantiate_noexcept (d
);
19674 /* Defer all other templates, unless we have been explicitly
19675 forbidden from doing so. */
19676 if (/* If there is no definition, we cannot instantiate the
19679 /* If it's OK to postpone instantiation, do so. */
19681 /* If this is a static data member that will be defined
19682 elsewhere, we don't want to instantiate the entire data
19683 member, but we do want to instantiate the initializer so that
19684 we can substitute that elsewhere. */
19685 || (external_p
&& VAR_P (d
)))
19687 /* The definition of the static data member is now required so
19688 we must substitute the initializer. */
19690 && !DECL_INITIAL (d
)
19691 && DECL_INITIAL (code_pattern
))
19695 bool const_init
= false;
19697 ns
= decl_namespace_context (d
);
19698 push_nested_namespace (ns
);
19699 push_nested_class (DECL_CONTEXT (d
));
19700 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
19702 tf_warning_or_error
, NULL_TREE
,
19703 /*integral_constant_expression_p=*/false);
19704 /* Make sure the initializer is still constant, in case of
19705 circular dependency (template/instantiate6.C). */
19707 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19708 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
19709 /*asmspec_tree=*/NULL_TREE
,
19710 LOOKUP_ONLYCONVERTING
);
19711 pop_nested_class ();
19712 pop_nested_namespace (ns
);
19715 /* We restore the source position here because it's used by
19716 add_pending_template. */
19717 input_location
= saved_loc
;
19719 if (at_eof
&& !pattern_defined
19720 && DECL_EXPLICIT_INSTANTIATION (d
)
19721 && DECL_NOT_REALLY_EXTERN (d
))
19724 The definition of a non-exported function template, a
19725 non-exported member function template, or a non-exported
19726 member function or static data member of a class template
19727 shall be present in every translation unit in which it is
19728 explicitly instantiated. */
19729 permerror (input_location
, "explicit instantiation of %qD "
19730 "but no definition available", d
);
19732 /* If we're in unevaluated context, we just wanted to get the
19733 constant value; this isn't an odr use, so don't queue
19734 a full instantiation. */
19735 if (cp_unevaluated_operand
!= 0)
19737 /* ??? Historically, we have instantiated inline functions, even
19738 when marked as "extern template". */
19739 if (!(external_p
&& VAR_P (d
)))
19740 add_pending_template (d
);
19743 /* Tell the repository that D is available in this translation unit
19744 -- and see if it is supposed to be instantiated here. */
19745 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
19747 /* In a PCH file, despite the fact that the repository hasn't
19748 requested instantiation in the PCH it is still possible that
19749 an instantiation will be required in a file that includes the
19752 add_pending_template (d
);
19753 /* Instantiate inline functions so that the inliner can do its
19754 job, even though we'll not be emitting a copy of this
19756 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
19760 fn_context
= decl_function_context (d
);
19761 nested
= (current_function_decl
!= NULL_TREE
);
19763 push_to_top_level ();
19767 push_function_context ();
19768 cp_unevaluated_operand
= 0;
19769 c_inhibit_evaluation_warnings
= 0;
19772 /* Mark D as instantiated so that recursive calls to
19773 instantiate_decl do not try to instantiate it again. */
19774 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
19776 /* Regenerate the declaration in case the template has been modified
19777 by a subsequent redeclaration. */
19778 regenerate_decl_from_template (d
, td
);
19780 /* We already set the file and line above. Reset them now in case
19781 they changed as a result of calling regenerate_decl_from_template. */
19782 input_location
= DECL_SOURCE_LOCATION (d
);
19787 bool const_init
= false;
19789 /* Clear out DECL_RTL; whatever was there before may not be right
19790 since we've reset the type of the declaration. */
19791 SET_DECL_RTL (d
, NULL
);
19792 DECL_IN_AGGR_P (d
) = 0;
19794 /* The initializer is placed in DECL_INITIAL by
19795 regenerate_decl_from_template so we don't need to
19796 push/pop_access_scope again here. Pull it out so that
19797 cp_finish_decl can process it. */
19798 init
= DECL_INITIAL (d
);
19799 DECL_INITIAL (d
) = NULL_TREE
;
19800 DECL_INITIALIZED_P (d
) = 0;
19802 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
19803 initializer. That function will defer actual emission until
19804 we have a chance to determine linkage. */
19805 DECL_EXTERNAL (d
) = 0;
19807 /* Enter the scope of D so that access-checking works correctly. */
19808 push_nested_class (DECL_CONTEXT (d
));
19809 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19810 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
19811 pop_nested_class ();
19813 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
19814 synthesize_method (d
);
19815 else if (TREE_CODE (d
) == FUNCTION_DECL
)
19817 struct pointer_map_t
*saved_local_specializations
;
19821 tree block
= NULL_TREE
;
19823 /* Save away the current list, in case we are instantiating one
19824 template from within the body of another. */
19825 saved_local_specializations
= local_specializations
;
19827 /* Set up the list of local specializations. */
19828 local_specializations
= pointer_map_create ();
19830 /* Set up context. */
19831 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
19832 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
19833 block
= push_stmt_list ();
19835 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
19837 /* Some typedefs referenced from within the template code need to be
19838 access checked at template instantiation time, i.e now. These
19839 types were added to the template at parsing time. Let's get those
19840 and perform the access checks then. */
19841 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
19844 /* Create substitution entries for the parameters. */
19845 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
19846 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
19847 spec_parm
= DECL_ARGUMENTS (d
);
19848 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
19850 register_local_specialization (spec_parm
, tmpl_parm
);
19851 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
19852 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
19854 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
19856 if (!DECL_PACK_P (tmpl_parm
))
19858 register_local_specialization (spec_parm
, tmpl_parm
);
19859 spec_parm
= DECL_CHAIN (spec_parm
);
19863 /* Register the (value) argument pack as a specialization of
19864 TMPL_PARM, then move on. */
19865 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
19866 register_local_specialization (argpack
, tmpl_parm
);
19869 gcc_assert (!spec_parm
);
19871 /* Substitute into the body of the function. */
19872 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
19873 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
19874 tf_warning_or_error
, tmpl
);
19877 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
19878 tf_warning_or_error
, tmpl
,
19879 /*integral_constant_expression_p=*/false);
19881 /* Set the current input_location to the end of the function
19882 so that finish_function knows where we are. */
19884 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
19886 /* Remember if we saw an infinite loop in the template. */
19887 current_function_infinite_loop
19888 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
19891 /* We don't need the local specializations any more. */
19892 pointer_map_destroy (local_specializations
);
19893 local_specializations
= saved_local_specializations
;
19895 /* Finish the function. */
19896 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
19897 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
19898 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
19901 d
= finish_function (0);
19902 expand_or_defer_fn (d
);
19905 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
19906 cp_check_omp_declare_reduction (d
);
19909 /* We're not deferring instantiation any more. */
19910 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
19913 pop_from_top_level ();
19915 pop_function_context ();
19918 input_location
= saved_loc
;
19919 cp_unevaluated_operand
= saved_unevaluated_operand
;
19920 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
19921 pop_deferring_access_checks ();
19922 pop_tinst_level ();
19924 timevar_pop (TV_TEMPLATE_INST
);
19929 /* Run through the list of templates that we wish we could
19930 instantiate, and instantiate any we can. RETRIES is the
19931 number of times we retry pending template instantiation. */
19934 instantiate_pending_templates (int retries
)
19937 location_t saved_loc
= input_location
;
19939 /* Instantiating templates may trigger vtable generation. This in turn
19940 may require further template instantiations. We place a limit here
19941 to avoid infinite loop. */
19942 if (pending_templates
&& retries
>= max_tinst_depth
)
19944 tree decl
= pending_templates
->tinst
->decl
;
19946 error ("template instantiation depth exceeds maximum of %d"
19947 " instantiating %q+D, possibly from virtual table generation"
19948 " (use -ftemplate-depth= to increase the maximum)",
19949 max_tinst_depth
, decl
);
19950 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19951 /* Pretend that we defined it. */
19952 DECL_INITIAL (decl
) = error_mark_node
;
19958 struct pending_template
**t
= &pending_templates
;
19959 struct pending_template
*last
= NULL
;
19963 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
19964 bool complete
= false;
19966 if (TYPE_P (instantiation
))
19970 if (!COMPLETE_TYPE_P (instantiation
))
19972 instantiate_class_template (instantiation
);
19973 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
19974 for (fn
= TYPE_METHODS (instantiation
);
19976 fn
= TREE_CHAIN (fn
))
19977 if (! DECL_ARTIFICIAL (fn
))
19978 instantiate_decl (fn
,
19980 /*expl_inst_class_mem_p=*/false);
19981 if (COMPLETE_TYPE_P (instantiation
))
19985 complete
= COMPLETE_TYPE_P (instantiation
);
19989 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
19990 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
19993 = instantiate_decl (instantiation
,
19995 /*expl_inst_class_mem_p=*/false);
19996 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20000 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20001 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20005 /* If INSTANTIATION has been instantiated, then we don't
20006 need to consider it again in the future. */
20014 current_tinst_level
= NULL
;
20016 last_pending_template
= last
;
20018 while (reconsider
);
20020 input_location
= saved_loc
;
20023 /* Substitute ARGVEC into T, which is a list of initializers for
20024 either base class or a non-static data member. The TREE_PURPOSEs
20025 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20026 instantiate_decl. */
20029 tsubst_initializer_list (tree t
, tree argvec
)
20031 tree inits
= NULL_TREE
;
20033 for (; t
; t
= TREE_CHAIN (t
))
20037 tree expanded_bases
= NULL_TREE
;
20038 tree expanded_arguments
= NULL_TREE
;
20041 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20046 /* Expand the base class expansion type into separate base
20048 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20049 tf_warning_or_error
,
20051 if (expanded_bases
== error_mark_node
)
20054 /* We'll be building separate TREE_LISTs of arguments for
20056 len
= TREE_VEC_LENGTH (expanded_bases
);
20057 expanded_arguments
= make_tree_vec (len
);
20058 for (i
= 0; i
< len
; i
++)
20059 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20061 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20062 expand each argument in the TREE_VALUE of t. */
20063 expr
= make_node (EXPR_PACK_EXPANSION
);
20064 PACK_EXPANSION_LOCAL_P (expr
) = true;
20065 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20066 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20068 if (TREE_VALUE (t
) == void_type_node
)
20069 /* VOID_TYPE_NODE is used to indicate
20070 value-initialization. */
20072 for (i
= 0; i
< len
; i
++)
20073 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20077 /* Substitute parameter packs into each argument in the
20079 in_base_initializer
= 1;
20080 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20082 tree expanded_exprs
;
20084 /* Expand the argument. */
20085 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20087 = tsubst_pack_expansion (expr
, argvec
,
20088 tf_warning_or_error
,
20090 if (expanded_exprs
== error_mark_node
)
20093 /* Prepend each of the expanded expressions to the
20094 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20095 for (i
= 0; i
< len
; i
++)
20097 TREE_VEC_ELT (expanded_arguments
, i
) =
20098 tree_cons (NULL_TREE
,
20099 TREE_VEC_ELT (expanded_exprs
, i
),
20100 TREE_VEC_ELT (expanded_arguments
, i
));
20103 in_base_initializer
= 0;
20105 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20106 since we built them backwards. */
20107 for (i
= 0; i
< len
; i
++)
20109 TREE_VEC_ELT (expanded_arguments
, i
) =
20110 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20115 for (i
= 0; i
< len
; ++i
)
20117 if (expanded_bases
)
20119 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20120 decl
= expand_member_init (decl
);
20121 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20126 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20127 tf_warning_or_error
, NULL_TREE
);
20129 decl
= expand_member_init (decl
);
20130 if (decl
&& !DECL_P (decl
))
20131 in_base_initializer
= 1;
20133 init
= TREE_VALUE (t
);
20135 if (init
!= void_type_node
)
20136 init
= tsubst_expr (init
, argvec
,
20137 tf_warning_or_error
, NULL_TREE
,
20138 /*integral_constant_expression_p=*/false);
20139 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20140 /* If we had an initializer but it instantiated to nothing,
20141 value-initialize the object. This will only occur when
20142 the initializer was a pack expansion where the parameter
20143 packs used in that expansion were of length zero. */
20144 init
= void_type_node
;
20145 in_base_initializer
= 0;
20150 init
= build_tree_list (decl
, init
);
20151 TREE_CHAIN (init
) = inits
;
20159 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20162 set_current_access_from_decl (tree decl
)
20164 if (TREE_PRIVATE (decl
))
20165 current_access_specifier
= access_private_node
;
20166 else if (TREE_PROTECTED (decl
))
20167 current_access_specifier
= access_protected_node
;
20169 current_access_specifier
= access_public_node
;
20172 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20173 is the instantiation (which should have been created with
20174 start_enum) and ARGS are the template arguments to use. */
20177 tsubst_enum (tree tag
, tree newtag
, tree args
)
20181 if (SCOPED_ENUM_P (newtag
))
20182 begin_scope (sk_scoped_enum
, newtag
);
20184 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20189 decl
= TREE_VALUE (e
);
20190 /* Note that in a template enum, the TREE_VALUE is the
20191 CONST_DECL, not the corresponding INTEGER_CST. */
20192 value
= tsubst_expr (DECL_INITIAL (decl
),
20193 args
, tf_warning_or_error
, NULL_TREE
,
20194 /*integral_constant_expression_p=*/true);
20196 /* Give this enumeration constant the correct access. */
20197 set_current_access_from_decl (decl
);
20199 /* Actually build the enumerator itself. */
20201 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
20204 if (SCOPED_ENUM_P (newtag
))
20207 finish_enum_value_list (newtag
);
20208 finish_enum (newtag
);
20210 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20211 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20214 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20215 its type -- but without substituting the innermost set of template
20216 arguments. So, innermost set of template parameters will appear in
20220 get_mostly_instantiated_function_type (tree decl
)
20228 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
20229 targs
= DECL_TI_ARGS (decl
);
20230 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
20231 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
20233 /* There should be as many levels of arguments as there are levels
20235 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
20237 fn_type
= TREE_TYPE (tmpl
);
20239 if (parm_depth
== 1)
20240 /* No substitution is necessary. */
20247 /* Replace the innermost level of the TARGS with NULL_TREEs to
20248 let tsubst know not to substitute for those parameters. */
20249 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20250 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
20251 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
20252 TMPL_ARGS_LEVEL (targs
, i
));
20253 SET_TMPL_ARGS_LEVEL (partial_args
,
20254 TMPL_ARGS_DEPTH (targs
),
20255 make_tree_vec (DECL_NTPARMS (tmpl
)));
20257 /* Make sure that we can see identifiers, and compute access
20259 push_access_scope (decl
);
20261 ++processing_template_decl
;
20262 /* Now, do the (partial) substitution to figure out the
20263 appropriate function type. */
20264 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
20265 --processing_template_decl
;
20267 /* Substitute into the template parameters to obtain the real
20268 innermost set of parameters. This step is important if the
20269 innermost set of template parameters contains value
20270 parameters whose types depend on outer template parameters. */
20271 TREE_VEC_LENGTH (partial_args
)--;
20272 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
20274 pop_access_scope (decl
);
20280 /* Return truthvalue if we're processing a template different from
20281 the last one involved in diagnostics. */
20283 problematic_instantiation_changed (void)
20285 return current_tinst_level
!= last_error_tinst_level
;
20288 /* Remember current template involved in diagnostics. */
20290 record_last_problematic_instantiation (void)
20292 last_error_tinst_level
= current_tinst_level
;
20295 struct tinst_level
*
20296 current_instantiation (void)
20298 return current_tinst_level
;
20301 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20302 type. Return zero for ok, nonzero for disallowed. Issue error and
20303 warning messages under control of COMPLAIN. */
20306 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20308 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20310 else if (POINTER_TYPE_P (type
))
20312 else if (TYPE_PTRMEM_P (type
))
20314 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20316 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20318 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20320 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20323 if (complain
& tf_error
)
20325 if (type
== error_mark_node
)
20326 inform (input_location
, "invalid template non-type parameter");
20328 error ("%q#T is not a valid type for a template non-type parameter",
20334 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20335 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20338 dependent_type_p_r (tree type
)
20344 A type is dependent if it is:
20346 -- a template parameter. Template template parameters are types
20347 for us (since TYPE_P holds true for them) so we handle
20349 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20350 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20352 /* -- a qualified-id with a nested-name-specifier which contains a
20353 class-name that names a dependent type or whose unqualified-id
20354 names a dependent type. */
20355 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20357 /* -- a cv-qualified type where the cv-unqualified type is
20359 type
= TYPE_MAIN_VARIANT (type
);
20360 /* -- a compound type constructed from any dependent type. */
20361 if (TYPE_PTRMEM_P (type
))
20362 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20363 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20365 else if (TYPE_PTR_P (type
)
20366 || TREE_CODE (type
) == REFERENCE_TYPE
)
20367 return dependent_type_p (TREE_TYPE (type
));
20368 else if (TREE_CODE (type
) == FUNCTION_TYPE
20369 || TREE_CODE (type
) == METHOD_TYPE
)
20373 if (dependent_type_p (TREE_TYPE (type
)))
20375 for (arg_type
= TYPE_ARG_TYPES (type
);
20377 arg_type
= TREE_CHAIN (arg_type
))
20378 if (dependent_type_p (TREE_VALUE (arg_type
)))
20382 /* -- an array type constructed from any dependent type or whose
20383 size is specified by a constant expression that is
20386 We checked for type- and value-dependence of the bounds in
20387 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20388 if (TREE_CODE (type
) == ARRAY_TYPE
)
20390 if (TYPE_DOMAIN (type
)
20391 && dependent_type_p (TYPE_DOMAIN (type
)))
20393 return dependent_type_p (TREE_TYPE (type
));
20396 /* -- a template-id in which either the template name is a template
20398 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20400 /* ... or any of the template arguments is a dependent type or
20401 an expression that is type-dependent or value-dependent. */
20402 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
20403 && (any_dependent_template_arguments_p
20404 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
20407 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20408 dependent; if the argument of the `typeof' expression is not
20409 type-dependent, then it should already been have resolved. */
20410 if (TREE_CODE (type
) == TYPEOF_TYPE
20411 || TREE_CODE (type
) == DECLTYPE_TYPE
20412 || TREE_CODE (type
) == UNDERLYING_TYPE
)
20415 /* A template argument pack is dependent if any of its packed
20417 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
20419 tree args
= ARGUMENT_PACK_ARGS (type
);
20420 int i
, len
= TREE_VEC_LENGTH (args
);
20421 for (i
= 0; i
< len
; ++i
)
20422 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20426 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20427 be template parameters. */
20428 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
20431 /* The standard does not specifically mention types that are local
20432 to template functions or local classes, but they should be
20433 considered dependent too. For example:
20435 template <int I> void f() {
20440 The size of `E' cannot be known until the value of `I' has been
20441 determined. Therefore, `E' must be considered dependent. */
20442 scope
= TYPE_CONTEXT (type
);
20443 if (scope
&& TYPE_P (scope
))
20444 return dependent_type_p (scope
);
20445 /* Don't use type_dependent_expression_p here, as it can lead
20446 to infinite recursion trying to determine whether a lambda
20447 nested in a lambda is dependent (c++/47687). */
20448 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
20449 && DECL_LANG_SPECIFIC (scope
)
20450 && DECL_TEMPLATE_INFO (scope
)
20451 && (any_dependent_template_arguments_p
20452 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
20455 /* Other types are non-dependent. */
20459 /* Returns TRUE if TYPE is dependent, in the sense of
20460 [temp.dep.type]. Note that a NULL type is considered dependent. */
20463 dependent_type_p (tree type
)
20465 /* If there are no template parameters in scope, then there can't be
20466 any dependent types. */
20467 if (!processing_template_decl
)
20469 /* If we are not processing a template, then nobody should be
20470 providing us with a dependent type. */
20472 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
20476 /* If the type is NULL, we have not computed a type for the entity
20477 in question; in that case, the type is dependent. */
20481 /* Erroneous types can be considered non-dependent. */
20482 if (type
== error_mark_node
)
20485 /* If we have not already computed the appropriate value for TYPE,
20487 if (!TYPE_DEPENDENT_P_VALID (type
))
20489 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
20490 TYPE_DEPENDENT_P_VALID (type
) = 1;
20493 return TYPE_DEPENDENT_P (type
);
20496 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20497 lookup. In other words, a dependent type that is not the current
20501 dependent_scope_p (tree scope
)
20503 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
20504 && !currently_open_class (scope
));
20507 /* T is a SCOPE_REF; return whether we need to consider it
20508 instantiation-dependent so that we can check access at instantiation
20509 time even though we know which member it resolves to. */
20512 instantiation_dependent_scope_ref_p (tree t
)
20514 if (DECL_P (TREE_OPERAND (t
, 1))
20515 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
20516 && accessible_in_template_p (TREE_OPERAND (t
, 0),
20517 TREE_OPERAND (t
, 1)))
20523 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20524 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20527 /* Note that this predicate is not appropriate for general expressions;
20528 only constant expressions (that satisfy potential_constant_expression)
20529 can be tested for value dependence. */
20532 value_dependent_expression_p (tree expression
)
20534 if (!processing_template_decl
)
20537 /* A name declared with a dependent type. */
20538 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
20541 switch (TREE_CODE (expression
))
20543 case IDENTIFIER_NODE
:
20544 /* A name that has not been looked up -- must be dependent. */
20547 case TEMPLATE_PARM_INDEX
:
20548 /* A non-type template parm. */
20552 /* A non-type template parm. */
20553 if (DECL_TEMPLATE_PARM_P (expression
))
20555 return value_dependent_expression_p (DECL_INITIAL (expression
));
20558 /* A constant with literal type and is initialized
20559 with an expression that is value-dependent.
20561 Note that a non-dependent parenthesized initializer will have
20562 already been replaced with its constant value, so if we see
20563 a TREE_LIST it must be dependent. */
20564 if (DECL_INITIAL (expression
)
20565 && decl_constant_var_p (expression
)
20566 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
20567 || value_dependent_expression_p (DECL_INITIAL (expression
))))
20571 case DYNAMIC_CAST_EXPR
:
20572 case STATIC_CAST_EXPR
:
20573 case CONST_CAST_EXPR
:
20574 case REINTERPRET_CAST_EXPR
:
20576 /* These expressions are value-dependent if the type to which
20577 the cast occurs is dependent or the expression being casted
20578 is value-dependent. */
20580 tree type
= TREE_TYPE (expression
);
20582 if (dependent_type_p (type
))
20585 /* A functional cast has a list of operands. */
20586 expression
= TREE_OPERAND (expression
, 0);
20589 /* If there are no operands, it must be an expression such
20590 as "int()". This should not happen for aggregate types
20591 because it would form non-constant expressions. */
20592 gcc_assert (cxx_dialect
>= cxx11
20593 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
20598 if (TREE_CODE (expression
) == TREE_LIST
)
20599 return any_value_dependent_elements_p (expression
);
20601 return value_dependent_expression_p (expression
);
20605 if (SIZEOF_EXPR_TYPE_P (expression
))
20606 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
20610 /* A `sizeof' expression is value-dependent if the operand is
20611 type-dependent or is a pack expansion. */
20612 expression
= TREE_OPERAND (expression
, 0);
20613 if (PACK_EXPANSION_P (expression
))
20615 else if (TYPE_P (expression
))
20616 return dependent_type_p (expression
);
20617 return instantiation_dependent_expression_p (expression
);
20619 case AT_ENCODE_EXPR
:
20620 /* An 'encode' expression is value-dependent if the operand is
20622 expression
= TREE_OPERAND (expression
, 0);
20623 return dependent_type_p (expression
);
20625 case NOEXCEPT_EXPR
:
20626 expression
= TREE_OPERAND (expression
, 0);
20627 return instantiation_dependent_expression_p (expression
);
20630 /* All instantiation-dependent expressions should also be considered
20631 value-dependent. */
20632 return instantiation_dependent_scope_ref_p (expression
);
20634 case COMPONENT_REF
:
20635 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
20636 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
20638 case NONTYPE_ARGUMENT_PACK
:
20639 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
20640 is value-dependent. */
20642 tree values
= ARGUMENT_PACK_ARGS (expression
);
20643 int i
, len
= TREE_VEC_LENGTH (values
);
20645 for (i
= 0; i
< len
; ++i
)
20646 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
20654 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
20655 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
20656 || (type2
? dependent_type_p (type2
) : false));
20660 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20661 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
20664 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20665 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
20669 tree op
= TREE_OPERAND (expression
, 0);
20670 return (value_dependent_expression_p (op
)
20671 || has_value_dependent_address (op
));
20676 tree fn
= get_callee_fndecl (expression
);
20678 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
20680 nargs
= call_expr_nargs (expression
);
20681 for (i
= 0; i
< nargs
; ++i
)
20683 tree op
= CALL_EXPR_ARG (expression
, i
);
20684 /* In a call to a constexpr member function, look through the
20685 implicit ADDR_EXPR on the object argument so that it doesn't
20686 cause the call to be considered value-dependent. We also
20687 look through it in potential_constant_expression. */
20688 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
20689 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
20690 && TREE_CODE (op
) == ADDR_EXPR
)
20691 op
= TREE_OPERAND (op
, 0);
20692 if (value_dependent_expression_p (op
))
20698 case TEMPLATE_ID_EXPR
:
20699 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
20701 return type_dependent_expression_p (expression
);
20707 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
20708 if (value_dependent_expression_p (val
))
20714 /* Treat a GNU statement expression as dependent to avoid crashing
20715 under fold_non_dependent_expr; it can't be constant. */
20719 /* A constant expression is value-dependent if any subexpression is
20720 value-dependent. */
20721 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
20723 case tcc_reference
:
20725 case tcc_comparison
:
20727 case tcc_expression
:
20730 int i
, len
= cp_tree_operand_length (expression
);
20732 for (i
= 0; i
< len
; i
++)
20734 tree t
= TREE_OPERAND (expression
, i
);
20736 /* In some cases, some of the operands may be missing.l
20737 (For example, in the case of PREDECREMENT_EXPR, the
20738 amount to increment by may be missing.) That doesn't
20739 make the expression dependent. */
20740 if (t
&& value_dependent_expression_p (t
))
20751 /* The expression is not value-dependent. */
20755 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
20756 [temp.dep.expr]. Note that an expression with no type is
20757 considered dependent. Other parts of the compiler arrange for an
20758 expression with type-dependent subexpressions to have no type, so
20759 this function doesn't have to be fully recursive. */
20762 type_dependent_expression_p (tree expression
)
20764 if (!processing_template_decl
)
20767 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
20770 /* An unresolved name is always dependent. */
20771 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
20774 /* Some expression forms are never type-dependent. */
20775 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
20776 || TREE_CODE (expression
) == SIZEOF_EXPR
20777 || TREE_CODE (expression
) == ALIGNOF_EXPR
20778 || TREE_CODE (expression
) == AT_ENCODE_EXPR
20779 || TREE_CODE (expression
) == NOEXCEPT_EXPR
20780 || TREE_CODE (expression
) == TRAIT_EXPR
20781 || TREE_CODE (expression
) == TYPEID_EXPR
20782 || TREE_CODE (expression
) == DELETE_EXPR
20783 || TREE_CODE (expression
) == VEC_DELETE_EXPR
20784 || TREE_CODE (expression
) == THROW_EXPR
)
20787 /* The types of these expressions depends only on the type to which
20788 the cast occurs. */
20789 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
20790 || TREE_CODE (expression
) == STATIC_CAST_EXPR
20791 || TREE_CODE (expression
) == CONST_CAST_EXPR
20792 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
20793 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
20794 || TREE_CODE (expression
) == CAST_EXPR
)
20795 return dependent_type_p (TREE_TYPE (expression
));
20797 /* The types of these expressions depends only on the type created
20798 by the expression. */
20799 if (TREE_CODE (expression
) == NEW_EXPR
20800 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
20802 /* For NEW_EXPR tree nodes created inside a template, either
20803 the object type itself or a TREE_LIST may appear as the
20805 tree type
= TREE_OPERAND (expression
, 1);
20806 if (TREE_CODE (type
) == TREE_LIST
)
20807 /* This is an array type. We need to check array dimensions
20809 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
20810 || value_dependent_expression_p
20811 (TREE_OPERAND (TREE_VALUE (type
), 1));
20813 return dependent_type_p (type
);
20816 if (TREE_CODE (expression
) == SCOPE_REF
)
20818 tree scope
= TREE_OPERAND (expression
, 0);
20819 tree name
= TREE_OPERAND (expression
, 1);
20821 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
20822 contains an identifier associated by name lookup with one or more
20823 declarations declared with a dependent type, or...a
20824 nested-name-specifier or qualified-id that names a member of an
20825 unknown specialization. */
20826 return (type_dependent_expression_p (name
)
20827 || dependent_scope_p (scope
));
20830 if (TREE_CODE (expression
) == FUNCTION_DECL
20831 && DECL_LANG_SPECIFIC (expression
)
20832 && DECL_TEMPLATE_INFO (expression
)
20833 && (any_dependent_template_arguments_p
20834 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
20837 if (TREE_CODE (expression
) == TEMPLATE_DECL
20838 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
20841 if (TREE_CODE (expression
) == STMT_EXPR
)
20842 expression
= stmt_expr_value_expr (expression
);
20844 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
20849 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
20851 if (type_dependent_expression_p (elt
))
20857 /* A static data member of the current instantiation with incomplete
20858 array type is type-dependent, as the definition and specializations
20859 can have different bounds. */
20860 if (VAR_P (expression
)
20861 && DECL_CLASS_SCOPE_P (expression
)
20862 && dependent_type_p (DECL_CONTEXT (expression
))
20863 && VAR_HAD_UNKNOWN_BOUND (expression
))
20866 /* An array of unknown bound depending on a variadic parameter, eg:
20868 template<typename... Args>
20869 void foo (Args... args)
20871 int arr[] = { args... };
20874 template<int... vals>
20877 int arr[] = { vals... };
20880 If the array has no length and has an initializer, it must be that
20881 we couldn't determine its length in cp_complete_array_type because
20882 it is dependent. */
20883 if (VAR_P (expression
)
20884 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
20885 && !TYPE_DOMAIN (TREE_TYPE (expression
))
20886 && DECL_INITIAL (expression
))
20889 if (TREE_TYPE (expression
) == unknown_type_node
)
20891 if (TREE_CODE (expression
) == ADDR_EXPR
)
20892 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
20893 if (TREE_CODE (expression
) == COMPONENT_REF
20894 || TREE_CODE (expression
) == OFFSET_REF
)
20896 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20898 expression
= TREE_OPERAND (expression
, 1);
20899 if (identifier_p (expression
))
20902 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
20903 if (TREE_CODE (expression
) == SCOPE_REF
)
20906 /* Always dependent, on the number of arguments if nothing else. */
20907 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
20910 if (BASELINK_P (expression
))
20911 expression
= BASELINK_FUNCTIONS (expression
);
20913 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
20915 if (any_dependent_template_arguments_p
20916 (TREE_OPERAND (expression
, 1)))
20918 expression
= TREE_OPERAND (expression
, 0);
20920 gcc_assert (TREE_CODE (expression
) == OVERLOAD
20921 || TREE_CODE (expression
) == FUNCTION_DECL
);
20925 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
20927 expression
= OVL_NEXT (expression
);
20932 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
20934 return (dependent_type_p (TREE_TYPE (expression
)));
20937 /* walk_tree callback function for instantiation_dependent_expression_p,
20938 below. Returns non-zero if a dependent subexpression is found. */
20941 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
20946 /* We don't have to worry about decltype currently because decltype
20947 of an instantiation-dependent expr is a dependent type. This
20948 might change depending on the resolution of DR 1172. */
20949 *walk_subtrees
= false;
20952 enum tree_code code
= TREE_CODE (*tp
);
20955 /* Don't treat an argument list as dependent just because it has no
20963 /* A constant with a dependent initializer is dependent. */
20964 if (value_dependent_expression_p (*tp
))
20968 case TEMPLATE_PARM_INDEX
:
20971 /* Handle expressions with type operands. */
20975 case AT_ENCODE_EXPR
:
20977 tree op
= TREE_OPERAND (*tp
, 0);
20978 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
20979 op
= TREE_TYPE (op
);
20982 if (dependent_type_p (op
))
20986 *walk_subtrees
= false;
20994 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
20995 || (TRAIT_EXPR_TYPE2 (*tp
)
20996 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
20998 *walk_subtrees
= false;
21001 case COMPONENT_REF
:
21002 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21003 /* In a template, finish_class_member_access_expr creates a
21004 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21005 type-dependent, so that we can check access control at
21006 instantiation time (PR 42277). See also Core issue 1273. */
21011 if (instantiation_dependent_scope_ref_p (*tp
))
21016 /* Treat statement-expressions as dependent. */
21024 if (type_dependent_expression_p (*tp
))
21030 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21031 sense defined by the ABI:
21033 "An expression is instantiation-dependent if it is type-dependent
21034 or value-dependent, or it has a subexpression that is type-dependent
21035 or value-dependent." */
21038 instantiation_dependent_expression_p (tree expression
)
21042 if (!processing_template_decl
)
21045 if (expression
== error_mark_node
)
21048 result
= cp_walk_tree_without_duplicates (&expression
,
21049 instantiation_dependent_r
, NULL
);
21050 return result
!= NULL_TREE
;
21053 /* Like type_dependent_expression_p, but it also works while not processing
21054 a template definition, i.e. during substitution or mangling. */
21057 type_dependent_expression_p_push (tree expr
)
21060 ++processing_template_decl
;
21061 b
= type_dependent_expression_p (expr
);
21062 --processing_template_decl
;
21066 /* Returns TRUE if ARGS contains a type-dependent expression. */
21069 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21074 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21076 if (type_dependent_expression_p (arg
))
21082 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21083 expressions) contains any type-dependent expressions. */
21086 any_type_dependent_elements_p (const_tree list
)
21088 for (; list
; list
= TREE_CHAIN (list
))
21089 if (type_dependent_expression_p (TREE_VALUE (list
)))
21095 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21096 expressions) contains any value-dependent expressions. */
21099 any_value_dependent_elements_p (const_tree list
)
21101 for (; list
; list
= TREE_CHAIN (list
))
21102 if (value_dependent_expression_p (TREE_VALUE (list
)))
21108 /* Returns TRUE if the ARG (a template argument) is dependent. */
21111 dependent_template_arg_p (tree arg
)
21113 if (!processing_template_decl
)
21116 /* Assume a template argument that was wrongly written by the user
21117 is dependent. This is consistent with what
21118 any_dependent_template_arguments_p [that calls this function]
21120 if (!arg
|| arg
== error_mark_node
)
21123 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21124 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21126 if (TREE_CODE (arg
) == TEMPLATE_DECL
21127 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21128 return dependent_template_p (arg
);
21129 else if (ARGUMENT_PACK_P (arg
))
21131 tree args
= ARGUMENT_PACK_ARGS (arg
);
21132 int i
, len
= TREE_VEC_LENGTH (args
);
21133 for (i
= 0; i
< len
; ++i
)
21135 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21141 else if (TYPE_P (arg
))
21142 return dependent_type_p (arg
);
21144 return (type_dependent_expression_p (arg
)
21145 || value_dependent_expression_p (arg
));
21148 /* Returns true if ARGS (a collection of template arguments) contains
21149 any types that require structural equality testing. */
21152 any_template_arguments_need_structural_equality_p (tree args
)
21159 if (args
== error_mark_node
)
21162 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21164 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21165 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21167 tree arg
= TREE_VEC_ELT (level
, j
);
21168 tree packed_args
= NULL_TREE
;
21171 if (ARGUMENT_PACK_P (arg
))
21173 /* Look inside the argument pack. */
21174 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21175 len
= TREE_VEC_LENGTH (packed_args
);
21178 for (k
= 0; k
< len
; ++k
)
21181 arg
= TREE_VEC_ELT (packed_args
, k
);
21183 if (error_operand_p (arg
))
21185 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21187 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21189 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21190 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21199 /* Returns true if ARGS (a collection of template arguments) contains
21200 any dependent arguments. */
21203 any_dependent_template_arguments_p (const_tree args
)
21210 if (args
== error_mark_node
)
21213 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21215 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21216 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21217 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21224 /* Returns TRUE if the template TMPL is dependent. */
21227 dependent_template_p (tree tmpl
)
21229 if (TREE_CODE (tmpl
) == OVERLOAD
)
21233 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21235 tmpl
= OVL_NEXT (tmpl
);
21240 /* Template template parameters are dependent. */
21241 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21242 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21244 /* So are names that have not been looked up. */
21245 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21247 /* So are member templates of dependent classes. */
21248 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21249 return dependent_type_p (DECL_CONTEXT (tmpl
));
21253 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21256 dependent_template_id_p (tree tmpl
, tree args
)
21258 return (dependent_template_p (tmpl
)
21259 || any_dependent_template_arguments_p (args
));
21262 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21266 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21270 if (!processing_template_decl
)
21273 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21275 tree decl
= TREE_VEC_ELT (declv
, i
);
21276 tree init
= TREE_VEC_ELT (initv
, i
);
21277 tree cond
= TREE_VEC_ELT (condv
, i
);
21278 tree incr
= TREE_VEC_ELT (incrv
, i
);
21280 if (type_dependent_expression_p (decl
))
21283 if (init
&& type_dependent_expression_p (init
))
21286 if (type_dependent_expression_p (cond
))
21289 if (COMPARISON_CLASS_P (cond
)
21290 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21291 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21294 if (TREE_CODE (incr
) == MODOP_EXPR
)
21296 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21297 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21300 else if (type_dependent_expression_p (incr
))
21302 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21304 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21306 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21308 tree t
= TREE_OPERAND (incr
, 1);
21309 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21310 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21319 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21320 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21321 no such TYPE can be found. Note that this function peers inside
21322 uninstantiated templates and therefore should be used only in
21323 extremely limited situations. ONLY_CURRENT_P restricts this
21324 peering to the currently open classes hierarchy (which is required
21325 when comparing types). */
21328 resolve_typename_type (tree type
, bool only_current_p
)
21337 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21339 scope
= TYPE_CONTEXT (type
);
21340 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21341 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21342 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21343 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21344 identifier of the TYPENAME_TYPE anymore.
21345 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21346 TYPENAME_TYPE instead, we avoid messing up with a possible
21347 typedef variant case. */
21348 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21350 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21351 it first before we can figure out what NAME refers to. */
21352 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21354 if (TYPENAME_IS_RESOLVING_P (scope
))
21355 /* Given a class template A with a dependent base with nested type C,
21356 typedef typename A::C::C C will land us here, as trying to resolve
21357 the initial A::C leads to the local C typedef, which leads back to
21358 A::C::C. So we break the recursion now. */
21361 scope
= resolve_typename_type (scope
, only_current_p
);
21363 /* If we don't know what SCOPE refers to, then we cannot resolve the
21365 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21367 /* If the SCOPE is a template type parameter, we have no way of
21368 resolving the name. */
21369 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21371 /* If the SCOPE is not the current instantiation, there's no reason
21372 to look inside it. */
21373 if (only_current_p
&& !currently_open_class (scope
))
21375 /* If this is a typedef, we don't want to look inside (c++/11987). */
21376 if (typedef_variant_p (type
))
21378 /* If SCOPE isn't the template itself, it will not have a valid
21379 TYPE_FIELDS list. */
21380 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21381 /* scope is either the template itself or a compatible instantiation
21382 like X<T>, so look up the name in the original template. */
21383 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
21385 /* scope is a partial instantiation, so we can't do the lookup or we
21386 will lose the template arguments. */
21388 /* Enter the SCOPE so that name lookup will be resolved as if we
21389 were in the class definition. In particular, SCOPE will no
21390 longer be considered a dependent type. */
21391 pushed_scope
= push_scope (scope
);
21392 /* Look up the declaration. */
21393 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
21394 tf_warning_or_error
);
21396 result
= NULL_TREE
;
21398 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21399 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21402 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
21403 && TREE_CODE (decl
) == TYPE_DECL
)
21405 result
= TREE_TYPE (decl
);
21406 if (result
== error_mark_node
)
21407 result
= NULL_TREE
;
21409 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
21410 && DECL_CLASS_TEMPLATE_P (decl
))
21414 /* Obtain the template and the arguments. */
21415 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
21416 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
21417 /* Instantiate the template. */
21418 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
21419 /*entering_scope=*/0,
21420 tf_error
| tf_user
);
21421 if (result
== error_mark_node
)
21422 result
= NULL_TREE
;
21425 /* Leave the SCOPE. */
21427 pop_scope (pushed_scope
);
21429 /* If we failed to resolve it, return the original typename. */
21433 /* If lookup found a typename type, resolve that too. */
21434 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
21436 /* Ill-formed programs can cause infinite recursion here, so we
21437 must catch that. */
21438 TYPENAME_IS_RESOLVING_P (type
) = 1;
21439 result
= resolve_typename_type (result
, only_current_p
);
21440 TYPENAME_IS_RESOLVING_P (type
) = 0;
21443 /* Qualify the resulting type. */
21444 quals
= cp_type_quals (type
);
21446 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
21451 /* EXPR is an expression which is not type-dependent. Return a proxy
21452 for EXPR that can be used to compute the types of larger
21453 expressions containing EXPR. */
21456 build_non_dependent_expr (tree expr
)
21460 #ifdef ENABLE_CHECKING
21461 /* Try to get a constant value for all non-dependent expressions in
21462 order to expose bugs in *_dependent_expression_p and constexpr. */
21463 if (cxx_dialect
>= cxx11
)
21464 maybe_constant_value (fold_non_dependent_expr_sfinae (expr
, tf_none
));
21467 /* Preserve OVERLOADs; the functions must be available to resolve
21470 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
21471 inner_expr
= stmt_expr_value_expr (inner_expr
);
21472 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
21473 inner_expr
= TREE_OPERAND (inner_expr
, 0);
21474 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
21475 inner_expr
= TREE_OPERAND (inner_expr
, 1);
21476 if (is_overloaded_fn (inner_expr
)
21477 || TREE_CODE (inner_expr
) == OFFSET_REF
)
21479 /* There is no need to return a proxy for a variable. */
21482 /* Preserve string constants; conversions from string constants to
21483 "char *" are allowed, even though normally a "const char *"
21484 cannot be used to initialize a "char *". */
21485 if (TREE_CODE (expr
) == STRING_CST
)
21487 /* Preserve arithmetic constants, as an optimization -- there is no
21488 reason to create a new node. */
21489 if (TREE_CODE (expr
) == INTEGER_CST
|| TREE_CODE (expr
) == REAL_CST
)
21491 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21492 There is at least one place where we want to know that a
21493 particular expression is a throw-expression: when checking a ?:
21494 expression, there are special rules if the second or third
21495 argument is a throw-expression. */
21496 if (TREE_CODE (expr
) == THROW_EXPR
)
21499 /* Don't wrap an initializer list, we need to be able to look inside. */
21500 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
21503 /* Don't wrap a dummy object, we need to be able to test for it. */
21504 if (is_dummy_object (expr
))
21507 if (TREE_CODE (expr
) == COND_EXPR
)
21508 return build3 (COND_EXPR
,
21510 TREE_OPERAND (expr
, 0),
21511 (TREE_OPERAND (expr
, 1)
21512 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
21513 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
21514 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
21515 if (TREE_CODE (expr
) == COMPOUND_EXPR
21516 && !COMPOUND_EXPR_OVERLOADED (expr
))
21517 return build2 (COMPOUND_EXPR
,
21519 TREE_OPERAND (expr
, 0),
21520 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
21522 /* If the type is unknown, it can't really be non-dependent */
21523 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
21525 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21526 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
21529 /* ARGS is a vector of expressions as arguments to a function call.
21530 Replace the arguments with equivalent non-dependent expressions.
21531 This modifies ARGS in place. */
21534 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
21539 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
21541 tree newarg
= build_non_dependent_expr (arg
);
21543 (*args
)[ix
] = newarg
;
21547 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21548 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21552 make_auto_1 (tree name
)
21554 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
21555 TYPE_NAME (au
) = build_decl (input_location
,
21556 TYPE_DECL
, name
, au
);
21557 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
21558 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
21559 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
21560 TYPE_NAME (au
), NULL_TREE
);
21561 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
21562 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
21563 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
21569 make_decltype_auto (void)
21571 return make_auto_1 (get_identifier ("decltype(auto)"));
21577 return make_auto_1 (get_identifier ("auto"));
21580 /* Given type ARG, return std::initializer_list<ARG>. */
21585 tree std_init_list
= namespace_binding
21586 (get_identifier ("initializer_list"), std_node
);
21588 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
21590 error ("deducing from brace-enclosed initializer list requires "
21591 "#include <initializer_list>");
21592 return error_mark_node
;
21594 argvec
= make_tree_vec (1);
21595 TREE_VEC_ELT (argvec
, 0) = arg
;
21596 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
21597 NULL_TREE
, 0, tf_warning_or_error
);
21600 /* Replace auto in TYPE with std::initializer_list<auto>. */
21603 listify_autos (tree type
, tree auto_node
)
21605 tree init_auto
= listify (auto_node
);
21606 tree argvec
= make_tree_vec (1);
21607 TREE_VEC_ELT (argvec
, 0) = init_auto
;
21608 if (processing_template_decl
)
21609 argvec
= add_to_template_args (current_template_args (), argvec
);
21610 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21613 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
21614 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
21617 do_auto_deduction (tree type
, tree init
, tree auto_node
)
21621 if (init
== error_mark_node
)
21622 return error_mark_node
;
21624 if (type_dependent_expression_p (init
))
21625 /* Defining a subset of type-dependent expressions that we can deduce
21626 from ahead of time isn't worth the trouble. */
21629 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
21630 with either a new invented type template parameter U or, if the
21631 initializer is a braced-init-list (8.5.4), with
21632 std::initializer_list<U>. */
21633 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
21634 type
= listify_autos (type
, auto_node
);
21636 init
= resolve_nondeduced_context (init
);
21638 targs
= make_tree_vec (1);
21639 if (AUTO_IS_DECLTYPE (auto_node
))
21641 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
21642 && !REF_PARENTHESIZED_P (init
)));
21643 TREE_VEC_ELT (targs
, 0)
21644 = finish_decltype_type (init
, id
, tf_warning_or_error
);
21645 if (type
!= auto_node
)
21647 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
21648 return error_mark_node
;
21653 tree parms
= build_tree_list (NULL_TREE
, type
);
21654 tree tparms
= make_tree_vec (1);
21657 TREE_VEC_ELT (tparms
, 0)
21658 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
21659 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
21660 DEDUCE_CALL
, LOOKUP_NORMAL
,
21661 NULL
, /*explain_p=*/false);
21664 if (processing_template_decl
)
21665 /* Try again at instantiation time. */
21667 if (type
&& type
!= error_mark_node
)
21668 /* If type is error_mark_node a diagnostic must have been
21669 emitted by now. Also, having a mention to '<type error>'
21670 in the diagnostic is not really useful to the user. */
21672 if (cfun
&& auto_node
== current_function_auto_return_pattern
21673 && LAMBDA_FUNCTION_P (current_function_decl
))
21674 error ("unable to deduce lambda return type from %qE", init
);
21676 error ("unable to deduce %qT from %qE", type
, init
);
21678 return error_mark_node
;
21682 /* If the list of declarators contains more than one declarator, the type
21683 of each declared variable is determined as described above. If the
21684 type deduced for the template parameter U is not the same in each
21685 deduction, the program is ill-formed. */
21686 if (TREE_TYPE (auto_node
)
21687 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
21689 if (cfun
&& auto_node
== current_function_auto_return_pattern
21690 && LAMBDA_FUNCTION_P (current_function_decl
))
21691 error ("inconsistent types %qT and %qT deduced for "
21692 "lambda return type", TREE_TYPE (auto_node
),
21693 TREE_VEC_ELT (targs
, 0));
21695 error ("inconsistent deduction for %qT: %qT and then %qT",
21696 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
21697 return error_mark_node
;
21699 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
21701 if (processing_template_decl
)
21702 targs
= add_to_template_args (current_template_args (), targs
);
21703 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
21706 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
21710 splice_late_return_type (tree type
, tree late_return_type
)
21714 if (late_return_type
== NULL_TREE
)
21716 argvec
= make_tree_vec (1);
21717 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
21718 if (processing_template_parmlist
)
21719 /* For a late-specified return type in a template type-parameter, we
21720 need to add a dummy argument level for its parmlist. */
21721 argvec
= add_to_template_args
21722 (make_tree_vec (processing_template_parmlist
), argvec
);
21723 if (current_template_parms
)
21724 argvec
= add_to_template_args (current_template_args (), argvec
);
21725 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21728 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
21729 'decltype(auto)'. */
21732 is_auto (const_tree type
)
21734 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
21735 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
21736 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
21742 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
21743 a use of `auto'. Returns NULL_TREE otherwise. */
21746 type_uses_auto (tree type
)
21748 return find_type_usage (type
, is_auto
);
21751 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
21752 'decltype(auto)' or a concept. */
21755 is_auto_or_concept (const_tree type
)
21757 return is_auto (type
); // or concept
21760 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
21761 a concept identifier) iff TYPE contains a use of a generic type. Returns
21762 NULL_TREE otherwise. */
21765 type_uses_auto_or_concept (tree type
)
21767 return find_type_usage (type
, is_auto_or_concept
);
21771 /* For a given template T, return the vector of typedefs referenced
21772 in T for which access check is needed at T instantiation time.
21773 T is either a FUNCTION_DECL or a RECORD_TYPE.
21774 Those typedefs were added to T by the function
21775 append_type_to_template_for_access_check. */
21777 vec
<qualified_typedef_usage_t
, va_gc
> *
21778 get_types_needing_access_check (tree t
)
21781 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
21783 if (!t
|| t
== error_mark_node
)
21786 if (!(ti
= get_template_info (t
)))
21789 if (CLASS_TYPE_P (t
)
21790 || TREE_CODE (t
) == FUNCTION_DECL
)
21792 if (!TI_TEMPLATE (ti
))
21795 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
21801 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
21802 tied to T. That list of typedefs will be access checked at
21803 T instantiation time.
21804 T is either a FUNCTION_DECL or a RECORD_TYPE.
21805 TYPE_DECL is a TYPE_DECL node representing a typedef.
21806 SCOPE is the scope through which TYPE_DECL is accessed.
21807 LOCATION is the location of the usage point of TYPE_DECL.
21809 This function is a subroutine of
21810 append_type_to_template_for_access_check. */
21813 append_type_to_template_for_access_check_1 (tree t
,
21816 location_t location
)
21818 qualified_typedef_usage_t typedef_usage
;
21821 if (!t
|| t
== error_mark_node
)
21824 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
21825 || CLASS_TYPE_P (t
))
21827 && TREE_CODE (type_decl
) == TYPE_DECL
21830 if (!(ti
= get_template_info (t
)))
21833 gcc_assert (TI_TEMPLATE (ti
));
21835 typedef_usage
.typedef_decl
= type_decl
;
21836 typedef_usage
.context
= scope
;
21837 typedef_usage
.locus
= location
;
21839 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
21842 /* Append TYPE_DECL to the template TEMPL.
21843 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
21844 At TEMPL instanciation time, TYPE_DECL will be checked to see
21845 if it can be accessed through SCOPE.
21846 LOCATION is the location of the usage point of TYPE_DECL.
21848 e.g. consider the following code snippet:
21855 template<class U> struct S
21857 C::myint mi; // <-- usage point of the typedef C::myint
21862 At S<char> instantiation time, we need to check the access of C::myint
21863 In other words, we need to check the access of the myint typedef through
21864 the C scope. For that purpose, this function will add the myint typedef
21865 and the scope C through which its being accessed to a list of typedefs
21866 tied to the template S. That list will be walked at template instantiation
21867 time and access check performed on each typedefs it contains.
21868 Note that this particular code snippet should yield an error because
21869 myint is private to C. */
21872 append_type_to_template_for_access_check (tree templ
,
21875 location_t location
)
21877 qualified_typedef_usage_t
*iter
;
21880 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
21882 /* Make sure we don't append the type to the template twice. */
21883 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
21884 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
21887 append_type_to_template_for_access_check_1 (templ
, type_decl
,
21891 /* Convert the generic type parameters in PARM that match the types given in the
21892 range [START_IDX, END_IDX) from the current_template_parms into generic type
21896 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
21898 tree current
= current_template_parms
;
21899 int depth
= TMPL_PARMS_DEPTH (current
);
21900 current
= INNERMOST_TEMPLATE_PARMS (current
);
21901 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
21903 for (int i
= 0; i
< start_idx
; ++i
)
21904 TREE_VEC_ELT (replacement
, i
)
21905 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
21907 for (int i
= start_idx
; i
< end_idx
; ++i
)
21909 /* Create a distinct parameter pack type from the current parm and add it
21910 to the replacement args to tsubst below into the generic function
21913 tree o
= TREE_TYPE (TREE_VALUE
21914 (TREE_VEC_ELT (current
, i
)));
21915 tree t
= copy_type (o
);
21916 TEMPLATE_TYPE_PARM_INDEX (t
)
21917 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
21919 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
21920 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
21921 TYPE_MAIN_VARIANT (t
) = t
;
21922 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
21923 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
21924 TREE_VEC_ELT (replacement
, i
) = t
;
21925 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
21928 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
21929 TREE_VEC_ELT (replacement
, i
)
21930 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
21932 /* If there are more levels then build up the replacement with the outer
21935 replacement
= add_to_template_args (template_parms_to_args
21936 (TREE_CHAIN (current_template_parms
)),
21939 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
21943 /* Set up the hash tables for template instantiations. */
21946 init_template_processing (void)
21948 decl_specializations
= htab_create_ggc (37,
21949 hash_specialization
,
21950 eq_specializations
,
21952 type_specializations
= htab_create_ggc (37,
21953 hash_specialization
,
21954 eq_specializations
,
21958 /* Print stats about the template hash tables for -fstats. */
21961 print_template_statistics (void)
21963 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
21964 "%f collisions\n", (long) htab_size (decl_specializations
),
21965 (long) htab_elements (decl_specializations
),
21966 htab_collisions (decl_specializations
));
21967 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
21968 "%f collisions\n", (long) htab_size (type_specializations
),
21969 (long) htab_elements (type_specializations
),
21970 htab_collisions (type_specializations
));
21973 #include "gt-cp-pt.h"