1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992-2013 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"
33 #include "pointer-set.h"
36 #include "c-family/c-common.h"
37 #include "c-family/c-objc.h"
38 #include "cp-objcp-common.h"
39 #include "tree-inline.h"
43 #include "tree-iterator.h"
45 /* The type of functions taking a tree, and some additional data, and
47 typedef int (*tree_fn_t
) (tree
, void*);
49 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
50 instantiations have been deferred, either because their definitions
51 were not yet available, or because we were putting off doing the work. */
52 struct GTY ((chain_next ("%h.next"))) pending_template
{
53 struct pending_template
*next
;
54 struct tinst_level
*tinst
;
57 static GTY(()) struct pending_template
*pending_templates
;
58 static GTY(()) struct pending_template
*last_pending_template
;
60 int processing_template_parmlist
;
61 static int template_header_count
;
63 static GTY(()) tree saved_trees
;
64 static vec
<int> inline_parm_levels
;
66 static GTY(()) struct tinst_level
*current_tinst_level
;
68 static GTY(()) tree saved_access_scope
;
70 /* Live only within one (recursive) call to tsubst_expr. We use
71 this to pass the statement expression node from the STMT_EXPR
72 to the EXPR_STMT that is its result. */
73 static tree cur_stmt_expr
;
75 /* A map from local variable declarations in the body of the template
76 presently being instantiated to the corresponding instantiated
78 static struct pointer_map_t
*local_specializations
;
80 /* True if we've recursed into fn_type_unification too many times. */
81 static bool excessive_deduction_depth
;
83 typedef struct GTY(()) spec_entry
90 static GTY ((param_is (spec_entry
)))
91 htab_t decl_specializations
;
93 static GTY ((param_is (spec_entry
)))
94 htab_t type_specializations
;
96 /* Contains canonical template parameter types. The vector is indexed by
97 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
98 TREE_LIST, whose TREE_VALUEs contain the canonical template
99 parameters of various types and levels. */
100 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
102 #define UNIFY_ALLOW_NONE 0
103 #define UNIFY_ALLOW_MORE_CV_QUAL 1
104 #define UNIFY_ALLOW_LESS_CV_QUAL 2
105 #define UNIFY_ALLOW_DERIVED 4
106 #define UNIFY_ALLOW_INTEGER 8
107 #define UNIFY_ALLOW_OUTER_LEVEL 16
108 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
109 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
111 enum template_base_result
{
113 tbr_ambiguous_baseclass
,
117 static void push_access_scope (tree
);
118 static void pop_access_scope (tree
);
119 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
120 unification_kind_t
, int,
122 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
123 unification_kind_t
, int, bool, bool);
124 static int unify (tree
, tree
, tree
, tree
, int, bool);
125 static void add_pending_template (tree
);
126 static tree
reopen_tinst_level (struct tinst_level
*);
127 static tree
tsubst_initializer_list (tree
, tree
);
128 static tree
get_class_bindings (tree
, tree
, tree
, tree
);
129 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
131 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
133 static void tsubst_enum (tree
, tree
, tree
);
134 static tree
add_to_template_args (tree
, tree
);
135 static tree
add_outermost_template_args (tree
, tree
);
136 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
137 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
139 static int type_unification_real (tree
, tree
, tree
, const tree
*,
140 unsigned int, int, unification_kind_t
, int,
142 static void note_template_header (int);
143 static tree
convert_nontype_argument_function (tree
, tree
);
144 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
145 static tree
convert_template_argument (tree
, tree
, tree
,
146 tsubst_flags_t
, int, tree
);
147 static int for_each_template_parm (tree
, tree_fn_t
, void*,
148 struct pointer_set_t
*, bool);
149 static tree
expand_template_argument_pack (tree
);
150 static tree
build_template_parm_index (int, int, int, tree
, tree
);
151 static bool inline_needs_template_parms (tree
);
152 static void push_inline_template_parms_recursive (tree
, int);
153 static tree
retrieve_local_specialization (tree
);
154 static void register_local_specialization (tree
, tree
);
155 static hashval_t
hash_specialization (const void *p
);
156 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
157 static int mark_template_parm (tree
, void *);
158 static int template_parm_this_level_p (tree
, void *);
159 static tree
tsubst_friend_function (tree
, tree
);
160 static tree
tsubst_friend_class (tree
, tree
);
161 static int can_complete_type_without_circularity (tree
);
162 static tree
get_bindings (tree
, tree
, tree
, bool);
163 static int template_decl_level (tree
);
164 static int check_cv_quals_for_unify (int, tree
, tree
);
165 static void template_parm_level_and_index (tree
, int*, int*);
166 static int unify_pack_expansion (tree
, tree
, tree
,
167 tree
, unification_kind_t
, bool, bool);
168 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
169 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
170 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
171 static void regenerate_decl_from_template (tree
, tree
);
172 static tree
most_specialized_class (tree
, tree
, tsubst_flags_t
);
173 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
174 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
175 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
176 static bool check_specialization_scope (void);
177 static tree
process_partial_specialization (tree
);
178 static void set_current_access_from_decl (tree
);
179 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
181 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
182 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
184 static bool template_template_parm_bindings_ok_p (tree
, tree
);
185 static int template_args_equal (tree
, tree
);
186 static void tsubst_default_arguments (tree
);
187 static tree
for_each_template_parm_r (tree
*, int *, void *);
188 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
189 static void copy_default_args_to_explicit_spec (tree
);
190 static int invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
191 static bool dependent_template_arg_p (tree
);
192 static bool any_template_arguments_need_structural_equality_p (tree
);
193 static bool dependent_type_p_r (tree
);
194 static tree
tsubst_expr (tree
, tree
, tsubst_flags_t
, tree
, bool);
195 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
196 static tree
tsubst_pack_expansion (tree
, tree
, tsubst_flags_t
, tree
);
197 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
198 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
199 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
201 static tree
listify (tree
);
202 static tree
listify_autos (tree
, tree
);
203 static tree
template_parm_to_arg (tree t
);
204 static tree
current_template_args (void);
205 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
206 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
208 /* Make the current scope suitable for access checking when we are
209 processing T. T can be FUNCTION_DECL for instantiated function
210 template, VAR_DECL for static member variable, or TYPE_DECL for
211 alias template (needed by instantiate_decl). */
214 push_access_scope (tree t
)
216 gcc_assert (TREE_CODE (t
) == FUNCTION_DECL
217 || TREE_CODE (t
) == TYPE_DECL
218 || TREE_CODE (t
) == VAR_DECL
);
220 if (DECL_FRIEND_CONTEXT (t
))
221 push_nested_class (DECL_FRIEND_CONTEXT (t
));
222 else if (DECL_CLASS_SCOPE_P (t
))
223 push_nested_class (DECL_CONTEXT (t
));
225 push_to_top_level ();
227 if (TREE_CODE (t
) == FUNCTION_DECL
)
229 saved_access_scope
= tree_cons
230 (NULL_TREE
, current_function_decl
, saved_access_scope
);
231 current_function_decl
= t
;
235 /* Restore the scope set up by push_access_scope. T is the node we
239 pop_access_scope (tree t
)
241 if (TREE_CODE (t
) == FUNCTION_DECL
)
243 current_function_decl
= TREE_VALUE (saved_access_scope
);
244 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
247 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
250 pop_from_top_level ();
253 /* Do any processing required when DECL (a member template
254 declaration) is finished. Returns the TEMPLATE_DECL corresponding
255 to DECL, unless it is a specialization, in which case the DECL
256 itself is returned. */
259 finish_member_template_decl (tree decl
)
261 if (decl
== error_mark_node
)
262 return error_mark_node
;
264 gcc_assert (DECL_P (decl
));
266 if (TREE_CODE (decl
) == TYPE_DECL
)
270 type
= TREE_TYPE (decl
);
271 if (type
== error_mark_node
)
272 return error_mark_node
;
273 if (MAYBE_CLASS_TYPE_P (type
)
274 && CLASSTYPE_TEMPLATE_INFO (type
)
275 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
277 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
278 check_member_template (tmpl
);
283 else if (TREE_CODE (decl
) == FIELD_DECL
)
284 error ("data member %qD cannot be a member template", decl
);
285 else if (DECL_TEMPLATE_INFO (decl
))
287 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
289 check_member_template (DECL_TI_TEMPLATE (decl
));
290 return DECL_TI_TEMPLATE (decl
);
296 error ("invalid member template declaration %qD", decl
);
298 return error_mark_node
;
301 /* Create a template info node. */
304 build_template_info (tree template_decl
, tree template_args
)
306 tree result
= make_node (TEMPLATE_INFO
);
307 TI_TEMPLATE (result
) = template_decl
;
308 TI_ARGS (result
) = template_args
;
312 /* Return the template info node corresponding to T, whatever T is. */
315 get_template_info (const_tree t
)
317 tree tinfo
= NULL_TREE
;
319 if (!t
|| t
== error_mark_node
)
322 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
323 tinfo
= DECL_TEMPLATE_INFO (t
);
325 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
328 if (TAGGED_TYPE_P (t
))
329 tinfo
= TYPE_TEMPLATE_INFO (t
);
330 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
331 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
336 /* Returns the template nesting level of the indicated class TYPE.
346 A<T>::B<U> has depth two, while A<T> has depth one.
347 Both A<T>::B<int> and A<int>::B<U> have depth one, if
348 they are instantiations, not specializations.
350 This function is guaranteed to return 0 if passed NULL_TREE so
351 that, for example, `template_class_depth (current_class_type)' is
355 template_class_depth (tree type
)
360 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
361 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
362 ? CP_DECL_CONTEXT (type
) : CP_TYPE_CONTEXT (type
))
364 tree tinfo
= get_template_info (type
);
366 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
367 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
374 /* Subroutine of maybe_begin_member_template_processing.
375 Returns true if processing DECL needs us to push template parms. */
378 inline_needs_template_parms (tree decl
)
380 if (! DECL_TEMPLATE_INFO (decl
))
383 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
384 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
387 /* Subroutine of maybe_begin_member_template_processing.
388 Push the template parms in PARMS, starting from LEVELS steps into the
389 chain, and ending at the beginning, since template parms are listed
393 push_inline_template_parms_recursive (tree parmlist
, int levels
)
395 tree parms
= TREE_VALUE (parmlist
);
399 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
401 ++processing_template_decl
;
402 current_template_parms
403 = tree_cons (size_int (processing_template_decl
),
404 parms
, current_template_parms
);
405 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
407 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
409 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
411 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
413 if (parm
== error_mark_node
)
416 gcc_assert (DECL_P (parm
));
418 switch (TREE_CODE (parm
))
427 /* Make a CONST_DECL as is done in process_template_parm.
428 It is ugly that we recreate this here; the original
429 version built in process_template_parm is no longer
431 tree decl
= build_decl (DECL_SOURCE_LOCATION (parm
),
432 CONST_DECL
, DECL_NAME (parm
),
434 DECL_ARTIFICIAL (decl
) = 1;
435 TREE_CONSTANT (decl
) = 1;
436 TREE_READONLY (decl
) = 1;
437 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
438 SET_DECL_TEMPLATE_PARM_P (decl
);
449 /* Restore the template parameter context for a member template or
450 a friend template defined in a class definition. */
453 maybe_begin_member_template_processing (tree decl
)
458 if (inline_needs_template_parms (decl
))
460 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
461 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
463 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
466 parms
= TREE_CHAIN (parms
);
469 push_inline_template_parms_recursive (parms
, levels
);
472 /* Remember how many levels of template parameters we pushed so that
473 we can pop them later. */
474 inline_parm_levels
.safe_push (levels
);
477 /* Undo the effects of maybe_begin_member_template_processing. */
480 maybe_end_member_template_processing (void)
485 if (inline_parm_levels
.length () == 0)
488 last
= inline_parm_levels
.pop ();
489 for (i
= 0; i
< last
; ++i
)
491 --processing_template_decl
;
492 current_template_parms
= TREE_CHAIN (current_template_parms
);
497 /* Return a new template argument vector which contains all of ARGS,
498 but has as its innermost set of arguments the EXTRA_ARGS. */
501 add_to_template_args (tree args
, tree extra_args
)
508 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
511 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
512 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
514 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
515 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
517 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
518 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
523 /* Like add_to_template_args, but only the outermost ARGS are added to
524 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
525 (EXTRA_ARGS) levels are added. This function is used to combine
526 the template arguments from a partial instantiation with the
527 template arguments used to attain the full instantiation from the
528 partial instantiation. */
531 add_outermost_template_args (tree args
, tree extra_args
)
535 /* If there are more levels of EXTRA_ARGS than there are ARGS,
536 something very fishy is going on. */
537 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
539 /* If *all* the new arguments will be the EXTRA_ARGS, just return
541 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
544 /* For the moment, we make ARGS look like it contains fewer levels. */
545 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
547 new_args
= add_to_template_args (args
, extra_args
);
549 /* Now, we restore ARGS to its full dimensions. */
550 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
555 /* Return the N levels of innermost template arguments from the ARGS. */
558 get_innermost_template_args (tree args
, int n
)
566 /* If N is 1, just return the innermost set of template arguments. */
568 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
570 /* If we're not removing anything, just return the arguments we were
572 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
573 gcc_assert (extra_levels
>= 0);
574 if (extra_levels
== 0)
577 /* Make a new set of arguments, not containing the outer arguments. */
578 new_args
= make_tree_vec (n
);
579 for (i
= 1; i
<= n
; ++i
)
580 SET_TMPL_ARGS_LEVEL (new_args
, i
,
581 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
586 /* The inverse of get_innermost_template_args: Return all but the innermost
587 EXTRA_LEVELS levels of template arguments from the ARGS. */
590 strip_innermost_template_args (tree args
, int extra_levels
)
593 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
598 /* If N is 1, just return the outermost set of template arguments. */
600 return TMPL_ARGS_LEVEL (args
, 1);
602 /* If we're not removing anything, just return the arguments we were
604 gcc_assert (extra_levels
>= 0);
605 if (extra_levels
== 0)
608 /* Make a new set of arguments, not containing the inner arguments. */
609 new_args
= make_tree_vec (n
);
610 for (i
= 1; i
<= n
; ++i
)
611 SET_TMPL_ARGS_LEVEL (new_args
, i
,
612 TMPL_ARGS_LEVEL (args
, i
));
617 /* We've got a template header coming up; push to a new level for storing
621 begin_template_parm_list (void)
623 /* We use a non-tag-transparent scope here, which causes pushtag to
624 put tags in this scope, rather than in the enclosing class or
625 namespace scope. This is the right thing, since we want
626 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
627 global template class, push_template_decl handles putting the
628 TEMPLATE_DECL into top-level scope. For a nested template class,
631 template <class T> struct S1 {
632 template <class T> struct S2 {};
635 pushtag contains special code to call pushdecl_with_scope on the
636 TEMPLATE_DECL for S2. */
637 begin_scope (sk_template_parms
, NULL
);
638 ++processing_template_decl
;
639 ++processing_template_parmlist
;
640 note_template_header (0);
643 /* This routine is called when a specialization is declared. If it is
644 invalid to declare a specialization here, an error is reported and
645 false is returned, otherwise this routine will return true. */
648 check_specialization_scope (void)
650 tree scope
= current_scope ();
654 An explicit specialization shall be declared in the namespace of
655 which the template is a member, or, for member templates, in the
656 namespace of which the enclosing class or enclosing class
657 template is a member. An explicit specialization of a member
658 function, member class or static data member of a class template
659 shall be declared in the namespace of which the class template
661 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
663 error ("explicit specialization in non-namespace scope %qD", scope
);
669 In an explicit specialization declaration for a member of a class
670 template or a member template that appears in namespace scope,
671 the member template and some of its enclosing class templates may
672 remain unspecialized, except that the declaration shall not
673 explicitly specialize a class member template if its enclosing
674 class templates are not explicitly specialized as well. */
675 if (current_template_parms
)
677 error ("enclosing class templates are not explicitly specialized");
684 /* We've just seen template <>. */
687 begin_specialization (void)
689 begin_scope (sk_template_spec
, NULL
);
690 note_template_header (1);
691 return check_specialization_scope ();
694 /* Called at then end of processing a declaration preceded by
698 end_specialization (void)
701 reset_specialization ();
704 /* Any template <>'s that we have seen thus far are not referring to a
705 function specialization. */
708 reset_specialization (void)
710 processing_specialization
= 0;
711 template_header_count
= 0;
714 /* We've just seen a template header. If SPECIALIZATION is nonzero,
715 it was of the form template <>. */
718 note_template_header (int specialization
)
720 processing_specialization
= specialization
;
721 template_header_count
++;
724 /* We're beginning an explicit instantiation. */
727 begin_explicit_instantiation (void)
729 gcc_assert (!processing_explicit_instantiation
);
730 processing_explicit_instantiation
= true;
735 end_explicit_instantiation (void)
737 gcc_assert (processing_explicit_instantiation
);
738 processing_explicit_instantiation
= false;
741 /* An explicit specialization or partial specialization of TMPL is being
742 declared. Check that the namespace in which the specialization is
743 occurring is permissible. Returns false iff it is invalid to
744 specialize TMPL in the current namespace. */
747 check_specialization_namespace (tree tmpl
)
749 tree tpl_ns
= decl_namespace_context (tmpl
);
753 An explicit specialization shall be declared in the namespace of
754 which the template is a member, or, for member templates, in the
755 namespace of which the enclosing class or enclosing class
756 template is a member. An explicit specialization of a member
757 function, member class or static data member of a class template
758 shall be declared in the namespace of which the class template is
760 if (current_scope() != DECL_CONTEXT (tmpl
)
761 && !at_namespace_scope_p ())
763 error ("specialization of %qD must appear at namespace scope", tmpl
);
766 if (is_associated_namespace (current_namespace
, tpl_ns
))
767 /* Same or super-using namespace. */
771 permerror (input_location
, "specialization of %qD in different namespace", tmpl
);
772 permerror (input_location
, " from definition of %q+#D", tmpl
);
777 /* SPEC is an explicit instantiation. Check that it is valid to
778 perform this explicit instantiation in the current namespace. */
781 check_explicit_instantiation_namespace (tree spec
)
785 /* DR 275: An explicit instantiation shall appear in an enclosing
786 namespace of its template. */
787 ns
= decl_namespace_context (spec
);
788 if (!is_ancestor (current_namespace
, ns
))
789 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
790 "(which does not enclose namespace %qD)",
791 spec
, current_namespace
, ns
);
794 /* The TYPE is being declared. If it is a template type, that means it
795 is a partial specialization. Do appropriate error-checking. */
798 maybe_process_partial_specialization (tree type
)
802 if (type
== error_mark_node
)
803 return error_mark_node
;
805 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
807 error ("name of class shadows template template parameter %qD",
809 return error_mark_node
;
812 context
= TYPE_CONTEXT (type
);
814 if (TYPE_ALIAS_P (type
))
816 if (TYPE_TEMPLATE_INFO (type
)
817 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type
)))
818 error ("specialization of alias template %qD",
819 TYPE_TI_TEMPLATE (type
));
821 error ("explicit specialization of non-template %qT", type
);
822 return error_mark_node
;
824 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
826 /* This is for ordinary explicit specialization and partial
827 specialization of a template class such as:
829 template <> class C<int>;
833 template <class T> class C<T*>;
835 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
837 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
838 && !COMPLETE_TYPE_P (type
))
840 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type
));
841 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
842 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
843 if (processing_template_decl
)
845 if (push_template_decl (TYPE_MAIN_DECL (type
))
847 return error_mark_node
;
850 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
851 error ("specialization of %qT after instantiation", type
);
852 else if (errorcount
&& !processing_specialization
853 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
854 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
855 /* Trying to define a specialization either without a template<> header
856 or in an inappropriate place. We've already given an error, so just
857 bail now so we don't actually define the specialization. */
858 return error_mark_node
;
860 else if (CLASS_TYPE_P (type
)
861 && !CLASSTYPE_USE_TEMPLATE (type
)
862 && CLASSTYPE_TEMPLATE_INFO (type
)
863 && context
&& CLASS_TYPE_P (context
)
864 && CLASSTYPE_TEMPLATE_INFO (context
))
866 /* This is for an explicit specialization of member class
867 template according to [temp.expl.spec/18]:
869 template <> template <class U> class C<int>::D;
871 The context `C<int>' must be an implicit instantiation.
872 Otherwise this is just a member class template declared
875 template <> class C<int> { template <class U> class D; };
876 template <> template <class U> class C<int>::D;
878 In the first case, `C<int>::D' is a specialization of `C<T>::D'
879 while in the second case, `C<int>::D' is a primary template
880 and `C<T>::D' may not exist. */
882 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
883 && !COMPLETE_TYPE_P (type
))
886 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
888 if (current_namespace
889 != decl_namespace_context (tmpl
))
891 permerror (input_location
, "specializing %q#T in different namespace", type
);
892 permerror (input_location
, " from definition of %q+#D", tmpl
);
895 /* Check for invalid specialization after instantiation:
897 template <> template <> class C<int>::D<int>;
898 template <> template <class U> class C<int>::D; */
900 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
901 t
; t
= TREE_CHAIN (t
))
903 tree inst
= TREE_VALUE (t
);
904 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
))
906 /* We already have a full specialization of this partial
907 instantiation. Reassign it to the new member
908 specialization template. */
913 elt
.tmpl
= most_general_template (tmpl
);
914 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
917 htab_remove_elt (type_specializations
, &elt
);
920 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
922 slot
= htab_find_slot (type_specializations
, &elt
, INSERT
);
923 entry
= ggc_alloc_spec_entry ();
927 else if (COMPLETE_OR_OPEN_TYPE_P (inst
))
928 /* But if we've had an implicit instantiation, that's a
929 problem ([temp.expl.spec]/6). */
930 error ("specialization %qT after instantiation %qT",
934 /* Mark TYPE as a specialization. And as a result, we only
935 have one level of template argument for the innermost
937 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
938 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
939 CLASSTYPE_TI_ARGS (type
)
940 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
943 else if (processing_specialization
)
945 /* Someday C++0x may allow for enum template specialization. */
946 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
947 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
948 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
949 "of %qD not allowed by ISO C++", type
);
952 error ("explicit specialization of non-template %qT", type
);
953 return error_mark_node
;
960 /* Returns nonzero if we can optimize the retrieval of specializations
961 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
962 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
965 optimize_specialization_lookup_p (tree tmpl
)
967 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
968 && DECL_CLASS_SCOPE_P (tmpl
)
969 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
971 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
972 /* The optimized lookup depends on the fact that the
973 template arguments for the member function template apply
974 purely to the containing class, which is not true if the
975 containing class is an explicit or partial
977 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
978 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
979 && !DECL_CONV_FN_P (tmpl
)
980 /* It is possible to have a template that is not a member
981 template and is not a member of a template class:
983 template <typename T>
984 struct S { friend A::f(); };
986 Here, the friend function is a template, but the context does
987 not have template information. The optimized lookup relies
988 on having ARGS be the template arguments for both the class
989 and the function template. */
990 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
993 /* Retrieve the specialization (in the sense of [temp.spec] - a
994 specialization is either an instantiation or an explicit
995 specialization) of TMPL for the given template ARGS. If there is
996 no such specialization, return NULL_TREE. The ARGS are a vector of
997 arguments, or a vector of vectors of arguments, in the case of
998 templates with more than one level of parameters.
1000 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1001 then we search for a partial specialization matching ARGS. This
1002 parameter is ignored if TMPL is not a class template. */
1005 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1007 if (args
== error_mark_node
)
1010 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1012 /* There should be as many levels of arguments as there are
1013 levels of parameters. */
1014 gcc_assert (TMPL_ARGS_DEPTH (args
)
1015 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)));
1017 if (optimize_specialization_lookup_p (tmpl
))
1019 tree class_template
;
1020 tree class_specialization
;
1021 vec
<tree
, va_gc
> *methods
;
1025 /* The template arguments actually apply to the containing
1026 class. Find the class specialization with those
1028 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1029 class_specialization
1030 = retrieve_specialization (class_template
, args
, 0);
1031 if (!class_specialization
)
1033 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1034 for the specialization. */
1035 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
1038 /* Iterate through the methods with the indicated name, looking
1039 for the one that has an instance of TMPL. */
1040 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
1041 for (fns
= (*methods
)[idx
]; fns
; fns
= OVL_NEXT (fns
))
1043 tree fn
= OVL_CURRENT (fns
);
1044 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1045 /* using-declarations can add base methods to the method vec,
1046 and we don't want those here. */
1047 && DECL_CONTEXT (fn
) == class_specialization
)
1056 htab_t specializations
;
1060 elt
.spec
= NULL_TREE
;
1062 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1063 specializations
= type_specializations
;
1065 specializations
= decl_specializations
;
1068 hash
= hash_specialization (&elt
);
1069 found
= (spec_entry
*) htab_find_with_hash (specializations
, &elt
, hash
);
1077 /* Like retrieve_specialization, but for local declarations. */
1080 retrieve_local_specialization (tree tmpl
)
1084 if (local_specializations
== NULL
)
1087 slot
= pointer_map_contains (local_specializations
, tmpl
);
1088 return slot
? (tree
) *slot
: NULL_TREE
;
1091 /* Returns nonzero iff DECL is a specialization of TMPL. */
1094 is_specialization_of (tree decl
, tree tmpl
)
1098 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1102 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1108 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1110 for (t
= TREE_TYPE (decl
);
1112 t
= CLASSTYPE_USE_TEMPLATE (t
)
1113 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1114 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1121 /* Returns nonzero iff DECL is a specialization of friend declaration
1122 FRIEND_DECL according to [temp.friend]. */
1125 is_specialization_of_friend (tree decl
, tree friend_decl
)
1127 bool need_template
= true;
1130 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1131 || TREE_CODE (decl
) == TYPE_DECL
);
1133 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1134 of a template class, we want to check if DECL is a specialization
1136 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1137 && DECL_TEMPLATE_INFO (friend_decl
)
1138 && !DECL_USE_TEMPLATE (friend_decl
))
1140 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1141 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1142 need_template
= false;
1144 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1145 && !PRIMARY_TEMPLATE_P (friend_decl
))
1146 need_template
= false;
1148 /* There is nothing to do if this is not a template friend. */
1149 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1152 if (is_specialization_of (decl
, friend_decl
))
1156 A member of a class template may be declared to be a friend of a
1157 non-template class. In this case, the corresponding member of
1158 every specialization of the class template is a friend of the
1159 class granting friendship.
1161 For example, given a template friend declaration
1163 template <class T> friend void A<T>::f();
1165 the member function below is considered a friend
1167 template <> struct A<int> {
1171 For this type of template friend, TEMPLATE_DEPTH below will be
1172 nonzero. To determine if DECL is a friend of FRIEND, we first
1173 check if the enclosing class is a specialization of another. */
1175 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1177 && DECL_CLASS_SCOPE_P (decl
)
1178 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1179 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1181 /* Next, we check the members themselves. In order to handle
1182 a few tricky cases, such as when FRIEND_DECL's are
1184 template <class T> friend void A<T>::g(T t);
1185 template <class T> template <T t> friend void A<T>::h();
1189 void A<int>::g(int);
1190 template <int> void A<int>::h();
1192 we need to figure out ARGS, the template arguments from
1193 the context of DECL. This is required for template substitution
1194 of `T' in the function parameter of `g' and template parameter
1195 of `h' in the above examples. Here ARGS corresponds to `int'. */
1197 tree context
= DECL_CONTEXT (decl
);
1198 tree args
= NULL_TREE
;
1199 int current_depth
= 0;
1201 while (current_depth
< template_depth
)
1203 if (CLASSTYPE_TEMPLATE_INFO (context
))
1205 if (current_depth
== 0)
1206 args
= TYPE_TI_ARGS (context
);
1208 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1211 context
= TYPE_CONTEXT (context
);
1214 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1219 tree friend_args_type
;
1220 tree decl_args_type
;
1222 /* Make sure that both DECL and FRIEND_DECL are templates or
1224 is_template
= DECL_TEMPLATE_INFO (decl
)
1225 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1226 if (need_template
^ is_template
)
1228 else if (is_template
)
1230 /* If both are templates, check template parameter list. */
1232 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1234 if (!comp_template_parms
1235 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1239 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1242 decl_type
= TREE_TYPE (decl
);
1244 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1245 tf_none
, NULL_TREE
);
1246 if (friend_type
== error_mark_node
)
1249 /* Check if return types match. */
1250 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1253 /* Check if function parameter types match, ignoring the
1254 `this' parameter. */
1255 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1256 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1257 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1258 friend_args_type
= TREE_CHAIN (friend_args_type
);
1259 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1260 decl_args_type
= TREE_CHAIN (decl_args_type
);
1262 return compparms (decl_args_type
, friend_args_type
);
1266 /* DECL is a TYPE_DECL */
1268 tree decl_type
= TREE_TYPE (decl
);
1270 /* Make sure that both DECL and FRIEND_DECL are templates or
1273 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1274 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1276 if (need_template
^ is_template
)
1278 else if (is_template
)
1281 /* If both are templates, check the name of the two
1282 TEMPLATE_DECL's first because is_friend didn't. */
1283 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1284 != DECL_NAME (friend_decl
))
1287 /* Now check template parameter list. */
1289 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1291 return comp_template_parms
1292 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1296 return (DECL_NAME (decl
)
1297 == DECL_NAME (friend_decl
));
1303 /* Register the specialization SPEC as a specialization of TMPL with
1304 the indicated ARGS. IS_FRIEND indicates whether the specialization
1305 is actually just a friend declaration. Returns SPEC, or an
1306 equivalent prior declaration, if available. */
1309 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1316 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
));
1318 if (TREE_CODE (spec
) == FUNCTION_DECL
1319 && uses_template_parms (DECL_TI_ARGS (spec
)))
1320 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1321 register it; we want the corresponding TEMPLATE_DECL instead.
1322 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1323 the more obvious `uses_template_parms (spec)' to avoid problems
1324 with default function arguments. In particular, given
1325 something like this:
1327 template <class T> void f(T t1, T t = T())
1329 the default argument expression is not substituted for in an
1330 instantiation unless and until it is actually needed. */
1333 if (optimize_specialization_lookup_p (tmpl
))
1334 /* We don't put these specializations in the hash table, but we might
1335 want to give an error about a mismatch. */
1336 fn
= retrieve_specialization (tmpl
, args
, 0);
1344 hash
= hash_specialization (&elt
);
1347 htab_find_slot_with_hash (decl_specializations
, &elt
, hash
, INSERT
);
1349 fn
= ((spec_entry
*) *slot
)->spec
;
1354 /* We can sometimes try to re-register a specialization that we've
1355 already got. In particular, regenerate_decl_from_template calls
1356 duplicate_decls which will update the specialization list. But,
1357 we'll still get called again here anyhow. It's more convenient
1358 to simply allow this than to try to prevent it. */
1361 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1363 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1365 if (DECL_ODR_USED (fn
)
1366 || DECL_EXPLICIT_INSTANTIATION (fn
))
1368 error ("specialization of %qD after instantiation",
1370 return error_mark_node
;
1375 /* This situation should occur only if the first
1376 specialization is an implicit instantiation, the
1377 second is an explicit specialization, and the
1378 implicit instantiation has not yet been used. That
1379 situation can occur if we have implicitly
1380 instantiated a member function and then specialized
1383 We can also wind up here if a friend declaration that
1384 looked like an instantiation turns out to be a
1387 template <class T> void foo(T);
1388 class S { friend void foo<>(int) };
1389 template <> void foo(int);
1391 We transform the existing DECL in place so that any
1392 pointers to it become pointers to the updated
1395 If there was a definition for the template, but not
1396 for the specialization, we want this to look as if
1397 there were no definition, and vice versa. */
1398 DECL_INITIAL (fn
) = NULL_TREE
;
1399 duplicate_decls (spec
, fn
, is_friend
);
1400 /* The call to duplicate_decls will have applied
1403 An explicit specialization of a function template
1404 is inline only if it is explicitly declared to be,
1405 and independently of whether its function template
1408 to the primary function; now copy the inline bits to
1409 the various clones. */
1410 FOR_EACH_CLONE (clone
, fn
)
1412 DECL_DECLARED_INLINE_P (clone
)
1413 = DECL_DECLARED_INLINE_P (fn
);
1414 DECL_SOURCE_LOCATION (clone
)
1415 = DECL_SOURCE_LOCATION (fn
);
1417 check_specialization_namespace (tmpl
);
1422 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1424 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1425 /* Dup decl failed, but this is a new definition. Set the
1426 line number so any errors match this new
1428 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1434 return duplicate_decls (spec
, fn
, is_friend
);
1436 /* A specialization must be declared in the same namespace as the
1437 template it is specializing. */
1438 if (DECL_TEMPLATE_SPECIALIZATION (spec
)
1439 && !check_specialization_namespace (tmpl
))
1440 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1442 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1444 spec_entry
*entry
= ggc_alloc_spec_entry ();
1445 gcc_assert (tmpl
&& args
&& spec
);
1448 if (TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1449 && PRIMARY_TEMPLATE_P (tmpl
)
1450 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1451 /* TMPL is a forward declaration of a template function; keep a list
1452 of all specializations in case we need to reassign them to a friend
1453 template later in tsubst_friend_function. */
1454 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1455 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1461 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1462 TMPL and ARGS members, ignores SPEC. */
1465 eq_specializations (const void *p1
, const void *p2
)
1467 const spec_entry
*e1
= (const spec_entry
*)p1
;
1468 const spec_entry
*e2
= (const spec_entry
*)p2
;
1470 return (e1
->tmpl
== e2
->tmpl
1471 && comp_template_args (e1
->args
, e2
->args
));
1474 /* Returns a hash for a template TMPL and template arguments ARGS. */
1477 hash_tmpl_and_args (tree tmpl
, tree args
)
1479 hashval_t val
= DECL_UID (tmpl
);
1480 return iterative_hash_template_arg (args
, val
);
1483 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1487 hash_specialization (const void *p
)
1489 const spec_entry
*e
= (const spec_entry
*)p
;
1490 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1493 /* Recursively calculate a hash value for a template argument ARG, for use
1494 in the hash tables of template specializations. */
1497 iterative_hash_template_arg (tree arg
, hashval_t val
)
1499 unsigned HOST_WIDE_INT i
;
1500 enum tree_code code
;
1503 if (arg
== NULL_TREE
)
1504 return iterative_hash_object (arg
, val
);
1509 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1510 /* We can get one of these when re-hashing a previous entry in the middle
1511 of substituting into a pack expansion. Just look through it. */
1512 arg
= ARGUMENT_PACK_SELECT_FROM_PACK (arg
);
1514 code
= TREE_CODE (arg
);
1515 tclass
= TREE_CODE_CLASS (code
);
1517 val
= iterative_hash_object (code
, val
);
1524 case IDENTIFIER_NODE
:
1525 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1529 int i
, len
= TREE_VEC_LENGTH (arg
);
1530 for (i
= 0; i
< len
; ++i
)
1531 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1535 case TYPE_PACK_EXPANSION
:
1536 case EXPR_PACK_EXPANSION
:
1537 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1538 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1540 case TYPE_ARGUMENT_PACK
:
1541 case NONTYPE_ARGUMENT_PACK
:
1542 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1545 for (; arg
; arg
= TREE_CHAIN (arg
))
1546 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1550 for (; arg
; arg
= OVL_NEXT (arg
))
1551 val
= iterative_hash_template_arg (OVL_CURRENT (arg
), val
);
1557 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1559 val
= iterative_hash_template_arg (field
, val
);
1560 val
= iterative_hash_template_arg (value
, val
);
1566 if (!DECL_ARTIFICIAL (arg
))
1568 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1569 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1571 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1574 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1577 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1578 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1580 case TEMPLATE_PARM_INDEX
:
1581 val
= iterative_hash_template_arg
1582 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1583 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1584 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1587 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1588 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1589 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1592 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1594 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1598 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1599 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1600 val
= iterative_hash_object (code
, val
);
1601 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1604 /* A lambda can't appear in a template arg, but don't crash on
1606 gcc_assert (seen_error ());
1610 case IMPLICIT_CONV_EXPR
:
1611 case STATIC_CAST_EXPR
:
1612 case REINTERPRET_CAST_EXPR
:
1613 case CONST_CAST_EXPR
:
1614 case DYNAMIC_CAST_EXPR
:
1616 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1617 /* Now hash operands as usual. */
1627 if (TYPE_CANONICAL (arg
))
1628 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1630 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1631 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1632 /* Otherwise just compare the types during lookup. */
1635 case tcc_declaration
:
1637 return iterative_hash_expr (arg
, val
);
1640 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1642 unsigned n
= cp_tree_operand_length (arg
);
1643 for (i
= 0; i
< n
; ++i
)
1644 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1652 /* Unregister the specialization SPEC as a specialization of TMPL.
1653 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1654 if the SPEC was listed as a specialization of TMPL.
1656 Note that SPEC has been ggc_freed, so we can't look inside it. */
1659 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1664 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1665 elt
.args
= TI_ARGS (tinfo
);
1666 elt
.spec
= NULL_TREE
;
1668 entry
= (spec_entry
*) htab_find (decl_specializations
, &elt
);
1671 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1672 gcc_assert (new_spec
!= NULL_TREE
);
1673 entry
->spec
= new_spec
;
1680 /* Like register_specialization, but for local declarations. We are
1681 registering SPEC, an instantiation of TMPL. */
1684 register_local_specialization (tree spec
, tree tmpl
)
1688 slot
= pointer_map_insert (local_specializations
, tmpl
);
1692 /* TYPE is a class type. Returns true if TYPE is an explicitly
1693 specialized class. */
1696 explicit_class_specialization_p (tree type
)
1698 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1700 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1703 /* Print the list of functions at FNS, going through all the overloads
1704 for each element of the list. Alternatively, FNS can not be a
1705 TREE_LIST, in which case it will be printed together with all the
1708 MORE and *STR should respectively be FALSE and NULL when the function
1709 is called from the outside. They are used internally on recursive
1710 calls. print_candidates manages the two parameters and leaves NULL
1711 in *STR when it ends. */
1714 print_candidates_1 (tree fns
, bool more
, const char **str
)
1717 char *spaces
= NULL
;
1719 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
1720 if (TREE_CODE (fn
) == TREE_LIST
)
1722 for (fn2
= fn
; fn2
!= NULL_TREE
; fn2
= TREE_CHAIN (fn2
))
1723 print_candidates_1 (TREE_VALUE (fn2
),
1724 TREE_CHAIN (fn2
) || more
, str
);
1728 tree cand
= OVL_CURRENT (fn
);
1731 /* Pick the prefix string. */
1732 if (!more
&& !OVL_NEXT (fns
))
1734 inform (DECL_SOURCE_LOCATION (cand
),
1735 "candidate is: %#D", cand
);
1739 *str
= _("candidates are:");
1740 spaces
= get_spaces (*str
);
1742 inform (DECL_SOURCE_LOCATION (cand
), "%s %#D", *str
, cand
);
1743 *str
= spaces
? spaces
: *str
;
1753 /* Print the list of candidate FNS in an error message. FNS can also
1754 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1757 print_candidates (tree fns
)
1759 const char *str
= NULL
;
1760 print_candidates_1 (fns
, false, &str
);
1761 gcc_assert (str
== NULL
);
1764 /* Returns the template (one of the functions given by TEMPLATE_ID)
1765 which can be specialized to match the indicated DECL with the
1766 explicit template args given in TEMPLATE_ID. The DECL may be
1767 NULL_TREE if none is available. In that case, the functions in
1768 TEMPLATE_ID are non-members.
1770 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1771 specialization of a member template.
1773 The TEMPLATE_COUNT is the number of references to qualifying
1774 template classes that appeared in the name of the function. See
1775 check_explicit_specialization for a more accurate description.
1777 TSK indicates what kind of template declaration (if any) is being
1778 declared. TSK_TEMPLATE indicates that the declaration given by
1779 DECL, though a FUNCTION_DECL, has template parameters, and is
1780 therefore a template function.
1782 The template args (those explicitly specified and those deduced)
1783 are output in a newly created vector *TARGS_OUT.
1785 If it is impossible to determine the result, an error message is
1786 issued. The error_mark_node is returned to indicate failure. */
1789 determine_specialization (tree template_id
,
1792 int need_member_template
,
1798 tree explicit_targs
;
1799 tree candidates
= NULL_TREE
;
1800 /* A TREE_LIST of templates of which DECL may be a specialization.
1801 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1802 corresponding TREE_PURPOSE is the set of template arguments that,
1803 when used to instantiate the template, would produce a function
1804 with the signature of DECL. */
1805 tree templates
= NULL_TREE
;
1807 cp_binding_level
*b
;
1809 *targs_out
= NULL_TREE
;
1811 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
1812 return error_mark_node
;
1814 /* We shouldn't be specializing a member template of an
1815 unspecialized class template; we already gave an error in
1816 check_specialization_scope, now avoid crashing. */
1817 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
1818 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
1820 gcc_assert (errorcount
);
1821 return error_mark_node
;
1824 fns
= TREE_OPERAND (template_id
, 0);
1825 explicit_targs
= TREE_OPERAND (template_id
, 1);
1827 if (fns
== error_mark_node
)
1828 return error_mark_node
;
1830 /* Check for baselinks. */
1831 if (BASELINK_P (fns
))
1832 fns
= BASELINK_FUNCTIONS (fns
);
1834 if (!is_overloaded_fn (fns
))
1836 error ("%qD is not a function template", fns
);
1837 return error_mark_node
;
1840 /* Count the number of template headers specified for this
1843 for (b
= current_binding_level
;
1844 b
->kind
== sk_template_parms
;
1848 for (; fns
; fns
= OVL_NEXT (fns
))
1850 tree fn
= OVL_CURRENT (fns
);
1852 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1854 tree decl_arg_types
;
1858 /* In case of explicit specialization, we need to check if
1859 the number of template headers appearing in the specialization
1860 is correct. This is usually done in check_explicit_specialization,
1861 but the check done there cannot be exhaustive when specializing
1862 member functions. Consider the following code:
1864 template <> void A<int>::f(int);
1865 template <> template <> void A<int>::f(int);
1867 Assuming that A<int> is not itself an explicit specialization
1868 already, the first line specializes "f" which is a non-template
1869 member function, whilst the second line specializes "f" which
1870 is a template member function. So both lines are syntactically
1871 correct, and check_explicit_specialization does not reject
1874 Here, we can do better, as we are matching the specialization
1875 against the declarations. We count the number of template
1876 headers, and we check if they match TEMPLATE_COUNT + 1
1877 (TEMPLATE_COUNT is the number of qualifying template classes,
1878 plus there must be another header for the member template
1881 Notice that if header_count is zero, this is not a
1882 specialization but rather a template instantiation, so there
1883 is no check we can perform here. */
1884 if (header_count
&& header_count
!= template_count
+ 1)
1887 /* Check that the number of template arguments at the
1888 innermost level for DECL is the same as for FN. */
1889 if (current_binding_level
->kind
== sk_template_parms
1890 && !current_binding_level
->explicit_spec_p
1891 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
1892 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1893 (current_template_parms
))))
1896 /* DECL might be a specialization of FN. */
1897 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1898 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1900 /* For a non-static member function, we need to make sure
1901 that the const qualification is the same. Since
1902 get_bindings does not try to merge the "this" parameter,
1903 we must do the comparison explicitly. */
1904 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1905 && !same_type_p (TREE_VALUE (fn_arg_types
),
1906 TREE_VALUE (decl_arg_types
)))
1909 /* Skip the "this" parameter and, for constructors of
1910 classes with virtual bases, the VTT parameter. A
1911 full specialization of a constructor will have a VTT
1912 parameter, but a template never will. */
1914 = skip_artificial_parms_for (decl
, decl_arg_types
);
1916 = skip_artificial_parms_for (fn
, fn_arg_types
);
1918 /* Function templates cannot be specializations; there are
1919 no partial specializations of functions. Therefore, if
1920 the type of DECL does not match FN, there is no
1922 if (tsk
== tsk_template
)
1924 if (compparms (fn_arg_types
, decl_arg_types
))
1925 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1929 /* See whether this function might be a specialization of this
1930 template. Suppress access control because we might be trying
1931 to make this specialization a friend, and we have already done
1932 access control for the declaration of the specialization. */
1933 push_deferring_access_checks (dk_no_check
);
1934 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
1935 pop_deferring_access_checks ();
1938 /* We cannot deduce template arguments that when used to
1939 specialize TMPL will produce DECL. */
1942 /* Make sure that the deduced arguments actually work. */
1943 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
);
1944 if (insttype
== error_mark_node
)
1947 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
1948 if (!compparms (fn_arg_types
, decl_arg_types
))
1951 /* Save this template, and the arguments deduced. */
1952 templates
= tree_cons (targs
, fn
, templates
);
1954 else if (need_member_template
)
1955 /* FN is an ordinary member function, and we need a
1956 specialization of a member template. */
1958 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
1959 /* We can get IDENTIFIER_NODEs here in certain erroneous
1962 else if (!DECL_FUNCTION_MEMBER_P (fn
))
1963 /* This is just an ordinary non-member function. Nothing can
1964 be a specialization of that. */
1966 else if (DECL_ARTIFICIAL (fn
))
1967 /* Cannot specialize functions that are created implicitly. */
1971 tree decl_arg_types
;
1973 /* This is an ordinary member function. However, since
1974 we're here, we can assume it's enclosing class is a
1975 template class. For example,
1977 template <typename T> struct S { void f(); };
1978 template <> void S<int>::f() {}
1980 Here, S<int>::f is a non-template, but S<int> is a
1981 template class. If FN has the same type as DECL, we
1982 might be in business. */
1984 if (!DECL_TEMPLATE_INFO (fn
))
1985 /* Its enclosing class is an explicit specialization
1986 of a template class. This is not a candidate. */
1989 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
1990 TREE_TYPE (TREE_TYPE (fn
))))
1991 /* The return types differ. */
1994 /* Adjust the type of DECL in case FN is a static member. */
1995 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1996 if (DECL_STATIC_FUNCTION_P (fn
)
1997 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1998 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2000 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2003 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2007 if (templates
&& TREE_CHAIN (templates
))
2013 It is possible for a specialization with a given function
2014 signature to be instantiated from more than one function
2015 template. In such cases, explicit specification of the
2016 template arguments must be used to uniquely identify the
2017 function template specialization being specialized.
2019 Note that here, there's no suggestion that we're supposed to
2020 determine which of the candidate templates is most
2021 specialized. However, we, also have:
2025 Partial ordering of overloaded function template
2026 declarations is used in the following contexts to select
2027 the function template to which a function template
2028 specialization refers:
2030 -- when an explicit specialization refers to a function
2033 So, we do use the partial ordering rules, at least for now.
2034 This extension can only serve to make invalid programs valid,
2035 so it's safe. And, there is strong anecdotal evidence that
2036 the committee intended the partial ordering rules to apply;
2037 the EDG front end has that behavior, and John Spicer claims
2038 that the committee simply forgot to delete the wording in
2039 [temp.expl.spec]. */
2040 tree tmpl
= most_specialized_instantiation (templates
);
2041 if (tmpl
!= error_mark_node
)
2044 TREE_CHAIN (templates
) = NULL_TREE
;
2048 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2050 error ("template-id %qD for %q+D does not match any template "
2051 "declaration", template_id
, decl
);
2052 if (header_count
&& header_count
!= template_count
+ 1)
2053 inform (input_location
, "saw %d %<template<>%>, need %d for "
2054 "specializing a member function template",
2055 header_count
, template_count
+ 1);
2056 return error_mark_node
;
2058 else if ((templates
&& TREE_CHAIN (templates
))
2059 || (candidates
&& TREE_CHAIN (candidates
))
2060 || (templates
&& candidates
))
2062 error ("ambiguous template specialization %qD for %q+D",
2064 candidates
= chainon (candidates
, templates
);
2065 print_candidates (candidates
);
2066 return error_mark_node
;
2069 /* We have one, and exactly one, match. */
2072 tree fn
= TREE_VALUE (candidates
);
2073 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2074 /* DECL is a re-declaration or partial instantiation of a template
2076 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2078 /* It was a specialization of an ordinary member function in a
2080 return DECL_TI_TEMPLATE (fn
);
2083 /* It was a specialization of a template. */
2084 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2085 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2087 *targs_out
= copy_node (targs
);
2088 SET_TMPL_ARGS_LEVEL (*targs_out
,
2089 TMPL_ARGS_DEPTH (*targs_out
),
2090 TREE_PURPOSE (templates
));
2093 *targs_out
= TREE_PURPOSE (templates
);
2094 return TREE_VALUE (templates
);
2097 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2098 but with the default argument values filled in from those in the
2102 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2105 tree new_spec_types
;
2110 if (spec_types
== void_list_node
)
2111 return void_list_node
;
2113 /* Substitute into the rest of the list. */
2115 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2116 TREE_CHAIN (tmpl_types
));
2118 /* Add the default argument for this parameter. */
2119 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2120 TREE_VALUE (spec_types
),
2124 /* DECL is an explicit specialization. Replicate default arguments
2125 from the template it specializes. (That way, code like:
2127 template <class T> void f(T = 3);
2128 template <> void f(double);
2131 works, as required.) An alternative approach would be to look up
2132 the correct default arguments at the call-site, but this approach
2133 is consistent with how implicit instantiations are handled. */
2136 copy_default_args_to_explicit_spec (tree decl
)
2141 tree new_spec_types
;
2145 tree object_type
= NULL_TREE
;
2146 tree in_charge
= NULL_TREE
;
2147 tree vtt
= NULL_TREE
;
2149 /* See if there's anything we need to do. */
2150 tmpl
= DECL_TI_TEMPLATE (decl
);
2151 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2152 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2153 if (TREE_PURPOSE (t
))
2158 old_type
= TREE_TYPE (decl
);
2159 spec_types
= TYPE_ARG_TYPES (old_type
);
2161 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2163 /* Remove the this pointer, but remember the object's type for
2165 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2166 spec_types
= TREE_CHAIN (spec_types
);
2167 tmpl_types
= TREE_CHAIN (tmpl_types
);
2169 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2171 /* DECL may contain more parameters than TMPL due to the extra
2172 in-charge parameter in constructors and destructors. */
2173 in_charge
= spec_types
;
2174 spec_types
= TREE_CHAIN (spec_types
);
2176 if (DECL_HAS_VTT_PARM_P (decl
))
2179 spec_types
= TREE_CHAIN (spec_types
);
2183 /* Compute the merged default arguments. */
2185 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2187 /* Compute the new FUNCTION_TYPE. */
2191 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2196 /* Put the in-charge parameter back. */
2197 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2198 TREE_VALUE (in_charge
),
2201 new_type
= build_method_type_directly (object_type
,
2202 TREE_TYPE (old_type
),
2206 new_type
= build_function_type (TREE_TYPE (old_type
),
2208 new_type
= cp_build_type_attribute_variant (new_type
,
2209 TYPE_ATTRIBUTES (old_type
));
2210 new_type
= build_exception_variant (new_type
,
2211 TYPE_RAISES_EXCEPTIONS (old_type
));
2212 TREE_TYPE (decl
) = new_type
;
2215 /* Return the number of template headers we expect to see for a definition
2216 or specialization of CTYPE or one of its non-template members. */
2219 num_template_headers_for_class (tree ctype
)
2221 int num_templates
= 0;
2223 while (ctype
&& CLASS_TYPE_P (ctype
))
2225 /* You're supposed to have one `template <...>' for every
2226 template class, but you don't need one for a full
2227 specialization. For example:
2229 template <class T> struct S{};
2230 template <> struct S<int> { void f(); };
2231 void S<int>::f () {}
2233 is correct; there shouldn't be a `template <>' for the
2234 definition of `S<int>::f'. */
2235 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2236 /* If CTYPE does not have template information of any
2237 kind, then it is not a template, nor is it nested
2238 within a template. */
2240 if (explicit_class_specialization_p (ctype
))
2242 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2245 ctype
= TYPE_CONTEXT (ctype
);
2248 return num_templates
;
2251 /* Do a simple sanity check on the template headers that precede the
2252 variable declaration DECL. */
2255 check_template_variable (tree decl
)
2257 tree ctx
= CP_DECL_CONTEXT (decl
);
2258 int wanted
= num_template_headers_for_class (ctx
);
2259 if (!TYPE_P (ctx
) || !CLASSTYPE_TEMPLATE_INFO (ctx
))
2260 permerror (DECL_SOURCE_LOCATION (decl
),
2261 "%qD is not a static data member of a class template", decl
);
2262 else if (template_header_count
> wanted
)
2264 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2265 "too many template headers for %D (should be %d)",
2267 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2268 inform (DECL_SOURCE_LOCATION (decl
),
2269 "members of an explicitly specialized class are defined "
2270 "without a template header");
2274 /* Check to see if the function just declared, as indicated in
2275 DECLARATOR, and in DECL, is a specialization of a function
2276 template. We may also discover that the declaration is an explicit
2277 instantiation at this point.
2279 Returns DECL, or an equivalent declaration that should be used
2280 instead if all goes well. Issues an error message if something is
2281 amiss. Returns error_mark_node if the error is not easily
2284 FLAGS is a bitmask consisting of the following flags:
2286 2: The function has a definition.
2287 4: The function is a friend.
2289 The TEMPLATE_COUNT is the number of references to qualifying
2290 template classes that appeared in the name of the function. For
2293 template <class T> struct S { void f(); };
2296 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2297 classes are not counted in the TEMPLATE_COUNT, so that in
2299 template <class T> struct S {};
2300 template <> struct S<int> { void f(); }
2301 template <> void S<int>::f();
2303 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2304 invalid; there should be no template <>.)
2306 If the function is a specialization, it is marked as such via
2307 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2308 is set up correctly, and it is added to the list of specializations
2309 for that template. */
2312 check_explicit_specialization (tree declarator
,
2317 int have_def
= flags
& 2;
2318 int is_friend
= flags
& 4;
2319 int specialization
= 0;
2320 int explicit_instantiation
= 0;
2321 int member_specialization
= 0;
2322 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2323 tree dname
= DECL_NAME (decl
);
2328 if (!processing_specialization
)
2331 tsk
= tsk_excessive_parms
;
2334 tsk
= current_tmpl_spec_kind (template_count
);
2339 if (processing_specialization
)
2342 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2344 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2347 /* This could be something like:
2349 template <class T> void f(T);
2350 class S { friend void f<>(int); } */
2354 /* This case handles bogus declarations like template <>
2355 template <class T> void f<int>(); */
2357 error ("template-id %qD in declaration of primary template",
2364 case tsk_invalid_member_spec
:
2365 /* The error has already been reported in
2366 check_specialization_scope. */
2367 return error_mark_node
;
2369 case tsk_invalid_expl_inst
:
2370 error ("template parameter list used in explicit instantiation");
2376 error ("definition provided for explicit instantiation");
2378 explicit_instantiation
= 1;
2381 case tsk_excessive_parms
:
2382 case tsk_insufficient_parms
:
2383 if (tsk
== tsk_excessive_parms
)
2384 error ("too many template parameter lists in declaration of %qD",
2386 else if (template_header_count
)
2387 error("too few template parameter lists in declaration of %qD", decl
);
2389 error("explicit specialization of %qD must be introduced by "
2390 "%<template <>%>", decl
);
2394 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2396 member_specialization
= 1;
2402 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2404 /* This case handles bogus declarations like template <>
2405 template <class T> void f<int>(); */
2407 if (uses_template_parms (declarator
))
2408 error ("function template partial specialization %qD "
2409 "is not allowed", declarator
);
2411 error ("template-id %qD in declaration of primary template",
2416 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2417 /* This is a specialization of a member template, without
2418 specialization the containing class. Something like:
2420 template <class T> struct S {
2421 template <class U> void f (U);
2423 template <> template <class U> void S<int>::f(U) {}
2425 That's a specialization -- but of the entire template. */
2433 if (specialization
|| member_specialization
)
2435 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2436 for (; t
; t
= TREE_CHAIN (t
))
2437 if (TREE_PURPOSE (t
))
2439 permerror (input_location
,
2440 "default argument specified in explicit specialization");
2445 if (specialization
|| member_specialization
|| explicit_instantiation
)
2447 tree tmpl
= NULL_TREE
;
2448 tree targs
= NULL_TREE
;
2450 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2451 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2455 gcc_assert (TREE_CODE (declarator
) == IDENTIFIER_NODE
);
2460 /* If there is no class context, the explicit instantiation
2461 must be at namespace scope. */
2462 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2464 /* Find the namespace binding, using the declaration
2466 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2468 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2470 error ("%qD is not a template function", dname
);
2471 fns
= error_mark_node
;
2475 tree fn
= OVL_CURRENT (fns
);
2476 if (!is_associated_namespace (CP_DECL_CONTEXT (decl
),
2477 CP_DECL_CONTEXT (fn
)))
2478 error ("%qD is not declared in %qD",
2479 decl
, current_namespace
);
2483 declarator
= lookup_template_function (fns
, NULL_TREE
);
2486 if (declarator
== error_mark_node
)
2487 return error_mark_node
;
2489 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2491 if (!explicit_instantiation
)
2492 /* A specialization in class scope. This is invalid,
2493 but the error will already have been flagged by
2494 check_specialization_scope. */
2495 return error_mark_node
;
2498 /* It's not valid to write an explicit instantiation in
2501 class C { template void f(); }
2503 This case is caught by the parser. However, on
2506 template class C { void f(); };
2508 (which is invalid) we can get here. The error will be
2515 else if (ctype
!= NULL_TREE
2516 && (TREE_CODE (TREE_OPERAND (declarator
, 0)) ==
2519 /* Find the list of functions in ctype that have the same
2520 name as the declared function. */
2521 tree name
= TREE_OPERAND (declarator
, 0);
2522 tree fns
= NULL_TREE
;
2525 if (constructor_name_p (name
, ctype
))
2527 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2529 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2530 : !CLASSTYPE_DESTRUCTORS (ctype
))
2532 /* From [temp.expl.spec]:
2534 If such an explicit specialization for the member
2535 of a class template names an implicitly-declared
2536 special member function (clause _special_), the
2537 program is ill-formed.
2539 Similar language is found in [temp.explicit]. */
2540 error ("specialization of implicitly-declared special member function");
2541 return error_mark_node
;
2544 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2547 if (!DECL_CONV_FN_P (decl
))
2549 idx
= lookup_fnfields_1 (ctype
, name
);
2551 fns
= (*CLASSTYPE_METHOD_VEC (ctype
))[idx
];
2555 vec
<tree
, va_gc
> *methods
;
2558 /* For a type-conversion operator, we cannot do a
2559 name-based lookup. We might be looking for `operator
2560 int' which will be a specialization of `operator T'.
2561 So, we find *all* the conversion operators, and then
2562 select from them. */
2565 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2567 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2568 methods
->iterate (idx
, &ovl
);
2571 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2572 /* There are no more conversion functions. */
2575 /* Glue all these conversion functions together
2576 with those we already have. */
2577 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2578 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2582 if (fns
== NULL_TREE
)
2584 error ("no member function %qD declared in %qT", name
, ctype
);
2585 return error_mark_node
;
2588 TREE_OPERAND (declarator
, 0) = fns
;
2591 /* Figure out what exactly is being specialized at this point.
2592 Note that for an explicit instantiation, even one for a
2593 member function, we cannot tell apriori whether the
2594 instantiation is for a member template, or just a member
2595 function of a template class. Even if a member template is
2596 being instantiated, the member template arguments may be
2597 elided if they can be deduced from the rest of the
2599 tmpl
= determine_specialization (declarator
, decl
,
2601 member_specialization
,
2605 if (!tmpl
|| tmpl
== error_mark_node
)
2606 /* We couldn't figure out what this declaration was
2608 return error_mark_node
;
2611 tree gen_tmpl
= most_general_template (tmpl
);
2613 if (explicit_instantiation
)
2615 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2616 is done by do_decl_instantiation later. */
2618 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2619 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2621 if (arg_depth
> parm_depth
)
2623 /* If TMPL is not the most general template (for
2624 example, if TMPL is a friend template that is
2625 injected into namespace scope), then there will
2626 be too many levels of TARGS. Remove some of them
2631 new_targs
= make_tree_vec (parm_depth
);
2632 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2633 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2634 = TREE_VEC_ELT (targs
, i
);
2638 return instantiate_template (tmpl
, targs
, tf_error
);
2641 /* If we thought that the DECL was a member function, but it
2642 turns out to be specializing a static member function,
2643 make DECL a static member function as well. */
2644 if (DECL_STATIC_FUNCTION_P (tmpl
)
2645 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2646 revert_static_member_fn (decl
);
2648 /* If this is a specialization of a member template of a
2649 template class, we want to return the TEMPLATE_DECL, not
2650 the specialization of it. */
2651 if (tsk
== tsk_template
)
2653 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
2654 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2655 DECL_INITIAL (result
) = NULL_TREE
;
2659 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2660 DECL_SOURCE_LOCATION (result
)
2661 = DECL_SOURCE_LOCATION (decl
);
2662 /* We want to use the argument list specified in the
2663 definition, not in the original declaration. */
2664 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
2665 for (parm
= DECL_ARGUMENTS (result
); parm
;
2666 parm
= DECL_CHAIN (parm
))
2667 DECL_CONTEXT (parm
) = result
;
2669 return register_specialization (tmpl
, gen_tmpl
, targs
,
2673 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2674 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
2676 /* Inherit default function arguments from the template
2677 DECL is specializing. */
2678 copy_default_args_to_explicit_spec (decl
);
2680 /* This specialization has the same protection as the
2681 template it specializes. */
2682 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
2683 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
2685 /* 7.1.1-1 [dcl.stc]
2687 A storage-class-specifier shall not be specified in an
2688 explicit specialization...
2690 The parser rejects these, so unless action is taken here,
2691 explicit function specializations will always appear with
2694 The action recommended by the C++ CWG in response to C++
2695 defect report 605 is to make the storage class and linkage
2696 of the explicit specialization match the templated function:
2698 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2700 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
2702 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
2703 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
2705 /* This specialization has the same linkage and visibility as
2706 the function template it specializes. */
2707 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
2708 if (! TREE_PUBLIC (decl
))
2710 DECL_INTERFACE_KNOWN (decl
) = 1;
2711 DECL_NOT_REALLY_EXTERN (decl
) = 1;
2713 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
2714 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
2716 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
2717 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
2721 /* If DECL is a friend declaration, declared using an
2722 unqualified name, the namespace associated with DECL may
2723 have been set incorrectly. For example, in:
2725 template <typename T> void f(T);
2727 struct S { friend void f<int>(int); }
2730 we will have set the DECL_CONTEXT for the friend
2731 declaration to N, rather than to the global namespace. */
2732 if (DECL_NAMESPACE_SCOPE_P (decl
))
2733 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
2735 if (is_friend
&& !have_def
)
2736 /* This is not really a declaration of a specialization.
2737 It's just the name of an instantiation. But, it's not
2738 a request for an instantiation, either. */
2739 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
2740 else if (DECL_CONSTRUCTOR_P (decl
) || DECL_DESTRUCTOR_P (decl
))
2741 /* This is indeed a specialization. In case of constructors
2742 and destructors, we need in-charge and not-in-charge
2743 versions in V3 ABI. */
2744 clone_function_decl (decl
, /*update_method_vec_p=*/0);
2746 /* Register this specialization so that we can find it
2748 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
, 0);
2755 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2756 parameters. These are represented in the same format used for
2757 DECL_TEMPLATE_PARMS. */
2760 comp_template_parms (const_tree parms1
, const_tree parms2
)
2765 if (parms1
== parms2
)
2768 for (p1
= parms1
, p2
= parms2
;
2769 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2770 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2772 tree t1
= TREE_VALUE (p1
);
2773 tree t2
= TREE_VALUE (p2
);
2776 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2777 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2779 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2782 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2784 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2785 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2787 /* If either of the template parameters are invalid, assume
2788 they match for the sake of error recovery. */
2789 if (parm1
== error_mark_node
|| parm2
== error_mark_node
)
2792 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2795 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2796 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2797 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2799 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2804 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2805 /* One set of parameters has more parameters lists than the
2812 /* Determine whether PARM is a parameter pack. */
2815 template_parameter_pack_p (const_tree parm
)
2817 /* Determine if we have a non-type template parameter pack. */
2818 if (TREE_CODE (parm
) == PARM_DECL
)
2819 return (DECL_TEMPLATE_PARM_P (parm
)
2820 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2821 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
2822 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
2824 /* If this is a list of template parameters, we could get a
2825 TYPE_DECL or a TEMPLATE_DECL. */
2826 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2827 parm
= TREE_TYPE (parm
);
2829 /* Otherwise it must be a type template parameter. */
2830 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2831 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2832 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2835 /* Determine if T is a function parameter pack. */
2838 function_parameter_pack_p (const_tree t
)
2840 if (t
&& TREE_CODE (t
) == PARM_DECL
)
2841 return FUNCTION_PARAMETER_PACK_P (t
);
2845 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2846 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2849 get_function_template_decl (const_tree primary_func_tmpl_inst
)
2851 if (! primary_func_tmpl_inst
2852 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
2853 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
2856 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
2859 /* Return true iff the function parameter PARAM_DECL was expanded
2860 from the function parameter pack PACK. */
2863 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
2865 if (DECL_ARTIFICIAL (param_decl
)
2866 || !function_parameter_pack_p (pack
))
2869 /* The parameter pack and its pack arguments have the same
2871 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
2874 /* Determine whether ARGS describes a variadic template args list,
2875 i.e., one that is terminated by a template argument pack. */
2878 template_args_variadic_p (tree args
)
2883 if (args
== NULL_TREE
)
2886 args
= INNERMOST_TEMPLATE_ARGS (args
);
2887 nargs
= TREE_VEC_LENGTH (args
);
2892 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
2894 return ARGUMENT_PACK_P (last_parm
);
2897 /* Generate a new name for the parameter pack name NAME (an
2898 IDENTIFIER_NODE) that incorporates its */
2901 make_ith_pack_parameter_name (tree name
, int i
)
2903 /* Munge the name to include the parameter index. */
2904 #define NUMBUF_LEN 128
2905 char numbuf
[NUMBUF_LEN
];
2909 if (name
== NULL_TREE
)
2911 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
2912 newname_len
= IDENTIFIER_LENGTH (name
)
2913 + strlen (numbuf
) + 2;
2914 newname
= (char*)alloca (newname_len
);
2915 snprintf (newname
, newname_len
,
2916 "%s#%i", IDENTIFIER_POINTER (name
), i
);
2917 return get_identifier (newname
);
2920 /* Return true if T is a primary function, class or alias template
2924 primary_template_instantiation_p (const_tree t
)
2929 if (TREE_CODE (t
) == FUNCTION_DECL
)
2930 return DECL_LANG_SPECIFIC (t
)
2931 && DECL_TEMPLATE_INSTANTIATION (t
)
2932 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
2933 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
2934 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
2935 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
2936 else if (alias_template_specialization_p (t
))
2941 /* Return true if PARM is a template template parameter. */
2944 template_template_parameter_p (const_tree parm
)
2946 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
2949 /* Return true iff PARM is a DECL representing a type template
2953 template_type_parameter_p (const_tree parm
)
2956 && (TREE_CODE (parm
) == TYPE_DECL
2957 || TREE_CODE (parm
) == TEMPLATE_DECL
)
2958 && DECL_TEMPLATE_PARM_P (parm
));
2961 /* Return the template parameters of T if T is a
2962 primary template instantiation, NULL otherwise. */
2965 get_primary_template_innermost_parameters (const_tree t
)
2967 tree parms
= NULL
, template_info
= NULL
;
2969 if ((template_info
= get_template_info (t
))
2970 && primary_template_instantiation_p (t
))
2971 parms
= INNERMOST_TEMPLATE_PARMS
2972 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
2977 /* Return the template parameters of the LEVELth level from the full list
2978 of template parameters PARMS. */
2981 get_template_parms_at_level (tree parms
, int level
)
2985 || TREE_CODE (parms
) != TREE_LIST
2986 || level
> TMPL_PARMS_DEPTH (parms
))
2989 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
2990 if (TMPL_PARMS_DEPTH (p
) == level
)
2996 /* Returns the template arguments of T if T is a template instantiation,
3000 get_template_innermost_arguments (const_tree t
)
3002 tree args
= NULL
, template_info
= NULL
;
3004 if ((template_info
= get_template_info (t
))
3005 && TI_ARGS (template_info
))
3006 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3011 /* Return the argument pack elements of T if T is a template argument pack,
3015 get_template_argument_pack_elems (const_tree t
)
3017 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3018 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3021 return ARGUMENT_PACK_ARGS (t
);
3024 /* Structure used to track the progress of find_parameter_packs_r. */
3025 struct find_parameter_pack_data
3027 /* TREE_LIST that will contain all of the parameter packs found by
3029 tree
* parameter_packs
;
3031 /* Set of AST nodes that have been visited by the traversal. */
3032 struct pointer_set_t
*visited
;
3035 /* Identifies all of the argument packs that occur in a template
3036 argument and appends them to the TREE_LIST inside DATA, which is a
3037 find_parameter_pack_data structure. This is a subroutine of
3038 make_pack_expansion and uses_parameter_packs. */
3040 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3043 struct find_parameter_pack_data
* ppd
=
3044 (struct find_parameter_pack_data
*)data
;
3045 bool parameter_pack_p
= false;
3047 /* Handle type aliases/typedefs. */
3050 && TREE_CODE (TYPE_NAME (t
)) == TYPE_DECL
3051 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3053 if (TYPE_TEMPLATE_INFO (t
))
3054 cp_walk_tree (&TYPE_TI_ARGS (t
),
3055 &find_parameter_packs_r
,
3061 /* Identify whether this is a parameter pack or not. */
3062 switch (TREE_CODE (t
))
3064 case TEMPLATE_PARM_INDEX
:
3065 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3066 parameter_pack_p
= true;
3069 case TEMPLATE_TYPE_PARM
:
3070 t
= TYPE_MAIN_VARIANT (t
);
3071 case TEMPLATE_TEMPLATE_PARM
:
3072 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3073 parameter_pack_p
= true;
3077 if (FUNCTION_PARAMETER_PACK_P (t
))
3079 /* We don't want to walk into the type of a PARM_DECL,
3080 because we don't want to see the type parameter pack. */
3082 parameter_pack_p
= true;
3087 parameter_pack_p
= true;
3090 /* Not a parameter pack. */
3094 if (parameter_pack_p
)
3096 /* Add this parameter pack to the list. */
3097 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3101 cp_walk_tree (&TYPE_CONTEXT (t
),
3102 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3104 /* This switch statement will return immediately if we don't find a
3106 switch (TREE_CODE (t
))
3108 case TEMPLATE_PARM_INDEX
:
3111 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3112 /* Check the template itself. */
3113 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3114 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3115 /* Check the template arguments. */
3116 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3121 case TEMPLATE_TYPE_PARM
:
3122 case TEMPLATE_TEMPLATE_PARM
:
3129 if (TYPE_PTRMEMFUNC_P (t
))
3135 if (TYPE_TEMPLATE_INFO (t
))
3136 cp_walk_tree (&TI_ARGS (TYPE_TEMPLATE_INFO (t
)),
3137 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3144 cp_walk_tree (&TREE_TYPE (t
),
3145 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3149 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3154 case TYPE_PACK_EXPANSION
:
3155 case EXPR_PACK_EXPANSION
:
3160 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3165 case IDENTIFIER_NODE
:
3166 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3178 /* Determines if the expression or type T uses any parameter packs. */
3180 uses_parameter_packs (tree t
)
3182 tree parameter_packs
= NULL_TREE
;
3183 struct find_parameter_pack_data ppd
;
3184 ppd
.parameter_packs
= ¶meter_packs
;
3185 ppd
.visited
= pointer_set_create ();
3186 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3187 pointer_set_destroy (ppd
.visited
);
3188 return parameter_packs
!= NULL_TREE
;
3191 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3192 representation a base-class initializer into a parameter pack
3193 expansion. If all goes well, the resulting node will be an
3194 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3197 make_pack_expansion (tree arg
)
3200 tree parameter_packs
= NULL_TREE
;
3201 bool for_types
= false;
3202 struct find_parameter_pack_data ppd
;
3204 if (!arg
|| arg
== error_mark_node
)
3207 if (TREE_CODE (arg
) == TREE_LIST
)
3209 /* The only time we will see a TREE_LIST here is for a base
3210 class initializer. In this case, the TREE_PURPOSE will be a
3211 _TYPE node (representing the base class expansion we're
3212 initializing) and the TREE_VALUE will be a TREE_LIST
3213 containing the initialization arguments.
3215 The resulting expansion looks somewhat different from most
3216 expansions. Rather than returning just one _EXPANSION, we
3217 return a TREE_LIST whose TREE_PURPOSE is a
3218 TYPE_PACK_EXPANSION containing the bases that will be
3219 initialized. The TREE_VALUE will be identical to the
3220 original TREE_VALUE, which is a list of arguments that will
3221 be passed to each base. We do not introduce any new pack
3222 expansion nodes into the TREE_VALUE (although it is possible
3223 that some already exist), because the TREE_PURPOSE and
3224 TREE_VALUE all need to be expanded together with the same
3225 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3226 resulting TREE_PURPOSE will mention the parameter packs in
3227 both the bases and the arguments to the bases. */
3230 tree parameter_packs
= NULL_TREE
;
3232 /* Determine which parameter packs will be used by the base
3234 ppd
.visited
= pointer_set_create ();
3235 ppd
.parameter_packs
= ¶meter_packs
;
3236 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3239 if (parameter_packs
== NULL_TREE
)
3241 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3242 pointer_set_destroy (ppd
.visited
);
3243 return error_mark_node
;
3246 if (TREE_VALUE (arg
) != void_type_node
)
3248 /* Collect the sets of parameter packs used in each of the
3249 initialization arguments. */
3250 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3252 /* Determine which parameter packs will be expanded in this
3254 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3259 pointer_set_destroy (ppd
.visited
);
3261 /* Create the pack expansion type for the base type. */
3262 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3263 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3264 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3266 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3267 they will rarely be compared to anything. */
3268 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3270 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3273 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3276 /* Build the PACK_EXPANSION_* node. */
3278 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3279 : make_node (EXPR_PACK_EXPANSION
);
3280 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3281 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3283 /* Propagate type and const-expression information. */
3284 TREE_TYPE (result
) = TREE_TYPE (arg
);
3285 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3288 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3289 they will rarely be compared to anything. */
3290 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3292 /* Determine which parameter packs will be expanded. */
3293 ppd
.parameter_packs
= ¶meter_packs
;
3294 ppd
.visited
= pointer_set_create ();
3295 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3296 pointer_set_destroy (ppd
.visited
);
3298 /* Make sure we found some parameter packs. */
3299 if (parameter_packs
== NULL_TREE
)
3302 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3304 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3305 return error_mark_node
;
3307 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3309 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3314 /* Checks T for any "bare" parameter packs, which have not yet been
3315 expanded, and issues an error if any are found. This operation can
3316 only be done on full expressions or types (e.g., an expression
3317 statement, "if" condition, etc.), because we could have expressions like:
3319 foo(f(g(h(args)))...)
3321 where "args" is a parameter pack. check_for_bare_parameter_packs
3322 should not be called for the subexpressions args, h(args),
3323 g(h(args)), or f(g(h(args))), because we would produce erroneous
3326 Returns TRUE and emits an error if there were bare parameter packs,
3327 returns FALSE otherwise. */
3329 check_for_bare_parameter_packs (tree t
)
3331 tree parameter_packs
= NULL_TREE
;
3332 struct find_parameter_pack_data ppd
;
3334 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3337 if (TREE_CODE (t
) == TYPE_DECL
)
3340 ppd
.parameter_packs
= ¶meter_packs
;
3341 ppd
.visited
= pointer_set_create ();
3342 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3343 pointer_set_destroy (ppd
.visited
);
3345 if (parameter_packs
)
3347 error ("parameter packs not expanded with %<...%>:");
3348 while (parameter_packs
)
3350 tree pack
= TREE_VALUE (parameter_packs
);
3351 tree name
= NULL_TREE
;
3353 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3354 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3355 name
= TYPE_NAME (pack
);
3356 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3357 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3359 name
= DECL_NAME (pack
);
3362 inform (input_location
, " %qD", name
);
3364 inform (input_location
, " <anonymous>");
3366 parameter_packs
= TREE_CHAIN (parameter_packs
);
3375 /* Expand any parameter packs that occur in the template arguments in
3378 expand_template_argument_pack (tree args
)
3380 tree result_args
= NULL_TREE
;
3381 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3382 int num_result_args
= -1;
3383 int non_default_args_count
= -1;
3385 /* First, determine if we need to expand anything, and the number of
3386 slots we'll need. */
3387 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3389 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3390 if (arg
== NULL_TREE
)
3392 if (ARGUMENT_PACK_P (arg
))
3394 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3395 if (num_result_args
< 0)
3396 num_result_args
= in_arg
+ num_packed
;
3398 num_result_args
+= num_packed
;
3402 if (num_result_args
>= 0)
3407 /* If no expansion is necessary, we're done. */
3408 if (num_result_args
< 0)
3411 /* Expand arguments. */
3412 result_args
= make_tree_vec (num_result_args
);
3413 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3414 non_default_args_count
=
3415 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3416 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3418 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3419 if (ARGUMENT_PACK_P (arg
))
3421 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3422 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3423 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3424 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3425 if (non_default_args_count
> 0)
3426 non_default_args_count
+= num_packed
;
3430 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3434 if (non_default_args_count
>= 0)
3435 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3439 /* Checks if DECL shadows a template parameter.
3441 [temp.local]: A template-parameter shall not be redeclared within its
3442 scope (including nested scopes).
3444 Emits an error and returns TRUE if the DECL shadows a parameter,
3445 returns FALSE otherwise. */
3448 check_template_shadow (tree decl
)
3452 /* If we're not in a template, we can't possibly shadow a template
3454 if (!current_template_parms
)
3457 /* Figure out what we're shadowing. */
3458 if (TREE_CODE (decl
) == OVERLOAD
)
3459 decl
= OVL_CURRENT (decl
);
3460 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3462 /* If there's no previous binding for this name, we're not shadowing
3463 anything, let alone a template parameter. */
3467 /* If we're not shadowing a template parameter, we're done. Note
3468 that OLDDECL might be an OVERLOAD (or perhaps even an
3469 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3471 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3474 /* We check for decl != olddecl to avoid bogus errors for using a
3475 name inside a class. We check TPFI to avoid duplicate errors for
3476 inline member templates. */
3478 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms
))
3481 error ("declaration of %q+#D", decl
);
3482 error (" shadows template parm %q+#D", olddecl
);
3486 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3487 ORIG_LEVEL, DECL, and TYPE. */
3490 build_template_parm_index (int index
,
3496 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3497 TEMPLATE_PARM_IDX (t
) = index
;
3498 TEMPLATE_PARM_LEVEL (t
) = level
;
3499 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3500 TEMPLATE_PARM_DECL (t
) = decl
;
3501 TREE_TYPE (t
) = type
;
3502 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3503 TREE_READONLY (t
) = TREE_READONLY (decl
);
3508 /* Find the canonical type parameter for the given template type
3509 parameter. Returns the canonical type parameter, which may be TYPE
3510 if no such parameter existed. */
3513 canonical_type_parameter (tree type
)
3516 int idx
= TEMPLATE_TYPE_IDX (type
);
3517 if (!canonical_template_parms
)
3518 vec_alloc (canonical_template_parms
, idx
+1);
3520 while (canonical_template_parms
->length () <= (unsigned)idx
)
3521 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3523 list
= (*canonical_template_parms
)[idx
];
3524 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3525 list
= TREE_CHAIN (list
);
3528 return TREE_VALUE (list
);
3531 (*canonical_template_parms
)[idx
]
3532 = tree_cons (NULL_TREE
, type
,
3533 (*canonical_template_parms
)[idx
]);
3538 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3539 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3540 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3541 new one is created. */
3544 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3545 tsubst_flags_t complain
)
3547 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3548 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3549 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3550 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3552 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3555 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3556 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3557 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3558 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3559 DECL_ARTIFICIAL (decl
) = 1;
3560 SET_DECL_TEMPLATE_PARM_P (decl
);
3562 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3563 TEMPLATE_PARM_LEVEL (index
) - levels
,
3564 TEMPLATE_PARM_ORIG_LEVEL (index
),
3566 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3567 TEMPLATE_PARM_PARAMETER_PACK (t
)
3568 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3570 /* Template template parameters need this. */
3571 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3572 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3573 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
)),
3577 return TEMPLATE_PARM_DESCENDANTS (index
);
3580 /* Process information from new template parameter PARM and append it
3581 to the LIST being built. This new parameter is a non-type
3582 parameter iff IS_NON_TYPE is true. This new parameter is a
3583 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3584 is in PARM_LOC. NUM_TEMPLATE_PARMS is the size of the template
3585 parameter list PARM belongs to. This is used used to create a
3586 proper canonical type for the type of PARM that is to be created,
3587 iff PARM is a type. If the size is not known, this parameter shall
3591 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
3592 bool is_non_type
, bool is_parameter_pack
)
3599 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
3600 defval
= TREE_PURPOSE (parm
);
3604 tree p
= tree_last (list
);
3606 if (p
&& TREE_VALUE (p
) != error_mark_node
)
3609 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
3610 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
3612 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
3622 parm
= TREE_VALUE (parm
);
3624 SET_DECL_TEMPLATE_PARM_P (parm
);
3626 if (TREE_TYPE (parm
) == error_mark_node
)
3628 err_parm_list
= build_tree_list (defval
, parm
);
3629 TREE_VALUE (err_parm_list
) = error_mark_node
;
3630 return chainon (list
, err_parm_list
);
3636 The top-level cv-qualifiers on the template-parameter are
3637 ignored when determining its type. */
3638 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
3639 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
3641 err_parm_list
= build_tree_list (defval
, parm
);
3642 TREE_VALUE (err_parm_list
) = error_mark_node
;
3643 return chainon (list
, err_parm_list
);
3646 if (uses_parameter_packs (TREE_TYPE (parm
)) && !is_parameter_pack
)
3648 /* This template parameter is not a parameter pack, but it
3649 should be. Complain about "bare" parameter packs. */
3650 check_for_bare_parameter_packs (TREE_TYPE (parm
));
3652 /* Recover by calling this a parameter pack. */
3653 is_parameter_pack
= true;
3657 /* A template parameter is not modifiable. */
3658 TREE_CONSTANT (parm
) = 1;
3659 TREE_READONLY (parm
) = 1;
3660 decl
= build_decl (parm_loc
,
3661 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
3662 TREE_CONSTANT (decl
) = 1;
3663 TREE_READONLY (decl
) = 1;
3664 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
3665 = build_template_parm_index (idx
, processing_template_decl
,
3666 processing_template_decl
,
3667 decl
, TREE_TYPE (parm
));
3669 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
3670 = is_parameter_pack
;
3675 parm
= TREE_VALUE (TREE_VALUE (parm
));
3677 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
3679 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
3680 /* This is for distinguishing between real templates and template
3681 template parameters */
3682 TREE_TYPE (parm
) = t
;
3683 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
3688 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
3689 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3690 decl
= build_decl (parm_loc
,
3691 TYPE_DECL
, parm
, t
);
3694 TYPE_NAME (t
) = decl
;
3695 TYPE_STUB_DECL (t
) = decl
;
3697 TEMPLATE_TYPE_PARM_INDEX (t
)
3698 = build_template_parm_index (idx
, processing_template_decl
,
3699 processing_template_decl
,
3700 decl
, TREE_TYPE (parm
));
3701 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
3702 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
3704 DECL_ARTIFICIAL (decl
) = 1;
3705 SET_DECL_TEMPLATE_PARM_P (decl
);
3707 parm
= build_tree_list (defval
, parm
);
3708 return chainon (list
, parm
);
3711 /* The end of a template parameter list has been reached. Process the
3712 tree list into a parameter vector, converting each parameter into a more
3713 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3717 end_template_parm_list (tree parms
)
3721 tree saved_parmlist
= make_tree_vec (list_length (parms
));
3723 current_template_parms
3724 = tree_cons (size_int (processing_template_decl
),
3725 saved_parmlist
, current_template_parms
);
3727 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3729 next
= TREE_CHAIN (parm
);
3730 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3731 TREE_CHAIN (parm
) = NULL_TREE
;
3734 --processing_template_parmlist
;
3736 return saved_parmlist
;
3739 /* end_template_decl is called after a template declaration is seen. */
3742 end_template_decl (void)
3744 reset_specialization ();
3746 if (! processing_template_decl
)
3749 /* This matches the pushlevel in begin_template_parm_list. */
3752 --processing_template_decl
;
3753 current_template_parms
= TREE_CHAIN (current_template_parms
);
3756 /* Takes a TREE_LIST representing a template parameter and convert it
3757 into an argument suitable to be passed to the type substitution
3758 functions. Note that If the TREE_LIST contains an error_mark
3759 node, the returned argument is error_mark_node. */
3762 template_parm_to_arg (tree t
)
3766 || TREE_CODE (t
) != TREE_LIST
)
3769 if (error_operand_p (TREE_VALUE (t
)))
3770 return error_mark_node
;
3774 if (TREE_CODE (t
) == TYPE_DECL
3775 || TREE_CODE (t
) == TEMPLATE_DECL
)
3779 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3781 /* Turn this argument into a TYPE_ARGUMENT_PACK
3782 with a single element, which expands T. */
3783 tree vec
= make_tree_vec (1);
3784 #ifdef ENABLE_CHECKING
3785 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3786 (vec
, TREE_VEC_LENGTH (vec
));
3788 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3790 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
3791 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3796 t
= DECL_INITIAL (t
);
3798 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3800 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3801 with a single element, which expands T. */
3802 tree vec
= make_tree_vec (1);
3803 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3804 #ifdef ENABLE_CHECKING
3805 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3806 (vec
, TREE_VEC_LENGTH (vec
));
3808 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3810 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3811 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3812 TREE_TYPE (t
) = type
;
3818 /* Given a set of template parameters, return them as a set of template
3819 arguments. The template parameters are represented as a TREE_VEC, in
3820 the form documented in cp-tree.h for template arguments. */
3823 template_parms_to_args (tree parms
)
3826 tree args
= NULL_TREE
;
3827 int length
= TMPL_PARMS_DEPTH (parms
);
3830 /* If there is only one level of template parameters, we do not
3831 create a TREE_VEC of TREE_VECs. Instead, we return a single
3832 TREE_VEC containing the arguments. */
3834 args
= make_tree_vec (length
);
3836 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
3838 tree a
= copy_node (TREE_VALUE (header
));
3841 TREE_TYPE (a
) = NULL_TREE
;
3842 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
3843 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
3845 #ifdef ENABLE_CHECKING
3846 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
3850 TREE_VEC_ELT (args
, --l
) = a
;
3855 if (length
> 1 && TREE_VEC_ELT (args
, 0) == NULL_TREE
)
3856 /* This can happen for template parms of a template template
3859 template<template<class T, class U> class TT> struct S;
3861 Consider the level of the parms of TT; T and U both have
3862 level 2; TT has no template parm of level 1. So in this case
3863 the first element of full_template_args is NULL_TREE. If we
3864 leave it like this TMPL_ARG_DEPTH on args returns 1 instead
3865 of 2. This will make tsubst wrongly consider that T and U
3866 have level 1. Instead, let's create a dummy vector as the
3867 first element of full_template_args so that TMPL_ARG_DEPTH
3868 returns the correct depth for args. */
3869 TREE_VEC_ELT (args
, 0) = make_tree_vec (1);
3873 /* Within the declaration of a template, return the currently active
3874 template parameters as an argument TREE_VEC. */
3877 current_template_args (void)
3879 return template_parms_to_args (current_template_parms
);
3882 /* Update the declared TYPE by doing any lookups which were thought to be
3883 dependent, but are not now that we know the SCOPE of the declarator. */
3886 maybe_update_decl_type (tree orig_type
, tree scope
)
3888 tree type
= orig_type
;
3890 if (type
== NULL_TREE
)
3893 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3894 type
= TREE_TYPE (type
);
3896 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
3897 && dependent_type_p (type
)
3898 /* Don't bother building up the args in this case. */
3899 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
3901 /* tsubst in the args corresponding to the template parameters,
3902 including auto if present. Most things will be unchanged, but
3903 make_typename_type and tsubst_qualified_id will resolve
3904 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3905 tree args
= current_template_args ();
3906 tree auto_node
= type_uses_auto (type
);
3910 tree auto_vec
= make_tree_vec (1);
3911 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
3912 args
= add_to_template_args (args
, auto_vec
);
3914 pushed
= push_scope (scope
);
3915 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
3920 if (type
== error_mark_node
)
3923 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3925 if (same_type_p (type
, TREE_TYPE (orig_type
)))
3928 type
= TYPE_NAME (type
);
3933 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3934 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3935 a member template. Used by push_template_decl below. */
3938 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
3940 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
3941 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
3942 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
3943 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
3944 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
3949 struct template_parm_data
3951 /* The level of the template parameters we are currently
3955 /* The index of the specialization argument we are currently
3959 /* An array whose size is the number of template parameters. The
3960 elements are nonzero if the parameter has been used in any one
3961 of the arguments processed so far. */
3964 /* An array whose size is the number of template arguments. The
3965 elements are nonzero if the argument makes use of template
3966 parameters of this level. */
3967 int* arg_uses_template_parms
;
3970 /* Subroutine of push_template_decl used to see if each template
3971 parameter in a partial specialization is used in the explicit
3972 argument list. If T is of the LEVEL given in DATA (which is
3973 treated as a template_parm_data*), then DATA->PARMS is marked
3977 mark_template_parm (tree t
, void* data
)
3981 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
3983 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
3985 level
= TEMPLATE_PARM_LEVEL (t
);
3986 idx
= TEMPLATE_PARM_IDX (t
);
3990 level
= TEMPLATE_TYPE_LEVEL (t
);
3991 idx
= TEMPLATE_TYPE_IDX (t
);
3994 if (level
== tpd
->level
)
3996 tpd
->parms
[idx
] = 1;
3997 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4000 /* Return zero so that for_each_template_parm will continue the
4001 traversal of the tree; we want to mark *every* template parm. */
4005 /* Process the partial specialization DECL. */
4008 process_partial_specialization (tree decl
)
4010 tree type
= TREE_TYPE (decl
);
4011 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
4012 tree specargs
= CLASSTYPE_TI_ARGS (type
);
4013 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4014 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4017 int nargs
= TREE_VEC_LENGTH (inner_args
);
4020 bool did_error_intro
= false;
4021 struct template_parm_data tpd
;
4022 struct template_parm_data tpd2
;
4024 gcc_assert (current_template_parms
);
4026 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4027 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4029 /* We check that each of the template parameters given in the
4030 partial specialization is used in the argument list to the
4031 specialization. For example:
4033 template <class T> struct S;
4034 template <class T> struct S<T*>;
4036 The second declaration is OK because `T*' uses the template
4037 parameter T, whereas
4039 template <class T> struct S<int>;
4041 is no good. Even trickier is:
4052 The S2<T> declaration is actually invalid; it is a
4053 full-specialization. Of course,
4056 struct S2<T (*)(U)>;
4058 or some such would have been OK. */
4059 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4060 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4061 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4063 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4064 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4065 for (i
= 0; i
< nargs
; ++i
)
4067 tpd
.current_arg
= i
;
4068 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4069 &mark_template_parm
,
4072 /*include_nondeduced_p=*/false);
4074 for (i
= 0; i
< ntparms
; ++i
)
4075 if (tpd
.parms
[i
] == 0)
4077 /* One of the template parms was not used in the
4079 if (!did_error_intro
)
4081 error ("template parameters not used in partial specialization:");
4082 did_error_intro
= true;
4085 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4088 if (did_error_intro
)
4089 return error_mark_node
;
4091 /* [temp.class.spec]
4093 The argument list of the specialization shall not be identical to
4094 the implicit argument list of the primary template. */
4095 if (comp_template_args
4097 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
4099 error ("partial specialization %qT does not specialize any template arguments", type
);
4101 /* A partial specialization that replaces multiple parameters of the
4102 primary template with a pack expansion is less specialized for those
4104 if (nargs
< DECL_NTPARMS (maintmpl
))
4106 error ("partial specialization is not more specialized than the "
4107 "primary template because it replaces multiple parameters "
4108 "with a pack expansion");
4109 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4113 /* [temp.class.spec]
4115 A partially specialized non-type argument expression shall not
4116 involve template parameters of the partial specialization except
4117 when the argument expression is a simple identifier.
4119 The type of a template parameter corresponding to a specialized
4120 non-type argument shall not be dependent on a parameter of the
4123 Also, we verify that pack expansions only occur at the
4124 end of the argument list. */
4125 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4127 for (i
= 0; i
< nargs
; ++i
)
4129 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4130 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4131 tree packed_args
= NULL_TREE
;
4134 if (ARGUMENT_PACK_P (arg
))
4136 /* Extract the arguments from the argument pack. We'll be
4137 iterating over these in the following loop. */
4138 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4139 len
= TREE_VEC_LENGTH (packed_args
);
4142 for (j
= 0; j
< len
; j
++)
4145 /* Get the Jth argument in the parameter pack. */
4146 arg
= TREE_VEC_ELT (packed_args
, j
);
4148 if (PACK_EXPANSION_P (arg
))
4150 /* Pack expansions must come at the end of the
4152 if ((packed_args
&& j
< len
- 1)
4153 || (!packed_args
&& i
< nargs
- 1))
4155 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4156 error ("parameter pack argument %qE must be at the "
4157 "end of the template argument list", arg
);
4159 error ("parameter pack argument %qT must be at the "
4160 "end of the template argument list", arg
);
4164 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4165 /* We only care about the pattern. */
4166 arg
= PACK_EXPANSION_PATTERN (arg
);
4168 if (/* These first two lines are the `non-type' bit. */
4170 && TREE_CODE (arg
) != TEMPLATE_DECL
4171 /* This next line is the `argument expression is not just a
4172 simple identifier' condition and also the `specialized
4173 non-type argument' bit. */
4174 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
)
4176 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4177 || (packed_args
&& uses_template_parms (arg
)))
4178 error ("template argument %qE involves template parameter(s)",
4182 /* Look at the corresponding template parameter,
4183 marking which template parameters its type depends
4185 tree type
= TREE_TYPE (parm
);
4189 /* We haven't yet initialized TPD2. Do so now. */
4190 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4191 /* The number of parameters here is the number in the
4192 main template, which, as checked in the assertion
4194 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4196 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4199 /* Mark the template parameters. But this time, we're
4200 looking for the template parameters of the main
4201 template, not in the specialization. */
4202 tpd2
.current_arg
= i
;
4203 tpd2
.arg_uses_template_parms
[i
] = 0;
4204 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4205 for_each_template_parm (type
,
4206 &mark_template_parm
,
4209 /*include_nondeduced_p=*/false);
4211 if (tpd2
.arg_uses_template_parms
[i
])
4213 /* The type depended on some template parameters.
4214 If they are fully specialized in the
4215 specialization, that's OK. */
4218 for (j
= 0; j
< nargs
; ++j
)
4219 if (tpd2
.parms
[j
] != 0
4220 && tpd
.arg_uses_template_parms
[j
])
4223 error_n (input_location
, count
,
4224 "type %qT of template argument %qE depends "
4225 "on a template parameter",
4226 "type %qT of template argument %qE depends "
4227 "on template parameters",
4236 /* We should only get here once. */
4237 gcc_assert (!COMPLETE_TYPE_P (type
));
4239 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4240 = tree_cons (specargs
, inner_parms
,
4241 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4242 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4244 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4245 inst
= TREE_CHAIN (inst
))
4247 tree inst_type
= TREE_VALUE (inst
);
4248 if (COMPLETE_TYPE_P (inst_type
)
4249 && CLASSTYPE_IMPLICIT_INSTANTIATION (inst_type
))
4251 tree spec
= most_specialized_class (inst_type
, maintmpl
, tf_none
);
4252 if (spec
&& TREE_TYPE (spec
) == type
)
4253 permerror (input_location
,
4254 "partial specialization of %qT after instantiation "
4255 "of %qT", type
, inst_type
);
4262 /* Check that a template declaration's use of default arguments and
4263 parameter packs is not invalid. Here, PARMS are the template
4264 parameters. IS_PRIMARY is true if DECL is the thing declared by
4265 a primary template. IS_PARTIAL is true if DECL is a partial
4268 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4269 declaration (but not a definition); 1 indicates a declaration, 2
4270 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4271 emitted for extraneous default arguments.
4273 Returns TRUE if there were no errors found, FALSE otherwise. */
4276 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4277 bool is_partial
, int is_friend_decl
)
4280 int last_level_to_check
;
4282 bool no_errors
= true;
4286 A default template-argument shall not be specified in a
4287 function template declaration or a function template definition, nor
4288 in the template-parameter-list of the definition of a member of a
4291 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
4292 /* You can't have a function template declaration in a local
4293 scope, nor you can you define a member of a class template in a
4297 if (current_class_type
4298 && !TYPE_BEING_DEFINED (current_class_type
)
4299 && DECL_LANG_SPECIFIC (decl
)
4300 && DECL_DECLARES_FUNCTION_P (decl
)
4301 /* If this is either a friend defined in the scope of the class
4302 or a member function. */
4303 && (DECL_FUNCTION_MEMBER_P (decl
)
4304 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4305 : DECL_FRIEND_CONTEXT (decl
)
4306 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4308 /* And, if it was a member function, it really was defined in
4309 the scope of the class. */
4310 && (!DECL_FUNCTION_MEMBER_P (decl
)
4311 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4312 /* We already checked these parameters when the template was
4313 declared, so there's no need to do it again now. This function
4314 was defined in class scope, but we're processing it's body now
4315 that the class is complete. */
4318 /* Core issue 226 (C++0x only): the following only applies to class
4321 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4325 If a template-parameter has a default template-argument, all
4326 subsequent template-parameters shall have a default
4327 template-argument supplied. */
4328 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4330 tree inner_parms
= TREE_VALUE (parm_level
);
4331 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4332 int seen_def_arg_p
= 0;
4335 for (i
= 0; i
< ntparms
; ++i
)
4337 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4339 if (parm
== error_mark_node
)
4342 if (TREE_PURPOSE (parm
))
4344 else if (seen_def_arg_p
4345 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4347 error ("no default argument for %qD", TREE_VALUE (parm
));
4348 /* For better subsequent error-recovery, we indicate that
4349 there should have been a default argument. */
4350 TREE_PURPOSE (parm
) = error_mark_node
;
4353 else if (!is_partial
4355 /* Don't complain about an enclosing partial
4357 && parm_level
== parms
4358 && TREE_CODE (decl
) == TYPE_DECL
4360 && template_parameter_pack_p (TREE_VALUE (parm
)))
4362 /* A primary class template can only have one
4363 parameter pack, at the end of the template
4366 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
4367 error ("parameter pack %qE must be at the end of the"
4368 " template parameter list", TREE_VALUE (parm
));
4370 error ("parameter pack %qT must be at the end of the"
4371 " template parameter list",
4372 TREE_TYPE (TREE_VALUE (parm
)));
4374 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4382 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4386 /* For an ordinary class template, default template arguments are
4387 allowed at the innermost level, e.g.:
4388 template <class T = int>
4390 but, in a partial specialization, they're not allowed even
4391 there, as we have in [temp.class.spec]:
4393 The template parameter list of a specialization shall not
4394 contain default template argument values.
4396 So, for a partial specialization, or for a function template
4397 (in C++98/C++03), we look at all of them. */
4400 /* But, for a primary class template that is not a partial
4401 specialization we look at all template parameters except the
4403 parms
= TREE_CHAIN (parms
);
4405 /* Figure out what error message to issue. */
4406 if (is_friend_decl
== 2)
4407 msg
= G_("default template arguments may not be used in function template "
4408 "friend re-declaration");
4409 else if (is_friend_decl
)
4410 msg
= G_("default template arguments may not be used in function template "
4411 "friend declarations");
4412 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4413 msg
= G_("default template arguments may not be used in function templates "
4414 "without -std=c++11 or -std=gnu++11");
4415 else if (is_partial
)
4416 msg
= G_("default template arguments may not be used in "
4417 "partial specializations");
4419 msg
= G_("default argument for template parameter for class enclosing %qD");
4421 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4422 /* If we're inside a class definition, there's no need to
4423 examine the parameters to the class itself. On the one
4424 hand, they will be checked when the class is defined, and,
4425 on the other, default arguments are valid in things like:
4426 template <class T = double>
4427 struct S { template <class U> void f(U); };
4428 Here the default argument for `S' has no bearing on the
4429 declaration of `f'. */
4430 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4432 /* Check everything. */
4433 last_level_to_check
= 0;
4435 for (parm_level
= parms
;
4436 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4437 parm_level
= TREE_CHAIN (parm_level
))
4439 tree inner_parms
= TREE_VALUE (parm_level
);
4443 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4444 for (i
= 0; i
< ntparms
; ++i
)
4446 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4449 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4454 if (is_friend_decl
== 2)
4461 /* Clear out the default argument so that we are not
4463 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
4467 /* At this point, if we're still interested in issuing messages,
4468 they must apply to classes surrounding the object declared. */
4470 msg
= G_("default argument for template parameter for class "
4477 /* Worker for push_template_decl_real, called via
4478 for_each_template_parm. DATA is really an int, indicating the
4479 level of the parameters we are interested in. If T is a template
4480 parameter of that level, return nonzero. */
4483 template_parm_this_level_p (tree t
, void* data
)
4485 int this_level
= *(int *)data
;
4488 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4489 level
= TEMPLATE_PARM_LEVEL (t
);
4491 level
= TEMPLATE_TYPE_LEVEL (t
);
4492 return level
== this_level
;
4495 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4496 parameters given by current_template_args, or reuses a
4497 previously existing one, if appropriate. Returns the DECL, or an
4498 equivalent one, if it is replaced via a call to duplicate_decls.
4500 If IS_FRIEND is true, DECL is a friend declaration. */
4503 push_template_decl_real (tree decl
, bool is_friend
)
4511 int new_template_p
= 0;
4512 /* True if the template is a member template, in the sense of
4514 bool member_template_p
= false;
4516 if (decl
== error_mark_node
|| !current_template_parms
)
4517 return error_mark_node
;
4519 /* See if this is a partial specialization. */
4520 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
4521 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
4522 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
4524 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
4528 /* For a friend, we want the context of the friend function, not
4529 the type of which it is a friend. */
4530 ctx
= CP_DECL_CONTEXT (decl
);
4531 else if (CP_DECL_CONTEXT (decl
)
4532 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4533 /* In the case of a virtual function, we want the class in which
4535 ctx
= CP_DECL_CONTEXT (decl
);
4537 /* Otherwise, if we're currently defining some class, the DECL
4538 is assumed to be a member of the class. */
4539 ctx
= current_scope ();
4541 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
4544 if (!DECL_CONTEXT (decl
))
4545 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
4547 /* See if this is a primary template. */
4548 if (is_friend
&& ctx
)
4549 /* A friend template that specifies a class context, i.e.
4550 template <typename T> friend void A<T>::f();
4554 is_primary
= template_parm_scope_p ();
4558 if (DECL_CLASS_SCOPE_P (decl
))
4559 member_template_p
= true;
4560 if (TREE_CODE (decl
) == TYPE_DECL
4561 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
4563 error ("template class without a name");
4564 return error_mark_node
;
4566 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
4568 if (DECL_DESTRUCTOR_P (decl
))
4572 A destructor shall not be a member template. */
4573 error ("destructor %qD declared as member template", decl
);
4574 return error_mark_node
;
4576 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
4577 && (!prototype_p (TREE_TYPE (decl
))
4578 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
4579 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
4580 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
4581 == void_list_node
)))
4583 /* [basic.stc.dynamic.allocation]
4585 An allocation function can be a function
4586 template. ... Template allocation functions shall
4587 have two or more parameters. */
4588 error ("invalid template declaration of %qD", decl
);
4589 return error_mark_node
;
4592 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4593 && CLASS_TYPE_P (TREE_TYPE (decl
)))
4595 else if (TREE_CODE (decl
) == TYPE_DECL
4596 && TYPE_DECL_ALIAS_P (decl
))
4597 /* alias-declaration */
4598 gcc_assert (!DECL_ARTIFICIAL (decl
));
4601 error ("template declaration of %q#D", decl
);
4602 return error_mark_node
;
4606 /* Check to see that the rules regarding the use of default
4607 arguments are not being violated. */
4608 check_default_tmpl_args (decl
, current_template_parms
,
4609 is_primary
, is_partial
, /*is_friend_decl=*/0);
4611 /* Ensure that there are no parameter packs in the type of this
4612 declaration that have not been expanded. */
4613 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4615 /* Check each of the arguments individually to see if there are
4616 any bare parameter packs. */
4617 tree type
= TREE_TYPE (decl
);
4618 tree arg
= DECL_ARGUMENTS (decl
);
4619 tree argtype
= TYPE_ARG_TYPES (type
);
4621 while (arg
&& argtype
)
4623 if (!FUNCTION_PARAMETER_PACK_P (arg
)
4624 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
4626 /* This is a PARM_DECL that contains unexpanded parameter
4627 packs. We have already complained about this in the
4628 check_for_bare_parameter_packs call, so just replace
4629 these types with ERROR_MARK_NODE. */
4630 TREE_TYPE (arg
) = error_mark_node
;
4631 TREE_VALUE (argtype
) = error_mark_node
;
4634 arg
= DECL_CHAIN (arg
);
4635 argtype
= TREE_CHAIN (argtype
);
4638 /* Check for bare parameter packs in the return type and the
4639 exception specifiers. */
4640 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
4641 /* Errors were already issued, set return type to int
4642 as the frontend doesn't expect error_mark_node as
4644 TREE_TYPE (type
) = integer_type_node
;
4645 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
4646 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
4648 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
4649 && TYPE_DECL_ALIAS_P (decl
))
4650 ? DECL_ORIGINAL_TYPE (decl
)
4651 : TREE_TYPE (decl
)))
4653 TREE_TYPE (decl
) = error_mark_node
;
4654 return error_mark_node
;
4658 return process_partial_specialization (decl
);
4660 args
= current_template_args ();
4663 || TREE_CODE (ctx
) == FUNCTION_DECL
4664 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
4665 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
4667 if (DECL_LANG_SPECIFIC (decl
)
4668 && DECL_TEMPLATE_INFO (decl
)
4669 && DECL_TI_TEMPLATE (decl
))
4670 tmpl
= DECL_TI_TEMPLATE (decl
);
4671 /* If DECL is a TYPE_DECL for a class-template, then there won't
4672 be DECL_LANG_SPECIFIC. The information equivalent to
4673 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4674 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4675 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
4676 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
4678 /* Since a template declaration already existed for this
4679 class-type, we must be redeclaring it here. Make sure
4680 that the redeclaration is valid. */
4681 redeclare_class_template (TREE_TYPE (decl
),
4682 current_template_parms
);
4683 /* We don't need to create a new TEMPLATE_DECL; just use the
4684 one we already had. */
4685 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
4689 tmpl
= build_template_decl (decl
, current_template_parms
,
4693 if (DECL_LANG_SPECIFIC (decl
)
4694 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4696 /* A specialization of a member template of a template
4698 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4699 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
4700 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
4706 tree a
, t
, current
, parms
;
4708 tree tinfo
= get_template_info (decl
);
4712 error ("template definition of non-template %q#D", decl
);
4713 return error_mark_node
;
4716 tmpl
= TI_TEMPLATE (tinfo
);
4718 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
4719 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
4720 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4721 && DECL_MEMBER_TEMPLATE_P (tmpl
))
4725 /* The declaration is a specialization of a member
4726 template, declared outside the class. Therefore, the
4727 innermost template arguments will be NULL, so we
4728 replace them with the arguments determined by the
4729 earlier call to check_explicit_specialization. */
4730 args
= DECL_TI_ARGS (decl
);
4733 = build_template_decl (decl
, current_template_parms
,
4735 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
4736 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
4737 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
4738 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
4739 DECL_TEMPLATE_INFO (new_tmpl
)
4740 = build_template_info (tmpl
, args
);
4742 register_specialization (new_tmpl
,
4743 most_general_template (tmpl
),
4749 /* Make sure the template headers we got make sense. */
4751 parms
= DECL_TEMPLATE_PARMS (tmpl
);
4752 i
= TMPL_PARMS_DEPTH (parms
);
4753 if (TMPL_ARGS_DEPTH (args
) != i
)
4755 error ("expected %d levels of template parms for %q#D, got %d",
4756 i
, decl
, TMPL_ARGS_DEPTH (args
));
4759 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
4761 a
= TMPL_ARGS_LEVEL (args
, i
);
4762 t
= INNERMOST_TEMPLATE_PARMS (parms
);
4764 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
4766 if (current
== decl
)
4767 error ("got %d template parameters for %q#D",
4768 TREE_VEC_LENGTH (a
), decl
);
4770 error ("got %d template parameters for %q#T",
4771 TREE_VEC_LENGTH (a
), current
);
4772 error (" but %d required", TREE_VEC_LENGTH (t
));
4773 return error_mark_node
;
4776 if (current
== decl
)
4778 else if (current
== NULL_TREE
)
4779 /* Can happen in erroneous input. */
4782 current
= (TYPE_P (current
)
4783 ? TYPE_CONTEXT (current
)
4784 : DECL_CONTEXT (current
));
4787 /* Check that the parms are used in the appropriate qualifying scopes
4788 in the declarator. */
4789 if (!comp_template_args
4791 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
4794 template arguments to %qD do not match original template %qD",
4795 decl
, DECL_TEMPLATE_RESULT (tmpl
));
4796 if (!uses_template_parms (TI_ARGS (tinfo
)))
4797 inform (input_location
, "use template<> for an explicit specialization");
4798 /* Avoid crash in import_export_decl. */
4799 DECL_INTERFACE_KNOWN (decl
) = 1;
4800 return error_mark_node
;
4804 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4805 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
4807 /* Push template declarations for global functions and types. Note
4808 that we do not try to push a global template friend declared in a
4809 template class; such a thing may well depend on the template
4810 parameters of the class. */
4811 if (new_template_p
&& !ctx
4812 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
4814 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
4815 if (tmpl
== error_mark_node
)
4816 return error_mark_node
;
4818 /* Hide template friend classes that haven't been declared yet. */
4819 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
4821 DECL_ANTICIPATED (tmpl
) = 1;
4822 DECL_FRIEND_P (tmpl
) = 1;
4828 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
4831 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
4832 if (DECL_CONV_FN_P (tmpl
))
4834 int depth
= TMPL_PARMS_DEPTH (parms
);
4836 /* It is a conversion operator. See if the type converted to
4837 depends on innermost template operands. */
4839 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
4841 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
4844 /* Give template template parms a DECL_CONTEXT of the template
4845 for which they are a parameter. */
4846 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
4847 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
4849 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
4850 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
4851 DECL_CONTEXT (parm
) = tmpl
;
4855 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4856 back to its most general template. If TMPL is a specialization,
4857 ARGS may only have the innermost set of arguments. Add the missing
4858 argument levels if necessary. */
4859 if (DECL_TEMPLATE_INFO (tmpl
))
4860 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
4862 info
= build_template_info (tmpl
, args
);
4864 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
4865 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
4868 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
4869 retrofit_lang_decl (decl
);
4870 if (DECL_LANG_SPECIFIC (decl
))
4871 DECL_TEMPLATE_INFO (decl
) = info
;
4874 return DECL_TEMPLATE_RESULT (tmpl
);
4878 push_template_decl (tree decl
)
4880 return push_template_decl_real (decl
, false);
4883 /* FN is an inheriting constructor that inherits from the constructor
4884 template INHERITED; turn FN into a constructor template with a matching
4888 add_inherited_template_parms (tree fn
, tree inherited
)
4891 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
4892 inner_parms
= copy_node (inner_parms
);
4894 = tree_cons (size_int (processing_template_decl
+ 1),
4895 inner_parms
, current_template_parms
);
4896 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
4897 tree args
= template_parms_to_args (parms
);
4898 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
4899 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
4900 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
4901 DECL_ARTIFICIAL (tmpl
) = true;
4902 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
4906 /* Called when a class template TYPE is redeclared with the indicated
4907 template PARMS, e.g.:
4909 template <class T> struct S;
4910 template <class T> struct S {}; */
4913 redeclare_class_template (tree type
, tree parms
)
4919 if (!TYPE_TEMPLATE_INFO (type
))
4921 error ("%qT is not a template type", type
);
4925 tmpl
= TYPE_TI_TEMPLATE (type
);
4926 if (!PRIMARY_TEMPLATE_P (tmpl
))
4927 /* The type is nested in some template class. Nothing to worry
4928 about here; there are no new template parameters for the nested
4934 error ("template specifiers not specified in declaration of %qD",
4939 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
4940 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
4942 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
4944 error_n (input_location
, TREE_VEC_LENGTH (parms
),
4945 "redeclared with %d template parameter",
4946 "redeclared with %d template parameters",
4947 TREE_VEC_LENGTH (parms
));
4948 inform_n (input_location
, TREE_VEC_LENGTH (tmpl_parms
),
4949 "previous declaration %q+D used %d template parameter",
4950 "previous declaration %q+D used %d template parameters",
4951 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
4955 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
4962 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
4963 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
4966 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
4967 if (tmpl_parm
== error_mark_node
)
4970 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
4971 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
4972 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
4974 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4976 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
4977 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
4978 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
4979 || (TREE_CODE (tmpl_parm
) != PARM_DECL
4980 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
4981 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
4982 || (TREE_CODE (tmpl_parm
) == PARM_DECL
4983 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
4984 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
4986 error ("template parameter %q+#D", tmpl_parm
);
4987 error ("redeclared here as %q#D", parm
);
4991 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
4993 /* We have in [temp.param]:
4995 A template-parameter may not be given default arguments
4996 by two different declarations in the same scope. */
4997 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
4998 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
4999 "original definition appeared here");
5003 if (parm_default
!= NULL_TREE
)
5004 /* Update the previous template parameters (which are the ones
5005 that will really count) with the new default value. */
5006 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5007 else if (tmpl_default
!= NULL_TREE
)
5008 /* Update the new parameters, too; they'll be used as the
5009 parameters for any members. */
5010 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5016 /* Simplify EXPR if it is a non-dependent expression. Returns the
5017 (possibly simplified) expression. */
5020 fold_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5022 if (expr
== NULL_TREE
)
5025 /* If we're in a template, but EXPR isn't value dependent, simplify
5026 it. We're supposed to treat:
5028 template <typename T> void f(T[1 + 1]);
5029 template <typename T> void f(T[2]);
5031 as two declarations of the same function, for example. */
5032 if (processing_template_decl
5033 && !type_dependent_expression_p (expr
)
5034 && potential_constant_expression (expr
)
5035 && !value_dependent_expression_p (expr
))
5037 HOST_WIDE_INT saved_processing_template_decl
;
5039 saved_processing_template_decl
= processing_template_decl
;
5040 processing_template_decl
= 0;
5041 expr
= tsubst_copy_and_build (expr
,
5044 /*in_decl=*/NULL_TREE
,
5045 /*function_p=*/false,
5046 /*integral_constant_expression_p=*/true);
5047 processing_template_decl
= saved_processing_template_decl
;
5053 fold_non_dependent_expr (tree expr
)
5055 return fold_non_dependent_expr_sfinae (expr
, tf_error
);
5058 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5059 template declaration, or a TYPE_DECL for an alias declaration. */
5062 alias_type_or_template_p (tree t
)
5066 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5069 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5070 || DECL_ALIAS_TEMPLATE_P (t
));
5073 /* Return TRUE iff is a specialization of an alias template. */
5076 alias_template_specialization_p (const_tree t
)
5082 && TYPE_TEMPLATE_INFO (t
)
5083 && PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (t
))
5084 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (t
)));
5087 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5088 must be a function or a pointer-to-function type, as specified
5089 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5090 and check that the resulting function has external linkage. */
5093 convert_nontype_argument_function (tree type
, tree expr
)
5097 linkage_kind linkage
;
5099 fn
= instantiate_type (type
, fns
, tf_none
);
5100 if (fn
== error_mark_node
)
5101 return error_mark_node
;
5104 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5105 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5106 if (BASELINK_P (fn_no_ptr
))
5107 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5109 /* [temp.arg.nontype]/1
5111 A template-argument for a non-type, non-template template-parameter
5114 -- the address of an object or function with external [C++11: or
5115 internal] linkage. */
5117 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5119 error ("%qE is not a valid template argument for type %qT", expr
, type
);
5120 if (TREE_CODE (type
) == POINTER_TYPE
)
5121 error ("it must be the address of a function with external linkage");
5123 error ("it must be the name of a function with external linkage");
5127 linkage
= decl_linkage (fn_no_ptr
);
5128 if (cxx_dialect
>= cxx0x
? linkage
== lk_none
: linkage
!= lk_external
)
5130 if (cxx_dialect
>= cxx0x
)
5131 error ("%qE is not a valid template argument for type %qT "
5132 "because %qD has no linkage",
5133 expr
, type
, fn_no_ptr
);
5135 error ("%qE is not a valid template argument for type %qT "
5136 "because %qD does not have external linkage",
5137 expr
, type
, fn_no_ptr
);
5144 /* Subroutine of convert_nontype_argument.
5145 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5146 Emit an error otherwise. */
5149 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5150 tsubst_flags_t complain
)
5153 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5155 if (cxx_dialect
>= cxx0x
&& null_member_pointer_value_p (expr
))
5157 if (complain
& tf_error
)
5159 error ("%qE is not a valid template argument for type %qT",
5161 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5166 /* Returns TRUE iff the address of OP is value-dependent.
5168 14.6.2.4 [temp.dep.temp]:
5169 A non-integral non-type template-argument is dependent if its type is
5170 dependent or it has either of the following forms
5173 and contains a nested-name-specifier which specifies a class-name that
5174 names a dependent type.
5176 We generalize this to just say that the address of a member of a
5177 dependent class is value-dependent; the above doesn't cover the
5178 address of a static data member named with an unqualified-id. */
5181 has_value_dependent_address (tree op
)
5183 /* We could use get_inner_reference here, but there's no need;
5184 this is only relevant for template non-type arguments, which
5185 can only be expressed as &id-expression. */
5188 tree ctx
= CP_DECL_CONTEXT (op
);
5189 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5196 /* The next set of functions are used for providing helpful explanatory
5197 diagnostics for failed overload resolution. Their messages should be
5198 indented by two spaces for consistency with the messages in
5202 unify_success (bool /*explain_p*/)
5208 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5211 inform (input_location
,
5212 " couldn't deduce template parameter %qD", parm
);
5217 unify_invalid (bool /*explain_p*/)
5223 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5226 inform (input_location
,
5227 " types %qT and %qT have incompatible cv-qualifiers",
5233 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5236 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5241 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5244 inform (input_location
,
5245 " template parameter %qD is not a parameter pack, but "
5252 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5255 inform (input_location
,
5256 " template argument %qE does not match "
5257 "pointer-to-member constant %qE",
5263 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5266 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5271 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5274 inform (input_location
,
5275 " inconsistent parameter pack deduction with %qT and %qT",
5281 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5286 inform (input_location
,
5287 " deduced conflicting types for parameter %qT (%qT and %qT)",
5288 parm
, first
, second
);
5290 inform (input_location
,
5291 " deduced conflicting values for non-type parameter "
5292 "%qE (%qE and %qE)", parm
, first
, second
);
5298 unify_vla_arg (bool explain_p
, tree arg
)
5301 inform (input_location
,
5302 " variable-sized array type %qT is not "
5303 "a valid template argument",
5309 unify_method_type_error (bool explain_p
, tree arg
)
5312 inform (input_location
,
5313 " member function type %qT is not a valid template argument",
5319 unify_arity (bool explain_p
, int have
, int wanted
)
5322 inform_n (input_location
, wanted
,
5323 " candidate expects %d argument, %d provided",
5324 " candidate expects %d arguments, %d provided",
5330 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5332 return unify_arity (explain_p
, have
, wanted
);
5336 unify_too_few_arguments (bool explain_p
, int have
, int wanted
)
5338 return unify_arity (explain_p
, have
, wanted
);
5342 unify_arg_conversion (bool explain_p
, tree to_type
,
5343 tree from_type
, tree arg
)
5346 inform (input_location
, " cannot convert %qE (type %qT) to type %qT",
5347 arg
, from_type
, to_type
);
5352 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5353 tree parm
, tree arg
)
5358 case tbr_ambiguous_baseclass
:
5359 inform (input_location
, " %qT is an ambiguous base class of %qT",
5363 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5370 unify_inconsistent_template_template_parameters (bool explain_p
)
5373 inform (input_location
,
5374 " template parameters of a template template argument are "
5375 "inconsistent with other deduced template arguments");
5380 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5383 inform (input_location
,
5384 " can't deduce a template for %qT from non-template type %qT",
5390 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5393 inform (input_location
,
5394 " template argument %qE does not match %qD", arg
, parm
);
5399 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5402 inform (input_location
,
5403 " could not resolve address from overloaded function %qE",
5408 /* Attempt to convert the non-type template parameter EXPR to the
5409 indicated TYPE. If the conversion is successful, return the
5410 converted value. If the conversion is unsuccessful, return
5411 NULL_TREE if we issued an error message, or error_mark_node if we
5412 did not. We issue error messages for out-and-out bad template
5413 parameters, but not simply because the conversion failed, since we
5414 might be just trying to do argument deduction. Both TYPE and EXPR
5415 must be non-dependent.
5417 The conversion follows the special rules described in
5418 [temp.arg.nontype], and it is much more strict than an implicit
5421 This function is called twice for each template argument (see
5422 lookup_template_class for a more accurate description of this
5423 problem). This means that we need to handle expressions which
5424 are not valid in a C++ source, but can be created from the
5425 first call (for instance, casts to perform conversions). These
5426 hacks can go away after we fix the double coercion problem. */
5429 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5433 /* Detect immediately string literals as invalid non-type argument.
5434 This special-case is not needed for correctness (we would easily
5435 catch this later), but only to provide better diagnostic for this
5436 common user mistake. As suggested by DR 100, we do not mention
5437 linkage issues in the diagnostic as this is not the point. */
5438 /* FIXME we're making this OK. */
5439 if (TREE_CODE (expr
) == STRING_CST
)
5441 if (complain
& tf_error
)
5442 error ("%qE is not a valid template argument for type %qT "
5443 "because string literals can never be used in this context",
5448 /* Add the ADDR_EXPR now for the benefit of
5449 value_dependent_expression_p. */
5450 if (TYPE_PTROBV_P (type
)
5451 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5453 expr
= decay_conversion (expr
, complain
);
5454 if (expr
== error_mark_node
)
5455 return error_mark_node
;
5458 /* If we are in a template, EXPR may be non-dependent, but still
5459 have a syntactic, rather than semantic, form. For example, EXPR
5460 might be a SCOPE_REF, rather than the VAR_DECL to which the
5461 SCOPE_REF refers. Preserving the qualifying scope is necessary
5462 so that access checking can be performed when the template is
5463 instantiated -- but here we need the resolved form so that we can
5464 convert the argument. */
5465 if (TYPE_REF_OBJ_P (type
)
5466 && has_value_dependent_address (expr
))
5467 /* If we want the address and it's value-dependent, don't fold. */;
5468 else if (!type_unknown_p (expr
))
5469 expr
= fold_non_dependent_expr_sfinae (expr
, complain
);
5470 if (error_operand_p (expr
))
5471 return error_mark_node
;
5472 expr_type
= TREE_TYPE (expr
);
5473 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5474 expr
= mark_lvalue_use (expr
);
5476 expr
= mark_rvalue_use (expr
);
5478 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5479 to a non-type argument of "nullptr". */
5480 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5481 expr
= convert (type
, expr
);
5483 /* In C++11, integral or enumeration non-type template arguments can be
5484 arbitrary constant expressions. Pointer and pointer to
5485 member arguments can be general constant expressions that evaluate
5486 to a null value, but otherwise still need to be of a specific form. */
5487 if (cxx_dialect
>= cxx0x
)
5489 if (TREE_CODE (expr
) == PTRMEM_CST
)
5490 /* A PTRMEM_CST is already constant, and a valid template
5491 argument for a parameter of pointer to member type, we just want
5492 to leave it in that form rather than lower it to a
5494 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5495 expr
= maybe_constant_value (expr
);
5496 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5498 tree folded
= maybe_constant_value (expr
);
5499 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5500 : null_member_pointer_value_p (folded
))
5505 /* HACK: Due to double coercion, we can get a
5506 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5507 which is the tree that we built on the first call (see
5508 below when coercing to reference to object or to reference to
5509 function). We just strip everything and get to the arg.
5510 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5512 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5514 tree probe_type
, probe
= expr
;
5515 if (REFERENCE_REF_P (probe
))
5516 probe
= TREE_OPERAND (probe
, 0);
5517 probe_type
= TREE_TYPE (probe
);
5518 if (TREE_CODE (probe
) == NOP_EXPR
)
5520 /* ??? Maybe we could use convert_from_reference here, but we
5521 would need to relax its constraints because the NOP_EXPR
5522 could actually change the type to something more cv-qualified,
5523 and this is not folded by convert_from_reference. */
5524 tree addr
= TREE_OPERAND (probe
, 0);
5525 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5526 && TREE_CODE (addr
) == ADDR_EXPR
5527 && TREE_CODE (TREE_TYPE (addr
)) == POINTER_TYPE
5528 && (same_type_ignoring_top_level_qualifiers_p
5529 (TREE_TYPE (probe_type
),
5530 TREE_TYPE (TREE_TYPE (addr
)))))
5532 expr
= TREE_OPERAND (addr
, 0);
5533 expr_type
= TREE_TYPE (expr
);
5538 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5539 parameter is a pointer to object, through decay and
5540 qualification conversion. Let's strip everything. */
5541 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5544 gcc_assert (TREE_CODE (expr
) == ADDR_EXPR
);
5545 gcc_assert (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
);
5546 /* Skip the ADDR_EXPR only if it is part of the decay for
5547 an array. Otherwise, it is part of the original argument
5548 in the source code. */
5549 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == ARRAY_TYPE
)
5550 expr
= TREE_OPERAND (expr
, 0);
5551 expr_type
= TREE_TYPE (expr
);
5554 /* [temp.arg.nontype]/5, bullet 1
5556 For a non-type template-parameter of integral or enumeration type,
5557 integral promotions (_conv.prom_) and integral conversions
5558 (_conv.integral_) are applied. */
5559 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5561 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5562 t
= maybe_constant_value (t
);
5563 if (t
!= error_mark_node
)
5566 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5567 return error_mark_node
;
5569 /* Notice that there are constant expressions like '4 % 0' which
5570 do not fold into integer constants. */
5571 if (TREE_CODE (expr
) != INTEGER_CST
)
5573 if (complain
& tf_error
)
5575 int errs
= errorcount
, warns
= warningcount
;
5576 if (processing_template_decl
5577 && !require_potential_constant_expression (expr
))
5579 expr
= cxx_constant_value (expr
);
5580 if (errorcount
> errs
|| warningcount
> warns
)
5581 inform (EXPR_LOC_OR_HERE (expr
),
5582 "in template argument for type %qT ", type
);
5583 if (expr
== error_mark_node
)
5585 /* else cxx_constant_value complained but gave us
5586 a real constant, so go ahead. */
5587 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
5593 /* [temp.arg.nontype]/5, bullet 2
5595 For a non-type template-parameter of type pointer to object,
5596 qualification conversions (_conv.qual_) and the array-to-pointer
5597 conversion (_conv.array_) are applied. */
5598 else if (TYPE_PTROBV_P (type
))
5600 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5602 A template-argument for a non-type, non-template template-parameter
5603 shall be one of: [...]
5605 -- the name of a non-type template-parameter;
5606 -- the address of an object or function with external linkage, [...]
5607 expressed as "& id-expression" where the & is optional if the name
5608 refers to a function or array, or if the corresponding
5609 template-parameter is a reference.
5611 Here, we do not care about functions, as they are invalid anyway
5612 for a parameter of type pointer-to-object. */
5614 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
5615 /* Non-type template parameters are OK. */
5617 else if (cxx_dialect
>= cxx0x
&& integer_zerop (expr
))
5618 /* Null pointer values are OK in C++11. */;
5619 else if (TREE_CODE (expr
) != ADDR_EXPR
5620 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
5622 if (TREE_CODE (expr
) == VAR_DECL
)
5624 error ("%qD is not a valid template argument "
5625 "because %qD is a variable, not the address of "
5630 /* Other values, like integer constants, might be valid
5631 non-type arguments of some other type. */
5632 return error_mark_node
;
5638 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
5639 ? TREE_OPERAND (expr
, 0) : expr
);
5640 if (TREE_CODE (decl
) != VAR_DECL
)
5642 error ("%qE is not a valid template argument of type %qT "
5643 "because %qE is not a variable",
5647 else if (cxx_dialect
< cxx0x
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
5649 error ("%qE is not a valid template argument of type %qT "
5650 "because %qD does not have external linkage",
5654 else if (cxx_dialect
>= cxx0x
&& decl_linkage (decl
) == lk_none
)
5656 error ("%qE is not a valid template argument of type %qT "
5657 "because %qD has no linkage",
5663 expr
= decay_conversion (expr
, complain
);
5664 if (expr
== error_mark_node
)
5665 return error_mark_node
;
5667 expr
= perform_qualification_conversions (type
, expr
);
5668 if (expr
== error_mark_node
)
5669 return error_mark_node
;
5671 /* [temp.arg.nontype]/5, bullet 3
5673 For a non-type template-parameter of type reference to object, no
5674 conversions apply. The type referred to by the reference may be more
5675 cv-qualified than the (otherwise identical) type of the
5676 template-argument. The template-parameter is bound directly to the
5677 template-argument, which must be an lvalue. */
5678 else if (TYPE_REF_OBJ_P (type
))
5680 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
5682 return error_mark_node
;
5684 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
5686 error ("%qE is not a valid template argument for type %qT "
5687 "because of conflicts in cv-qualification", expr
, type
);
5691 if (!real_lvalue_p (expr
))
5693 error ("%qE is not a valid template argument for type %qT "
5694 "because it is not an lvalue", expr
, type
);
5698 /* [temp.arg.nontype]/1
5700 A template-argument for a non-type, non-template template-parameter
5701 shall be one of: [...]
5703 -- the address of an object or function with external linkage. */
5704 if (TREE_CODE (expr
) == INDIRECT_REF
5705 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
5707 expr
= TREE_OPERAND (expr
, 0);
5710 error ("%q#D is not a valid template argument for type %qT "
5711 "because a reference variable does not have a constant "
5712 "address", expr
, type
);
5719 error ("%qE is not a valid template argument for type %qT "
5720 "because it is not an object with external linkage",
5725 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
5727 error ("%qE is not a valid template argument for type %qT "
5728 "because object %qD has not external linkage",
5733 expr
= build_nop (type
, build_address (expr
));
5735 /* [temp.arg.nontype]/5, bullet 4
5737 For a non-type template-parameter of type pointer to function, only
5738 the function-to-pointer conversion (_conv.func_) is applied. If the
5739 template-argument represents a set of overloaded functions (or a
5740 pointer to such), the matching function is selected from the set
5742 else if (TYPE_PTRFN_P (type
))
5744 /* If the argument is a template-id, we might not have enough
5745 context information to decay the pointer. */
5746 if (!type_unknown_p (expr_type
))
5748 expr
= decay_conversion (expr
, complain
);
5749 if (expr
== error_mark_node
)
5750 return error_mark_node
;
5753 if (cxx_dialect
>= cxx0x
&& integer_zerop (expr
))
5754 /* Null pointer values are OK in C++11. */
5755 return perform_qualification_conversions (type
, expr
);
5757 expr
= convert_nontype_argument_function (type
, expr
);
5758 if (!expr
|| expr
== error_mark_node
)
5761 /* [temp.arg.nontype]/5, bullet 5
5763 For a non-type template-parameter of type reference to function, no
5764 conversions apply. If the template-argument represents a set of
5765 overloaded functions, the matching function is selected from the set
5767 else if (TYPE_REFFN_P (type
))
5769 if (TREE_CODE (expr
) == ADDR_EXPR
)
5771 error ("%qE is not a valid template argument for type %qT "
5772 "because it is a pointer", expr
, type
);
5773 inform (input_location
, "try using %qE instead", TREE_OPERAND (expr
, 0));
5777 expr
= convert_nontype_argument_function (TREE_TYPE (type
), expr
);
5778 if (!expr
|| expr
== error_mark_node
)
5781 expr
= build_nop (type
, build_address (expr
));
5783 /* [temp.arg.nontype]/5, bullet 6
5785 For a non-type template-parameter of type pointer to member function,
5786 no conversions apply. If the template-argument represents a set of
5787 overloaded member functions, the matching member function is selected
5788 from the set (_over.over_). */
5789 else if (TYPE_PTRMEMFUNC_P (type
))
5791 expr
= instantiate_type (type
, expr
, tf_none
);
5792 if (expr
== error_mark_node
)
5793 return error_mark_node
;
5795 /* [temp.arg.nontype] bullet 1 says the pointer to member
5796 expression must be a pointer-to-member constant. */
5797 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
5798 return error_mark_node
;
5800 /* There is no way to disable standard conversions in
5801 resolve_address_of_overloaded_function (called by
5802 instantiate_type). It is possible that the call succeeded by
5803 converting &B::I to &D::I (where B is a base of D), so we need
5804 to reject this conversion here.
5806 Actually, even if there was a way to disable standard conversions,
5807 it would still be better to reject them here so that we can
5808 provide a superior diagnostic. */
5809 if (!same_type_p (TREE_TYPE (expr
), type
))
5811 error ("%qE is not a valid template argument for type %qT "
5812 "because it is of type %qT", expr
, type
,
5814 /* If we are just one standard conversion off, explain. */
5815 if (can_convert (type
, TREE_TYPE (expr
), complain
))
5816 inform (input_location
,
5817 "standard conversions are not allowed in this context");
5821 /* [temp.arg.nontype]/5, bullet 7
5823 For a non-type template-parameter of type pointer to data member,
5824 qualification conversions (_conv.qual_) are applied. */
5825 else if (TYPE_PTRDATAMEM_P (type
))
5827 /* [temp.arg.nontype] bullet 1 says the pointer to member
5828 expression must be a pointer-to-member constant. */
5829 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
5830 return error_mark_node
;
5832 expr
= perform_qualification_conversions (type
, expr
);
5833 if (expr
== error_mark_node
)
5836 else if (NULLPTR_TYPE_P (type
))
5838 if (expr
!= nullptr_node
)
5840 error ("%qE is not a valid template argument for type %qT "
5841 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
5846 /* A template non-type parameter must be one of the above. */
5850 /* Sanity check: did we actually convert the argument to the
5852 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5853 (type
, TREE_TYPE (expr
)));
5857 /* Subroutine of coerce_template_template_parms, which returns 1 if
5858 PARM_PARM and ARG_PARM match using the rule for the template
5859 parameters of template template parameters. Both PARM and ARG are
5860 template parameters; the rest of the arguments are the same as for
5861 coerce_template_template_parms.
5864 coerce_template_template_parm (tree parm
,
5866 tsubst_flags_t complain
,
5870 if (arg
== NULL_TREE
|| arg
== error_mark_node
5871 || parm
== NULL_TREE
|| parm
== error_mark_node
)
5874 if (TREE_CODE (arg
) != TREE_CODE (parm
))
5877 switch (TREE_CODE (parm
))
5880 /* We encounter instantiations of templates like
5881 template <template <template <class> class> class TT>
5884 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
5885 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
5887 if (!coerce_template_template_parms
5888 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
5894 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
5895 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
5896 /* Argument is a parameter pack but parameter is not. */
5901 /* The tsubst call is used to handle cases such as
5903 template <int> class C {};
5904 template <class T, template <T> class TT> class D {};
5907 i.e. the parameter list of TT depends on earlier parameters. */
5908 if (!uses_template_parms (TREE_TYPE (arg
))
5910 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
5914 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
5915 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
5916 /* Argument is a parameter pack but parameter is not. */
5929 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
5930 template template parameters. Both PARM_PARMS and ARG_PARMS are
5931 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
5934 Consider the example:
5935 template <class T> class A;
5936 template<template <class U> class TT> class B;
5938 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
5939 the parameters to A, and OUTER_ARGS contains A. */
5942 coerce_template_template_parms (tree parm_parms
,
5944 tsubst_flags_t complain
,
5948 int nparms
, nargs
, i
;
5952 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
5953 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
5955 nparms
= TREE_VEC_LENGTH (parm_parms
);
5956 nargs
= TREE_VEC_LENGTH (arg_parms
);
5958 /* Determine whether we have a parameter pack at the end of the
5959 template template parameter's template parameter list. */
5960 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
5962 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
5964 if (parm
== error_mark_node
)
5967 switch (TREE_CODE (parm
))
5971 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
5976 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
5986 && !(variadic_p
&& nargs
>= nparms
- 1))
5989 /* Check all of the template parameters except the parameter pack at
5990 the end (if any). */
5991 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
5993 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
5994 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
5997 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
5998 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6000 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6008 /* Check each of the template parameters in the template
6009 argument against the template parameter pack at the end of
6010 the template template parameter. */
6011 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6014 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6016 for (; i
< nargs
; ++i
)
6018 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6021 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6023 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6032 /* Verifies that the deduced template arguments (in TARGS) for the
6033 template template parameters (in TPARMS) represent valid bindings,
6034 by comparing the template parameter list of each template argument
6035 to the template parameter list of its corresponding template
6036 template parameter, in accordance with DR150. This
6037 routine can only be called after all template arguments have been
6038 deduced. It will return TRUE if all of the template template
6039 parameter bindings are okay, FALSE otherwise. */
6041 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6043 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6046 /* We're dealing with template parms in this process. */
6047 ++processing_template_decl
;
6049 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6051 for (i
= 0; i
< ntparms
; ++i
)
6053 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6054 tree targ
= TREE_VEC_ELT (targs
, i
);
6056 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6058 tree packed_args
= NULL_TREE
;
6061 if (ARGUMENT_PACK_P (targ
))
6063 /* Look inside the argument pack. */
6064 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6065 len
= TREE_VEC_LENGTH (packed_args
);
6068 for (idx
= 0; idx
< len
; ++idx
)
6070 tree targ_parms
= NULL_TREE
;
6073 /* Extract the next argument from the argument
6075 targ
= TREE_VEC_ELT (packed_args
, idx
);
6077 if (PACK_EXPANSION_P (targ
))
6078 /* Look at the pattern of the pack expansion. */
6079 targ
= PACK_EXPANSION_PATTERN (targ
);
6081 /* Extract the template parameters from the template
6083 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6084 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6085 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6086 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6088 /* Verify that we can coerce the template template
6089 parameters from the template argument to the template
6090 parameter. This requires an exact match. */
6092 && !coerce_template_template_parms
6093 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6108 --processing_template_decl
;
6112 /* Since type attributes aren't mangled, we need to strip them from
6113 template type arguments. */
6116 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6119 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6121 mv
= TYPE_MAIN_VARIANT (arg
);
6122 arg
= strip_typedefs (arg
);
6123 if (TYPE_ALIGN (arg
) != TYPE_ALIGN (mv
)
6124 || TYPE_ATTRIBUTES (arg
) != TYPE_ATTRIBUTES (mv
))
6126 if (complain
& tf_warning
)
6127 warning (0, "ignoring attributes on template argument %qT", arg
);
6128 arg
= build_aligned_type (arg
, TYPE_ALIGN (mv
));
6129 arg
= cp_build_type_attribute_variant (arg
, TYPE_ATTRIBUTES (mv
));
6134 /* Convert the indicated template ARG as necessary to match the
6135 indicated template PARM. Returns the converted ARG, or
6136 error_mark_node if the conversion was unsuccessful. Error and
6137 warning messages are issued under control of COMPLAIN. This
6138 conversion is for the Ith parameter in the parameter list. ARGS is
6139 the full set of template arguments deduced so far. */
6142 convert_template_argument (tree parm
,
6145 tsubst_flags_t complain
,
6151 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6153 if (TREE_CODE (arg
) == TREE_LIST
6154 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6156 /* The template argument was the name of some
6157 member function. That's usually
6158 invalid, but static members are OK. In any
6159 case, grab the underlying fields/functions
6160 and issue an error later if required. */
6161 orig_arg
= TREE_VALUE (arg
);
6162 TREE_TYPE (arg
) = unknown_type_node
;
6167 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6168 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6169 || requires_tmpl_type
);
6171 /* When determining whether an argument pack expansion is a template,
6172 look at the pattern. */
6173 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6174 arg
= PACK_EXPANSION_PATTERN (arg
);
6176 /* Deal with an injected-class-name used as a template template arg. */
6177 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6179 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6180 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6182 if (cxx_dialect
>= cxx0x
)
6183 /* OK under DR 1004. */;
6184 else if (complain
& tf_warning_or_error
)
6185 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6186 " used as template template argument", TYPE_NAME (arg
));
6187 else if (flag_pedantic_errors
)
6195 ((TREE_CODE (arg
) == TEMPLATE_DECL
6196 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6197 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6198 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6199 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6202 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6203 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6204 arg
= TYPE_STUB_DECL (arg
);
6206 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6208 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6209 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6211 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6213 if (complain
& tf_error
)
6214 error ("invalid use of destructor %qE as a type", orig_arg
);
6215 return error_mark_node
;
6218 permerror (input_location
,
6219 "to refer to a type member of a template parameter, "
6220 "use %<typename %E%>", orig_arg
);
6222 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6223 TREE_OPERAND (arg
, 1),
6229 if (is_type
!= requires_type
)
6233 if (complain
& tf_error
)
6235 error ("type/value mismatch at argument %d in template "
6236 "parameter list for %qD",
6239 error (" expected a constant of type %qT, got %qT",
6241 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6242 else if (requires_tmpl_type
)
6243 error (" expected a class template, got %qE", orig_arg
);
6245 error (" expected a type, got %qE", orig_arg
);
6248 return error_mark_node
;
6250 if (is_tmpl_type
^ requires_tmpl_type
)
6252 if (in_decl
&& (complain
& tf_error
))
6254 error ("type/value mismatch at argument %d in template "
6255 "parameter list for %qD",
6258 error (" expected a type, got %qT", DECL_NAME (arg
));
6260 error (" expected a class template, got %qT", orig_arg
);
6262 return error_mark_node
;
6267 if (requires_tmpl_type
)
6269 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6271 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6272 /* The number of argument required is not known yet.
6273 Just accept it for now. */
6274 val
= TREE_TYPE (arg
);
6277 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6280 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6282 if (coerce_template_template_parms (parmparm
, argparm
,
6288 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6290 if (val
!= error_mark_node
)
6292 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6293 val
= TREE_TYPE (val
);
6294 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6295 val
= make_pack_expansion (val
);
6300 if (in_decl
&& (complain
& tf_error
))
6302 error ("type/value mismatch at argument %d in "
6303 "template parameter list for %qD",
6305 error (" expected a template of type %qD, got %qT",
6309 val
= error_mark_node
;
6315 /* We only form one instance of each template specialization.
6316 Therefore, if we use a non-canonical variant (i.e., a
6317 typedef), any future messages referring to the type will use
6318 the typedef, which is confusing if those future uses do not
6319 themselves also use the typedef. */
6321 val
= canonicalize_type_argument (val
, complain
);
6325 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6327 if (invalid_nontype_parm_type_p (t
, complain
))
6328 return error_mark_node
;
6330 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6332 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6336 /* Not sure if this is reachable, but it doesn't hurt
6338 error ("type mismatch in nontype parameter pack");
6339 val
= error_mark_node
;
6342 else if (!uses_template_parms (orig_arg
) && !uses_template_parms (t
))
6343 /* We used to call digest_init here. However, digest_init
6344 will report errors, which we don't want when complain
6345 is zero. More importantly, digest_init will try too
6346 hard to convert things: for example, `0' should not be
6347 converted to pointer type at this point according to
6348 the standard. Accepting this is not merely an
6349 extension, since deciding whether or not these
6350 conversions can occur is part of determining which
6351 function template to call, or whether a given explicit
6352 argument specification is valid. */
6353 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6355 val
= strip_typedefs_expr (orig_arg
);
6357 if (val
== NULL_TREE
)
6358 val
= error_mark_node
;
6359 else if (val
== error_mark_node
&& (complain
& tf_error
))
6360 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6362 if (TREE_CODE (val
) == SCOPE_REF
)
6364 /* Strip typedefs from the SCOPE_REF. */
6365 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6366 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6368 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6369 QUALIFIED_NAME_IS_TEMPLATE (val
));
6376 /* Coerces the remaining template arguments in INNER_ARGS (from
6377 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6378 Returns the coerced argument pack. PARM_IDX is the position of this
6379 parameter in the template parameter list. ARGS is the original
6380 template argument list. */
6382 coerce_template_parameter_pack (tree parms
,
6390 tsubst_flags_t complain
)
6392 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6393 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6396 tree packed_types
= NULL_TREE
;
6398 if (arg_idx
> nargs
)
6401 packed_args
= make_tree_vec (nargs
- arg_idx
);
6403 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
6404 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm
))))
6406 /* When the template parameter is a non-type template
6407 parameter pack whose type uses parameter packs, we need
6408 to look at each of the template arguments
6409 separately. Build a vector of the types for these
6410 non-type template parameters in PACKED_TYPES. */
6412 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm
)));
6413 packed_types
= tsubst_pack_expansion (expansion
, args
,
6416 if (packed_types
== error_mark_node
)
6417 return error_mark_node
;
6419 /* Check that we have the right number of arguments. */
6421 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
))
6422 && nargs
- arg_idx
!= TREE_VEC_LENGTH (packed_types
))
6425 = TREE_VEC_LENGTH (parms
) - 1 + TREE_VEC_LENGTH (packed_types
);
6426 error ("wrong number of template arguments (%d, should be %d)",
6427 nargs
, needed_parms
);
6428 return error_mark_node
;
6431 /* If we aren't able to check the actual arguments now
6432 (because they haven't been expanded yet), we can at least
6433 verify that all of the types used for the non-type
6434 template parameter pack are, in fact, valid for non-type
6435 template parameters. */
6437 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6439 int j
, len
= TREE_VEC_LENGTH (packed_types
);
6440 for (j
= 0; j
< len
; ++j
)
6442 tree t
= TREE_VEC_ELT (packed_types
, j
);
6443 if (invalid_nontype_parm_type_p (t
, complain
))
6444 return error_mark_node
;
6449 /* Convert the remaining arguments, which will be a part of the
6450 parameter pack "parm". */
6451 for (; arg_idx
< nargs
; ++arg_idx
)
6453 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6454 tree actual_parm
= TREE_VALUE (parm
);
6456 if (packed_types
&& !PACK_EXPANSION_P (arg
))
6458 /* When we have a vector of types (corresponding to the
6459 non-type template parameter pack that uses parameter
6460 packs in its type, as mention above), and the
6461 argument is not an expansion (which expands to a
6462 currently unknown number of arguments), clone the
6463 parm and give it the next type in PACKED_TYPES. */
6464 actual_parm
= copy_node (actual_parm
);
6465 TREE_TYPE (actual_parm
) =
6466 TREE_VEC_ELT (packed_types
, arg_idx
- parm_idx
);
6469 if (arg
== error_mark_node
)
6471 if (complain
& tf_error
)
6472 error ("template argument %d is invalid", arg_idx
+ 1);
6475 arg
= convert_template_argument (actual_parm
,
6476 arg
, new_args
, complain
, parm_idx
,
6478 if (arg
== error_mark_node
)
6480 TREE_VEC_ELT (packed_args
, arg_idx
- parm_idx
) = arg
;
6483 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6484 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6485 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6488 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6489 TREE_TYPE (argument_pack
)
6490 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6491 TREE_CONSTANT (argument_pack
) = 1;
6494 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6495 #ifdef ENABLE_CHECKING
6496 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6497 TREE_VEC_LENGTH (packed_args
));
6499 return argument_pack
;
6502 /* Returns true if the template argument vector ARGS contains
6503 any pack expansions, false otherwise. */
6506 any_pack_expanson_args_p (tree args
)
6510 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6511 if (PACK_EXPANSION_P (TREE_VEC_ELT (args
, i
)))
6516 /* Convert all template arguments to their appropriate types, and
6517 return a vector containing the innermost resulting template
6518 arguments. If any error occurs, return error_mark_node. Error and
6519 warning messages are issued under control of COMPLAIN.
6521 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6522 for arguments not specified in ARGS. Otherwise, if
6523 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6524 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6525 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6529 coerce_template_parms (tree parms
,
6532 tsubst_flags_t complain
,
6533 bool require_all_args
,
6534 bool use_default_args
)
6536 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6539 tree new_inner_args
;
6540 int saved_unevaluated_operand
;
6541 int saved_inhibit_evaluation_warnings
;
6543 /* When used as a boolean value, indicates whether this is a
6544 variadic template parameter list. Since it's an int, we can also
6545 subtract it from nparms to get the number of non-variadic
6548 int post_variadic_parms
= 0;
6550 if (args
== error_mark_node
)
6551 return error_mark_node
;
6553 nparms
= TREE_VEC_LENGTH (parms
);
6555 /* Determine if there are any parameter packs. */
6556 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
6558 tree tparm
= TREE_VALUE (TREE_VEC_ELT (parms
, parm_idx
));
6560 ++post_variadic_parms
;
6561 if (template_parameter_pack_p (tparm
))
6565 inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
6566 /* If there are no parameters that follow a parameter pack, we need to
6567 expand any argument packs so that we can deduce a parameter pack from
6568 some non-packed args followed by an argument pack, as in variadic85.C.
6569 If there are such parameters, we need to leave argument packs intact
6570 so the arguments are assigned properly. This can happen when dealing
6571 with a nested class inside a partial specialization of a class
6572 template, as in variadic92.C, or when deducing a template parameter pack
6573 from a sub-declarator, as in variadic114.C. */
6574 if (!post_variadic_parms
)
6575 inner_args
= expand_template_argument_pack (inner_args
);
6577 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6578 if ((nargs
> nparms
&& !variadic_p
)
6579 || (nargs
< nparms
- variadic_p
6581 && !any_pack_expanson_args_p (inner_args
)
6582 && (!use_default_args
6583 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
6584 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
6586 if (complain
& tf_error
)
6590 nparms
-= variadic_p
;
6591 error ("wrong number of template arguments "
6592 "(%d, should be %d or more)", nargs
, nparms
);
6595 error ("wrong number of template arguments "
6596 "(%d, should be %d)", nargs
, nparms
);
6599 error ("provided for %q+D", in_decl
);
6602 return error_mark_node
;
6605 /* We need to evaluate the template arguments, even though this
6606 template-id may be nested within a "sizeof". */
6607 saved_unevaluated_operand
= cp_unevaluated_operand
;
6608 cp_unevaluated_operand
= 0;
6609 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6610 c_inhibit_evaluation_warnings
= 0;
6611 new_inner_args
= make_tree_vec (nparms
);
6612 new_args
= add_outermost_template_args (args
, new_inner_args
);
6613 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
6618 /* Get the Ith template parameter. */
6619 parm
= TREE_VEC_ELT (parms
, parm_idx
);
6621 if (parm
== error_mark_node
)
6623 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
6627 /* Calculate the next argument. */
6628 if (arg_idx
< nargs
)
6629 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6633 if (template_parameter_pack_p (TREE_VALUE (parm
))
6634 && !(arg
&& ARGUMENT_PACK_P (arg
)))
6636 /* All remaining arguments will be placed in the
6637 template parameter pack PARM. */
6638 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
6639 inner_args
, arg_idx
,
6643 /* Store this argument. */
6644 if (arg
== error_mark_node
)
6646 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
6648 /* We are done with all of the arguments. */
6655 if (PACK_EXPANSION_P (arg
))
6657 /* We don't know how many args we have yet, just
6658 use the unconverted ones for now. */
6659 new_inner_args
= inner_args
;
6663 else if (require_all_args
)
6665 /* There must be a default arg in this case. */
6666 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
6668 /* The position of the first default template argument,
6669 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6671 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
6672 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
, arg_idx
);
6677 if (arg
== error_mark_node
)
6679 if (complain
& tf_error
)
6680 error ("template argument %d is invalid", arg_idx
+ 1);
6683 /* This only occurs if there was an error in the template
6684 parameter list itself (which we would already have
6685 reported) that we are trying to recover from, e.g., a class
6686 template with a parameter list such as
6687 template<typename..., typename>. */
6690 arg
= convert_template_argument (TREE_VALUE (parm
),
6691 arg
, new_args
, complain
,
6694 if (arg
== error_mark_node
)
6696 TREE_VEC_ELT (new_inner_args
, arg_idx
) = arg
;
6698 cp_unevaluated_operand
= saved_unevaluated_operand
;
6699 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
6702 return error_mark_node
;
6704 #ifdef ENABLE_CHECKING
6705 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
6706 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
6707 TREE_VEC_LENGTH (new_inner_args
));
6710 return new_inner_args
;
6713 /* Like coerce_template_parms. If PARMS represents all template
6714 parameters levels, this function returns a vector of vectors
6715 representing all the resulting argument levels. Note that in this
6716 case, only the innermost arguments are coerced because the
6717 outermost ones are supposed to have been coerced already.
6719 Otherwise, if PARMS represents only (the innermost) vector of
6720 parameters, this function returns a vector containing just the
6721 innermost resulting arguments. */
6724 coerce_innermost_template_parms (tree parms
,
6727 tsubst_flags_t complain
,
6728 bool require_all_args
,
6729 bool use_default_args
)
6731 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
6732 int args_depth
= TMPL_ARGS_DEPTH (args
);
6735 if (parms_depth
> 1)
6737 coerced_args
= make_tree_vec (parms_depth
);
6741 for (level
= parms
, cur_depth
= parms_depth
;
6742 parms_depth
> 0 && level
!= NULL_TREE
;
6743 level
= TREE_CHAIN (level
), --cur_depth
)
6746 if (cur_depth
== args_depth
)
6747 l
= coerce_template_parms (TREE_VALUE (level
),
6748 args
, in_decl
, complain
,
6752 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
6754 if (l
== error_mark_node
)
6755 return error_mark_node
;
6757 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
6761 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
6762 args
, in_decl
, complain
,
6765 return coerced_args
;
6768 /* Returns 1 if template args OT and NT are equivalent. */
6771 template_args_equal (tree ot
, tree nt
)
6775 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
6778 if (TREE_CODE (nt
) == TREE_VEC
)
6779 /* For member templates */
6780 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
6781 else if (PACK_EXPANSION_P (ot
))
6782 return (PACK_EXPANSION_P (nt
)
6783 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
6784 PACK_EXPANSION_PATTERN (nt
))
6785 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
6786 PACK_EXPANSION_EXTRA_ARGS (nt
)));
6787 else if (ARGUMENT_PACK_P (ot
))
6792 if (!ARGUMENT_PACK_P (nt
))
6795 opack
= ARGUMENT_PACK_ARGS (ot
);
6796 npack
= ARGUMENT_PACK_ARGS (nt
);
6797 len
= TREE_VEC_LENGTH (opack
);
6798 if (TREE_VEC_LENGTH (npack
) != len
)
6800 for (i
= 0; i
< len
; ++i
)
6801 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
6802 TREE_VEC_ELT (npack
, i
)))
6806 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
6808 /* We get here probably because we are in the middle of substituting
6809 into the pattern of a pack expansion. In that case the
6810 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
6811 interested in. So we want to use the initial pack argument for
6813 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
6814 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
6815 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
6816 return template_args_equal (ot
, nt
);
6818 else if (TYPE_P (nt
))
6819 return TYPE_P (ot
) && same_type_p (ot
, nt
);
6820 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
6823 return cp_tree_equal (ot
, nt
);
6826 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
6827 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
6828 NEWARG_PTR with the offending arguments if they are non-NULL. */
6831 comp_template_args_with_info (tree oldargs
, tree newargs
,
6832 tree
*oldarg_ptr
, tree
*newarg_ptr
)
6836 if (oldargs
== newargs
)
6839 if (!oldargs
|| !newargs
)
6842 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
6845 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
6847 tree nt
= TREE_VEC_ELT (newargs
, i
);
6848 tree ot
= TREE_VEC_ELT (oldargs
, i
);
6850 if (! template_args_equal (ot
, nt
))
6852 if (oldarg_ptr
!= NULL
)
6854 if (newarg_ptr
!= NULL
)
6862 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
6863 of template arguments. Returns 0 otherwise. */
6866 comp_template_args (tree oldargs
, tree newargs
)
6868 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
6872 add_pending_template (tree d
)
6874 tree ti
= (TYPE_P (d
)
6875 ? CLASSTYPE_TEMPLATE_INFO (d
)
6876 : DECL_TEMPLATE_INFO (d
));
6877 struct pending_template
*pt
;
6880 if (TI_PENDING_TEMPLATE_FLAG (ti
))
6883 /* We are called both from instantiate_decl, where we've already had a
6884 tinst_level pushed, and instantiate_template, where we haven't.
6886 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
6889 push_tinst_level (d
);
6891 pt
= ggc_alloc_pending_template ();
6893 pt
->tinst
= current_tinst_level
;
6894 if (last_pending_template
)
6895 last_pending_template
->next
= pt
;
6897 pending_templates
= pt
;
6899 last_pending_template
= pt
;
6901 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
6908 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
6909 ARGLIST. Valid choices for FNS are given in the cp-tree.def
6910 documentation for TEMPLATE_ID_EXPR. */
6913 lookup_template_function (tree fns
, tree arglist
)
6917 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
6918 return error_mark_node
;
6920 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
6922 if (!is_overloaded_fn (fns
) && TREE_CODE (fns
) != IDENTIFIER_NODE
)
6924 error ("%q#D is not a function template", fns
);
6925 return error_mark_node
;
6928 if (BASELINK_P (fns
))
6930 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
6932 BASELINK_FUNCTIONS (fns
),
6937 type
= TREE_TYPE (fns
);
6938 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
6939 type
= unknown_type_node
;
6941 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
6944 /* Within the scope of a template class S<T>, the name S gets bound
6945 (in build_self_reference) to a TYPE_DECL for the class, not a
6946 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
6947 or one of its enclosing classes, and that type is a template,
6948 return the associated TEMPLATE_DECL. Otherwise, the original
6951 Also handle the case when DECL is a TREE_LIST of ambiguous
6952 injected-class-names from different bases. */
6955 maybe_get_template_decl_from_type_decl (tree decl
)
6957 if (decl
== NULL_TREE
)
6960 /* DR 176: A lookup that finds an injected-class-name (10.2
6961 [class.member.lookup]) can result in an ambiguity in certain cases
6962 (for example, if it is found in more than one base class). If all of
6963 the injected-class-names that are found refer to specializations of
6964 the same class template, and if the name is followed by a
6965 template-argument-list, the reference refers to the class template
6966 itself and not a specialization thereof, and is not ambiguous. */
6967 if (TREE_CODE (decl
) == TREE_LIST
)
6969 tree t
, tmpl
= NULL_TREE
;
6970 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
6972 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
6975 else if (tmpl
!= elt
)
6978 if (tmpl
&& t
== NULL_TREE
)
6984 return (decl
!= NULL_TREE
6985 && DECL_SELF_REFERENCE_P (decl
)
6986 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
6987 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
6990 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
6991 parameters, find the desired type.
6993 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
6995 IN_DECL, if non-NULL, is the template declaration we are trying to
6998 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
6999 the class we are looking up.
7001 Issue error and warning messages under control of COMPLAIN.
7003 If the template class is really a local class in a template
7004 function, then the FUNCTION_CONTEXT is the function in which it is
7007 ??? Note that this function is currently called *twice* for each
7008 template-id: the first time from the parser, while creating the
7009 incomplete type (finish_template_type), and the second type during the
7010 real instantiation (instantiate_template_class). This is surely something
7011 that we want to avoid. It also causes some problems with argument
7012 coercion (see convert_nontype_argument for more information on this). */
7015 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7016 int entering_scope
, tsubst_flags_t complain
)
7018 tree templ
= NULL_TREE
, parmlist
;
7025 if (TREE_CODE (d1
) == IDENTIFIER_NODE
)
7027 tree value
= innermost_non_namespace_value (d1
);
7028 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7033 push_decl_namespace (context
);
7034 templ
= lookup_name (d1
);
7035 templ
= maybe_get_template_decl_from_type_decl (templ
);
7037 pop_decl_namespace ();
7040 context
= DECL_CONTEXT (templ
);
7042 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7044 tree type
= TREE_TYPE (d1
);
7046 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7047 an implicit typename for the second A. Deal with it. */
7048 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7049 type
= TREE_TYPE (type
);
7051 if (CLASSTYPE_TEMPLATE_INFO (type
))
7053 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7054 d1
= DECL_NAME (templ
);
7057 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7058 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7060 templ
= TYPE_TI_TEMPLATE (d1
);
7061 d1
= DECL_NAME (templ
);
7063 else if (TREE_CODE (d1
) == TEMPLATE_DECL
7064 && DECL_TEMPLATE_RESULT (d1
)
7065 && TREE_CODE (DECL_TEMPLATE_RESULT (d1
)) == TYPE_DECL
)
7068 d1
= DECL_NAME (templ
);
7069 context
= DECL_CONTEXT (templ
);
7072 /* Issue an error message if we didn't find a template. */
7075 if (complain
& tf_error
)
7076 error ("%qT is not a template", d1
);
7077 return error_mark_node
;
7080 if (TREE_CODE (templ
) != TEMPLATE_DECL
7081 /* Make sure it's a user visible template, if it was named by
7083 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7084 && !PRIMARY_TEMPLATE_P (templ
)))
7086 if (complain
& tf_error
)
7088 error ("non-template type %qT used as a template", d1
);
7090 error ("for template declaration %q+D", in_decl
);
7092 return error_mark_node
;
7095 complain
&= ~tf_user
;
7097 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7099 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7100 template arguments */
7106 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7108 /* Consider an example where a template template parameter declared as
7110 template <class T, class U = std::allocator<T> > class TT
7112 The template parameter level of T and U are one level larger than
7113 of TT. To proper process the default argument of U, say when an
7114 instantiation `TT<int>' is seen, we need to build the full
7115 arguments containing {int} as the innermost level. Outer levels,
7116 available when not appearing as default template argument, can be
7117 obtained from the arguments of the enclosing template.
7119 Suppose that TT is later substituted with std::vector. The above
7120 instantiation is `TT<int, std::allocator<T> >' with TT at
7121 level 1, and T at level 2, while the template arguments at level 1
7122 becomes {std::vector} and the inner level 2 is {int}. */
7124 outer
= DECL_CONTEXT (templ
);
7126 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7127 else if (current_template_parms
)
7128 /* This is an argument of the current template, so we haven't set
7129 DECL_CONTEXT yet. */
7130 outer
= current_template_args ();
7133 arglist
= add_to_template_args (outer
, arglist
);
7135 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7137 /*require_all_args=*/true,
7138 /*use_default_args=*/true);
7139 if (arglist2
== error_mark_node
7140 || (!uses_template_parms (arglist2
)
7141 && check_instantiated_args (templ
, arglist2
, complain
)))
7142 return error_mark_node
;
7144 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7149 tree template_type
= TREE_TYPE (templ
);
7152 tree found
= NULL_TREE
;
7155 int is_dependent_type
;
7156 int use_partial_inst_tmpl
= false;
7158 if (template_type
== error_mark_node
)
7159 /* An error occured while building the template TEMPL, and a
7160 diagnostic has most certainly been emitted for that
7161 already. Let's propagate that error. */
7162 return error_mark_node
;
7164 gen_tmpl
= most_general_template (templ
);
7165 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7166 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7167 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7169 if (arg_depth
== 1 && parm_depth
> 1)
7171 /* We've been given an incomplete set of template arguments.
7174 template <class T> struct S1 {
7175 template <class U> struct S2 {};
7176 template <class U> struct S2<U*> {};
7179 we will be called with an ARGLIST of `U*', but the
7180 TEMPLATE will be `template <class T> template
7181 <class U> struct S1<T>::S2'. We must fill in the missing
7184 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7186 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7189 /* Now we should have enough arguments. */
7190 gcc_assert (parm_depth
== arg_depth
);
7192 /* From here on, we're only interested in the most general
7195 /* Calculate the BOUND_ARGS. These will be the args that are
7196 actually tsubst'd into the definition to create the
7200 /* We have multiple levels of arguments to coerce, at once. */
7202 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
7204 tree bound_args
= make_tree_vec (parm_depth
);
7206 for (i
= saved_depth
,
7207 t
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7208 i
> 0 && t
!= NULL_TREE
;
7209 --i
, t
= TREE_CHAIN (t
))
7212 if (i
== saved_depth
)
7213 a
= coerce_template_parms (TREE_VALUE (t
),
7216 /*require_all_args=*/true,
7217 /*use_default_args=*/true);
7219 /* Outer levels should have already been coerced. */
7220 a
= TMPL_ARGS_LEVEL (arglist
, i
);
7222 /* Don't process further if one of the levels fails. */
7223 if (a
== error_mark_node
)
7225 /* Restore the ARGLIST to its full size. */
7226 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7227 return error_mark_node
;
7230 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
7232 /* We temporarily reduce the length of the ARGLIST so
7233 that coerce_template_parms will see only the arguments
7234 corresponding to the template parameters it is
7236 TREE_VEC_LENGTH (arglist
)--;
7239 /* Restore the ARGLIST to its full size. */
7240 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7242 arglist
= bound_args
;
7246 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
7247 INNERMOST_TEMPLATE_ARGS (arglist
),
7250 /*require_all_args=*/true,
7251 /*use_default_args=*/true);
7253 if (arglist
== error_mark_node
)
7254 /* We were unable to bind the arguments. */
7255 return error_mark_node
;
7257 /* In the scope of a template class, explicit references to the
7258 template class refer to the type of the template, not any
7259 instantiation of it. For example, in:
7261 template <class T> class C { void f(C<T>); }
7263 the `C<T>' is just the same as `C'. Outside of the
7264 class, however, such a reference is an instantiation. */
7266 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7267 || currently_open_class (template_type
))
7268 /* comp_template_args is expensive, check it last. */
7269 && comp_template_args (TYPE_TI_ARGS (template_type
),
7271 return template_type
;
7273 /* If we already have this specialization, return it. */
7274 elt
.tmpl
= gen_tmpl
;
7276 hash
= hash_specialization (&elt
);
7277 entry
= (spec_entry
*) htab_find_with_hash (type_specializations
,
7283 is_dependent_type
= uses_template_parms (arglist
);
7285 /* If the deduced arguments are invalid, then the binding
7287 if (!is_dependent_type
7288 && check_instantiated_args (gen_tmpl
,
7289 INNERMOST_TEMPLATE_ARGS (arglist
),
7291 return error_mark_node
;
7293 if (!is_dependent_type
7294 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7295 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7296 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7298 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7299 DECL_NAME (gen_tmpl
),
7300 /*tag_scope=*/ts_global
);
7304 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7306 if (context
== error_mark_node
)
7307 return error_mark_node
;
7310 context
= global_namespace
;
7312 /* Create the type. */
7313 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7315 if (!is_dependent_type
)
7317 set_current_access_from_decl (TYPE_NAME (template_type
));
7318 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7319 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7320 arglist
, complain
, in_decl
),
7321 SCOPED_ENUM_P (template_type
), NULL
);
7325 /* We don't want to call start_enum for this type, since
7326 the values for the enumeration constants may involve
7327 template parameters. And, no one should be interested
7328 in the enumeration constants for such a type. */
7329 t
= cxx_make_type (ENUMERAL_TYPE
);
7330 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7332 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7333 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7334 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7336 else if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7338 /* The user referred to a specialization of an alias
7339 template represented by GEN_TMPL.
7341 [temp.alias]/2 says:
7343 When a template-id refers to the specialization of an
7344 alias template, it is equivalent to the associated
7345 type obtained by substitution of its
7346 template-arguments for the template-parameters in the
7347 type-id of the alias template. */
7349 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7350 /* Note that the call above (by indirectly calling
7351 register_specialization in tsubst_decl) registers the
7352 TYPE_DECL representing the specialization of the alias
7353 template. So next time someone substitutes ARGLIST for
7354 the template parms into the alias template (GEN_TMPL),
7355 she'll get that TYPE_DECL back. */
7357 if (t
== error_mark_node
)
7360 else if (CLASS_TYPE_P (template_type
))
7362 t
= make_class_type (TREE_CODE (template_type
));
7363 CLASSTYPE_DECLARED_CLASS (t
)
7364 = CLASSTYPE_DECLARED_CLASS (template_type
);
7365 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7366 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7368 /* A local class. Make sure the decl gets registered properly. */
7369 if (context
== current_function_decl
)
7370 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7372 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7373 /* This instantiation is another name for the primary
7374 template type. Set the TYPE_CANONICAL field
7376 TYPE_CANONICAL (t
) = template_type
;
7377 else if (any_template_arguments_need_structural_equality_p (arglist
))
7378 /* Some of the template arguments require structural
7379 equality testing, so this template class requires
7380 structural equality testing. */
7381 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7386 /* If we called start_enum or pushtag above, this information
7387 will already be set up. */
7390 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7392 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7393 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7394 DECL_SOURCE_LOCATION (type_decl
)
7395 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7398 type_decl
= TYPE_NAME (t
);
7400 if (CLASS_TYPE_P (template_type
))
7402 TREE_PRIVATE (type_decl
)
7403 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7404 TREE_PROTECTED (type_decl
)
7405 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7406 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7408 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7409 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7413 /* Let's consider the explicit specialization of a member
7414 of a class template specialization that is implicitely instantiated,
7419 template<class U> struct M {}; //#0
7424 struct S<int>::M<char> //#1
7428 [temp.expl.spec]/4 says this is valid.
7430 In this case, when we write:
7433 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7436 When we encounter #1, we want to store the partial instantiation
7437 of M (template<class T> S<int>::M<T>) in it's CLASSTYPE_TI_TEMPLATE.
7439 For all cases other than this "explicit specialization of member of a
7440 class template", we just want to store the most general template into
7441 the CLASSTYPE_TI_TEMPLATE of M.
7443 This case of "explicit specialization of member of a class template"
7445 1/ the enclosing class is an instantiation of, and therefore not
7446 the same as, the context of the most general template, and
7447 2/ we aren't looking at the partial instantiation itself, i.e.
7448 the innermost arguments are not the same as the innermost parms of
7449 the most general template.
7451 So it's only when 1/ and 2/ happens that we want to use the partial
7452 instantiation of the member template in lieu of its most general
7455 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
7456 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
7457 /* the enclosing class must be an instantiation... */
7458 && CLASS_TYPE_P (context
)
7459 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
7461 tree partial_inst_args
;
7462 TREE_VEC_LENGTH (arglist
)--;
7463 ++processing_template_decl
;
7465 tsubst (INNERMOST_TEMPLATE_ARGS
7466 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
7467 arglist
, complain
, NULL_TREE
);
7468 --processing_template_decl
;
7469 TREE_VEC_LENGTH (arglist
)++;
7470 use_partial_inst_tmpl
=
7471 /*...and we must not be looking at the partial instantiation
7473 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
7477 if (!use_partial_inst_tmpl
)
7478 /* This case is easy; there are no member templates involved. */
7482 /* This is a full instantiation of a member template. Find
7483 the partial instantiation of which this is an instance. */
7485 /* Temporarily reduce by one the number of levels in the ARGLIST
7486 so as to avoid comparing the last set of arguments. */
7487 TREE_VEC_LENGTH (arglist
)--;
7488 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
7489 TREE_VEC_LENGTH (arglist
)++;
7490 /* FOUND is either a proper class type, or an alias
7491 template specialization. In the later case, it's a
7492 TYPE_DECL, resulting from the substituting of arguments
7493 for parameters in the TYPE_DECL of the alias template
7494 done earlier. So be careful while getting the template
7496 found
= TREE_CODE (found
) == TYPE_DECL
7497 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
7498 : CLASSTYPE_TI_TEMPLATE (found
);
7501 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
7504 slot
= htab_find_slot_with_hash (type_specializations
,
7505 &elt
, hash
, INSERT
);
7506 entry
= ggc_alloc_spec_entry ();
7510 /* Note this use of the partial instantiation so we can check it
7511 later in maybe_process_partial_specialization. */
7512 DECL_TEMPLATE_INSTANTIATIONS (templ
)
7513 = tree_cons (arglist
, t
,
7514 DECL_TEMPLATE_INSTANTIATIONS (templ
));
7516 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
)
7517 /* Now that the type has been registered on the instantiations
7518 list, we set up the enumerators. Because the enumeration
7519 constants may involve the enumeration type itself, we make
7520 sure to register the type first, and then create the
7521 constants. That way, doing tsubst_expr for the enumeration
7522 constants won't result in recursive calls here; we'll find
7523 the instantiation and exit above. */
7524 tsubst_enum (template_type
, t
, arglist
);
7526 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
7527 /* If the type makes use of template parameters, the
7528 code that generates debugging information will crash. */
7529 DECL_IGNORED_P (TYPE_STUB_DECL (t
)) = 1;
7531 /* Possibly limit visibility based on template args. */
7532 TREE_PUBLIC (type_decl
) = 1;
7533 determine_visibility (type_decl
);
7539 /* Wrapper for lookup_template_class_1. */
7542 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
7543 int entering_scope
, tsubst_flags_t complain
)
7546 timevar_push (TV_TEMPLATE_INST
);
7547 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
7548 entering_scope
, complain
);
7549 timevar_pop (TV_TEMPLATE_INST
);
7557 /* True when we should also visit template parameters that occur in
7558 non-deduced contexts. */
7559 bool include_nondeduced_p
;
7560 struct pointer_set_t
*visited
;
7563 /* Called from for_each_template_parm via walk_tree. */
7566 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
7569 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
7570 tree_fn_t fn
= pfd
->fn
;
7571 void *data
= pfd
->data
;
7574 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
7575 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
7576 pfd
->include_nondeduced_p
))
7577 return error_mark_node
;
7579 switch (TREE_CODE (t
))
7582 if (TYPE_PTRMEMFUNC_P (t
))
7588 if (!TYPE_TEMPLATE_INFO (t
))
7590 else if (for_each_template_parm (TI_ARGS (TYPE_TEMPLATE_INFO (t
)),
7591 fn
, data
, pfd
->visited
,
7592 pfd
->include_nondeduced_p
))
7593 return error_mark_node
;
7597 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
7598 fn
, data
, pfd
->visited
,
7599 pfd
->include_nondeduced_p
)
7600 || for_each_template_parm (TYPE_MAX_VALUE (t
),
7601 fn
, data
, pfd
->visited
,
7602 pfd
->include_nondeduced_p
))
7603 return error_mark_node
;
7607 /* Since we're not going to walk subtrees, we have to do this
7609 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
7610 pfd
->visited
, pfd
->include_nondeduced_p
))
7611 return error_mark_node
;
7615 /* Check the return type. */
7616 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
7617 pfd
->include_nondeduced_p
))
7618 return error_mark_node
;
7620 /* Check the parameter types. Since default arguments are not
7621 instantiated until they are needed, the TYPE_ARG_TYPES may
7622 contain expressions that involve template parameters. But,
7623 no-one should be looking at them yet. And, once they're
7624 instantiated, they don't contain template parameters, so
7625 there's no point in looking at them then, either. */
7629 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
7630 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
7631 pfd
->visited
, pfd
->include_nondeduced_p
))
7632 return error_mark_node
;
7634 /* Since we've already handled the TYPE_ARG_TYPES, we don't
7635 want walk_tree walking into them itself. */
7641 case UNDERLYING_TYPE
:
7642 if (pfd
->include_nondeduced_p
7643 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
7645 pfd
->include_nondeduced_p
))
7646 return error_mark_node
;
7651 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
7652 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
7653 pfd
->visited
, pfd
->include_nondeduced_p
))
7654 return error_mark_node
;
7659 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
7660 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
7661 pfd
->visited
, pfd
->include_nondeduced_p
))
7662 return error_mark_node
;
7663 if (DECL_CONTEXT (t
)
7664 && pfd
->include_nondeduced_p
7665 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
7666 pfd
->visited
, pfd
->include_nondeduced_p
))
7667 return error_mark_node
;
7670 case BOUND_TEMPLATE_TEMPLATE_PARM
:
7671 /* Record template parameters such as `T' inside `TT<T>'. */
7672 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
7673 pfd
->include_nondeduced_p
))
7674 return error_mark_node
;
7677 case TEMPLATE_TEMPLATE_PARM
:
7678 case TEMPLATE_TYPE_PARM
:
7679 case TEMPLATE_PARM_INDEX
:
7680 if (fn
&& (*fn
)(t
, data
))
7681 return error_mark_node
;
7683 return error_mark_node
;
7687 /* A template template parameter is encountered. */
7688 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
7689 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
7690 pfd
->include_nondeduced_p
))
7691 return error_mark_node
;
7693 /* Already substituted template template parameter */
7699 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
7701 pfd
->include_nondeduced_p
))
7702 return error_mark_node
;
7706 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
7707 && pfd
->include_nondeduced_p
7708 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
7709 (TREE_TYPE (t
)), fn
, data
,
7710 pfd
->visited
, pfd
->include_nondeduced_p
))
7711 return error_mark_node
;
7716 /* If there's no type, then this thing must be some expression
7717 involving template parameters. */
7718 if (!fn
&& !TREE_TYPE (t
))
7719 return error_mark_node
;
7724 case IMPLICIT_CONV_EXPR
:
7725 case REINTERPRET_CAST_EXPR
:
7726 case CONST_CAST_EXPR
:
7727 case STATIC_CAST_EXPR
:
7728 case DYNAMIC_CAST_EXPR
:
7732 case PSEUDO_DTOR_EXPR
:
7734 return error_mark_node
;
7741 /* We didn't find any template parameters we liked. */
7745 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
7746 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
7747 call FN with the parameter and the DATA.
7748 If FN returns nonzero, the iteration is terminated, and
7749 for_each_template_parm returns 1. Otherwise, the iteration
7750 continues. If FN never returns a nonzero value, the value
7751 returned by for_each_template_parm is 0. If FN is NULL, it is
7752 considered to be the function which always returns 1.
7754 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
7755 parameters that occur in non-deduced contexts. When false, only
7756 visits those template parameters that can be deduced. */
7759 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
7760 struct pointer_set_t
*visited
,
7761 bool include_nondeduced_p
)
7763 struct pair_fn_data pfd
;
7769 pfd
.include_nondeduced_p
= include_nondeduced_p
;
7771 /* Walk the tree. (Conceptually, we would like to walk without
7772 duplicates, but for_each_template_parm_r recursively calls
7773 for_each_template_parm, so we would need to reorganize a fair
7774 bit to use walk_tree_without_duplicates, so we keep our own
7777 pfd
.visited
= visited
;
7779 pfd
.visited
= pointer_set_create ();
7780 result
= cp_walk_tree (&t
,
7781 for_each_template_parm_r
,
7783 pfd
.visited
) != NULL_TREE
;
7788 pointer_set_destroy (pfd
.visited
);
7795 /* Returns true if T depends on any template parameter. */
7798 uses_template_parms (tree t
)
7801 int saved_processing_template_decl
;
7803 saved_processing_template_decl
= processing_template_decl
;
7804 if (!saved_processing_template_decl
)
7805 processing_template_decl
= 1;
7807 dependent_p
= dependent_type_p (t
);
7808 else if (TREE_CODE (t
) == TREE_VEC
)
7809 dependent_p
= any_dependent_template_arguments_p (t
);
7810 else if (TREE_CODE (t
) == TREE_LIST
)
7811 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
7812 || uses_template_parms (TREE_CHAIN (t
)));
7813 else if (TREE_CODE (t
) == TYPE_DECL
)
7814 dependent_p
= dependent_type_p (TREE_TYPE (t
));
7817 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
7818 || TREE_CODE (t
) == OVERLOAD
7820 || TREE_CODE (t
) == IDENTIFIER_NODE
7821 || TREE_CODE (t
) == TRAIT_EXPR
7822 || TREE_CODE (t
) == CONSTRUCTOR
7823 || CONSTANT_CLASS_P (t
))
7824 dependent_p
= (type_dependent_expression_p (t
)
7825 || value_dependent_expression_p (t
));
7828 gcc_assert (t
== error_mark_node
);
7829 dependent_p
= false;
7832 processing_template_decl
= saved_processing_template_decl
;
7837 /* Returns true iff current_function_decl is an incompletely instantiated
7838 template. Useful instead of processing_template_decl because the latter
7839 is set to 0 during fold_non_dependent_expr. */
7842 in_template_function (void)
7844 tree fn
= current_function_decl
;
7846 ++processing_template_decl
;
7847 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
7848 && DECL_TEMPLATE_INFO (fn
)
7849 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
7850 --processing_template_decl
;
7854 /* Returns true if T depends on any template parameter with level LEVEL. */
7857 uses_template_parms_level (tree t
, int level
)
7859 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
7860 /*include_nondeduced_p=*/true);
7863 /* Returns TRUE iff INST is an instantiation we don't need to do in an
7864 ill-formed translation unit, i.e. a variable or function that isn't
7865 usable in a constant expression. */
7868 neglectable_inst_p (tree d
)
7871 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
7872 : decl_maybe_constant_var_p (d
)));
7875 /* Returns TRUE iff we should refuse to instantiate DECL because it's
7876 neglectable and instantiated from within an erroneous instantiation. */
7879 limit_bad_template_recursion (tree decl
)
7881 struct tinst_level
*lev
= current_tinst_level
;
7882 int errs
= errorcount
+ sorrycount
;
7883 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
7886 for (; lev
; lev
= lev
->next
)
7887 if (neglectable_inst_p (lev
->decl
))
7890 return (lev
&& errs
> lev
->errors
);
7893 static int tinst_depth
;
7894 extern int max_tinst_depth
;
7897 static GTY(()) struct tinst_level
*last_error_tinst_level
;
7899 /* We're starting to instantiate D; record the template instantiation context
7900 for diagnostics and to restore it later. */
7903 push_tinst_level (tree d
)
7905 struct tinst_level
*new_level
;
7907 if (tinst_depth
>= max_tinst_depth
)
7909 last_error_tinst_level
= current_tinst_level
;
7910 if (TREE_CODE (d
) == TREE_LIST
)
7911 error ("template instantiation depth exceeds maximum of %d (use "
7912 "-ftemplate-depth= to increase the maximum) substituting %qS",
7913 max_tinst_depth
, d
);
7915 error ("template instantiation depth exceeds maximum of %d (use "
7916 "-ftemplate-depth= to increase the maximum) instantiating %qD",
7917 max_tinst_depth
, d
);
7919 print_instantiation_context ();
7924 /* If the current instantiation caused problems, don't let it instantiate
7925 anything else. Do allow deduction substitution and decls usable in
7926 constant expressions. */
7927 if (limit_bad_template_recursion (d
))
7930 new_level
= ggc_alloc_tinst_level ();
7931 new_level
->decl
= d
;
7932 new_level
->locus
= input_location
;
7933 new_level
->errors
= errorcount
+sorrycount
;
7934 new_level
->in_system_header_p
= in_system_header
;
7935 new_level
->next
= current_tinst_level
;
7936 current_tinst_level
= new_level
;
7939 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
7940 depth_reached
= tinst_depth
;
7945 /* We're done instantiating this template; return to the instantiation
7949 pop_tinst_level (void)
7951 /* Restore the filename and line number stashed away when we started
7952 this instantiation. */
7953 input_location
= current_tinst_level
->locus
;
7954 current_tinst_level
= current_tinst_level
->next
;
7958 /* We're instantiating a deferred template; restore the template
7959 instantiation context in which the instantiation was requested, which
7960 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
7963 reopen_tinst_level (struct tinst_level
*level
)
7965 struct tinst_level
*t
;
7968 for (t
= level
; t
; t
= t
->next
)
7971 current_tinst_level
= level
;
7973 if (current_tinst_level
)
7974 current_tinst_level
->errors
= errorcount
+sorrycount
;
7978 /* Returns the TINST_LEVEL which gives the original instantiation
7981 struct tinst_level
*
7982 outermost_tinst_level (void)
7984 struct tinst_level
*level
= current_tinst_level
;
7987 level
= level
->next
;
7991 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
7992 vector of template arguments, as for tsubst.
7994 Returns an appropriate tsubst'd friend declaration. */
7997 tsubst_friend_function (tree decl
, tree args
)
8001 if (TREE_CODE (decl
) == FUNCTION_DECL
8002 && DECL_TEMPLATE_INSTANTIATION (decl
)
8003 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8004 /* This was a friend declared with an explicit template
8005 argument list, e.g.:
8009 to indicate that f was a template instantiation, not a new
8010 function declaration. Now, we have to figure out what
8011 instantiation of what template. */
8013 tree template_id
, arglist
, fns
;
8016 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8018 /* Friend functions are looked up in the containing namespace scope.
8019 We must enter that scope, to avoid finding member functions of the
8020 current class with same name. */
8021 push_nested_namespace (ns
);
8022 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8023 tf_warning_or_error
, NULL_TREE
,
8024 /*integral_constant_expression_p=*/false);
8025 pop_nested_namespace (ns
);
8026 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8027 tf_warning_or_error
, NULL_TREE
);
8028 template_id
= lookup_template_function (fns
, arglist
);
8030 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8031 tmpl
= determine_specialization (template_id
, new_friend
,
8033 /*need_member_template=*/0,
8034 TREE_VEC_LENGTH (args
),
8036 return instantiate_template (tmpl
, new_args
, tf_error
);
8039 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8041 /* The NEW_FRIEND will look like an instantiation, to the
8042 compiler, but is not an instantiation from the point of view of
8043 the language. For example, we might have had:
8045 template <class T> struct S {
8046 template <class U> friend void f(T, U);
8049 Then, in S<int>, template <class U> void f(int, U) is not an
8050 instantiation of anything. */
8051 if (new_friend
== error_mark_node
)
8052 return error_mark_node
;
8054 DECL_USE_TEMPLATE (new_friend
) = 0;
8055 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8057 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8058 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8059 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8062 /* The mangled name for the NEW_FRIEND is incorrect. The function
8063 is not a template instantiation and should not be mangled like
8064 one. Therefore, we forget the mangling here; we'll recompute it
8065 later if we need it. */
8066 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8068 SET_DECL_RTL (new_friend
, NULL
);
8069 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8072 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8075 tree new_friend_template_info
;
8076 tree new_friend_result_template_info
;
8078 int new_friend_is_defn
;
8080 /* We must save some information from NEW_FRIEND before calling
8081 duplicate decls since that function will free NEW_FRIEND if
8083 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8084 new_friend_is_defn
=
8085 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8086 (template_for_substitution (new_friend
)))
8088 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8090 /* This declaration is a `primary' template. */
8091 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8093 new_friend_result_template_info
8094 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8097 new_friend_result_template_info
= NULL_TREE
;
8099 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8100 if (new_friend_is_defn
)
8101 DECL_INITIAL (new_friend
) = error_mark_node
;
8103 /* Inside pushdecl_namespace_level, we will push into the
8104 current namespace. However, the friend function should go
8105 into the namespace of the template. */
8106 ns
= decl_namespace_context (new_friend
);
8107 push_nested_namespace (ns
);
8108 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8109 pop_nested_namespace (ns
);
8111 if (old_decl
== error_mark_node
)
8112 return error_mark_node
;
8114 if (old_decl
!= new_friend
)
8116 /* This new friend declaration matched an existing
8117 declaration. For example, given:
8119 template <class T> void f(T);
8120 template <class U> class C {
8121 template <class T> friend void f(T) {}
8124 the friend declaration actually provides the definition
8125 of `f', once C has been instantiated for some type. So,
8126 old_decl will be the out-of-class template declaration,
8127 while new_friend is the in-class definition.
8129 But, if `f' was called before this point, the
8130 instantiation of `f' will have DECL_TI_ARGS corresponding
8131 to `T' but not to `U', references to which might appear
8132 in the definition of `f'. Previously, the most general
8133 template for an instantiation of `f' was the out-of-class
8134 version; now it is the in-class version. Therefore, we
8135 run through all specialization of `f', adding to their
8136 DECL_TI_ARGS appropriately. In particular, they need a
8137 new set of outer arguments, corresponding to the
8138 arguments for this class instantiation.
8140 The same situation can arise with something like this:
8143 template <class T> class C {
8147 when `C<int>' is instantiated. Now, `f(int)' is defined
8150 if (!new_friend_is_defn
)
8151 /* On the other hand, if the in-class declaration does
8152 *not* provide a definition, then we don't want to alter
8153 existing definitions. We can just leave everything
8158 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8159 tree new_args
= TI_ARGS (new_friend_template_info
);
8161 /* Overwrite whatever template info was there before, if
8162 any, with the new template information pertaining to
8164 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8166 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8168 /* We should have called reregister_specialization in
8170 gcc_assert (retrieve_specialization (new_template
,
8174 /* Instantiate it if the global has already been used. */
8175 if (DECL_ODR_USED (old_decl
))
8176 instantiate_decl (old_decl
, /*defer_ok=*/true,
8177 /*expl_inst_class_mem_p=*/false);
8183 /* Indicate that the old function template is a partial
8185 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8186 = new_friend_result_template_info
;
8188 gcc_assert (new_template
8189 == most_general_template (new_template
));
8190 gcc_assert (new_template
!= old_decl
);
8192 /* Reassign any specializations already in the hash table
8193 to the new more general template, and add the
8194 additional template args. */
8195 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8199 tree spec
= TREE_VALUE (t
);
8202 elt
.tmpl
= old_decl
;
8203 elt
.args
= DECL_TI_ARGS (spec
);
8204 elt
.spec
= NULL_TREE
;
8206 htab_remove_elt (decl_specializations
, &elt
);
8209 = add_outermost_template_args (new_args
,
8210 DECL_TI_ARGS (spec
));
8212 register_specialization
8213 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8216 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8220 /* The information from NEW_FRIEND has been merged into OLD_DECL
8221 by duplicate_decls. */
8222 new_friend
= old_decl
;
8227 tree context
= DECL_CONTEXT (new_friend
);
8231 template <class T> class C {
8232 template <class U> friend void C1<U>::f (); // case 1
8233 friend void C2<T>::f (); // case 2
8235 we only need to make sure CONTEXT is a complete type for
8236 case 2. To distinguish between the two cases, we note that
8237 CONTEXT of case 1 remains dependent type after tsubst while
8238 this isn't true for case 2. */
8239 ++processing_template_decl
;
8240 dependent_p
= dependent_type_p (context
);
8241 --processing_template_decl
;
8244 && !complete_type_or_else (context
, NULL_TREE
))
8245 return error_mark_node
;
8247 if (COMPLETE_TYPE_P (context
))
8249 /* Check to see that the declaration is really present, and,
8250 possibly obtain an improved declaration. */
8251 tree fn
= check_classfn (context
,
8252 new_friend
, NULL_TREE
);
8262 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8263 template arguments, as for tsubst.
8265 Returns an appropriate tsubst'd friend type or error_mark_node on
8269 tsubst_friend_class (tree friend_tmpl
, tree args
)
8275 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8277 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8278 return TREE_TYPE (t
);
8281 context
= CP_DECL_CONTEXT (friend_tmpl
);
8283 if (context
!= global_namespace
)
8285 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8286 push_nested_namespace (context
);
8288 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8291 /* Look for a class template declaration. We look for hidden names
8292 because two friend declarations of the same template are the
8293 same. For example, in:
8296 template <typename> friend class F;
8298 template <typename> struct B {
8299 template <typename> friend class F;
8302 both F templates are the same. */
8303 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8304 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8306 /* But, if we don't find one, it might be because we're in a
8307 situation like this:
8315 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8316 for `S<int>', not the TEMPLATE_DECL. */
8317 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8319 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8320 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8323 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8325 /* The friend template has already been declared. Just
8326 check to see that the declarations match, and install any new
8327 default parameters. We must tsubst the default parameters,
8328 of course. We only need the innermost template parameters
8329 because that is all that redeclare_class_template will look
8331 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8332 > TMPL_ARGS_DEPTH (args
))
8335 location_t saved_input_location
;
8336 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8337 args
, tf_warning_or_error
);
8339 saved_input_location
= input_location
;
8340 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8341 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8342 input_location
= saved_input_location
;
8346 friend_type
= TREE_TYPE (tmpl
);
8350 /* The friend template has not already been declared. In this
8351 case, the instantiation of the template class will cause the
8352 injection of this template into the global scope. */
8353 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8354 if (tmpl
== error_mark_node
)
8355 return error_mark_node
;
8357 /* The new TMPL is not an instantiation of anything, so we
8358 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8359 the new type because that is supposed to be the corresponding
8360 template decl, i.e., TMPL. */
8361 DECL_USE_TEMPLATE (tmpl
) = 0;
8362 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8363 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8364 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8365 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8367 /* Inject this template into the global scope. */
8368 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8371 if (context
!= global_namespace
)
8373 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8374 pop_nested_namespace (context
);
8376 pop_nested_class ();
8382 /* Returns zero if TYPE cannot be completed later due to circularity.
8383 Otherwise returns one. */
8386 can_complete_type_without_circularity (tree type
)
8388 if (type
== NULL_TREE
|| type
== error_mark_node
)
8390 else if (COMPLETE_TYPE_P (type
))
8392 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8393 return can_complete_type_without_circularity (TREE_TYPE (type
));
8394 else if (CLASS_TYPE_P (type
)
8395 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
8401 /* Apply any attributes which had to be deferred until instantiation
8402 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8403 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8406 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
8407 tree args
, tsubst_flags_t complain
, tree in_decl
)
8409 tree last_dep
= NULL_TREE
;
8413 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
8414 if (ATTR_IS_DEPENDENT (t
))
8417 attributes
= copy_list (attributes
);
8421 if (DECL_P (*decl_p
))
8423 if (TREE_TYPE (*decl_p
) == error_mark_node
)
8425 p
= &DECL_ATTRIBUTES (*decl_p
);
8428 p
= &TYPE_ATTRIBUTES (*decl_p
);
8432 tree late_attrs
= NULL_TREE
;
8433 tree
*q
= &late_attrs
;
8435 for (*p
= attributes
; *p
; )
8438 if (ATTR_IS_DEPENDENT (t
))
8440 *p
= TREE_CHAIN (t
);
8441 TREE_CHAIN (t
) = NULL_TREE
;
8442 /* If the first attribute argument is an identifier, don't
8443 pass it through tsubst. Attributes like mode, format,
8444 cleanup and several target specific attributes expect it
8447 && TREE_CODE (TREE_VALUE (t
)) == TREE_LIST
8448 && TREE_VALUE (TREE_VALUE (t
))
8449 && (TREE_CODE (TREE_VALUE (TREE_VALUE (t
)))
8450 == IDENTIFIER_NODE
))
8453 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
8455 /*integral_constant_expression_p=*/false);
8456 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
8458 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
8463 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
8464 /*integral_constant_expression_p=*/false);
8466 q
= &TREE_CHAIN (t
);
8469 p
= &TREE_CHAIN (t
);
8472 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
8476 /* Perform (or defer) access check for typedefs that were referenced
8477 from within the template TMPL code.
8478 This is a subroutine of instantiate_decl and instantiate_class_template.
8479 TMPL is the template to consider and TARGS is the list of arguments of
8483 perform_typedefs_access_check (tree tmpl
, tree targs
)
8485 location_t saved_location
;
8487 qualified_typedef_usage_t
*iter
;
8490 || (!CLASS_TYPE_P (tmpl
)
8491 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
8494 saved_location
= input_location
;
8495 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
8497 tree type_decl
= iter
->typedef_decl
;
8498 tree type_scope
= iter
->context
;
8500 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
8503 if (uses_template_parms (type_decl
))
8504 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
8505 if (uses_template_parms (type_scope
))
8506 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
8508 /* Make access check error messages point to the location
8509 of the use of the typedef. */
8510 input_location
= iter
->locus
;
8511 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
8512 type_decl
, type_decl
,
8513 tf_warning_or_error
);
8515 input_location
= saved_location
;
8519 instantiate_class_template_1 (tree type
)
8521 tree templ
, args
, pattern
, t
, member
;
8525 unsigned int saved_maximum_field_alignment
;
8528 if (type
== error_mark_node
)
8529 return error_mark_node
;
8531 if (COMPLETE_OR_OPEN_TYPE_P (type
)
8532 || uses_template_parms (type
))
8535 /* Figure out which template is being instantiated. */
8536 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
8537 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
8539 /* Determine what specialization of the original template to
8541 t
= most_specialized_class (type
, templ
, tf_warning_or_error
);
8542 if (t
== error_mark_node
)
8544 TYPE_BEING_DEFINED (type
) = 1;
8545 return error_mark_node
;
8549 /* This TYPE is actually an instantiation of a partial
8550 specialization. We replace the innermost set of ARGS with
8551 the arguments appropriate for substitution. For example,
8554 template <class T> struct S {};
8555 template <class T> struct S<T*> {};
8557 and supposing that we are instantiating S<int*>, ARGS will
8558 presently be {int*} -- but we need {int}. */
8559 pattern
= TREE_TYPE (t
);
8560 args
= TREE_PURPOSE (t
);
8564 pattern
= TREE_TYPE (templ
);
8565 args
= CLASSTYPE_TI_ARGS (type
);
8568 /* If the template we're instantiating is incomplete, then clearly
8569 there's nothing we can do. */
8570 if (!COMPLETE_TYPE_P (pattern
))
8573 /* If we've recursively instantiated too many templates, stop. */
8574 if (! push_tinst_level (type
))
8577 /* Now we're really doing the instantiation. Mark the type as in
8578 the process of being defined. */
8579 TYPE_BEING_DEFINED (type
) = 1;
8581 /* We may be in the middle of deferred access check. Disable
8583 push_deferring_access_checks (dk_no_deferred
);
8585 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
8587 push_to_top_level ();
8588 /* Use #pragma pack from the template context. */
8589 saved_maximum_field_alignment
= maximum_field_alignment
;
8590 maximum_field_alignment
= TYPE_PRECISION (pattern
);
8592 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
8594 /* Set the input location to the most specialized template definition.
8595 This is needed if tsubsting causes an error. */
8596 typedecl
= TYPE_MAIN_DECL (pattern
);
8597 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
8598 DECL_SOURCE_LOCATION (typedecl
);
8600 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
8601 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
8602 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
8603 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
8604 if (ANON_AGGR_TYPE_P (pattern
))
8605 SET_ANON_AGGR_TYPE_P (type
);
8606 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
8608 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
8609 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
8610 /* Adjust visibility for template arguments. */
8611 determine_visibility (TYPE_MAIN_DECL (type
));
8613 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
8615 pbinfo
= TYPE_BINFO (pattern
);
8617 /* We should never instantiate a nested class before its enclosing
8618 class; we need to look up the nested class by name before we can
8619 instantiate it, and that lookup should instantiate the enclosing
8621 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
8622 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
8624 base_list
= NULL_TREE
;
8625 if (BINFO_N_BASE_BINFOS (pbinfo
))
8631 /* We must enter the scope containing the type, as that is where
8632 the accessibility of types named in dependent bases are
8634 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
8636 /* Substitute into each of the bases to determine the actual
8638 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
8641 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
8642 tree expanded_bases
= NULL_TREE
;
8645 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
8648 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
8649 args
, tf_error
, NULL_TREE
);
8650 if (expanded_bases
== error_mark_node
)
8653 len
= TREE_VEC_LENGTH (expanded_bases
);
8656 for (idx
= 0; idx
< len
; idx
++)
8659 /* Extract the already-expanded base class. */
8660 base
= TREE_VEC_ELT (expanded_bases
, idx
);
8662 /* Substitute to figure out the base class. */
8663 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
8666 if (base
== error_mark_node
)
8669 base_list
= tree_cons (access
, base
, base_list
);
8670 if (BINFO_VIRTUAL_P (pbase_binfo
))
8671 TREE_TYPE (base_list
) = integer_type_node
;
8675 /* The list is now in reverse order; correct that. */
8676 base_list
= nreverse (base_list
);
8679 pop_scope (pushed_scope
);
8681 /* Now call xref_basetypes to set up all the base-class
8683 xref_basetypes (type
, base_list
);
8685 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
8686 (int) ATTR_FLAG_TYPE_IN_PLACE
,
8687 args
, tf_error
, NULL_TREE
);
8688 fixup_attribute_variants (type
);
8690 /* Now that our base classes are set up, enter the scope of the
8691 class, so that name lookups into base classes, etc. will work
8692 correctly. This is precisely analogous to what we do in
8693 begin_class_definition when defining an ordinary non-template
8694 class, except we also need to push the enclosing classes. */
8695 push_nested_class (type
);
8697 /* Now members are processed in the order of declaration. */
8698 for (member
= CLASSTYPE_DECL_LIST (pattern
);
8699 member
; member
= TREE_CHAIN (member
))
8701 tree t
= TREE_VALUE (member
);
8703 if (TREE_PURPOSE (member
))
8707 /* Build new CLASSTYPE_NESTED_UTDS. */
8710 bool class_template_p
;
8712 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
8713 && TYPE_LANG_SPECIFIC (t
)
8714 && CLASSTYPE_IS_TEMPLATE (t
));
8715 /* If the member is a class template, then -- even after
8716 substitution -- there may be dependent types in the
8717 template argument list for the class. We increment
8718 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
8719 that function will assume that no types are dependent
8720 when outside of a template. */
8721 if (class_template_p
)
8722 ++processing_template_decl
;
8723 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
8724 if (class_template_p
)
8725 --processing_template_decl
;
8726 if (newtag
== error_mark_node
)
8729 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
8731 tree name
= TYPE_IDENTIFIER (t
);
8733 if (class_template_p
)
8734 /* Unfortunately, lookup_template_class sets
8735 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
8736 instantiation (i.e., for the type of a member
8737 template class nested within a template class.)
8738 This behavior is required for
8739 maybe_process_partial_specialization to work
8740 correctly, but is not accurate in this case;
8741 the TAG is not an instantiation of anything.
8742 (The corresponding TEMPLATE_DECL is an
8743 instantiation, but the TYPE is not.) */
8744 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
8746 /* Now, we call pushtag to put this NEWTAG into the scope of
8747 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
8748 pushtag calling push_template_decl. We don't have to do
8749 this for enums because it will already have been done in
8752 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
8753 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
8756 else if (TREE_CODE (t
) == FUNCTION_DECL
8757 || DECL_FUNCTION_TEMPLATE_P (t
))
8759 /* Build new TYPE_METHODS. */
8762 if (TREE_CODE (t
) == TEMPLATE_DECL
)
8763 ++processing_template_decl
;
8764 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
8765 if (TREE_CODE (t
) == TEMPLATE_DECL
)
8766 --processing_template_decl
;
8767 set_current_access_from_decl (r
);
8768 finish_member_declaration (r
);
8769 /* Instantiate members marked with attribute used. */
8770 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
8775 /* Build new TYPE_FIELDS. */
8776 if (TREE_CODE (t
) == STATIC_ASSERT
)
8780 ++c_inhibit_evaluation_warnings
;
8782 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
8783 tf_warning_or_error
, NULL_TREE
,
8784 /*integral_constant_expression_p=*/true);
8785 --c_inhibit_evaluation_warnings
;
8787 finish_static_assert (condition
,
8788 STATIC_ASSERT_MESSAGE (t
),
8789 STATIC_ASSERT_SOURCE_LOCATION (t
),
8792 else if (TREE_CODE (t
) != CONST_DECL
)
8796 /* The file and line for this declaration, to
8797 assist in error message reporting. Since we
8798 called push_tinst_level above, we don't need to
8800 input_location
= DECL_SOURCE_LOCATION (t
);
8802 if (TREE_CODE (t
) == TEMPLATE_DECL
)
8803 ++processing_template_decl
;
8804 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
8805 if (TREE_CODE (t
) == TEMPLATE_DECL
)
8806 --processing_template_decl
;
8807 if (TREE_CODE (r
) == VAR_DECL
)
8811 [t]he initialization (and any associated
8812 side-effects) of a static data member does
8813 not occur unless the static data member is
8814 itself used in a way that requires the
8815 definition of the static data member to
8818 Therefore, we do not substitute into the
8819 initialized for the static data member here. */
8820 finish_static_data_member_decl
8823 /*init_const_expr_p=*/false,
8824 /*asmspec_tree=*/NULL_TREE
,
8826 /* Instantiate members marked with attribute used. */
8827 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
8830 else if (TREE_CODE (r
) == FIELD_DECL
)
8832 /* Determine whether R has a valid type and can be
8833 completed later. If R is invalid, then it is
8834 replaced by error_mark_node so that it will not be
8835 added to TYPE_FIELDS. */
8836 tree rtype
= TREE_TYPE (r
);
8837 if (can_complete_type_without_circularity (rtype
))
8838 complete_type (rtype
);
8840 if (!COMPLETE_TYPE_P (rtype
))
8842 cxx_incomplete_type_error (r
, rtype
);
8843 r
= error_mark_node
;
8847 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
8848 such a thing will already have been added to the field
8849 list by tsubst_enum in finish_member_declaration in the
8850 CLASSTYPE_NESTED_UTDS case above. */
8851 if (!(TREE_CODE (r
) == TYPE_DECL
8852 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
8853 && DECL_ARTIFICIAL (r
)))
8855 set_current_access_from_decl (r
);
8856 finish_member_declaration (r
);
8863 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
8864 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
8866 /* Build new CLASSTYPE_FRIEND_CLASSES. */
8868 tree friend_type
= t
;
8869 bool adjust_processing_template_decl
= false;
8871 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
8873 /* template <class T> friend class C; */
8874 friend_type
= tsubst_friend_class (friend_type
, args
);
8875 adjust_processing_template_decl
= true;
8877 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
8879 /* template <class T> friend class C::D; */
8880 friend_type
= tsubst (friend_type
, args
,
8881 tf_warning_or_error
, NULL_TREE
);
8882 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
8883 friend_type
= TREE_TYPE (friend_type
);
8884 adjust_processing_template_decl
= true;
8886 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
8887 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
8889 /* This could be either
8893 when dependent_type_p is false or
8895 template <class U> friend class T::C;
8898 friend_type
= tsubst (friend_type
, args
,
8899 tf_warning_or_error
, NULL_TREE
);
8900 /* Bump processing_template_decl for correct
8901 dependent_type_p calculation. */
8902 ++processing_template_decl
;
8903 if (dependent_type_p (friend_type
))
8904 adjust_processing_template_decl
= true;
8905 --processing_template_decl
;
8907 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
8908 && hidden_name_p (TYPE_NAME (friend_type
)))
8912 where C hasn't been declared yet. Let's lookup name
8913 from namespace scope directly, bypassing any name that
8914 come from dependent base class. */
8915 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
8917 /* The call to xref_tag_from_type does injection for friend
8919 push_nested_namespace (ns
);
8921 xref_tag_from_type (friend_type
, NULL_TREE
,
8922 /*tag_scope=*/ts_current
);
8923 pop_nested_namespace (ns
);
8925 else if (uses_template_parms (friend_type
))
8926 /* friend class C<T>; */
8927 friend_type
= tsubst (friend_type
, args
,
8928 tf_warning_or_error
, NULL_TREE
);
8933 where C is already declared or
8935 friend class C<int>;
8937 We don't have to do anything in these cases. */
8939 if (adjust_processing_template_decl
)
8940 /* Trick make_friend_class into realizing that the friend
8941 we're adding is a template, not an ordinary class. It's
8942 important that we use make_friend_class since it will
8943 perform some error-checking and output cross-reference
8945 ++processing_template_decl
;
8947 if (friend_type
!= error_mark_node
)
8948 make_friend_class (type
, friend_type
, /*complain=*/false);
8950 if (adjust_processing_template_decl
)
8951 --processing_template_decl
;
8955 /* Build new DECL_FRIENDLIST. */
8958 /* The file and line for this declaration, to
8959 assist in error message reporting. Since we
8960 called push_tinst_level above, we don't need to
8962 input_location
= DECL_SOURCE_LOCATION (t
);
8964 if (TREE_CODE (t
) == TEMPLATE_DECL
)
8966 ++processing_template_decl
;
8967 push_deferring_access_checks (dk_no_check
);
8970 r
= tsubst_friend_function (t
, args
);
8971 add_friend (type
, r
, /*complain=*/false);
8972 if (TREE_CODE (t
) == TEMPLATE_DECL
)
8974 pop_deferring_access_checks ();
8975 --processing_template_decl
;
8981 if (CLASSTYPE_LAMBDA_EXPR (type
))
8983 tree decl
= lambda_function (type
);
8986 instantiate_decl (decl
, false, false);
8987 maybe_add_lambda_conv_op (type
);
8990 gcc_assert (errorcount
);
8993 /* Set the file and line number information to whatever is given for
8994 the class itself. This puts error messages involving generated
8995 implicit functions at a predictable point, and the same point
8996 that would be used for non-template classes. */
8997 input_location
= DECL_SOURCE_LOCATION (typedecl
);
8999 unreverse_member_declarations (type
);
9000 finish_struct_1 (type
);
9001 TYPE_BEING_DEFINED (type
) = 0;
9003 /* We don't instantiate default arguments for member functions. 14.7.1:
9005 The implicit instantiation of a class template specialization causes
9006 the implicit instantiation of the declarations, but not of the
9007 definitions or default arguments, of the class member functions,
9008 member classes, static data members and member templates.... */
9010 /* Some typedefs referenced from within the template code need to be access
9011 checked at template instantiation time, i.e now. These types were
9012 added to the template at parsing time. Let's get those and perform
9013 the access checks then. */
9014 perform_typedefs_access_check (pattern
, args
);
9015 perform_deferred_access_checks (tf_warning_or_error
);
9016 pop_nested_class ();
9017 maximum_field_alignment
= saved_maximum_field_alignment
;
9019 pop_from_top_level ();
9020 pop_deferring_access_checks ();
9023 /* The vtable for a template class can be emitted in any translation
9024 unit in which the class is instantiated. When there is no key
9025 method, however, finish_struct_1 will already have added TYPE to
9026 the keyed_classes list. */
9027 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9028 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9033 /* Wrapper for instantiate_class_template_1. */
9036 instantiate_class_template (tree type
)
9039 timevar_push (TV_TEMPLATE_INST
);
9040 ret
= instantiate_class_template_1 (type
);
9041 timevar_pop (TV_TEMPLATE_INST
);
9046 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9052 else if (TYPE_P (t
))
9053 r
= tsubst (t
, args
, complain
, in_decl
);
9056 if (!(complain
& tf_warning
))
9057 ++c_inhibit_evaluation_warnings
;
9058 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9059 /*integral_constant_expression_p=*/true);
9060 if (!(complain
& tf_warning
))
9061 --c_inhibit_evaluation_warnings
;
9062 /* Preserve the raw-reference nature of T. */
9063 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
9064 && REFERENCE_REF_P (r
))
9065 r
= TREE_OPERAND (r
, 0);
9070 /* Given a function parameter pack TMPL_PARM and some function parameters
9071 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9072 and set *SPEC_P to point at the next point in the list. */
9075 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9077 /* Collect all of the extra "packed" parameters into an
9081 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9082 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9083 tree spec_parm
= *spec_p
;
9086 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9088 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9091 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9092 parmvec
= make_tree_vec (len
);
9093 parmtypevec
= make_tree_vec (len
);
9094 spec_parm
= *spec_p
;
9095 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9097 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9098 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9101 /* Build the argument packs. */
9102 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9103 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9104 TREE_TYPE (argpack
) = argtypepack
;
9105 *spec_p
= spec_parm
;
9110 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9111 NONTYPE_ARGUMENT_PACK. */
9114 make_fnparm_pack (tree spec_parm
)
9116 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9119 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9123 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9125 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9126 if (i
>= TREE_VEC_LENGTH (vec
))
9128 return PACK_EXPANSION_P (TREE_VEC_ELT (vec
, i
));
9132 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9135 make_argument_pack_select (tree arg_pack
, unsigned index
)
9137 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9139 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9140 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9145 /* This is a subroutine of tsubst_pack_expansion.
9147 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9148 mechanism to store the (non complete list of) arguments of the
9149 substitution and return a non substituted pack expansion, in order
9150 to wait for when we have enough arguments to really perform the
9154 use_pack_expansion_extra_args_p (tree parm_packs
,
9158 if (parm_packs
== NULL_TREE
)
9161 bool has_expansion_arg
= false;
9162 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9164 bool has_non_expansion_arg
= false;
9165 for (tree parm_pack
= parm_packs
;
9167 parm_pack
= TREE_CHAIN (parm_pack
))
9169 tree arg
= TREE_VALUE (parm_pack
);
9171 if (argument_pack_element_is_expansion_p (arg
, i
))
9172 has_expansion_arg
= true;
9174 has_non_expansion_arg
= true;
9177 /* If one pack has an expansion and another pack has a normal
9178 argument or if one pack has an empty argument another one
9179 hasn't then tsubst_pack_expansion cannot perform the
9180 substitution and need to fall back on the
9181 PACK_EXPANSION_EXTRA mechanism. */
9182 if ((has_expansion_arg
&& has_non_expansion_arg
)
9183 || (has_empty_arg
&& (has_expansion_arg
|| has_non_expansion_arg
)))
9189 /* [temp.variadic]/6 says that:
9191 The instantiation of a pack expansion [...]
9192 produces a list E1,E2, ..., En, where N is the number of elements
9193 in the pack expansion parameters.
9195 This subroutine of tsubst_pack_expansion produces one of these Ei.
9197 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9198 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9199 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9200 INDEX is the index 'i' of the element Ei to produce. ARGS,
9201 COMPLAIN, and IN_DECL are the same parameters as for the
9202 tsubst_pack_expansion function.
9204 The function returns the resulting Ei upon successful completion,
9207 Note that this function possibly modifies the ARGS parameter, so
9208 it's the responsibility of the caller to restore it. */
9211 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9214 tree args
/* This parm gets
9216 tsubst_flags_t complain
,
9220 bool ith_elem_is_expansion
= false;
9222 /* For each parameter pack, change the substitution of the parameter
9223 pack to the ith argument in its argument pack, then expand the
9225 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9227 tree parm
= TREE_PURPOSE (pack
);
9228 tree arg_pack
= TREE_VALUE (pack
);
9229 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9231 ith_elem_is_expansion
|=
9232 argument_pack_element_is_expansion_p (arg_pack
, index
);
9234 /* Select the Ith argument from the pack. */
9235 if (TREE_CODE (parm
) == PARM_DECL
)
9239 aps
= make_argument_pack_select (arg_pack
, index
);
9241 register_local_specialization (aps
, parm
);
9244 aps
= retrieve_local_specialization (parm
);
9249 template_parm_level_and_index (parm
, &level
, &idx
);
9253 aps
= make_argument_pack_select (arg_pack
, index
);
9254 /* Update the corresponding argument. */
9255 TMPL_ARG (args
, level
, idx
) = aps
;
9258 /* Re-use the ARGUMENT_PACK_SELECT. */
9259 aps
= TMPL_ARG (args
, level
, idx
);
9261 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9264 /* Substitute into the PATTERN with the (possibly altered)
9266 if (!TYPE_P (pattern
))
9267 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9268 /*integral_constant_expression_p=*/false);
9270 t
= tsubst (pattern
, args
, complain
, in_decl
);
9272 /* If the Ith argument pack element is a pack expansion, then
9273 the Ith element resulting from the substituting is going to
9274 be a pack expansion as well. */
9275 if (ith_elem_is_expansion
)
9276 t
= make_pack_expansion (t
);
9281 /* Substitute ARGS into T, which is an pack expansion
9282 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9283 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9284 (if only a partial substitution could be performed) or
9285 ERROR_MARK_NODE if there was an error. */
9287 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9291 tree pack
, packs
= NULL_TREE
;
9292 bool unsubstituted_packs
= false;
9295 struct pointer_map_t
*saved_local_specializations
= NULL
;
9296 bool need_local_specializations
= false;
9299 gcc_assert (PACK_EXPANSION_P (t
));
9300 pattern
= PACK_EXPANSION_PATTERN (t
);
9302 /* Add in any args remembered from an earlier partial instantiation. */
9303 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9305 levels
= TMPL_ARGS_DEPTH (args
);
9307 /* Determine the argument packs that will instantiate the parameter
9308 packs used in the expansion expression. While we're at it,
9309 compute the number of arguments to be expanded and make sure it
9311 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
9312 pack
= TREE_CHAIN (pack
))
9314 tree parm_pack
= TREE_VALUE (pack
);
9315 tree arg_pack
= NULL_TREE
;
9316 tree orig_arg
= NULL_TREE
;
9319 if (TREE_CODE (parm_pack
) == BASES
)
9321 if (BASES_DIRECT (parm_pack
))
9322 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9323 args
, complain
, in_decl
, false));
9325 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9326 args
, complain
, in_decl
, false));
9328 if (TREE_CODE (parm_pack
) == PARM_DECL
)
9330 if (PACK_EXPANSION_LOCAL_P (t
))
9331 arg_pack
= retrieve_local_specialization (parm_pack
);
9334 /* We can't rely on local_specializations for a parameter
9335 name used later in a function declaration (such as in a
9336 late-specified return type). Even if it exists, it might
9337 have the wrong value for a recursive call. Just make a
9338 dummy decl, since it's only used for its type. */
9339 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
9340 if (arg_pack
&& FUNCTION_PARAMETER_PACK_P (arg_pack
))
9341 /* Partial instantiation of the parm_pack, we can't build
9342 up an argument pack yet. */
9343 arg_pack
= NULL_TREE
;
9345 arg_pack
= make_fnparm_pack (arg_pack
);
9346 need_local_specializations
= true;
9352 template_parm_level_and_index (parm_pack
, &level
, &idx
);
9354 if (level
<= levels
)
9355 arg_pack
= TMPL_ARG (args
, level
, idx
);
9358 orig_arg
= arg_pack
;
9359 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
9360 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
9362 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
9363 /* This can only happen if we forget to expand an argument
9364 pack somewhere else. Just return an error, silently. */
9366 result
= make_tree_vec (1);
9367 TREE_VEC_ELT (result
, 0) = error_mark_node
;
9374 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
9376 /* Don't bother trying to do a partial substitution with
9377 incomplete packs; we'll try again after deduction. */
9378 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
9383 else if (len
!= my_len
)
9385 if (!(complain
& tf_error
))
9386 /* Fail quietly. */;
9387 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
9388 error ("mismatched argument pack lengths while expanding "
9392 error ("mismatched argument pack lengths while expanding "
9395 return error_mark_node
;
9398 /* Keep track of the parameter packs and their corresponding
9400 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
9401 TREE_TYPE (packs
) = orig_arg
;
9405 /* We can't substitute for this parameter pack. We use a flag as
9406 well as the missing_level counter because function parameter
9407 packs don't have a level. */
9408 unsubstituted_packs
= true;
9412 /* We cannot expand this expansion expression, because we don't have
9413 all of the argument packs we need. */
9414 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
9416 /* We got some full packs, but we can't substitute them in until we
9417 have values for all the packs. So remember these until then. */
9419 t
= make_pack_expansion (pattern
);
9420 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
9423 else if (unsubstituted_packs
)
9425 /* There were no real arguments, we're just replacing a parameter
9426 pack with another version of itself. Substitute into the
9427 pattern and return a PACK_EXPANSION_*. The caller will need to
9429 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
9430 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9431 /*integral_constant_expression_p=*/false);
9433 t
= tsubst (pattern
, args
, complain
, in_decl
);
9434 t
= make_pack_expansion (t
);
9438 gcc_assert (len
>= 0);
9440 if (need_local_specializations
)
9442 /* We're in a late-specified return type, so create our own local
9443 specializations map; the current map is either NULL or (in the
9444 case of recursive unification) might have bindings that we don't
9445 want to use or alter. */
9446 saved_local_specializations
= local_specializations
;
9447 local_specializations
= pointer_map_create ();
9450 /* For each argument in each argument pack, substitute into the
9452 result
= make_tree_vec (len
);
9453 for (i
= 0; i
< len
; ++i
)
9455 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
9459 TREE_VEC_ELT (result
, i
) = t
;
9460 if (t
== error_mark_node
)
9462 result
= error_mark_node
;
9467 /* Update ARGS to restore the substitution from parameter packs to
9468 their argument packs. */
9469 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
9471 tree parm
= TREE_PURPOSE (pack
);
9473 if (TREE_CODE (parm
) == PARM_DECL
)
9474 register_local_specialization (TREE_TYPE (pack
), parm
);
9479 if (TREE_VALUE (pack
) == NULL_TREE
)
9482 template_parm_level_and_index (parm
, &level
, &idx
);
9484 /* Update the corresponding argument. */
9485 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
9486 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
9489 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
9493 if (need_local_specializations
)
9495 pointer_map_destroy (local_specializations
);
9496 local_specializations
= saved_local_specializations
;
9502 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
9503 TMPL. We do this using DECL_PARM_INDEX, which should work even with
9504 parameter packs; all parms generated from a function parameter pack will
9505 have the same DECL_PARM_INDEX. */
9508 get_pattern_parm (tree parm
, tree tmpl
)
9510 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
9513 if (DECL_ARTIFICIAL (parm
))
9515 for (patparm
= DECL_ARGUMENTS (pattern
);
9516 patparm
; patparm
= DECL_CHAIN (patparm
))
9517 if (DECL_ARTIFICIAL (patparm
)
9518 && DECL_NAME (parm
) == DECL_NAME (patparm
))
9523 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
9524 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
9525 gcc_assert (DECL_PARM_INDEX (patparm
)
9526 == DECL_PARM_INDEX (parm
));
9532 /* Substitute ARGS into the vector or list of template arguments T. */
9535 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9538 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
9541 if (t
== error_mark_node
)
9542 return error_mark_node
;
9544 len
= TREE_VEC_LENGTH (t
);
9545 elts
= XALLOCAVEC (tree
, len
);
9547 for (i
= 0; i
< len
; i
++)
9549 tree orig_arg
= TREE_VEC_ELT (t
, i
);
9552 if (TREE_CODE (orig_arg
) == TREE_VEC
)
9553 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
9554 else if (PACK_EXPANSION_P (orig_arg
))
9556 /* Substitute into an expansion expression. */
9557 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
9559 if (TREE_CODE (new_arg
) == TREE_VEC
)
9560 /* Add to the expanded length adjustment the number of
9561 expanded arguments. We subtract one from this
9562 measurement, because the argument pack expression
9563 itself is already counted as 1 in
9564 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
9565 the argument pack is empty. */
9566 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
9568 else if (ARGUMENT_PACK_P (orig_arg
))
9570 /* Substitute into each of the arguments. */
9571 new_arg
= TYPE_P (orig_arg
)
9572 ? cxx_make_type (TREE_CODE (orig_arg
))
9573 : make_node (TREE_CODE (orig_arg
));
9575 SET_ARGUMENT_PACK_ARGS (
9577 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
9578 args
, complain
, in_decl
));
9580 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
9581 new_arg
= error_mark_node
;
9583 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
9584 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
9586 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
9588 if (TREE_TYPE (new_arg
) == error_mark_node
)
9589 new_arg
= error_mark_node
;
9593 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
9595 if (new_arg
== error_mark_node
)
9596 return error_mark_node
;
9599 if (new_arg
!= orig_arg
)
9606 /* Make space for the expanded arguments coming from template
9608 t
= make_tree_vec (len
+ expanded_len_adjust
);
9609 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
9610 arguments for a member template.
9611 In that case each TREE_VEC in ORIG_T represents a level of template
9612 arguments, and ORIG_T won't carry any non defaulted argument count.
9613 It will rather be the nested TREE_VECs that will carry one.
9614 In other words, ORIG_T carries a non defaulted argument count only
9615 if it doesn't contain any nested TREE_VEC. */
9616 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
9618 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
9619 count
+= expanded_len_adjust
;
9620 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
9622 for (i
= 0, out
= 0; i
< len
; i
++)
9624 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
9625 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
9626 && TREE_CODE (elts
[i
]) == TREE_VEC
)
9630 /* Now expand the template argument pack "in place". */
9631 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
9632 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
9636 TREE_VEC_ELT (t
, out
) = elts
[i
];
9644 /* Return the result of substituting ARGS into the template parameters
9645 given by PARMS. If there are m levels of ARGS and m + n levels of
9646 PARMS, then the result will contain n levels of PARMS. For
9647 example, if PARMS is `template <class T> template <class U>
9648 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
9649 result will be `template <int*, double, class V>'. */
9652 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
9657 /* When substituting into a template, we must set
9658 PROCESSING_TEMPLATE_DECL as the template parameters may be
9659 dependent if they are based on one-another, and the dependency
9660 predicates are short-circuit outside of templates. */
9661 ++processing_template_decl
;
9663 for (new_parms
= &r
;
9664 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
9665 new_parms
= &(TREE_CHAIN (*new_parms
)),
9666 parms
= TREE_CHAIN (parms
))
9669 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
9672 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
9676 if (parms
== error_mark_node
)
9679 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
9681 if (tuple
== error_mark_node
)
9684 TREE_VEC_ELT (new_vec
, i
) =
9685 tsubst_template_parm (tuple
, args
, complain
);
9689 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
9690 - TMPL_ARGS_DEPTH (args
)),
9691 new_vec
, NULL_TREE
);
9694 --processing_template_decl
;
9699 /* Return the result of substituting ARGS into one template parameter
9700 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
9701 parameter and which TREE_PURPOSE is the default argument of the
9702 template parameter. */
9705 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
9707 tree default_value
, parm_decl
;
9709 if (args
== NULL_TREE
9711 || t
== error_mark_node
)
9714 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
9716 default_value
= TREE_PURPOSE (t
);
9717 parm_decl
= TREE_VALUE (t
);
9719 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
9720 if (TREE_CODE (parm_decl
) == PARM_DECL
9721 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
9722 parm_decl
= error_mark_node
;
9723 default_value
= tsubst_template_arg (default_value
, args
,
9724 complain
, NULL_TREE
);
9726 return build_tree_list (default_value
, parm_decl
);
9729 /* Substitute the ARGS into the indicated aggregate (or enumeration)
9730 type T. If T is not an aggregate or enumeration type, it is
9731 handled as if by tsubst. IN_DECL is as for tsubst. If
9732 ENTERING_SCOPE is nonzero, T is the context for a template which
9733 we are presently tsubst'ing. Return the substituted value. */
9736 tsubst_aggr_type (tree t
,
9738 tsubst_flags_t complain
,
9745 switch (TREE_CODE (t
))
9748 if (TYPE_PTRMEMFUNC_P (t
))
9749 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
9751 /* Else fall through. */
9754 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
9759 int saved_unevaluated_operand
;
9760 int saved_inhibit_evaluation_warnings
;
9762 /* In "sizeof(X<I>)" we need to evaluate "I". */
9763 saved_unevaluated_operand
= cp_unevaluated_operand
;
9764 cp_unevaluated_operand
= 0;
9765 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
9766 c_inhibit_evaluation_warnings
= 0;
9768 /* First, determine the context for the type we are looking
9770 context
= TYPE_CONTEXT (t
);
9771 if (context
&& TYPE_P (context
))
9773 context
= tsubst_aggr_type (context
, args
, complain
,
9774 in_decl
, /*entering_scope=*/1);
9775 /* If context is a nested class inside a class template,
9776 it may still need to be instantiated (c++/33959). */
9777 context
= complete_type (context
);
9780 /* Then, figure out what arguments are appropriate for the
9781 type we are trying to find. For example, given:
9783 template <class T> struct S;
9784 template <class T, class U> void f(T, U) { S<U> su; }
9786 and supposing that we are instantiating f<int, double>,
9787 then our ARGS will be {int, double}, but, when looking up
9788 S we only want {double}. */
9789 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
9791 if (argvec
== error_mark_node
)
9792 r
= error_mark_node
;
9795 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
9796 entering_scope
, complain
);
9797 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
9800 cp_unevaluated_operand
= saved_unevaluated_operand
;
9801 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
9806 /* This is not a template type, so there's nothing to do. */
9810 return tsubst (t
, args
, complain
, in_decl
);
9814 /* Substitute into the default argument ARG (a default argument for
9815 FN), which has the indicated TYPE. */
9818 tsubst_default_argument (tree fn
, tree type
, tree arg
)
9820 tree saved_class_ptr
= NULL_TREE
;
9821 tree saved_class_ref
= NULL_TREE
;
9822 int errs
= errorcount
+ sorrycount
;
9824 /* This can happen in invalid code. */
9825 if (TREE_CODE (arg
) == DEFAULT_ARG
)
9828 /* This default argument came from a template. Instantiate the
9829 default argument here, not in tsubst. In the case of
9838 we must be careful to do name lookup in the scope of S<T>,
9839 rather than in the current class. */
9840 push_access_scope (fn
);
9841 /* The "this" pointer is not valid in a default argument. */
9844 saved_class_ptr
= current_class_ptr
;
9845 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
9846 saved_class_ref
= current_class_ref
;
9847 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
9850 push_deferring_access_checks(dk_no_deferred
);
9851 /* The default argument expression may cause implicitly defined
9852 member functions to be synthesized, which will result in garbage
9853 collection. We must treat this situation as if we were within
9854 the body of function so as to avoid collecting live data on the
9857 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
9858 tf_warning_or_error
, NULL_TREE
,
9859 /*integral_constant_expression_p=*/false);
9861 pop_deferring_access_checks();
9863 /* Restore the "this" pointer. */
9866 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
9867 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
9870 if (errorcount
+sorrycount
> errs
)
9871 inform (input_location
,
9872 " when instantiating default argument for call to %D", fn
);
9874 /* Make sure the default argument is reasonable. */
9875 arg
= check_default_argument (type
, arg
);
9877 pop_access_scope (fn
);
9882 /* Substitute into all the default arguments for FN. */
9885 tsubst_default_arguments (tree fn
)
9890 tmpl_args
= DECL_TI_ARGS (fn
);
9892 /* If this function is not yet instantiated, we certainly don't need
9893 its default arguments. */
9894 if (uses_template_parms (tmpl_args
))
9896 /* Don't do this again for clones. */
9897 if (DECL_CLONED_FUNCTION_P (fn
))
9900 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
9902 arg
= TREE_CHAIN (arg
))
9903 if (TREE_PURPOSE (arg
))
9904 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
9906 TREE_PURPOSE (arg
));
9909 /* Substitute the ARGS into the T, which is a _DECL. Return the
9910 result of the substitution. Issue error and warning messages under
9911 control of COMPLAIN. */
9914 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
9916 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
9917 location_t saved_loc
;
9922 /* Set the filename and linenumber to improve error-reporting. */
9923 saved_loc
= input_location
;
9924 input_location
= DECL_SOURCE_LOCATION (t
);
9926 switch (TREE_CODE (t
))
9930 /* We can get here when processing a member function template,
9931 member class template, or template template parameter. */
9932 tree decl
= DECL_TEMPLATE_RESULT (t
);
9937 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9939 /* Template template parameter is treated here. */
9940 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
9941 if (new_type
== error_mark_node
)
9942 RETURN (error_mark_node
);
9943 /* If we get a real template back, return it. This can happen in
9944 the context of most_specialized_class. */
9945 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
9949 DECL_CHAIN (r
) = NULL_TREE
;
9950 TREE_TYPE (r
) = new_type
;
9951 DECL_TEMPLATE_RESULT (r
)
9952 = build_decl (DECL_SOURCE_LOCATION (decl
),
9953 TYPE_DECL
, DECL_NAME (decl
), new_type
);
9954 DECL_TEMPLATE_PARMS (r
)
9955 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
9957 TYPE_NAME (new_type
) = r
;
9961 /* We might already have an instance of this template.
9962 The ARGS are for the surrounding class type, so the
9963 full args contain the tsubst'd args for the context,
9964 plus the innermost args from the template decl. */
9965 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
9966 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
9967 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
9968 /* Because this is a template, the arguments will still be
9969 dependent, even after substitution. If
9970 PROCESSING_TEMPLATE_DECL is not set, the dependency
9971 predicates will short-circuit. */
9972 ++processing_template_decl
;
9973 full_args
= tsubst_template_args (tmpl_args
, args
,
9975 --processing_template_decl
;
9976 if (full_args
== error_mark_node
)
9977 RETURN (error_mark_node
);
9979 /* If this is a default template template argument,
9980 tsubst might not have changed anything. */
9981 if (full_args
== tmpl_args
)
9984 hash
= hash_tmpl_and_args (t
, full_args
);
9985 spec
= retrieve_specialization (t
, full_args
, hash
);
9986 if (spec
!= NULL_TREE
)
9992 /* Make a new template decl. It will be similar to the
9993 original, but will record the current template arguments.
9994 We also create a new function declaration, which is just
9995 like the old one, but points to this new template, rather
9996 than the old one. */
9998 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
9999 DECL_CHAIN (r
) = NULL_TREE
;
10001 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10003 if (TREE_CODE (decl
) == TYPE_DECL
10004 && !TYPE_DECL_ALIAS_P (decl
))
10007 ++processing_template_decl
;
10008 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10009 --processing_template_decl
;
10010 if (new_type
== error_mark_node
)
10011 RETURN (error_mark_node
);
10013 TREE_TYPE (r
) = new_type
;
10014 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10015 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10016 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10017 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10022 ++processing_template_decl
;
10023 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10024 --processing_template_decl
;
10025 if (new_decl
== error_mark_node
)
10026 RETURN (error_mark_node
);
10028 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10029 DECL_TI_TEMPLATE (new_decl
) = r
;
10030 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10031 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10032 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10035 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10036 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10037 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10039 /* The template parameters for this new template are all the
10040 template parameters for the old template, except the
10041 outermost level of parameters. */
10042 DECL_TEMPLATE_PARMS (r
)
10043 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10046 if (PRIMARY_TEMPLATE_P (t
))
10047 DECL_PRIMARY_TEMPLATE (r
) = r
;
10049 if (TREE_CODE (decl
) != TYPE_DECL
)
10050 /* Record this non-type partial instantiation. */
10051 register_specialization (r
, t
,
10052 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10057 case FUNCTION_DECL
:
10060 tree argvec
= NULL_TREE
;
10068 /* Nobody should be tsubst'ing into non-template functions. */
10069 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10071 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10076 /* If T is not dependent, just return it. We have to
10077 increment PROCESSING_TEMPLATE_DECL because
10078 value_dependent_expression_p assumes that nothing is
10079 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10080 ++processing_template_decl
;
10081 dependent_p
= value_dependent_expression_p (t
);
10082 --processing_template_decl
;
10086 /* Calculate the most general template of which R is a
10087 specialization, and the complete set of arguments used to
10089 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10090 argvec
= tsubst_template_args (DECL_TI_ARGS
10091 (DECL_TEMPLATE_RESULT
10092 (DECL_TI_TEMPLATE (t
))),
10093 args
, complain
, in_decl
);
10094 if (argvec
== error_mark_node
)
10095 RETURN (error_mark_node
);
10097 /* Check to see if we already have this specialization. */
10098 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10099 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10107 /* We can see more levels of arguments than parameters if
10108 there was a specialization of a member template, like
10111 template <class T> struct S { template <class U> void f(); }
10112 template <> template <class U> void S<int>::f(U);
10114 Here, we'll be substituting into the specialization,
10115 because that's where we can find the code we actually
10116 want to generate, but we'll have enough arguments for
10117 the most general template.
10119 We also deal with the peculiar case:
10121 template <class T> struct S {
10122 template <class U> friend void f();
10124 template <class U> void f() {}
10126 template void f<double>();
10128 Here, the ARGS for the instantiation of will be {int,
10129 double}. But, we only need as many ARGS as there are
10130 levels of template parameters in CODE_PATTERN. We are
10131 careful not to get fooled into reducing the ARGS in
10134 template <class T> struct S { template <class U> void f(U); }
10135 template <class T> template <> void S<T>::f(int) {}
10137 which we can spot because the pattern will be a
10138 specialization in this case. */
10139 args_depth
= TMPL_ARGS_DEPTH (args
);
10141 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10142 if (args_depth
> parms_depth
10143 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10144 args
= get_innermost_template_args (args
, parms_depth
);
10148 /* This special case arises when we have something like this:
10150 template <class T> struct S {
10151 friend void f<int>(int, double);
10154 Here, the DECL_TI_TEMPLATE for the friend declaration
10155 will be an IDENTIFIER_NODE. We are being called from
10156 tsubst_friend_function, and we want only to create a
10157 new decl (R) with appropriate types so that we can call
10158 determine_specialization. */
10159 gen_tmpl
= NULL_TREE
;
10162 if (DECL_CLASS_SCOPE_P (t
))
10164 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10168 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10169 complain
, t
, /*entering_scope=*/1);
10174 ctx
= DECL_CONTEXT (t
);
10176 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10177 if (type
== error_mark_node
)
10178 RETURN (error_mark_node
);
10180 /* If we hit excessive deduction depth, the type is bogus even if
10181 it isn't error_mark_node, so don't build a decl. */
10182 if (excessive_deduction_depth
)
10183 RETURN (error_mark_node
);
10185 /* We do NOT check for matching decls pushed separately at this
10186 point, as they may not represent instantiations of this
10187 template, and in any case are considered separate under the
10190 DECL_USE_TEMPLATE (r
) = 0;
10191 TREE_TYPE (r
) = type
;
10192 /* Clear out the mangled name and RTL for the instantiation. */
10193 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10194 SET_DECL_RTL (r
, NULL
);
10195 /* Leave DECL_INITIAL set on deleted instantiations. */
10196 if (!DECL_DELETED_FN (r
))
10197 DECL_INITIAL (r
) = NULL_TREE
;
10198 DECL_CONTEXT (r
) = ctx
;
10200 if (member
&& DECL_CONV_FN_P (r
))
10201 /* Type-conversion operator. Reconstruct the name, in
10202 case it's the name of one of the template's parameters. */
10203 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10205 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10207 DECL_RESULT (r
) = NULL_TREE
;
10209 TREE_STATIC (r
) = 0;
10210 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10211 DECL_EXTERNAL (r
) = 1;
10212 /* If this is an instantiation of a function with internal
10213 linkage, we already know what object file linkage will be
10214 assigned to the instantiation. */
10215 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10216 DECL_DEFER_OUTPUT (r
) = 0;
10217 DECL_CHAIN (r
) = NULL_TREE
;
10218 DECL_PENDING_INLINE_INFO (r
) = 0;
10219 DECL_PENDING_INLINE_P (r
) = 0;
10220 DECL_SAVED_TREE (r
) = NULL_TREE
;
10221 DECL_STRUCT_FUNCTION (r
) = NULL
;
10223 /* We'll re-clone as appropriate in instantiate_template. */
10224 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10226 /* If we aren't complaining now, return on error before we register
10227 the specialization so that we'll complain eventually. */
10228 if ((complain
& tf_error
) == 0
10229 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10230 && !grok_op_properties (r
, /*complain=*/false))
10231 RETURN (error_mark_node
);
10233 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10234 this in the special friend case mentioned above where
10235 GEN_TMPL is NULL. */
10238 DECL_TEMPLATE_INFO (r
)
10239 = build_template_info (gen_tmpl
, argvec
);
10240 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10241 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10243 /* We're not supposed to instantiate default arguments
10244 until they are called, for a template. But, for a
10247 template <class T> void f ()
10248 { extern void g(int i = T()); }
10250 we should do the substitution when the template is
10251 instantiated. We handle the member function case in
10252 instantiate_class_template since the default arguments
10253 might refer to other members of the class. */
10255 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10256 && !uses_template_parms (argvec
))
10257 tsubst_default_arguments (r
);
10260 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10262 /* Copy the list of befriending classes. */
10263 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10265 friends
= &TREE_CHAIN (*friends
))
10267 *friends
= copy_node (*friends
);
10268 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
10273 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
10275 maybe_retrofit_in_chrg (r
);
10276 if (DECL_CONSTRUCTOR_P (r
))
10277 grok_ctor_properties (ctx
, r
);
10278 if (DECL_INHERITED_CTOR_BASE (r
))
10279 deduce_inheriting_ctor (r
);
10280 /* If this is an instantiation of a member template, clone it.
10281 If it isn't, that'll be handled by
10282 clone_constructors_and_destructors. */
10283 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
10284 clone_function_decl (r
, /*update_method_vec_p=*/0);
10286 else if ((complain
& tf_error
) != 0
10287 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10288 && !grok_op_properties (r
, /*complain=*/true))
10289 RETURN (error_mark_node
);
10291 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
10292 SET_DECL_FRIEND_CONTEXT (r
,
10293 tsubst (DECL_FRIEND_CONTEXT (t
),
10294 args
, complain
, in_decl
));
10296 /* Possibly limit visibility based on template args. */
10297 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10298 if (DECL_VISIBILITY_SPECIFIED (t
))
10300 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10301 DECL_ATTRIBUTES (r
)
10302 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10304 determine_visibility (r
);
10305 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
10306 && !processing_template_decl
)
10307 defaulted_late_check (r
);
10309 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10310 args
, complain
, in_decl
);
10316 tree type
= NULL_TREE
;
10318 tree expanded_types
= NULL_TREE
;
10319 tree prev_r
= NULL_TREE
;
10320 tree first_r
= NULL_TREE
;
10322 if (FUNCTION_PARAMETER_PACK_P (t
))
10324 /* If there is a local specialization that isn't a
10325 parameter pack, it means that we're doing a "simple"
10326 substitution from inside tsubst_pack_expansion. Just
10327 return the local specialization (which will be a single
10329 tree spec
= retrieve_local_specialization (t
);
10331 && TREE_CODE (spec
) == PARM_DECL
10332 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
10335 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10336 the parameters in this function parameter pack. */
10337 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10338 complain
, in_decl
);
10339 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10341 len
= TREE_VEC_LENGTH (expanded_types
);
10343 /* Zero-length parameter packs are boring. Just substitute
10346 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
10351 /* All we did was update the type. Make a note of that. */
10352 type
= expanded_types
;
10353 expanded_types
= NULL_TREE
;
10357 /* Loop through all of the parameter's we'll build. When T is
10358 a function parameter pack, LEN is the number of expanded
10359 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10361 for (i
= 0; i
< len
; ++i
)
10365 if (DECL_TEMPLATE_PARM_P (t
))
10366 SET_DECL_TEMPLATE_PARM_P (r
);
10368 if (expanded_types
)
10369 /* We're on the Ith parameter of the function parameter
10372 /* An argument of a function parameter pack is not a parameter
10374 FUNCTION_PARAMETER_PACK_P (r
) = false;
10376 /* Get the Ith type. */
10377 type
= TREE_VEC_ELT (expanded_types
, i
);
10379 /* Rename the parameter to include the index. */
10381 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10384 /* We're dealing with a normal parameter. */
10385 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10387 type
= type_decays_to (type
);
10388 TREE_TYPE (r
) = type
;
10389 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10391 if (DECL_INITIAL (r
))
10393 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
10394 DECL_INITIAL (r
) = TREE_TYPE (r
);
10396 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
10397 complain
, in_decl
);
10400 DECL_CONTEXT (r
) = NULL_TREE
;
10402 if (!DECL_TEMPLATE_PARM_P (r
))
10403 DECL_ARG_TYPE (r
) = type_passed_as (type
);
10405 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10406 args
, complain
, in_decl
);
10408 /* Keep track of the first new parameter we
10409 generate. That's what will be returned to the
10414 /* Build a proper chain of parameters when substituting
10415 into a function parameter pack. */
10417 DECL_CHAIN (prev_r
) = r
;
10420 /* If cp_unevaluated_operand is set, we're just looking for a
10421 single dummy parameter, so don't keep going. */
10422 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
10423 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
10424 complain
, DECL_CHAIN (t
));
10426 /* FIRST_R contains the start of the chain we've built. */
10436 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10437 if (type
== error_mark_node
)
10438 RETURN (error_mark_node
);
10439 TREE_TYPE (r
) = type
;
10440 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10442 if (DECL_C_BIT_FIELD (r
))
10443 /* For bit-fields, DECL_INITIAL gives the number of bits. For
10444 non-bit-fields DECL_INITIAL is a non-static data member
10445 initializer, which gets deferred instantiation. */
10447 = tsubst_expr (DECL_INITIAL (t
), args
,
10449 /*integral_constant_expression_p=*/true);
10450 else if (DECL_INITIAL (t
))
10452 /* Set up DECL_TEMPLATE_INFO so that we can get at the
10453 NSDMI in perform_member_init. Still set DECL_INITIAL
10454 so that we know there is one. */
10455 DECL_INITIAL (r
) = void_zero_node
;
10456 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
10457 retrofit_lang_decl (r
);
10458 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10460 /* We don't have to set DECL_CONTEXT here; it is set by
10461 finish_member_declaration. */
10462 DECL_CHAIN (r
) = NULL_TREE
;
10463 if (VOID_TYPE_P (type
))
10464 error ("instantiation of %q+D as type %qT", r
, type
);
10466 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10467 args
, complain
, in_decl
);
10472 /* We reach here only for member using decls. We also need to check
10473 uses_template_parms because DECL_DEPENDENT_P is not set for a
10474 using-declaration that designates a member of the current
10475 instantiation (c++/53549). */
10476 if (DECL_DEPENDENT_P (t
)
10477 || uses_template_parms (USING_DECL_SCOPE (t
)))
10479 tree scope
= USING_DECL_SCOPE (t
);
10480 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
10481 complain
, in_decl
);
10482 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
10483 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
10484 && name
== TYPE_IDENTIFIER (scope
))
10485 name
= TYPE_IDENTIFIER (inst_scope
);
10486 r
= do_class_using_decl (inst_scope
, name
);
10488 r
= error_mark_node
;
10491 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
10492 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
10498 DECL_CHAIN (r
) = NULL_TREE
;
10505 tree argvec
= NULL_TREE
;
10506 tree gen_tmpl
= NULL_TREE
;
10508 tree tmpl
= NULL_TREE
;
10510 tree type
= NULL_TREE
;
10513 if (TREE_CODE (t
) == TYPE_DECL
10514 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
10516 /* If this is the canonical decl, we don't have to
10517 mess with instantiations, and often we can't (for
10518 typename, template type parms and such). Note that
10519 TYPE_NAME is not correct for the above test if
10520 we've copied the type for a typedef. */
10521 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10522 if (type
== error_mark_node
)
10523 RETURN (error_mark_node
);
10524 r
= TYPE_NAME (type
);
10528 /* Check to see if we already have the specialization we
10531 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
10533 /* T is a static data member or namespace-scope entity.
10534 We have to substitute into namespace-scope variables
10535 (even though such entities are never templates) because
10538 template <class T> void f() { extern T t; }
10540 where the entity referenced is not known until
10541 instantiation time. */
10543 ctx
= DECL_CONTEXT (t
);
10544 if (DECL_CLASS_SCOPE_P (t
))
10546 ctx
= tsubst_aggr_type (ctx
, args
,
10548 in_decl
, /*entering_scope=*/1);
10549 /* If CTX is unchanged, then T is in fact the
10550 specialization we want. That situation occurs when
10551 referencing a static data member within in its own
10552 class. We can use pointer equality, rather than
10553 same_type_p, because DECL_CONTEXT is always
10555 if (ctx
== DECL_CONTEXT (t
)
10556 && (TREE_CODE (t
) != TYPE_DECL
10557 /* ... unless T is a member template; in which
10558 case our caller can be willing to create a
10559 specialization of that template represented
10561 || !(DECL_TI_TEMPLATE (t
)
10562 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))))
10568 tmpl
= DECL_TI_TEMPLATE (t
);
10569 gen_tmpl
= most_general_template (tmpl
);
10570 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
10571 if (argvec
== error_mark_node
)
10572 RETURN (error_mark_node
);
10573 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10574 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10579 /* A local variable. */
10581 /* Subsequent calls to pushdecl will fill this in. */
10583 spec
= retrieve_local_specialization (t
);
10585 /* If we already have the specialization we need, there is
10586 nothing more to do. */
10593 if (TREE_CODE (t
) == VAR_DECL
&& DECL_ANON_UNION_VAR_P (t
))
10595 /* Just use name lookup to find a member alias for an anonymous
10596 union, but then add it to the hash table. */
10597 r
= lookup_name (DECL_NAME (t
));
10598 gcc_assert (DECL_ANON_UNION_VAR_P (r
));
10599 register_local_specialization (r
, t
);
10603 /* Create a new node for the specialization we need. */
10605 if (type
== NULL_TREE
)
10607 if (is_typedef_decl (t
))
10608 type
= DECL_ORIGINAL_TYPE (t
);
10610 type
= TREE_TYPE (t
);
10611 if (TREE_CODE (t
) == VAR_DECL
10612 && VAR_HAD_UNKNOWN_BOUND (t
)
10613 && type
!= error_mark_node
)
10614 type
= strip_array_domain (type
);
10615 type
= tsubst (type
, args
, complain
, in_decl
);
10617 if (TREE_CODE (r
) == VAR_DECL
)
10619 /* Even if the original location is out of scope, the
10620 newly substituted one is not. */
10621 DECL_DEAD_FOR_LOCAL (r
) = 0;
10622 DECL_INITIALIZED_P (r
) = 0;
10623 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
10624 if (type
== error_mark_node
)
10625 RETURN (error_mark_node
);
10626 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10628 /* It may seem that this case cannot occur, since:
10633 declares a function, not a variable. However:
10636 template <typename T> void g() { T t; }
10637 template void g<f>();
10639 is an attempt to declare a variable with function
10641 error ("variable %qD has function type",
10642 /* R is not yet sufficiently initialized, so we
10643 just use its name. */
10645 RETURN (error_mark_node
);
10647 type
= complete_type (type
);
10648 /* Wait until cp_finish_decl to set this again, to handle
10649 circular dependency (template/instantiate6.C). */
10650 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
10651 type
= check_var_type (DECL_NAME (r
), type
);
10653 if (DECL_HAS_VALUE_EXPR_P (t
))
10655 tree ve
= DECL_VALUE_EXPR (t
);
10656 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
10657 /*constant_expression_p=*/false);
10658 if (REFERENCE_REF_P (ve
))
10660 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
10661 ve
= TREE_OPERAND (ve
, 0);
10663 SET_DECL_VALUE_EXPR (r
, ve
);
10666 else if (DECL_SELF_REFERENCE_P (t
))
10667 SET_DECL_SELF_REFERENCE_P (r
);
10668 TREE_TYPE (r
) = type
;
10669 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10670 DECL_CONTEXT (r
) = ctx
;
10671 /* Clear out the mangled name and RTL for the instantiation. */
10672 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10673 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
10674 SET_DECL_RTL (r
, NULL
);
10675 /* The initializer must not be expanded until it is required;
10676 see [temp.inst]. */
10677 DECL_INITIAL (r
) = NULL_TREE
;
10678 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
10679 SET_DECL_RTL (r
, NULL
);
10680 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
10681 if (TREE_CODE (r
) == VAR_DECL
)
10683 /* Possibly limit visibility based on template args. */
10684 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10685 if (DECL_VISIBILITY_SPECIFIED (t
))
10687 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10688 DECL_ATTRIBUTES (r
)
10689 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10691 determine_visibility (r
);
10696 /* A static data member declaration is always marked
10697 external when it is declared in-class, even if an
10698 initializer is present. We mimic the non-template
10699 processing here. */
10700 DECL_EXTERNAL (r
) = 1;
10702 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10703 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
10704 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10706 else if (cp_unevaluated_operand
)
10708 /* We're substituting this var in a decltype outside of its
10709 scope, such as for a lambda return type. Don't add it to
10710 local_specializations, do perform auto deduction. */
10711 tree auto_node
= type_uses_auto (type
);
10715 = tsubst_expr (DECL_INITIAL (t
), args
, complain
, in_decl
,
10716 /*constant_expression_p=*/false);
10717 init
= resolve_nondeduced_context (init
);
10718 TREE_TYPE (r
) = type
10719 = do_auto_deduction (type
, init
, auto_node
);
10723 register_local_specialization (r
, t
);
10725 DECL_CHAIN (r
) = NULL_TREE
;
10727 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
10729 args
, complain
, in_decl
);
10731 /* Preserve a typedef that names a type. */
10732 if (is_typedef_decl (r
))
10734 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
10735 set_underlying_type (r
);
10738 layout_decl (r
, 0);
10743 gcc_unreachable ();
10748 /* Restore the file and line information. */
10749 input_location
= saved_loc
;
10754 /* Substitute into the ARG_TYPES of a function type.
10755 If END is a TREE_CHAIN, leave it and any following types
10759 tsubst_arg_types (tree arg_types
,
10762 tsubst_flags_t complain
,
10765 tree remaining_arg_types
;
10766 tree type
= NULL_TREE
;
10768 tree expanded_args
= NULL_TREE
;
10771 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
10774 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
10775 args
, end
, complain
, in_decl
);
10776 if (remaining_arg_types
== error_mark_node
)
10777 return error_mark_node
;
10779 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
10781 /* For a pack expansion, perform substitution on the
10782 entire expression. Later on, we'll handle the arguments
10784 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
10785 args
, complain
, in_decl
);
10787 if (TREE_CODE (expanded_args
) == TREE_VEC
)
10788 /* So that we'll spin through the parameters, one by one. */
10789 i
= TREE_VEC_LENGTH (expanded_args
);
10792 /* We only partially substituted into the parameter
10793 pack. Our type is TYPE_PACK_EXPANSION. */
10794 type
= expanded_args
;
10795 expanded_args
= NULL_TREE
;
10803 type
= TREE_VEC_ELT (expanded_args
, i
);
10805 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
10807 if (type
== error_mark_node
)
10808 return error_mark_node
;
10809 if (VOID_TYPE_P (type
))
10811 if (complain
& tf_error
)
10813 error ("invalid parameter type %qT", type
);
10815 error ("in declaration %q+D", in_decl
);
10817 return error_mark_node
;
10820 /* Do array-to-pointer, function-to-pointer conversion, and ignore
10821 top-level qualifiers as required. */
10822 type
= cv_unqualified (type_decays_to (type
));
10824 /* We do not substitute into default arguments here. The standard
10825 mandates that they be instantiated only when needed, which is
10826 done in build_over_call. */
10827 default_arg
= TREE_PURPOSE (arg_types
);
10829 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
10831 /* We've instantiated a template before its default arguments
10832 have been parsed. This can happen for a nested template
10833 class, and is not an error unless we require the default
10834 argument in a call of this function. */
10835 remaining_arg_types
=
10836 tree_cons (default_arg
, type
, remaining_arg_types
);
10837 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
10840 remaining_arg_types
=
10841 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
10844 return remaining_arg_types
;
10847 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
10848 *not* handle the exception-specification for FNTYPE, because the
10849 initial substitution of explicitly provided template parameters
10850 during argument deduction forbids substitution into the
10851 exception-specification:
10855 All references in the function type of the function template to the
10856 corresponding template parameters are replaced by the specified tem-
10857 plate argument values. If a substitution in a template parameter or
10858 in the function type of the function template results in an invalid
10859 type, type deduction fails. [Note: The equivalent substitution in
10860 exception specifications is done only when the function is instanti-
10861 ated, at which point a program is ill-formed if the substitution
10862 results in an invalid type.] */
10865 tsubst_function_type (tree t
,
10867 tsubst_flags_t complain
,
10874 /* The TYPE_CONTEXT is not used for function/method types. */
10875 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
10877 /* Substitute the return type. */
10878 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10879 if (return_type
== error_mark_node
)
10880 return error_mark_node
;
10881 /* The standard does not presently indicate that creation of a
10882 function type with an invalid return type is a deduction failure.
10883 However, that is clearly analogous to creating an array of "void"
10884 or a reference to a reference. This is core issue #486. */
10885 if (TREE_CODE (return_type
) == ARRAY_TYPE
10886 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
10888 if (complain
& tf_error
)
10890 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
10891 error ("function returning an array");
10893 error ("function returning a function");
10895 return error_mark_node
;
10898 /* Substitute the argument types. */
10899 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
10900 complain
, in_decl
);
10901 if (arg_types
== error_mark_node
)
10902 return error_mark_node
;
10904 /* Construct a new type node and return it. */
10905 if (TREE_CODE (t
) == FUNCTION_TYPE
)
10907 fntype
= build_function_type (return_type
, arg_types
);
10908 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (t
));
10912 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
10913 if (! MAYBE_CLASS_TYPE_P (r
))
10917 Type deduction may fail for any of the following
10920 -- Attempting to create "pointer to member of T" when T
10921 is not a class type. */
10922 if (complain
& tf_error
)
10923 error ("creating pointer to member function of non-class type %qT",
10925 return error_mark_node
;
10928 fntype
= build_method_type_directly (r
, return_type
,
10929 TREE_CHAIN (arg_types
));
10931 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
10936 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
10937 ARGS into that specification, and return the substituted
10938 specification. If there is no specification, return NULL_TREE. */
10941 tsubst_exception_specification (tree fntype
,
10943 tsubst_flags_t complain
,
10950 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
10951 new_specs
= NULL_TREE
;
10952 if (specs
&& TREE_PURPOSE (specs
))
10954 /* A noexcept-specifier. */
10955 tree expr
= TREE_PURPOSE (specs
);
10956 if (TREE_CODE (expr
) == INTEGER_CST
)
10960 /* Defer instantiation of noexcept-specifiers to avoid
10961 excessive instantiations (c++/49107). */
10962 new_specs
= make_node (DEFERRED_NOEXCEPT
);
10963 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
10965 /* We already partially instantiated this member template,
10966 so combine the new args with the old. */
10967 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
10968 = DEFERRED_NOEXCEPT_PATTERN (expr
);
10969 DEFERRED_NOEXCEPT_ARGS (new_specs
)
10970 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
10974 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
10975 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
10979 new_specs
= tsubst_copy_and_build
10980 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
10981 /*integral_constant_expression_p=*/true);
10982 new_specs
= build_noexcept_spec (new_specs
, complain
);
10986 if (! TREE_VALUE (specs
))
10993 tree expanded_specs
= NULL_TREE
;
10995 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
10997 /* Expand the pack expansion type. */
10998 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11002 if (expanded_specs
== error_mark_node
)
11003 return error_mark_node
;
11004 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11005 len
= TREE_VEC_LENGTH (expanded_specs
);
11008 /* We're substituting into a member template, so
11009 we got a TYPE_PACK_EXPANSION back. Add that
11010 expansion and move on. */
11011 gcc_assert (TREE_CODE (expanded_specs
)
11012 == TYPE_PACK_EXPANSION
);
11013 new_specs
= add_exception_specifier (new_specs
,
11016 specs
= TREE_CHAIN (specs
);
11021 for (i
= 0; i
< len
; ++i
)
11023 if (expanded_specs
)
11024 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11026 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11027 if (spec
== error_mark_node
)
11029 new_specs
= add_exception_specifier (new_specs
, spec
,
11033 specs
= TREE_CHAIN (specs
);
11039 /* Take the tree structure T and replace template parameters used
11040 therein with the argument vector ARGS. IN_DECL is an associated
11041 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11042 Issue error and warning messages under control of COMPLAIN. Note
11043 that we must be relatively non-tolerant of extensions here, in
11044 order to preserve conformance; if we allow substitutions that
11045 should not be allowed, we may allow argument deductions that should
11046 not succeed, and therefore report ambiguous overload situations
11047 where there are none. In theory, we could allow the substitution,
11048 but indicate that it should have failed, and allow our caller to
11049 make sure that the right thing happens, but we don't try to do this
11052 This function is used for dealing with types, decls and the like;
11053 for expressions, use tsubst_expr or tsubst_copy. */
11056 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11058 enum tree_code code
;
11059 tree type
, r
= NULL_TREE
;
11061 if (t
== NULL_TREE
|| t
== error_mark_node
11062 || t
== integer_type_node
11063 || t
== void_type_node
11064 || t
== char_type_node
11065 || t
== unknown_type_node
11066 || TREE_CODE (t
) == NAMESPACE_DECL
11067 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11071 return tsubst_decl (t
, args
, complain
);
11073 if (args
== NULL_TREE
)
11076 code
= TREE_CODE (t
);
11078 if (code
== IDENTIFIER_NODE
)
11079 type
= IDENTIFIER_TYPE_VALUE (t
);
11081 type
= TREE_TYPE (t
);
11083 gcc_assert (type
!= unknown_type_node
);
11085 /* Reuse typedefs. We need to do this to handle dependent attributes,
11086 such as attribute aligned. */
11088 && typedef_variant_p (t
))
11090 tree decl
= TYPE_NAME (t
);
11092 if (alias_template_specialization_p (t
))
11094 /* DECL represents an alias template and we want to
11096 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11097 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11098 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11100 else if (DECL_CLASS_SCOPE_P (decl
)
11101 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11102 && uses_template_parms (DECL_CONTEXT (decl
)))
11104 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11105 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11106 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11108 else if (DECL_FUNCTION_SCOPE_P (decl
)
11109 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11110 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11111 r
= retrieve_local_specialization (decl
);
11113 /* The typedef is from a non-template context. */
11119 r
= cp_build_qualified_type_real
11120 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11121 complain
| tf_ignore_bad_quals
);
11126 /* We don't have an instantiation yet, so drop the typedef. */
11127 int quals
= cp_type_quals (t
);
11128 t
= DECL_ORIGINAL_TYPE (decl
);
11129 t
= cp_build_qualified_type_real (t
, quals
,
11130 complain
| tf_ignore_bad_quals
);
11135 && code
!= TYPENAME_TYPE
11136 && code
!= TEMPLATE_TYPE_PARM
11137 && code
!= IDENTIFIER_NODE
11138 && code
!= FUNCTION_TYPE
11139 && code
!= METHOD_TYPE
)
11140 type
= tsubst (type
, args
, complain
, in_decl
);
11141 if (type
== error_mark_node
)
11142 return error_mark_node
;
11148 case ENUMERAL_TYPE
:
11149 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11150 /*entering_scope=*/0);
11153 case IDENTIFIER_NODE
:
11164 if (t
== integer_type_node
)
11167 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11168 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11172 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11174 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11175 /*integral_constant_expression_p=*/false);
11177 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11179 if (TREE_CODE (max
) == NOP_EXPR
11180 && TREE_SIDE_EFFECTS (omax
)
11181 && !TREE_TYPE (max
))
11182 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11184 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11185 with TREE_SIDE_EFFECTS that indicates this is not an integral
11186 constant expression. */
11187 if (processing_template_decl
11188 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11190 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11191 TREE_SIDE_EFFECTS (max
) = 1;
11194 return compute_array_index_type (NULL_TREE
, max
, complain
);
11197 case TEMPLATE_TYPE_PARM
:
11198 case TEMPLATE_TEMPLATE_PARM
:
11199 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11200 case TEMPLATE_PARM_INDEX
:
11205 tree arg
= NULL_TREE
;
11209 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
11210 template_parm_level_and_index (t
, &level
, &idx
);
11212 levels
= TMPL_ARGS_DEPTH (args
);
11213 if (level
<= levels
)
11215 arg
= TMPL_ARG (args
, level
, idx
);
11217 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
11219 /* See through ARGUMENT_PACK_SELECT arguments. */
11220 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
11221 /* If the selected argument is an expansion E, that most
11222 likely means we were called from
11223 gen_elem_of_pack_expansion_instantiation during the
11224 substituting of pack an argument pack (which Ith
11225 element is a pack expansion, where I is
11226 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11227 In this case, the Ith element resulting from this
11228 substituting is going to be a pack expansion, which
11229 pattern is the pattern of E. Let's return the
11231 gen_elem_of_pack_expansion_instantiation will
11232 build the resulting pack expansion from it. */
11233 if (PACK_EXPANSION_P (arg
))
11234 arg
= PACK_EXPANSION_PATTERN (arg
);
11238 if (arg
== error_mark_node
)
11239 return error_mark_node
;
11240 else if (arg
!= NULL_TREE
)
11242 if (ARGUMENT_PACK_P (arg
))
11243 /* If ARG is an argument pack, we don't actually want to
11244 perform a substitution here, because substitutions
11245 for argument packs are only done
11246 element-by-element. We can get to this point when
11247 substituting the type of a non-type template
11248 parameter pack, when that type actually contains
11249 template parameter packs from an outer template, e.g.,
11251 template<typename... Types> struct A {
11252 template<Types... Values> struct B { };
11256 if (code
== TEMPLATE_TYPE_PARM
)
11259 gcc_assert (TYPE_P (arg
));
11261 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
11263 return cp_build_qualified_type_real
11264 (arg
, quals
, complain
| tf_ignore_bad_quals
);
11266 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11268 /* We are processing a type constructed from a
11269 template template parameter. */
11270 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
11271 args
, complain
, in_decl
);
11272 if (argvec
== error_mark_node
)
11273 return error_mark_node
;
11275 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
11276 || TREE_CODE (arg
) == TEMPLATE_DECL
11277 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
11279 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
11280 /* Consider this code:
11282 template <template <class> class Template>
11284 template <class Arg> using Bind = Template<Arg>;
11287 template <template <class> class Template, class Arg>
11288 using Instantiate = Template<Arg>; //#0
11290 template <template <class> class Template,
11293 Instantiate<Internal<Template>::template Bind,
11296 When #1 is parsed, the
11297 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11298 parameter `Template' in #0 matches the
11299 UNBOUND_CLASS_TEMPLATE representing the argument
11300 `Internal<Template>::template Bind'; We then want
11301 to assemble the type `Bind<Argument>' that can't
11302 be fully created right now, because
11303 `Internal<Template>' not being complete, the Bind
11304 template cannot be looked up in that context. So
11305 we need to "store" `Bind<Argument>' for later
11306 when the context of Bind becomes complete. Let's
11307 store that in a TYPENAME_TYPE. */
11308 return make_typename_type (TYPE_CONTEXT (arg
),
11309 build_nt (TEMPLATE_ID_EXPR
,
11310 TYPE_IDENTIFIER (arg
),
11315 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11316 are resolving nested-types in the signature of a
11317 member function templates. Otherwise ARG is a
11318 TEMPLATE_DECL and is the real template to be
11320 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11321 arg
= TYPE_NAME (arg
);
11323 r
= lookup_template_class (arg
,
11325 DECL_CONTEXT (arg
),
11326 /*entering_scope=*/0,
11328 return cp_build_qualified_type_real
11329 (r
, cp_type_quals (t
), complain
);
11332 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11333 return convert_from_reference (unshare_expr (arg
));
11337 /* This can happen during the attempted tsubst'ing in
11338 unify. This means that we don't yet have any information
11339 about the template parameter in question. */
11342 /* Early in template argument deduction substitution, we don't
11343 want to reduce the level of 'auto', or it will be confused
11344 with a normal template parm in subsequent deduction. */
11345 if (is_auto (t
) && (complain
& tf_partial
))
11348 /* If we get here, we must have been looking at a parm for a
11349 more deeply nested template. Make a new version of this
11350 template parameter, but with a lower level. */
11353 case TEMPLATE_TYPE_PARM
:
11354 case TEMPLATE_TEMPLATE_PARM
:
11355 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11356 if (cp_type_quals (t
))
11358 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
11359 r
= cp_build_qualified_type_real
11360 (r
, cp_type_quals (t
),
11361 complain
| (code
== TEMPLATE_TYPE_PARM
11362 ? tf_ignore_bad_quals
: 0));
11367 TEMPLATE_TYPE_PARM_INDEX (r
)
11368 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
11369 r
, levels
, args
, complain
);
11370 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
11371 TYPE_MAIN_VARIANT (r
) = r
;
11372 TYPE_POINTER_TO (r
) = NULL_TREE
;
11373 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
11375 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
11376 /* We have reduced the level of the template
11377 template parameter, but not the levels of its
11378 template parameters, so canonical_type_parameter
11379 will not be able to find the canonical template
11380 template parameter for this level. Thus, we
11381 require structural equality checking to compare
11382 TEMPLATE_TEMPLATE_PARMs. */
11383 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11384 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
11385 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11387 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
11389 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11391 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
11392 complain
, in_decl
);
11393 if (argvec
== error_mark_node
)
11394 return error_mark_node
;
11396 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
11397 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
11402 case TEMPLATE_PARM_INDEX
:
11403 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
11407 gcc_unreachable ();
11415 tree purpose
, value
, chain
;
11417 if (t
== void_list_node
)
11420 purpose
= TREE_PURPOSE (t
);
11423 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
11424 if (purpose
== error_mark_node
)
11425 return error_mark_node
;
11427 value
= TREE_VALUE (t
);
11430 value
= tsubst (value
, args
, complain
, in_decl
);
11431 if (value
== error_mark_node
)
11432 return error_mark_node
;
11434 chain
= TREE_CHAIN (t
);
11435 if (chain
&& chain
!= void_type_node
)
11437 chain
= tsubst (chain
, args
, complain
, in_decl
);
11438 if (chain
== error_mark_node
)
11439 return error_mark_node
;
11441 if (purpose
== TREE_PURPOSE (t
)
11442 && value
== TREE_VALUE (t
)
11443 && chain
== TREE_CHAIN (t
))
11445 return hash_tree_cons (purpose
, value
, chain
);
11449 /* We should never be tsubsting a binfo. */
11450 gcc_unreachable ();
11453 /* A vector of template arguments. */
11454 gcc_assert (!type
);
11455 return tsubst_template_args (t
, args
, complain
, in_decl
);
11458 case REFERENCE_TYPE
:
11460 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
11465 Type deduction may fail for any of the following
11468 -- Attempting to create a pointer to reference type.
11469 -- Attempting to create a reference to a reference type or
11470 a reference to void.
11472 Core issue 106 says that creating a reference to a reference
11473 during instantiation is no longer a cause for failure. We
11474 only enforce this check in strict C++98 mode. */
11475 if ((TREE_CODE (type
) == REFERENCE_TYPE
11476 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
11477 || (code
== REFERENCE_TYPE
&& TREE_CODE (type
) == VOID_TYPE
))
11479 static location_t last_loc
;
11481 /* We keep track of the last time we issued this error
11482 message to avoid spewing a ton of messages during a
11483 single bad template instantiation. */
11484 if (complain
& tf_error
11485 && last_loc
!= input_location
)
11487 if (TREE_CODE (type
) == VOID_TYPE
)
11488 error ("forming reference to void");
11489 else if (code
== POINTER_TYPE
)
11490 error ("forming pointer to reference type %qT", type
);
11492 error ("forming reference to reference type %qT", type
);
11493 last_loc
= input_location
;
11496 return error_mark_node
;
11498 else if (code
== POINTER_TYPE
)
11500 r
= build_pointer_type (type
);
11501 if (TREE_CODE (type
) == METHOD_TYPE
)
11502 r
= build_ptrmemfunc_type (r
);
11504 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
11505 /* In C++0x, during template argument substitution, when there is an
11506 attempt to create a reference to a reference type, reference
11507 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
11509 "If a template-argument for a template-parameter T names a type
11510 that is a reference to a type A, an attempt to create the type
11511 'lvalue reference to cv T' creates the type 'lvalue reference to
11512 A,' while an attempt to create the type type rvalue reference to
11513 cv T' creates the type T"
11515 r
= cp_build_reference_type
11517 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
11519 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
11520 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
11522 if (r
!= error_mark_node
)
11523 /* Will this ever be needed for TYPE_..._TO values? */
11530 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
11531 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
11535 Type deduction may fail for any of the following
11538 -- Attempting to create "pointer to member of T" when T
11539 is not a class type. */
11540 if (complain
& tf_error
)
11541 error ("creating pointer to member of non-class type %qT", r
);
11542 return error_mark_node
;
11544 if (TREE_CODE (type
) == REFERENCE_TYPE
)
11546 if (complain
& tf_error
)
11547 error ("creating pointer to member reference type %qT", type
);
11548 return error_mark_node
;
11550 if (TREE_CODE (type
) == VOID_TYPE
)
11552 if (complain
& tf_error
)
11553 error ("creating pointer to member of type void");
11554 return error_mark_node
;
11556 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
11557 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11559 /* The type of the implicit object parameter gets its
11560 cv-qualifiers from the FUNCTION_TYPE. */
11562 tree method_type
= build_memfn_type (type
, r
, type_memfn_quals (type
));
11563 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
11564 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
11568 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
11572 case FUNCTION_TYPE
:
11577 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
11578 if (fntype
== error_mark_node
)
11579 return error_mark_node
;
11581 /* Substitute the exception specification. */
11582 specs
= tsubst_exception_specification (t
, args
, complain
,
11583 in_decl
, /*defer_ok*/true);
11584 if (specs
== error_mark_node
)
11585 return error_mark_node
;
11587 fntype
= build_exception_variant (fntype
, specs
);
11592 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
11593 if (domain
== error_mark_node
)
11594 return error_mark_node
;
11596 /* As an optimization, we avoid regenerating the array type if
11597 it will obviously be the same as T. */
11598 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
11601 /* These checks should match the ones in grokdeclarator.
11605 The deduction may fail for any of the following reasons:
11607 -- Attempting to create an array with an element type that
11608 is void, a function type, or a reference type, or [DR337]
11609 an abstract class type. */
11610 if (TREE_CODE (type
) == VOID_TYPE
11611 || TREE_CODE (type
) == FUNCTION_TYPE
11612 || TREE_CODE (type
) == REFERENCE_TYPE
)
11614 if (complain
& tf_error
)
11615 error ("creating array of %qT", type
);
11616 return error_mark_node
;
11618 if (ABSTRACT_CLASS_TYPE_P (type
))
11620 if (complain
& tf_error
)
11621 error ("creating array of %qT, which is an abstract class type",
11623 return error_mark_node
;
11626 r
= build_cplus_array_type (type
, domain
);
11628 if (TYPE_USER_ALIGN (t
))
11630 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
11631 TYPE_USER_ALIGN (r
) = 1;
11637 case TYPENAME_TYPE
:
11639 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
11640 in_decl
, /*entering_scope=*/1);
11641 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
11642 complain
, in_decl
);
11644 if (ctx
== error_mark_node
|| f
== error_mark_node
)
11645 return error_mark_node
;
11647 if (!MAYBE_CLASS_TYPE_P (ctx
))
11649 if (complain
& tf_error
)
11650 error ("%qT is not a class, struct, or union type", ctx
);
11651 return error_mark_node
;
11653 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
11655 /* Normally, make_typename_type does not require that the CTX
11656 have complete type in order to allow things like:
11658 template <class T> struct S { typename S<T>::X Y; };
11660 But, such constructs have already been resolved by this
11661 point, so here CTX really should have complete type, unless
11662 it's a partial instantiation. */
11663 ctx
= complete_type (ctx
);
11664 if (!COMPLETE_TYPE_P (ctx
))
11666 if (complain
& tf_error
)
11667 cxx_incomplete_type_error (NULL_TREE
, ctx
);
11668 return error_mark_node
;
11672 f
= make_typename_type (ctx
, f
, typename_type
,
11673 complain
| tf_keep_type_decl
);
11674 if (f
== error_mark_node
)
11676 if (TREE_CODE (f
) == TYPE_DECL
)
11678 complain
|= tf_ignore_bad_quals
;
11682 if (TREE_CODE (f
) != TYPENAME_TYPE
)
11684 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
11686 if (complain
& tf_error
)
11687 error ("%qT resolves to %qT, which is not an enumeration type",
11690 return error_mark_node
;
11692 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
11694 if (complain
& tf_error
)
11695 error ("%qT resolves to %qT, which is is not a class type",
11698 return error_mark_node
;
11702 return cp_build_qualified_type_real
11703 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
11706 case UNBOUND_CLASS_TEMPLATE
:
11708 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
11709 in_decl
, /*entering_scope=*/1);
11710 tree name
= TYPE_IDENTIFIER (t
);
11711 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
11713 if (ctx
== error_mark_node
|| name
== error_mark_node
)
11714 return error_mark_node
;
11717 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
11718 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
11725 ++cp_unevaluated_operand
;
11726 ++c_inhibit_evaluation_warnings
;
11728 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
11730 /*integral_constant_expression_p=*/false);
11732 --cp_unevaluated_operand
;
11733 --c_inhibit_evaluation_warnings
;
11735 type
= finish_typeof (type
);
11736 return cp_build_qualified_type_real (type
,
11738 | cp_type_quals (type
),
11742 case DECLTYPE_TYPE
:
11746 ++cp_unevaluated_operand
;
11747 ++c_inhibit_evaluation_warnings
;
11749 type
= tsubst_expr (DECLTYPE_TYPE_EXPR (t
), args
,
11751 /*integral_constant_expression_p=*/false);
11753 --cp_unevaluated_operand
;
11754 --c_inhibit_evaluation_warnings
;
11756 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
11757 type
= lambda_capture_field_type (type
);
11758 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
11759 type
= lambda_proxy_type (type
);
11761 type
= finish_decltype_type
11762 (type
, DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
), complain
);
11763 return cp_build_qualified_type_real (type
,
11765 | cp_type_quals (type
),
11769 case UNDERLYING_TYPE
:
11771 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
11772 complain
, in_decl
);
11773 return finish_underlying_type (type
);
11776 case TYPE_ARGUMENT_PACK
:
11777 case NONTYPE_ARGUMENT_PACK
:
11779 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
11781 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
11785 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
11787 /* For template nontype argument packs, also substitute into
11789 if (code
== NONTYPE_ARGUMENT_PACK
)
11790 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11808 /* We should use one of the expression tsubsts for these codes. */
11809 gcc_unreachable ();
11812 sorry ("use of %qs in template", tree_code_name
[(int) code
]);
11813 return error_mark_node
;
11817 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
11818 type of the expression on the left-hand side of the "." or "->"
11822 tsubst_baselink (tree baselink
, tree object_type
,
11823 tree args
, tsubst_flags_t complain
, tree in_decl
)
11826 tree qualifying_scope
;
11829 tree template_args
= 0;
11830 bool template_id_p
= false;
11831 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
11833 /* A baselink indicates a function from a base class. Both the
11834 BASELINK_ACCESS_BINFO and the base class referenced may
11835 indicate bases of the template class, rather than the
11836 instantiated class. In addition, lookups that were not
11837 ambiguous before may be ambiguous now. Therefore, we perform
11838 the lookup again. */
11839 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
11840 qualifying_scope
= tsubst (qualifying_scope
, args
,
11841 complain
, in_decl
);
11842 fns
= BASELINK_FUNCTIONS (baselink
);
11843 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
11844 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
11846 template_id_p
= true;
11847 template_args
= TREE_OPERAND (fns
, 1);
11848 fns
= TREE_OPERAND (fns
, 0);
11850 template_args
= tsubst_template_args (template_args
, args
,
11851 complain
, in_decl
);
11853 name
= DECL_NAME (get_first_fn (fns
));
11854 if (IDENTIFIER_TYPENAME_P (name
))
11855 name
= mangle_conv_op_name_for_type (optype
);
11856 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
11858 return error_mark_node
;
11860 /* If lookup found a single function, mark it as used at this
11861 point. (If it lookup found multiple functions the one selected
11862 later by overload resolution will be marked as used at that
11864 if (BASELINK_P (baselink
))
11865 fns
= BASELINK_FUNCTIONS (baselink
);
11866 if (!template_id_p
&& !really_overloaded_fn (fns
))
11867 mark_used (OVL_CURRENT (fns
));
11869 /* Add back the template arguments, if present. */
11870 if (BASELINK_P (baselink
) && template_id_p
)
11871 BASELINK_FUNCTIONS (baselink
)
11872 = build_nt (TEMPLATE_ID_EXPR
,
11873 BASELINK_FUNCTIONS (baselink
),
11875 /* Update the conversion operator type. */
11876 BASELINK_OPTYPE (baselink
) = optype
;
11879 object_type
= current_class_type
;
11882 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
11888 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
11889 true if the qualified-id will be a postfix-expression in-and-of
11890 itself; false if more of the postfix-expression follows the
11891 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
11895 tsubst_qualified_id (tree qualified_id
, tree args
,
11896 tsubst_flags_t complain
, tree in_decl
,
11897 bool done
, bool address_p
)
11903 tree template_args
;
11904 location_t loc
= UNKNOWN_LOCATION
;
11906 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
11908 /* Figure out what name to look up. */
11909 name
= TREE_OPERAND (qualified_id
, 1);
11910 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
11912 is_template
= true;
11913 loc
= EXPR_LOCATION (name
);
11914 template_args
= TREE_OPERAND (name
, 1);
11916 template_args
= tsubst_template_args (template_args
, args
,
11917 complain
, in_decl
);
11918 name
= TREE_OPERAND (name
, 0);
11922 is_template
= false;
11923 template_args
= NULL_TREE
;
11926 /* Substitute into the qualifying scope. When there are no ARGS, we
11927 are just trying to simplify a non-dependent expression. In that
11928 case the qualifying scope may be dependent, and, in any case,
11929 substituting will not help. */
11930 scope
= TREE_OPERAND (qualified_id
, 0);
11933 scope
= tsubst (scope
, args
, complain
, in_decl
);
11934 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
11939 if (dependent_scope_p (scope
))
11942 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
11943 return build_qualified_name (NULL_TREE
, scope
, expr
,
11944 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
11947 if (!BASELINK_P (name
) && !DECL_P (expr
))
11949 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
11951 /* A BIT_NOT_EXPR is used to represent a destructor. */
11952 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
11954 error ("qualifying type %qT does not match destructor name ~%qT",
11955 scope
, TREE_OPERAND (expr
, 0));
11956 expr
= error_mark_node
;
11959 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
11960 /*is_type_p=*/0, false);
11963 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
11964 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
11965 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
11967 if (complain
& tf_error
)
11969 error ("dependent-name %qE is parsed as a non-type, but "
11970 "instantiation yields a type", qualified_id
);
11971 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
11973 return error_mark_node
;
11979 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
11981 /* Remember that there was a reference to this entity. */
11985 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
11987 if (complain
& tf_error
)
11988 qualified_name_lookup_error (scope
,
11989 TREE_OPERAND (qualified_id
, 1),
11990 expr
, input_location
);
11991 return error_mark_node
;
11995 expr
= lookup_template_function (expr
, template_args
);
11997 if (expr
== error_mark_node
&& complain
& tf_error
)
11998 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
11999 expr
, input_location
);
12000 else if (TYPE_P (scope
))
12002 expr
= (adjust_result_of_qualified_name_lookup
12003 (expr
, scope
, current_class_type
));
12004 expr
= (finish_qualified_id_expr
12005 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12006 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12007 /*template_arg_p=*/false));
12010 /* Expressions do not generally have reference type. */
12011 if (TREE_CODE (expr
) != SCOPE_REF
12012 /* However, if we're about to form a pointer-to-member, we just
12013 want the referenced member referenced. */
12014 && TREE_CODE (expr
) != OFFSET_REF
)
12015 expr
= convert_from_reference (expr
);
12020 /* Like tsubst, but deals with expressions. This function just replaces
12021 template parms; to finish processing the resultant expression, use
12022 tsubst_copy_and_build or tsubst_expr. */
12025 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12027 enum tree_code code
;
12030 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12033 code
= TREE_CODE (t
);
12038 r
= retrieve_local_specialization (t
);
12040 if (r
== NULL_TREE
)
12042 /* We get here for a use of 'this' in an NSDMI. */
12043 if (DECL_NAME (t
) == this_identifier
12044 && at_function_scope_p ()
12045 && DECL_CONSTRUCTOR_P (current_function_decl
))
12046 return current_class_ptr
;
12048 /* This can happen for a parameter name used later in a function
12049 declaration (such as in a late-specified return type). Just
12050 make a dummy decl, since it's only used for its type. */
12051 gcc_assert (cp_unevaluated_operand
!= 0);
12052 r
= tsubst_decl (t
, args
, complain
);
12053 /* Give it the template pattern as its context; its true context
12054 hasn't been instantiated yet and this is good enough for
12056 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12059 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12060 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12069 if (DECL_TEMPLATE_PARM_P (t
))
12070 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12071 /* There is no need to substitute into namespace-scope
12073 if (DECL_NAMESPACE_SCOPE_P (t
))
12075 /* If ARGS is NULL, then T is known to be non-dependent. */
12076 if (args
== NULL_TREE
)
12077 return integral_constant_value (t
);
12079 /* Unfortunately, we cannot just call lookup_name here.
12082 template <int I> int f() {
12084 struct S { void g() { E e = a; } };
12087 When we instantiate f<7>::S::g(), say, lookup_name is not
12088 clever enough to find f<7>::a. */
12090 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12091 /*entering_scope=*/0);
12093 for (v
= TYPE_VALUES (enum_type
);
12095 v
= TREE_CHAIN (v
))
12096 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12097 return TREE_VALUE (v
);
12099 /* We didn't find the name. That should never happen; if
12100 name-lookup found it during preliminary parsing, we
12101 should find it again here during instantiation. */
12102 gcc_unreachable ();
12107 if (DECL_CONTEXT (t
))
12111 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12112 /*entering_scope=*/1);
12113 if (ctx
!= DECL_CONTEXT (t
))
12115 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
12118 if (complain
& tf_error
)
12119 error ("using invalid field %qD", t
);
12120 return error_mark_node
;
12129 case FUNCTION_DECL
:
12130 if ((DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
12131 || local_variable_p (t
))
12132 t
= tsubst (t
, args
, complain
, in_decl
);
12136 case NAMESPACE_DECL
:
12140 /* An OVERLOAD will always be a non-dependent overload set; an
12141 overload set from function scope will just be represented with an
12142 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12143 gcc_assert (!uses_template_parms (t
));
12147 return tsubst_baselink (t
, current_class_type
, args
, complain
, in_decl
);
12149 case TEMPLATE_DECL
:
12150 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12151 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
12152 args
, complain
, in_decl
);
12153 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
12154 return tsubst (t
, args
, complain
, in_decl
);
12155 else if (DECL_CLASS_SCOPE_P (t
)
12156 && uses_template_parms (DECL_CONTEXT (t
)))
12158 /* Template template argument like the following example need
12161 template <template <class> class TT> struct C {};
12162 template <class T> struct D {
12163 template <class U> struct E {};
12168 We are processing the template argument `E' in #1 for
12169 the template instantiation #2. Originally, `E' is a
12170 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12171 have to substitute this with one having context `D<int>'. */
12173 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
12174 return lookup_field (context
, DECL_NAME(t
), 0, false);
12177 /* Ordinary template template argument. */
12181 case REINTERPRET_CAST_EXPR
:
12182 case CONST_CAST_EXPR
:
12183 case STATIC_CAST_EXPR
:
12184 case DYNAMIC_CAST_EXPR
:
12185 case IMPLICIT_CONV_EXPR
:
12189 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
12190 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
12193 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
12196 tree expanded
, op
= TREE_OPERAND (t
, 0);
12199 if (SIZEOF_EXPR_TYPE_P (t
))
12200 op
= TREE_TYPE (op
);
12202 ++cp_unevaluated_operand
;
12203 ++c_inhibit_evaluation_warnings
;
12204 /* We only want to compute the number of arguments. */
12205 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
12206 --cp_unevaluated_operand
;
12207 --c_inhibit_evaluation_warnings
;
12209 if (TREE_CODE (expanded
) == TREE_VEC
)
12210 len
= TREE_VEC_LENGTH (expanded
);
12212 if (expanded
== error_mark_node
)
12213 return error_mark_node
;
12214 else if (PACK_EXPANSION_P (expanded
)
12215 || (TREE_CODE (expanded
) == TREE_VEC
12217 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
12219 if (TREE_CODE (expanded
) == TREE_VEC
)
12220 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
12222 if (TYPE_P (expanded
))
12223 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
12224 complain
& tf_error
);
12226 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
12227 complain
& tf_error
);
12230 return build_int_cst (size_type_node
, len
);
12232 if (SIZEOF_EXPR_TYPE_P (t
))
12234 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
12235 args
, complain
, in_decl
);
12236 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
12237 r
= build1 (SIZEOF_EXPR
,
12238 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
12239 SIZEOF_EXPR_TYPE_P (r
) = 1;
12246 case TRUTH_NOT_EXPR
:
12249 case UNARY_PLUS_EXPR
: /* Unary + */
12251 case AT_ENCODE_EXPR
:
12255 case REALPART_EXPR
:
12256 case IMAGPART_EXPR
:
12258 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
12259 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
12261 case COMPONENT_REF
:
12266 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12267 name
= TREE_OPERAND (t
, 1);
12268 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
12270 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12271 complain
, in_decl
);
12272 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12274 else if (TREE_CODE (name
) == SCOPE_REF
12275 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
12277 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12278 complain
, in_decl
);
12279 name
= TREE_OPERAND (name
, 1);
12280 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
12281 complain
, in_decl
);
12282 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
12283 name
= build_qualified_name (/*type=*/NULL_TREE
,
12285 /*template_p=*/false);
12287 else if (BASELINK_P (name
))
12288 name
= tsubst_baselink (name
,
12289 non_reference (TREE_TYPE (object
)),
12293 name
= tsubst_copy (name
, args
, complain
, in_decl
);
12294 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
12300 case TRUNC_DIV_EXPR
:
12301 case CEIL_DIV_EXPR
:
12302 case FLOOR_DIV_EXPR
:
12303 case ROUND_DIV_EXPR
:
12304 case EXACT_DIV_EXPR
:
12308 case TRUNC_MOD_EXPR
:
12309 case FLOOR_MOD_EXPR
:
12310 case TRUTH_ANDIF_EXPR
:
12311 case TRUTH_ORIF_EXPR
:
12312 case TRUTH_AND_EXPR
:
12313 case TRUTH_OR_EXPR
:
12326 case COMPOUND_EXPR
:
12329 case PREDECREMENT_EXPR
:
12330 case PREINCREMENT_EXPR
:
12331 case POSTDECREMENT_EXPR
:
12332 case POSTINCREMENT_EXPR
:
12334 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12335 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
12338 return build_qualified_name (/*type=*/NULL_TREE
,
12339 tsubst_copy (TREE_OPERAND (t
, 0),
12340 args
, complain
, in_decl
),
12341 tsubst_copy (TREE_OPERAND (t
, 1),
12342 args
, complain
, in_decl
),
12343 QUALIFIED_NAME_IS_TEMPLATE (t
));
12348 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12349 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12350 NULL_TREE
, NULL_TREE
);
12354 int n
= VL_EXP_OPERAND_LENGTH (t
);
12355 tree result
= build_vl_exp (CALL_EXPR
, n
);
12357 for (i
= 0; i
< n
; i
++)
12358 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
12359 complain
, in_decl
);
12365 case PSEUDO_DTOR_EXPR
:
12368 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12369 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12370 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
12371 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
12378 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12379 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
12380 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
12381 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
12388 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12389 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
12390 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
12391 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
12395 case TEMPLATE_ID_EXPR
:
12397 /* Substituted template arguments */
12398 tree fn
= TREE_OPERAND (t
, 0);
12399 tree targs
= TREE_OPERAND (t
, 1);
12401 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
12403 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
12405 return lookup_template_function (fn
, targs
);
12410 tree purpose
, value
, chain
;
12412 if (t
== void_list_node
)
12415 purpose
= TREE_PURPOSE (t
);
12417 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
12418 value
= TREE_VALUE (t
);
12420 value
= tsubst_copy (value
, args
, complain
, in_decl
);
12421 chain
= TREE_CHAIN (t
);
12422 if (chain
&& chain
!= void_type_node
)
12423 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
12424 if (purpose
== TREE_PURPOSE (t
)
12425 && value
== TREE_VALUE (t
)
12426 && chain
== TREE_CHAIN (t
))
12428 return tree_cons (purpose
, value
, chain
);
12433 case ENUMERAL_TYPE
:
12435 case TEMPLATE_TYPE_PARM
:
12436 case TEMPLATE_TEMPLATE_PARM
:
12437 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12438 case TEMPLATE_PARM_INDEX
:
12440 case REFERENCE_TYPE
:
12442 case FUNCTION_TYPE
:
12445 case TYPENAME_TYPE
:
12446 case UNBOUND_CLASS_TEMPLATE
:
12448 case DECLTYPE_TYPE
:
12450 return tsubst (t
, args
, complain
, in_decl
);
12452 case IDENTIFIER_NODE
:
12453 if (IDENTIFIER_TYPENAME_P (t
))
12455 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12456 return mangle_conv_op_name_for_type (new_type
);
12462 /* This is handled by tsubst_copy_and_build. */
12463 gcc_unreachable ();
12466 return build_x_va_arg (EXPR_LOCATION (t
),
12467 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
,
12469 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
12471 case CLEANUP_POINT_EXPR
:
12472 /* We shouldn't have built any of these during initial template
12473 generation. Instead, they should be built during instantiation
12474 in response to the saved STMT_IS_FULL_EXPR_P setting. */
12475 gcc_unreachable ();
12479 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
12480 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
12481 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
12482 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
12483 mark_used (TREE_OPERAND (r
, 1));
12486 case EXPR_PACK_EXPANSION
:
12487 error ("invalid use of pack expansion expression");
12488 return error_mark_node
;
12490 case NONTYPE_ARGUMENT_PACK
:
12491 error ("use %<...%> to expand argument pack");
12492 return error_mark_node
;
12499 /* Instantiate any typedefs in the type. */
12500 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12501 r
= fold_convert (type
, t
);
12502 gcc_assert (TREE_CODE (r
) == code
);
12507 /* These can sometimes show up in a partial instantiation, but never
12508 involve template parms. */
12509 gcc_assert (!uses_template_parms (t
));
12513 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
12514 gcc_checking_assert (false);
12519 /* Like tsubst_copy, but specifically for OpenMP clauses. */
12522 tsubst_omp_clauses (tree clauses
, tree args
, tsubst_flags_t complain
,
12525 tree new_clauses
= NULL
, nc
, oc
;
12527 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
12529 nc
= copy_node (oc
);
12530 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
12533 switch (OMP_CLAUSE_CODE (nc
))
12535 case OMP_CLAUSE_LASTPRIVATE
:
12536 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
12538 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
12539 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
12540 in_decl
, /*integral_constant_expression_p=*/false);
12541 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
12542 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
12545 case OMP_CLAUSE_PRIVATE
:
12546 case OMP_CLAUSE_SHARED
:
12547 case OMP_CLAUSE_FIRSTPRIVATE
:
12548 case OMP_CLAUSE_REDUCTION
:
12549 case OMP_CLAUSE_COPYIN
:
12550 case OMP_CLAUSE_COPYPRIVATE
:
12551 case OMP_CLAUSE_IF
:
12552 case OMP_CLAUSE_NUM_THREADS
:
12553 case OMP_CLAUSE_SCHEDULE
:
12554 case OMP_CLAUSE_COLLAPSE
:
12555 case OMP_CLAUSE_FINAL
:
12556 OMP_CLAUSE_OPERAND (nc
, 0)
12557 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
12558 in_decl
, /*integral_constant_expression_p=*/false);
12560 case OMP_CLAUSE_NOWAIT
:
12561 case OMP_CLAUSE_ORDERED
:
12562 case OMP_CLAUSE_DEFAULT
:
12563 case OMP_CLAUSE_UNTIED
:
12564 case OMP_CLAUSE_MERGEABLE
:
12567 gcc_unreachable ();
12571 return finish_omp_clauses (nreverse (new_clauses
));
12574 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
12577 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
12580 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
12582 tree purpose
, value
, chain
;
12587 if (TREE_CODE (t
) != TREE_LIST
)
12588 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
12589 /*function_p=*/false,
12590 /*integral_constant_expression_p=*/false);
12592 if (t
== void_list_node
)
12595 purpose
= TREE_PURPOSE (t
);
12597 purpose
= RECUR (purpose
);
12598 value
= TREE_VALUE (t
);
12601 if (TREE_CODE (value
) != LABEL_DECL
)
12602 value
= RECUR (value
);
12605 value
= lookup_label (DECL_NAME (value
));
12606 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
12607 TREE_USED (value
) = 1;
12610 chain
= TREE_CHAIN (t
);
12611 if (chain
&& chain
!= void_type_node
)
12612 chain
= RECUR (chain
);
12613 return tree_cons (purpose
, value
, chain
);
12617 /* Substitute one OMP_FOR iterator. */
12620 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
12621 tree condv
, tree incrv
, tree
*clauses
,
12622 tree args
, tsubst_flags_t complain
, tree in_decl
,
12623 bool integral_constant_expression_p
)
12625 #define RECUR(NODE) \
12626 tsubst_expr ((NODE), args, complain, in_decl, \
12627 integral_constant_expression_p)
12628 tree decl
, init
, cond
, incr
;
12631 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
12632 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
12633 decl
= TREE_OPERAND (init
, 0);
12634 init
= TREE_OPERAND (init
, 1);
12635 /* Do this before substituting into decl to handle 'auto'. */
12636 init_decl
= (init
&& TREE_CODE (init
) == DECL_EXPR
);
12637 init
= RECUR (init
);
12638 decl
= RECUR (decl
);
12641 gcc_assert (!processing_template_decl
);
12642 init
= DECL_INITIAL (decl
);
12643 DECL_INITIAL (decl
) = NULL_TREE
;
12646 gcc_assert (!type_dependent_expression_p (decl
));
12648 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
12650 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
12651 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
12652 if (TREE_CODE (incr
) == MODIFY_EXPR
)
12653 incr
= build_x_modify_expr (EXPR_LOCATION (incr
),
12654 RECUR (TREE_OPERAND (incr
, 0)), NOP_EXPR
,
12655 RECUR (TREE_OPERAND (incr
, 1)),
12658 incr
= RECUR (incr
);
12659 TREE_VEC_ELT (declv
, i
) = decl
;
12660 TREE_VEC_ELT (initv
, i
) = init
;
12661 TREE_VEC_ELT (condv
, i
) = cond
;
12662 TREE_VEC_ELT (incrv
, i
) = incr
;
12666 if (init
&& !init_decl
)
12669 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
12671 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
12672 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
12673 && OMP_CLAUSE_DECL (c
) == decl
)
12675 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
12676 && OMP_CLAUSE_DECL (c
) == decl
)
12677 error ("iteration variable %qD should not be firstprivate", decl
);
12678 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
12679 && OMP_CLAUSE_DECL (c
) == decl
)
12680 error ("iteration variable %qD should not be reduction", decl
);
12684 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
12685 OMP_CLAUSE_DECL (c
) = decl
;
12686 c
= finish_omp_clauses (c
);
12689 OMP_CLAUSE_CHAIN (c
) = *clauses
;
12694 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
12695 if (COMPARISON_CLASS_P (cond
))
12696 cond
= build2 (TREE_CODE (cond
), boolean_type_node
,
12697 RECUR (TREE_OPERAND (cond
, 0)),
12698 RECUR (TREE_OPERAND (cond
, 1)));
12700 cond
= RECUR (cond
);
12701 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
12702 switch (TREE_CODE (incr
))
12704 case PREINCREMENT_EXPR
:
12705 case PREDECREMENT_EXPR
:
12706 case POSTINCREMENT_EXPR
:
12707 case POSTDECREMENT_EXPR
:
12708 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
12709 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
12712 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
12713 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
12715 tree rhs
= TREE_OPERAND (incr
, 1);
12716 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
),
12717 RECUR (TREE_OPERAND (incr
, 0)),
12718 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
12719 RECUR (TREE_OPERAND (rhs
, 0)),
12720 RECUR (TREE_OPERAND (rhs
, 1))));
12723 incr
= RECUR (incr
);
12726 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
12727 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
12729 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
12730 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
12731 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
12732 TREE_TYPE (decl
), lhs
,
12733 RECUR (TREE_OPERAND (incr
, 2))));
12735 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
12736 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
12737 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
12739 tree rhs
= TREE_OPERAND (incr
, 2);
12740 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
),
12741 RECUR (TREE_OPERAND (incr
, 0)),
12742 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
12743 RECUR (TREE_OPERAND (rhs
, 0)),
12744 RECUR (TREE_OPERAND (rhs
, 1))));
12747 incr
= RECUR (incr
);
12750 incr
= RECUR (incr
);
12754 TREE_VEC_ELT (declv
, i
) = decl
;
12755 TREE_VEC_ELT (initv
, i
) = init
;
12756 TREE_VEC_ELT (condv
, i
) = cond
;
12757 TREE_VEC_ELT (incrv
, i
) = incr
;
12761 /* Like tsubst_copy for expressions, etc. but also does semantic
12765 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
12766 bool integral_constant_expression_p
)
12768 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
12769 #define RECUR(NODE) \
12770 tsubst_expr ((NODE), args, complain, in_decl, \
12771 integral_constant_expression_p)
12777 if (t
== NULL_TREE
|| t
== error_mark_node
)
12780 loc
= input_location
;
12781 if (EXPR_HAS_LOCATION (t
))
12782 input_location
= EXPR_LOCATION (t
);
12783 if (STATEMENT_CODE_P (TREE_CODE (t
)))
12784 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
12786 switch (TREE_CODE (t
))
12788 case STATEMENT_LIST
:
12790 tree_stmt_iterator i
;
12791 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
12792 RECUR (tsi_stmt (i
));
12796 case CTOR_INITIALIZER
:
12797 finish_mem_initializers (tsubst_initializer_list
12798 (TREE_OPERAND (t
, 0), args
));
12802 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
12806 tmp
= RECUR (EXPR_STMT_EXPR (t
));
12807 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
12808 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
12810 finish_expr_stmt (tmp
);
12814 do_using_directive (USING_STMT_NAMESPACE (t
));
12819 tree decl
, pattern_decl
;
12822 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
12823 if (TREE_CODE (decl
) == LABEL_DECL
)
12824 finish_label_decl (DECL_NAME (decl
));
12825 else if (TREE_CODE (decl
) == USING_DECL
)
12827 tree scope
= USING_DECL_SCOPE (decl
);
12828 tree name
= DECL_NAME (decl
);
12831 scope
= tsubst (scope
, args
, complain
, in_decl
);
12832 decl
= lookup_qualified_name (scope
, name
,
12833 /*is_type_p=*/false,
12834 /*complain=*/false);
12835 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
12836 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
12838 do_local_using_decl (decl
, scope
, name
);
12842 init
= DECL_INITIAL (decl
);
12843 decl
= tsubst (decl
, args
, complain
, in_decl
);
12844 if (decl
!= error_mark_node
)
12846 /* By marking the declaration as instantiated, we avoid
12847 trying to instantiate it. Since instantiate_decl can't
12848 handle local variables, and since we've already done
12849 all that needs to be done, that's the right thing to
12851 if (TREE_CODE (decl
) == VAR_DECL
)
12852 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
12853 if (TREE_CODE (decl
) == VAR_DECL
12854 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
12855 /* Anonymous aggregates are a special case. */
12856 finish_anon_union (decl
);
12857 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
12859 DECL_CONTEXT (decl
) = current_function_decl
;
12860 if (DECL_NAME (decl
) == this_identifier
)
12862 tree lam
= DECL_CONTEXT (current_function_decl
);
12863 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
12864 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
12866 insert_capture_proxy (decl
);
12868 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
12869 /* We already did a pushtag. */;
12872 int const_init
= false;
12873 maybe_push_decl (decl
);
12874 if (TREE_CODE (decl
) == VAR_DECL
12875 && DECL_PRETTY_FUNCTION_P (decl
))
12877 /* For __PRETTY_FUNCTION__ we have to adjust the
12879 const char *const name
12880 = cxx_printable_name (current_function_decl
, 2);
12881 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
12885 tree t
= RECUR (init
);
12889 /* If we had an initializer but it
12890 instantiated to nothing,
12891 value-initialize the object. This will
12892 only occur when the initializer was a
12893 pack expansion where the parameter packs
12894 used in that expansion were of length
12896 init
= build_value_init (TREE_TYPE (decl
),
12898 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12899 init
= get_target_expr_sfinae (init
, complain
);
12905 if (TREE_CODE (decl
) == VAR_DECL
)
12906 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
12908 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
12917 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
12918 RECUR (FOR_INIT_STMT (t
));
12919 finish_for_init_stmt (stmt
);
12920 tmp
= RECUR (FOR_COND (t
));
12921 finish_for_cond (tmp
, stmt
);
12922 tmp
= RECUR (FOR_EXPR (t
));
12923 finish_for_expr (tmp
, stmt
);
12924 RECUR (FOR_BODY (t
));
12925 finish_for_stmt (stmt
);
12928 case RANGE_FOR_STMT
:
12931 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
12932 decl
= RANGE_FOR_DECL (t
);
12933 decl
= tsubst (decl
, args
, complain
, in_decl
);
12934 maybe_push_decl (decl
);
12935 expr
= RECUR (RANGE_FOR_EXPR (t
));
12936 stmt
= cp_convert_range_for (stmt
, decl
, expr
);
12937 RECUR (RANGE_FOR_BODY (t
));
12938 finish_for_stmt (stmt
);
12943 stmt
= begin_while_stmt ();
12944 tmp
= RECUR (WHILE_COND (t
));
12945 finish_while_stmt_cond (tmp
, stmt
);
12946 RECUR (WHILE_BODY (t
));
12947 finish_while_stmt (stmt
);
12951 stmt
= begin_do_stmt ();
12952 RECUR (DO_BODY (t
));
12953 finish_do_body (stmt
);
12954 tmp
= RECUR (DO_COND (t
));
12955 finish_do_stmt (tmp
, stmt
);
12959 stmt
= begin_if_stmt ();
12960 tmp
= RECUR (IF_COND (t
));
12961 finish_if_stmt_cond (tmp
, stmt
);
12962 RECUR (THEN_CLAUSE (t
));
12963 finish_then_clause (stmt
);
12965 if (ELSE_CLAUSE (t
))
12967 begin_else_clause (stmt
);
12968 RECUR (ELSE_CLAUSE (t
));
12969 finish_else_clause (stmt
);
12972 finish_if_stmt (stmt
);
12976 if (BIND_EXPR_BODY_BLOCK (t
))
12977 stmt
= begin_function_body ();
12979 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
12980 ? BCS_TRY_BLOCK
: 0);
12982 RECUR (BIND_EXPR_BODY (t
));
12984 if (BIND_EXPR_BODY_BLOCK (t
))
12985 finish_function_body (stmt
);
12987 finish_compound_stmt (stmt
);
12991 finish_break_stmt ();
12994 case CONTINUE_STMT
:
12995 finish_continue_stmt ();
12999 stmt
= begin_switch_stmt ();
13000 tmp
= RECUR (SWITCH_STMT_COND (t
));
13001 finish_switch_cond (tmp
, stmt
);
13002 RECUR (SWITCH_STMT_BODY (t
));
13003 finish_switch_stmt (stmt
);
13006 case CASE_LABEL_EXPR
:
13007 finish_case_label (EXPR_LOCATION (t
),
13008 RECUR (CASE_LOW (t
)),
13009 RECUR (CASE_HIGH (t
)));
13014 tree decl
= LABEL_EXPR_LABEL (t
);
13017 label
= finish_label_stmt (DECL_NAME (decl
));
13018 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13019 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13024 tmp
= GOTO_DESTINATION (t
);
13025 if (TREE_CODE (tmp
) != LABEL_DECL
)
13026 /* Computed goto's must be tsubst'd into. On the other hand,
13027 non-computed gotos must not be; the identifier in question
13028 will have no binding. */
13031 tmp
= DECL_NAME (tmp
);
13032 finish_goto_stmt (tmp
);
13036 tmp
= finish_asm_stmt
13037 (ASM_VOLATILE_P (t
),
13038 RECUR (ASM_STRING (t
)),
13039 tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
, complain
, in_decl
),
13040 tsubst_copy_asm_operands (ASM_INPUTS (t
), args
, complain
, in_decl
),
13041 tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
, complain
, in_decl
),
13042 tsubst_copy_asm_operands (ASM_LABELS (t
), args
, complain
, in_decl
));
13044 tree asm_expr
= tmp
;
13045 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
13046 asm_expr
= TREE_OPERAND (asm_expr
, 0);
13047 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
13054 stmt
= begin_try_block ();
13055 RECUR (TRY_STMTS (t
));
13056 finish_cleanup_try_block (stmt
);
13057 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
13061 tree compound_stmt
= NULL_TREE
;
13063 if (FN_TRY_BLOCK_P (t
))
13064 stmt
= begin_function_try_block (&compound_stmt
);
13066 stmt
= begin_try_block ();
13068 RECUR (TRY_STMTS (t
));
13070 if (FN_TRY_BLOCK_P (t
))
13071 finish_function_try_block (stmt
);
13073 finish_try_block (stmt
);
13075 RECUR (TRY_HANDLERS (t
));
13076 if (FN_TRY_BLOCK_P (t
))
13077 finish_function_handler_sequence (stmt
, compound_stmt
);
13079 finish_handler_sequence (stmt
);
13085 tree decl
= HANDLER_PARMS (t
);
13089 decl
= tsubst (decl
, args
, complain
, in_decl
);
13090 /* Prevent instantiate_decl from trying to instantiate
13091 this variable. We've already done all that needs to be
13093 if (decl
!= error_mark_node
)
13094 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13096 stmt
= begin_handler ();
13097 finish_handler_parms (decl
, stmt
);
13098 RECUR (HANDLER_BODY (t
));
13099 finish_handler (stmt
);
13104 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
13105 if (CLASS_TYPE_P (tmp
))
13107 /* Local classes are not independent templates; they are
13108 instantiated along with their containing function. And this
13109 way we don't have to deal with pushing out of one local class
13110 to instantiate a member of another local class. */
13112 /* Closures are handled by the LAMBDA_EXPR. */
13113 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
13114 complete_type (tmp
);
13115 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
13116 if (!DECL_ARTIFICIAL (fn
))
13117 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
13121 case STATIC_ASSERT
:
13125 ++c_inhibit_evaluation_warnings
;
13127 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
13130 /*integral_constant_expression_p=*/true);
13131 --c_inhibit_evaluation_warnings
;
13133 finish_static_assert (condition
,
13134 STATIC_ASSERT_MESSAGE (t
),
13135 STATIC_ASSERT_SOURCE_LOCATION (t
),
13136 /*member_p=*/false);
13141 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
),
13142 args
, complain
, in_decl
);
13143 stmt
= begin_omp_parallel ();
13144 RECUR (OMP_PARALLEL_BODY (t
));
13145 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
13146 = OMP_PARALLEL_COMBINED (t
);
13150 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
),
13151 args
, complain
, in_decl
);
13152 stmt
= begin_omp_task ();
13153 RECUR (OMP_TASK_BODY (t
));
13154 finish_omp_task (tmp
, stmt
);
13159 tree clauses
, body
, pre_body
;
13160 tree declv
, initv
, condv
, incrv
;
13163 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
),
13164 args
, complain
, in_decl
);
13165 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13166 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13167 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13168 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
13170 stmt
= begin_omp_structured_block ();
13172 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
13173 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
13174 &clauses
, args
, complain
, in_decl
,
13175 integral_constant_expression_p
);
13177 pre_body
= push_stmt_list ();
13178 RECUR (OMP_FOR_PRE_BODY (t
));
13179 pre_body
= pop_stmt_list (pre_body
);
13181 body
= push_stmt_list ();
13182 RECUR (OMP_FOR_BODY (t
));
13183 body
= pop_stmt_list (body
);
13185 t
= finish_omp_for (EXPR_LOCATION (t
), declv
, initv
, condv
, incrv
,
13186 body
, pre_body
, clauses
);
13188 add_stmt (finish_omp_structured_block (stmt
));
13194 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), args
, complain
, in_decl
);
13195 stmt
= push_stmt_list ();
13196 RECUR (OMP_BODY (t
));
13197 stmt
= pop_stmt_list (stmt
);
13200 OMP_BODY (t
) = stmt
;
13201 OMP_CLAUSES (t
) = tmp
;
13209 stmt
= push_stmt_list ();
13210 RECUR (OMP_BODY (t
));
13211 stmt
= pop_stmt_list (stmt
);
13214 OMP_BODY (t
) = stmt
;
13219 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
13220 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
13222 tree op1
= TREE_OPERAND (t
, 1);
13223 tree rhs1
= NULL_TREE
;
13225 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
13227 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
13228 op1
= TREE_OPERAND (op1
, 1);
13230 lhs
= RECUR (TREE_OPERAND (op1
, 0));
13231 rhs
= RECUR (TREE_OPERAND (op1
, 1));
13232 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
13233 NULL_TREE
, NULL_TREE
, rhs1
);
13237 tree op1
= TREE_OPERAND (t
, 1);
13238 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
13239 tree rhs1
= NULL_TREE
;
13240 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
13241 enum tree_code opcode
= NOP_EXPR
;
13242 if (code
== OMP_ATOMIC_READ
)
13244 v
= RECUR (TREE_OPERAND (op1
, 0));
13245 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
13247 else if (code
== OMP_ATOMIC_CAPTURE_OLD
13248 || code
== OMP_ATOMIC_CAPTURE_NEW
)
13250 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
13251 v
= RECUR (TREE_OPERAND (op1
, 0));
13252 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
13253 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
13255 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
13256 op11
= TREE_OPERAND (op11
, 1);
13258 lhs
= RECUR (TREE_OPERAND (op11
, 0));
13259 rhs
= RECUR (TREE_OPERAND (op11
, 1));
13260 opcode
= TREE_CODE (op11
);
13265 lhs
= RECUR (TREE_OPERAND (op1
, 0));
13266 rhs
= RECUR (TREE_OPERAND (op1
, 1));
13268 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
);
13272 case TRANSACTION_EXPR
:
13275 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
13276 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
13278 if (TRANSACTION_EXPR_IS_STMT (t
))
13280 tree body
= TRANSACTION_EXPR_BODY (t
);
13281 tree noex
= NULL_TREE
;
13282 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
13284 noex
= MUST_NOT_THROW_COND (body
);
13285 if (noex
== NULL_TREE
)
13286 noex
= boolean_true_node
;
13287 body
= TREE_OPERAND (body
, 0);
13289 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
13291 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
13295 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
13296 RECUR (TRANSACTION_EXPR_BODY (t
)),
13303 case MUST_NOT_THROW_EXPR
:
13304 RETURN (build_must_not_throw_expr (RECUR (TREE_OPERAND (t
, 0)),
13305 RECUR (MUST_NOT_THROW_COND (t
))));
13307 case EXPR_PACK_EXPANSION
:
13308 error ("invalid use of pack expansion expression");
13309 RETURN (error_mark_node
);
13311 case NONTYPE_ARGUMENT_PACK
:
13312 error ("use %<...%> to expand argument pack");
13313 RETURN (error_mark_node
);
13315 case COMPOUND_EXPR
:
13316 tmp
= RECUR (TREE_OPERAND (t
, 0));
13317 if (tmp
== NULL_TREE
)
13318 /* If the first operand was a statement, we're done with it. */
13319 RETURN (RECUR (TREE_OPERAND (t
, 1)));
13320 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
13321 RECUR (TREE_OPERAND (t
, 1)),
13325 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
13327 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13328 /*function_p=*/false,
13329 integral_constant_expression_p
));
13332 RETURN (NULL_TREE
);
13334 input_location
= loc
;
13340 /* T is a postfix-expression that is not being used in a function
13341 call. Return the substituted version of T. */
13344 tsubst_non_call_postfix_expression (tree t
, tree args
,
13345 tsubst_flags_t complain
,
13348 if (TREE_CODE (t
) == SCOPE_REF
)
13349 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
13350 /*done=*/false, /*address_p=*/false);
13352 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13353 /*function_p=*/false,
13354 /*integral_constant_expression_p=*/false);
13359 /* Like tsubst but deals with expressions and performs semantic
13360 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
13363 tsubst_copy_and_build (tree t
,
13365 tsubst_flags_t complain
,
13368 bool integral_constant_expression_p
)
13370 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
13371 #define RECUR(NODE) \
13372 tsubst_copy_and_build (NODE, args, complain, in_decl, \
13373 /*function_p=*/false, \
13374 integral_constant_expression_p)
13379 if (t
== NULL_TREE
|| t
== error_mark_node
)
13382 loc
= input_location
;
13383 if (EXPR_HAS_LOCATION (t
))
13384 input_location
= EXPR_LOCATION (t
);
13386 switch (TREE_CODE (t
))
13390 /* Fall through. */
13391 case IDENTIFIER_NODE
:
13395 bool non_integral_constant_expression_p
;
13396 const char *error_msg
;
13398 if (IDENTIFIER_TYPENAME_P (t
))
13400 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13401 t
= mangle_conv_op_name_for_type (new_type
);
13404 /* Look up the name. */
13405 decl
= lookup_name (t
);
13407 /* By convention, expressions use ERROR_MARK_NODE to indicate
13408 failure, not NULL_TREE. */
13409 if (decl
== NULL_TREE
)
13410 decl
= error_mark_node
;
13412 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
13414 integral_constant_expression_p
,
13415 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx0x
),
13416 &non_integral_constant_expression_p
,
13417 /*template_p=*/false,
13419 /*address_p=*/false,
13420 /*template_arg_p=*/false,
13425 if (!function_p
&& TREE_CODE (decl
) == IDENTIFIER_NODE
)
13427 if (complain
& tf_error
)
13428 unqualified_name_lookup_error (decl
);
13429 decl
= error_mark_node
;
13434 case TEMPLATE_ID_EXPR
:
13437 tree templ
= RECUR (TREE_OPERAND (t
, 0));
13438 tree targs
= TREE_OPERAND (t
, 1);
13441 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13443 if (TREE_CODE (templ
) == COMPONENT_REF
)
13445 object
= TREE_OPERAND (templ
, 0);
13446 templ
= TREE_OPERAND (templ
, 1);
13449 object
= NULL_TREE
;
13450 templ
= lookup_template_function (templ
, targs
);
13453 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
13454 object
, templ
, NULL_TREE
));
13456 RETURN (baselink_for_fns (templ
));
13461 tree r
= RECUR (TREE_OPERAND (t
, 0));
13463 if (REFERENCE_REF_P (t
))
13465 /* A type conversion to reference type will be enclosed in
13466 such an indirect ref, but the substitution of the cast
13467 will have also added such an indirect ref. */
13468 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
13469 r
= convert_from_reference (r
);
13472 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
, complain
);
13478 (tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
13479 RECUR (TREE_OPERAND (t
, 0))));
13481 case IMPLICIT_CONV_EXPR
:
13483 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13484 tree expr
= RECUR (TREE_OPERAND (t
, 0));
13485 int flags
= LOOKUP_IMPLICIT
;
13486 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
13487 flags
= LOOKUP_NORMAL
;
13488 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
13495 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
13496 RECUR (TREE_OPERAND (t
, 0))));
13499 case REINTERPRET_CAST_EXPR
:
13500 case CONST_CAST_EXPR
:
13501 case DYNAMIC_CAST_EXPR
:
13502 case STATIC_CAST_EXPR
:
13505 tree op
, r
= NULL_TREE
;
13507 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13508 if (integral_constant_expression_p
13509 && !cast_valid_in_integral_constant_expression_p (type
))
13511 if (complain
& tf_error
)
13512 error ("a cast to a type other than an integral or "
13513 "enumeration type cannot appear in a constant-expression");
13514 RETURN (error_mark_node
);
13517 op
= RECUR (TREE_OPERAND (t
, 0));
13519 ++c_inhibit_evaluation_warnings
;
13520 switch (TREE_CODE (t
))
13523 r
= build_functional_cast (type
, op
, complain
);
13525 case REINTERPRET_CAST_EXPR
:
13526 r
= build_reinterpret_cast (type
, op
, complain
);
13528 case CONST_CAST_EXPR
:
13529 r
= build_const_cast (type
, op
, complain
);
13531 case DYNAMIC_CAST_EXPR
:
13532 r
= build_dynamic_cast (type
, op
, complain
);
13534 case STATIC_CAST_EXPR
:
13535 r
= build_static_cast (type
, op
, complain
);
13538 gcc_unreachable ();
13540 --c_inhibit_evaluation_warnings
;
13545 case POSTDECREMENT_EXPR
:
13546 case POSTINCREMENT_EXPR
:
13547 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
13548 args
, complain
, in_decl
);
13549 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
, complain
));
13551 case PREDECREMENT_EXPR
:
13552 case PREINCREMENT_EXPR
:
13556 case TRUTH_NOT_EXPR
:
13557 case UNARY_PLUS_EXPR
: /* Unary + */
13558 case REALPART_EXPR
:
13559 case IMAGPART_EXPR
:
13560 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
13561 RECUR (TREE_OPERAND (t
, 0)), complain
));
13563 case FIX_TRUNC_EXPR
:
13564 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
13568 op1
= TREE_OPERAND (t
, 0);
13569 if (TREE_CODE (op1
) == LABEL_DECL
)
13570 RETURN (finish_label_address_expr (DECL_NAME (op1
),
13571 EXPR_LOCATION (op1
)));
13572 if (TREE_CODE (op1
) == SCOPE_REF
)
13573 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
13574 /*done=*/true, /*address_p=*/true);
13576 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
13578 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
, complain
));
13583 case TRUNC_DIV_EXPR
:
13584 case CEIL_DIV_EXPR
:
13585 case FLOOR_DIV_EXPR
:
13586 case ROUND_DIV_EXPR
:
13587 case EXACT_DIV_EXPR
:
13591 case TRUNC_MOD_EXPR
:
13592 case FLOOR_MOD_EXPR
:
13593 case TRUTH_ANDIF_EXPR
:
13594 case TRUTH_ORIF_EXPR
:
13595 case TRUTH_AND_EXPR
:
13596 case TRUTH_OR_EXPR
:
13614 ++c_inhibit_evaluation_warnings
;
13616 r
= build_x_binary_op
13617 (input_location
, TREE_CODE (t
),
13618 RECUR (TREE_OPERAND (t
, 0)),
13619 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
13621 : TREE_CODE (TREE_OPERAND (t
, 0))),
13622 RECUR (TREE_OPERAND (t
, 1)),
13623 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
13625 : TREE_CODE (TREE_OPERAND (t
, 1))),
13628 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
13629 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13631 --c_inhibit_evaluation_warnings
;
13637 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
13638 /*address_p=*/false));
13640 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
13641 args
, complain
, in_decl
);
13642 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
13643 RECUR (TREE_OPERAND (t
, 1)), complain
));
13646 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
13647 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
13654 op1
= TREE_OPERAND (t
, 0);
13655 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
13656 op1
= TREE_TYPE (op1
);
13659 /* When there are no ARGS, we are trying to evaluate a
13660 non-dependent expression from the parser. Trying to do
13661 the substitutions may not work. */
13663 op1
= TREE_TYPE (op1
);
13667 ++cp_unevaluated_operand
;
13668 ++c_inhibit_evaluation_warnings
;
13670 op1
= tsubst (op1
, args
, complain
, in_decl
);
13672 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
13673 /*function_p=*/false,
13674 /*integral_constant_expression_p=*/
13676 --cp_unevaluated_operand
;
13677 --c_inhibit_evaluation_warnings
;
13680 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
13681 complain
& tf_error
);
13683 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
13684 complain
& tf_error
);
13685 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
13687 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
13689 if (!processing_template_decl
&& TYPE_P (op1
))
13691 r
= build_min (SIZEOF_EXPR
, size_type_node
,
13692 build1 (NOP_EXPR
, op1
, error_mark_node
));
13693 SIZEOF_EXPR_TYPE_P (r
) = 1;
13696 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
13697 TREE_SIDE_EFFECTS (r
) = 0;
13698 TREE_READONLY (r
) = 1;
13700 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
13705 case AT_ENCODE_EXPR
:
13707 op1
= TREE_OPERAND (t
, 0);
13708 ++cp_unevaluated_operand
;
13709 ++c_inhibit_evaluation_warnings
;
13710 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
13711 /*function_p=*/false,
13712 /*integral_constant_expression_p=*/false);
13713 --cp_unevaluated_operand
;
13714 --c_inhibit_evaluation_warnings
;
13715 RETURN (objc_build_encode_expr (op1
));
13718 case NOEXCEPT_EXPR
:
13719 op1
= TREE_OPERAND (t
, 0);
13720 ++cp_unevaluated_operand
;
13721 ++c_inhibit_evaluation_warnings
;
13722 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
13723 /*function_p=*/false,
13724 /*integral_constant_expression_p=*/false);
13725 --cp_unevaluated_operand
;
13726 --c_inhibit_evaluation_warnings
;
13727 RETURN (finish_noexcept_expr (op1
, complain
));
13731 tree r
= build_x_modify_expr
13732 (EXPR_LOCATION (t
),
13733 RECUR (TREE_OPERAND (t
, 0)),
13734 TREE_CODE (TREE_OPERAND (t
, 1)),
13735 RECUR (TREE_OPERAND (t
, 2)),
13737 /* TREE_NO_WARNING must be set if either the expression was
13738 parenthesized or it uses an operator such as >>= rather
13739 than plain assignment. In the former case, it was already
13740 set and must be copied. In the latter case,
13741 build_x_modify_expr sets it and it must not be reset
13743 if (TREE_NO_WARNING (t
))
13744 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13749 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
13750 args
, complain
, in_decl
);
13751 /* Remember that there was a reference to this entity. */
13754 RETURN (build_x_arrow (input_location
, op1
, complain
));
13758 tree placement
= RECUR (TREE_OPERAND (t
, 0));
13759 tree init
= RECUR (TREE_OPERAND (t
, 3));
13760 vec
<tree
, va_gc
> *placement_vec
;
13761 vec
<tree
, va_gc
> *init_vec
;
13764 if (placement
== NULL_TREE
)
13765 placement_vec
= NULL
;
13768 placement_vec
= make_tree_vector ();
13769 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
13770 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
13773 /* If there was an initializer in the original tree, but it
13774 instantiated to an empty list, then we should pass a
13775 non-NULL empty vector to tell build_new that it was an
13776 empty initializer() rather than no initializer. This can
13777 only happen when the initializer is a pack expansion whose
13778 parameter packs are of length zero. */
13779 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
13783 init_vec
= make_tree_vector ();
13784 if (init
== void_zero_node
)
13785 gcc_assert (init_vec
!= NULL
);
13788 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
13789 vec_safe_push (init_vec
, TREE_VALUE (init
));
13793 ret
= build_new (&placement_vec
,
13794 tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
13795 RECUR (TREE_OPERAND (t
, 2)),
13797 NEW_EXPR_USE_GLOBAL (t
),
13800 if (placement_vec
!= NULL
)
13801 release_tree_vector (placement_vec
);
13802 if (init_vec
!= NULL
)
13803 release_tree_vector (init_vec
);
13809 RETURN (delete_sanity
13810 (RECUR (TREE_OPERAND (t
, 0)),
13811 RECUR (TREE_OPERAND (t
, 1)),
13812 DELETE_EXPR_USE_VEC (t
),
13813 DELETE_EXPR_USE_GLOBAL (t
),
13816 case COMPOUND_EXPR
:
13817 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
13818 RECUR (TREE_OPERAND (t
, 0)),
13819 RECUR (TREE_OPERAND (t
, 1)),
13825 vec
<tree
, va_gc
> *call_args
;
13826 unsigned int nargs
, i
;
13831 function
= CALL_EXPR_FN (t
);
13832 /* When we parsed the expression, we determined whether or
13833 not Koenig lookup should be performed. */
13834 koenig_p
= KOENIG_LOOKUP_P (t
);
13835 if (TREE_CODE (function
) == SCOPE_REF
)
13837 qualified_p
= true;
13838 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
13840 /*address_p=*/false);
13842 else if (koenig_p
&& TREE_CODE (function
) == IDENTIFIER_NODE
)
13844 /* Do nothing; calling tsubst_copy_and_build on an identifier
13845 would incorrectly perform unqualified lookup again.
13847 Note that we can also have an IDENTIFIER_NODE if the earlier
13848 unqualified lookup found a member function; in that case
13849 koenig_p will be false and we do want to do the lookup
13850 again to find the instantiated member function.
13852 FIXME but doing that causes c++/15272, so we need to stop
13853 using IDENTIFIER_NODE in that situation. */
13854 qualified_p
= false;
13858 if (TREE_CODE (function
) == COMPONENT_REF
)
13860 tree op
= TREE_OPERAND (function
, 1);
13862 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
13863 || (BASELINK_P (op
)
13864 && BASELINK_QUALIFIED_P (op
)));
13867 qualified_p
= false;
13869 if (TREE_CODE (function
) == ADDR_EXPR
13870 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
13871 /* Avoid error about taking the address of a constructor. */
13872 function
= TREE_OPERAND (function
, 0);
13874 function
= tsubst_copy_and_build (function
, args
, complain
,
13877 integral_constant_expression_p
);
13879 if (BASELINK_P (function
))
13880 qualified_p
= true;
13883 nargs
= call_expr_nargs (t
);
13884 call_args
= make_tree_vector ();
13885 for (i
= 0; i
< nargs
; ++i
)
13887 tree arg
= CALL_EXPR_ARG (t
, i
);
13889 if (!PACK_EXPANSION_P (arg
))
13890 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
13893 /* Expand the pack expansion and push each entry onto
13895 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
13896 if (TREE_CODE (arg
) == TREE_VEC
)
13898 unsigned int len
, j
;
13900 len
= TREE_VEC_LENGTH (arg
);
13901 for (j
= 0; j
< len
; ++j
)
13903 tree value
= TREE_VEC_ELT (arg
, j
);
13904 if (value
!= NULL_TREE
)
13905 value
= convert_from_reference (value
);
13906 vec_safe_push (call_args
, value
);
13911 /* A partial substitution. Add one entry. */
13912 vec_safe_push (call_args
, arg
);
13917 /* We do not perform argument-dependent lookup if normal
13918 lookup finds a non-function, in accordance with the
13919 expected resolution of DR 218. */
13921 && ((is_overloaded_fn (function
)
13922 /* If lookup found a member function, the Koenig lookup is
13923 not appropriate, even if an unqualified-name was used
13924 to denote the function. */
13925 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
13926 || TREE_CODE (function
) == IDENTIFIER_NODE
)
13927 /* Only do this when substitution turns a dependent call
13928 into a non-dependent call. */
13929 && type_dependent_expression_p_push (t
)
13930 && !any_type_dependent_arguments_p (call_args
))
13931 function
= perform_koenig_lookup (function
, call_args
, false,
13934 if (TREE_CODE (function
) == IDENTIFIER_NODE
13935 && !any_type_dependent_arguments_p (call_args
))
13937 if (koenig_p
&& (complain
& tf_warning_or_error
))
13939 /* For backwards compatibility and good diagnostics, try
13940 the unqualified lookup again if we aren't in SFINAE
13942 tree unq
= (tsubst_copy_and_build
13943 (function
, args
, complain
, in_decl
, true,
13944 integral_constant_expression_p
));
13945 if (unq
== error_mark_node
)
13946 RETURN (error_mark_node
);
13948 if (unq
!= function
)
13951 if (TREE_CODE (fn
) == INDIRECT_REF
)
13952 fn
= TREE_OPERAND (fn
, 0);
13953 if (TREE_CODE (fn
) == COMPONENT_REF
)
13954 fn
= TREE_OPERAND (fn
, 1);
13955 if (is_overloaded_fn (fn
))
13956 fn
= get_first_fn (fn
);
13957 permerror (EXPR_LOC_OR_HERE (t
),
13958 "%qD was not declared in this scope, "
13959 "and no declarations were found by "
13960 "argument-dependent lookup at the point "
13961 "of instantiation", function
);
13963 /* Can't say anything more. */;
13964 else if (DECL_CLASS_SCOPE_P (fn
))
13966 inform (EXPR_LOC_OR_HERE (t
),
13967 "declarations in dependent base %qT are "
13968 "not found by unqualified lookup",
13969 DECL_CLASS_CONTEXT (fn
));
13970 if (current_class_ptr
)
13971 inform (EXPR_LOC_OR_HERE (t
),
13972 "use %<this->%D%> instead", function
);
13974 inform (EXPR_LOC_OR_HERE (t
),
13975 "use %<%T::%D%> instead",
13976 current_class_name
, function
);
13979 inform (0, "%q+D declared here, later in the "
13980 "translation unit", fn
);
13984 if (TREE_CODE (function
) == IDENTIFIER_NODE
)
13986 if (complain
& tf_error
)
13987 unqualified_name_lookup_error (function
);
13988 release_tree_vector (call_args
);
13989 RETURN (error_mark_node
);
13993 /* Remember that there was a reference to this entity. */
13994 if (DECL_P (function
))
13995 mark_used (function
);
13997 if (TREE_CODE (function
) == OFFSET_REF
)
13998 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
14000 else if (TREE_CODE (function
) == COMPONENT_REF
)
14002 tree instance
= TREE_OPERAND (function
, 0);
14003 tree fn
= TREE_OPERAND (function
, 1);
14005 if (processing_template_decl
14006 && (type_dependent_expression_p (instance
)
14007 || (!BASELINK_P (fn
)
14008 && TREE_CODE (fn
) != FIELD_DECL
)
14009 || type_dependent_expression_p (fn
)
14010 || any_type_dependent_arguments_p (call_args
)))
14011 ret
= build_nt_call_vec (function
, call_args
);
14012 else if (!BASELINK_P (fn
))
14013 ret
= finish_call_expr (function
, &call_args
,
14014 /*disallow_virtual=*/false,
14015 /*koenig_p=*/false,
14018 ret
= (build_new_method_call
14020 &call_args
, NULL_TREE
,
14021 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
14026 ret
= finish_call_expr (function
, &call_args
,
14027 /*disallow_virtual=*/qualified_p
,
14031 release_tree_vector (call_args
);
14038 tree cond
= RECUR (TREE_OPERAND (t
, 0));
14041 if (TREE_CODE (cond
) == INTEGER_CST
)
14043 if (integer_zerop (cond
))
14045 ++c_inhibit_evaluation_warnings
;
14046 exp1
= RECUR (TREE_OPERAND (t
, 1));
14047 --c_inhibit_evaluation_warnings
;
14048 exp2
= RECUR (TREE_OPERAND (t
, 2));
14052 exp1
= RECUR (TREE_OPERAND (t
, 1));
14053 ++c_inhibit_evaluation_warnings
;
14054 exp2
= RECUR (TREE_OPERAND (t
, 2));
14055 --c_inhibit_evaluation_warnings
;
14060 exp1
= RECUR (TREE_OPERAND (t
, 1));
14061 exp2
= RECUR (TREE_OPERAND (t
, 2));
14064 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
14065 cond
, exp1
, exp2
, complain
));
14068 case PSEUDO_DTOR_EXPR
:
14069 RETURN (finish_pseudo_destructor_expr
14070 (RECUR (TREE_OPERAND (t
, 0)),
14071 RECUR (TREE_OPERAND (t
, 1)),
14072 tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
)));
14076 tree purpose
, value
, chain
;
14078 if (t
== void_list_node
)
14081 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
14082 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
14084 /* We have pack expansions, so expand those and
14085 create a new list out of it. */
14086 tree purposevec
= NULL_TREE
;
14087 tree valuevec
= NULL_TREE
;
14091 /* Expand the argument expressions. */
14092 if (TREE_PURPOSE (t
))
14093 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
14094 complain
, in_decl
);
14095 if (TREE_VALUE (t
))
14096 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
14097 complain
, in_decl
);
14099 /* Build the rest of the list. */
14100 chain
= TREE_CHAIN (t
);
14101 if (chain
&& chain
!= void_type_node
)
14102 chain
= RECUR (chain
);
14104 /* Determine the number of arguments. */
14105 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
14107 len
= TREE_VEC_LENGTH (purposevec
);
14108 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
14110 else if (TREE_CODE (valuevec
) == TREE_VEC
)
14111 len
= TREE_VEC_LENGTH (valuevec
);
14114 /* Since we only performed a partial substitution into
14115 the argument pack, we only RETURN (a single list
14117 if (purposevec
== TREE_PURPOSE (t
)
14118 && valuevec
== TREE_VALUE (t
)
14119 && chain
== TREE_CHAIN (t
))
14122 RETURN (tree_cons (purposevec
, valuevec
, chain
));
14125 /* Convert the argument vectors into a TREE_LIST */
14129 /* Grab the Ith values. */
14131 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
14134 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
14137 /* Build the list (backwards). */
14138 chain
= tree_cons (purpose
, value
, chain
);
14144 purpose
= TREE_PURPOSE (t
);
14146 purpose
= RECUR (purpose
);
14147 value
= TREE_VALUE (t
);
14149 value
= RECUR (value
);
14150 chain
= TREE_CHAIN (t
);
14151 if (chain
&& chain
!= void_type_node
)
14152 chain
= RECUR (chain
);
14153 if (purpose
== TREE_PURPOSE (t
)
14154 && value
== TREE_VALUE (t
)
14155 && chain
== TREE_CHAIN (t
))
14157 RETURN (tree_cons (purpose
, value
, chain
));
14160 case COMPONENT_REF
:
14166 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14167 args
, complain
, in_decl
);
14168 /* Remember that there was a reference to this entity. */
14169 if (DECL_P (object
))
14170 mark_used (object
);
14171 object_type
= TREE_TYPE (object
);
14173 member
= TREE_OPERAND (t
, 1);
14174 if (BASELINK_P (member
))
14175 member
= tsubst_baselink (member
,
14176 non_reference (TREE_TYPE (object
)),
14177 args
, complain
, in_decl
);
14179 member
= tsubst_copy (member
, args
, complain
, in_decl
);
14180 if (member
== error_mark_node
)
14181 RETURN (error_mark_node
);
14183 if (type_dependent_expression_p (object
))
14184 /* We can't do much here. */;
14185 else if (!CLASS_TYPE_P (object_type
))
14187 if (scalarish_type_p (object_type
))
14189 tree s
= NULL_TREE
;
14190 tree dtor
= member
;
14192 if (TREE_CODE (dtor
) == SCOPE_REF
)
14194 s
= TREE_OPERAND (dtor
, 0);
14195 dtor
= TREE_OPERAND (dtor
, 1);
14197 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
14199 dtor
= TREE_OPERAND (dtor
, 0);
14201 RETURN (finish_pseudo_destructor_expr (object
, s
, dtor
));
14205 else if (TREE_CODE (member
) == SCOPE_REF
14206 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
14208 /* Lookup the template functions now that we know what the
14210 tree scope
= TREE_OPERAND (member
, 0);
14211 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
14212 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
14213 member
= lookup_qualified_name (scope
, tmpl
,
14214 /*is_type_p=*/false,
14215 /*complain=*/false);
14216 if (BASELINK_P (member
))
14218 BASELINK_FUNCTIONS (member
)
14219 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
14221 member
= (adjust_result_of_qualified_name_lookup
14222 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
14227 qualified_name_lookup_error (scope
, tmpl
, member
,
14229 RETURN (error_mark_node
);
14232 else if (TREE_CODE (member
) == SCOPE_REF
14233 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
14234 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
14236 if (complain
& tf_error
)
14238 if (TYPE_P (TREE_OPERAND (member
, 0)))
14239 error ("%qT is not a class or namespace",
14240 TREE_OPERAND (member
, 0));
14242 error ("%qD is not a class or namespace",
14243 TREE_OPERAND (member
, 0));
14245 RETURN (error_mark_node
);
14247 else if (TREE_CODE (member
) == FIELD_DECL
)
14248 RETURN (finish_non_static_data_member (member
, object
, NULL_TREE
));
14250 RETURN (finish_class_member_access_expr (object
, member
,
14251 /*template_p=*/false,
14256 RETURN (build_throw
14257 (RECUR (TREE_OPERAND (t
, 0))));
14261 vec
<constructor_elt
, va_gc
> *n
;
14262 constructor_elt
*ce
;
14263 unsigned HOST_WIDE_INT idx
;
14264 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14265 bool process_index_p
;
14267 bool need_copy_p
= false;
14270 if (type
== error_mark_node
)
14271 RETURN (error_mark_node
);
14273 /* digest_init will do the wrong thing if we let it. */
14274 if (type
&& TYPE_PTRMEMFUNC_P (type
))
14277 /* We do not want to process the index of aggregate
14278 initializers as they are identifier nodes which will be
14279 looked up by digest_init. */
14280 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
14282 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
14283 newlen
= vec_safe_length (n
);
14284 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
14286 if (ce
->index
&& process_index_p
)
14287 ce
->index
= RECUR (ce
->index
);
14289 if (PACK_EXPANSION_P (ce
->value
))
14291 /* Substitute into the pack expansion. */
14292 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
14295 if (ce
->value
== error_mark_node
14296 || PACK_EXPANSION_P (ce
->value
))
14298 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
14299 /* Just move the argument into place. */
14300 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
14303 /* Update the length of the final CONSTRUCTOR
14304 arguments vector, and note that we will need to
14306 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
14307 need_copy_p
= true;
14311 ce
->value
= RECUR (ce
->value
);
14316 vec
<constructor_elt
, va_gc
> *old_n
= n
;
14318 vec_alloc (n
, newlen
);
14319 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
14321 if (TREE_CODE (ce
->value
) == TREE_VEC
)
14323 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
14324 for (i
= 0; i
< len
; ++i
)
14325 CONSTRUCTOR_APPEND_ELT (n
, 0,
14326 TREE_VEC_ELT (ce
->value
, i
));
14329 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
14333 r
= build_constructor (init_list_type_node
, n
);
14334 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
14336 if (TREE_HAS_CONSTRUCTOR (t
))
14337 RETURN (finish_compound_literal (type
, r
, complain
));
14339 TREE_TYPE (r
) = type
;
14345 tree operand_0
= TREE_OPERAND (t
, 0);
14346 if (TYPE_P (operand_0
))
14348 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
14349 RETURN (get_typeid (operand_0
, complain
));
14353 operand_0
= RECUR (operand_0
);
14354 RETURN (build_typeid (operand_0
, complain
));
14365 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
14367 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
14368 /* If the original type was a reference, we'll be wrapped in
14369 the appropriate INDIRECT_REF. */
14370 r
= convert_from_reference (r
);
14375 RETURN (build_x_va_arg (EXPR_LOCATION (t
),
14376 RECUR (TREE_OPERAND (t
, 0)),
14377 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
)));
14379 case OFFSETOF_EXPR
:
14380 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0))));
14384 tree type1
= tsubst_copy (TRAIT_EXPR_TYPE1 (t
), args
,
14385 complain
, in_decl
);
14387 tree type2
= TRAIT_EXPR_TYPE2 (t
);
14389 type2
= tsubst_copy (type2
, args
, complain
, in_decl
);
14391 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
14396 tree old_stmt_expr
= cur_stmt_expr
;
14397 tree stmt_expr
= begin_stmt_expr ();
14399 cur_stmt_expr
= stmt_expr
;
14400 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
14401 integral_constant_expression_p
);
14402 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
14403 cur_stmt_expr
= old_stmt_expr
;
14405 /* If the resulting list of expression statement is empty,
14406 fold it further into void_zero_node. */
14407 if (empty_expr_stmt_p (stmt_expr
))
14408 stmt_expr
= void_zero_node
;
14410 RETURN (stmt_expr
);
14415 tree r
= build_lambda_expr ();
14417 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
14418 LAMBDA_EXPR_CLOSURE (r
) = type
;
14419 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
14421 LAMBDA_EXPR_LOCATION (r
)
14422 = LAMBDA_EXPR_LOCATION (t
);
14423 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
14424 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
14425 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
14426 LAMBDA_EXPR_DISCRIMINATOR (r
)
14427 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
14428 /* For a function scope, we want to use tsubst so that we don't
14429 complain about referring to an auto function before its return
14430 type has been deduced. Otherwise, we want to use tsubst_copy so
14431 that we look up the existing field/parameter/variable rather
14432 than build a new one. */
14433 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
14434 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
14435 scope
= tsubst (LAMBDA_EXPR_EXTRA_SCOPE (t
), args
,
14436 complain
, in_decl
);
14438 scope
= RECUR (scope
);
14439 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
14440 LAMBDA_EXPR_RETURN_TYPE (r
)
14441 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
14443 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
14444 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
14446 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
14447 determine_visibility (TYPE_NAME (type
));
14448 /* Now that we know visibility, instantiate the type so we have a
14449 declaration of the op() for later calls to lambda_function. */
14450 complete_type (type
);
14452 /* The capture list refers to closure members, so this needs to
14453 wait until after we finish instantiating the type. */
14454 LAMBDA_EXPR_CAPTURE_LIST (r
)
14455 = RECUR (LAMBDA_EXPR_CAPTURE_LIST (t
));
14456 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
14458 RETURN (build_lambda_object (r
));
14462 /* We can get here for a constant initializer of non-dependent type.
14463 FIXME stop folding in cp_parser_initializer_clause. */
14465 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
14470 case TRANSACTION_EXPR
:
14471 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
14472 integral_constant_expression_p
));
14475 /* Handle Objective-C++ constructs, if appropriate. */
14478 = objcp_tsubst_copy_and_build (t
, args
, complain
,
14479 in_decl
, /*function_p=*/false);
14483 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14489 input_location
= loc
;
14493 /* Verify that the instantiated ARGS are valid. For type arguments,
14494 make sure that the type's linkage is ok. For non-type arguments,
14495 make sure they are constants if they are integral or enumerations.
14496 Emit an error under control of COMPLAIN, and return TRUE on error. */
14499 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
14501 if (dependent_template_arg_p (t
))
14503 if (ARGUMENT_PACK_P (t
))
14505 tree vec
= ARGUMENT_PACK_ARGS (t
);
14506 int len
= TREE_VEC_LENGTH (vec
);
14507 bool result
= false;
14510 for (i
= 0; i
< len
; ++i
)
14511 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
14515 else if (TYPE_P (t
))
14517 /* [basic.link]: A name with no linkage (notably, the name
14518 of a class or enumeration declared in a local scope)
14519 shall not be used to declare an entity with linkage.
14520 This implies that names with no linkage cannot be used as
14523 DR 757 relaxes this restriction for C++0x. */
14524 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
14525 : no_linkage_check (t
, /*relaxed_p=*/false));
14529 /* DR 488 makes use of a type with no linkage cause
14530 type deduction to fail. */
14531 if (complain
& tf_error
)
14533 if (TYPE_ANONYMOUS_P (nt
))
14534 error ("%qT is/uses anonymous type", t
);
14536 error ("template argument for %qD uses local type %qT",
14541 /* In order to avoid all sorts of complications, we do not
14542 allow variably-modified types as template arguments. */
14543 else if (variably_modified_type_p (t
, NULL_TREE
))
14545 if (complain
& tf_error
)
14546 error ("%qT is a variably modified type", t
);
14550 /* Class template and alias template arguments should be OK. */
14551 else if (DECL_TYPE_TEMPLATE_P (t
))
14553 /* A non-type argument of integral or enumerated type must be a
14555 else if (TREE_TYPE (t
)
14556 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
14557 && !TREE_CONSTANT (t
))
14559 if (complain
& tf_error
)
14560 error ("integral expression %qE is not constant", t
);
14567 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
14569 int ix
, len
= DECL_NTPARMS (tmpl
);
14570 bool result
= false;
14572 for (ix
= 0; ix
!= len
; ix
++)
14574 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
14577 if (result
&& (complain
& tf_error
))
14578 error (" trying to instantiate %qD", tmpl
);
14582 /* We're out of SFINAE context now, so generate diagnostics for the access
14583 errors we saw earlier when instantiating D from TMPL and ARGS. */
14586 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
14588 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
14589 tree type
= TREE_TYPE (pattern
);
14590 location_t loc
= input_location
;
14592 push_access_scope (d
);
14593 push_deferring_access_checks (dk_no_deferred
);
14594 input_location
= DECL_SOURCE_LOCATION (pattern
);
14595 tsubst (type
, args
, tf_warning_or_error
, d
);
14596 input_location
= loc
;
14597 pop_deferring_access_checks ();
14598 pop_access_scope (d
);
14601 /* Instantiate the indicated variable, function, or alias template TMPL with
14602 the template arguments in TARG_PTR. */
14605 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
14607 tree targ_ptr
= orig_args
;
14611 bool access_ok
= true;
14613 if (tmpl
== error_mark_node
)
14614 return error_mark_node
;
14616 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
14618 /* If this function is a clone, handle it specially. */
14619 if (DECL_CLONED_FUNCTION_P (tmpl
))
14624 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
14625 DECL_CLONED_FUNCTION. */
14626 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
14627 targ_ptr
, complain
);
14628 if (spec
== error_mark_node
)
14629 return error_mark_node
;
14631 /* Look for the clone. */
14632 FOR_EACH_CLONE (clone
, spec
)
14633 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
14635 /* We should always have found the clone by now. */
14636 gcc_unreachable ();
14640 /* Check to see if we already have this specialization. */
14641 gen_tmpl
= most_general_template (tmpl
);
14642 if (tmpl
!= gen_tmpl
)
14643 /* The TMPL is a partial instantiation. To get a full set of
14644 arguments we must add the arguments used to perform the
14645 partial instantiation. */
14646 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
14649 /* It would be nice to avoid hashing here and then again in tsubst_decl,
14650 but it doesn't seem to be on the hot path. */
14651 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
14653 gcc_assert (tmpl
== gen_tmpl
14654 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
14656 || fndecl
== NULL_TREE
);
14658 if (spec
!= NULL_TREE
)
14660 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
14662 if (complain
& tf_error
)
14663 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
14664 return error_mark_node
;
14669 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
14671 return error_mark_node
;
14673 /* We are building a FUNCTION_DECL, during which the access of its
14674 parameters and return types have to be checked. However this
14675 FUNCTION_DECL which is the desired context for access checking
14676 is not built yet. We solve this chicken-and-egg problem by
14677 deferring all checks until we have the FUNCTION_DECL. */
14678 push_deferring_access_checks (dk_deferred
);
14680 /* Instantiation of the function happens in the context of the function
14681 template, not the context of the overload resolution we're doing. */
14682 push_to_top_level ();
14683 /* If there are dependent arguments, e.g. because we're doing partial
14684 ordering, make sure processing_template_decl stays set. */
14685 if (uses_template_parms (targ_ptr
))
14686 ++processing_template_decl
;
14687 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
14689 tree ctx
= tsubst (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
14690 complain
, gen_tmpl
);
14691 push_nested_class (ctx
);
14693 /* Substitute template parameters to obtain the specialization. */
14694 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
14695 targ_ptr
, complain
, gen_tmpl
);
14696 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
14697 pop_nested_class ();
14698 pop_from_top_level ();
14700 if (fndecl
== error_mark_node
)
14702 pop_deferring_access_checks ();
14703 return error_mark_node
;
14706 /* The DECL_TI_TEMPLATE should always be the immediate parent
14707 template, not the most general template. */
14708 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
14710 /* Now we know the specialization, compute access previously
14712 push_access_scope (fndecl
);
14713 if (!perform_deferred_access_checks (complain
))
14715 pop_access_scope (fndecl
);
14716 pop_deferring_access_checks ();
14718 /* If we've just instantiated the main entry point for a function,
14719 instantiate all the alternate entry points as well. We do this
14720 by cloning the instantiation of the main entry point, not by
14721 instantiating the template clones. */
14722 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
14723 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
14727 if (!(complain
& tf_error
))
14729 /* Remember to reinstantiate when we're out of SFINAE so the user
14730 can see the errors. */
14731 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
14733 return error_mark_node
;
14738 /* Wrapper for instantiate_template_1. */
14741 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
14744 timevar_push (TV_TEMPLATE_INST
);
14745 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
14746 timevar_pop (TV_TEMPLATE_INST
);
14750 /* Instantiate the alias template TMPL with ARGS. Also push a template
14751 instantiation level, which instantiate_template doesn't do because
14752 functions and variables have sufficient context established by the
14756 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
14758 struct pending_template
*old_last_pend
= last_pending_template
;
14759 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
14760 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
14761 return error_mark_node
;
14762 tree tinst
= build_tree_list (tmpl
, args
);
14763 if (!push_tinst_level (tinst
))
14766 return error_mark_node
;
14770 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
14771 args
, tmpl
, complain
,
14772 /*require_all_args=*/true,
14773 /*use_default_args=*/true);
14775 tree r
= instantiate_template (tmpl
, args
, complain
);
14776 pop_tinst_level ();
14777 /* We can't free this if a pending_template entry or last_error_tinst_level
14778 is pointing at it. */
14779 if (last_pending_template
== old_last_pend
14780 && last_error_tinst_level
== old_error_tinst
)
14786 /* PARM is a template parameter pack for FN. Returns true iff
14787 PARM is used in a deducible way in the argument list of FN. */
14790 pack_deducible_p (tree parm
, tree fn
)
14792 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
14793 for (; t
; t
= TREE_CHAIN (t
))
14795 tree type
= TREE_VALUE (t
);
14797 if (!PACK_EXPANSION_P (type
))
14799 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
14800 packs
; packs
= TREE_CHAIN (packs
))
14801 if (TREE_VALUE (packs
) == parm
)
14803 /* The template parameter pack is used in a function parameter
14804 pack. If this is the end of the parameter list, the
14805 template parameter pack is deducible. */
14806 if (TREE_CHAIN (t
) == void_list_node
)
14809 /* Otherwise, not. Well, it could be deduced from
14810 a non-pack parameter, but doing so would end up with
14811 a deduction mismatch, so don't bother. */
14815 /* The template parameter pack isn't used in any function parameter
14816 packs, but it might be used deeper, e.g. tuple<Args...>. */
14820 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
14821 NARGS elements of the arguments that are being used when calling
14822 it. TARGS is a vector into which the deduced template arguments
14825 Return zero for success, 2 for an incomplete match that doesn't resolve
14826 all the types, and 1 for complete failure. An error message will be
14827 printed only for an incomplete match.
14829 If FN is a conversion operator, or we are trying to produce a specific
14830 specialization, RETURN_TYPE is the return type desired.
14832 The EXPLICIT_TARGS are explicit template arguments provided via a
14835 The parameter STRICT is one of:
14838 We are deducing arguments for a function call, as in
14839 [temp.deduct.call].
14842 We are deducing arguments for a conversion function, as in
14843 [temp.deduct.conv].
14846 We are deducing arguments when doing an explicit instantiation
14847 as in [temp.explicit], when determining an explicit specialization
14848 as in [temp.expl.spec], or when taking the address of a function
14849 template, as in [temp.deduct.funcaddr]. */
14852 fn_type_unification (tree fn
,
14853 tree explicit_targs
,
14856 unsigned int nargs
,
14858 unification_kind_t strict
,
14864 tree decl
= NULL_TREE
;
14865 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
14867 static int deduction_depth
;
14868 struct pending_template
*old_last_pend
= last_pending_template
;
14869 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
14870 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
14872 tree r
= error_mark_node
;
14874 /* Adjust any explicit template arguments before entering the
14875 substitution context. */
14876 if (explicit_targs
)
14879 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
14881 /*require_all_args=*/false,
14882 /*use_default_args=*/false));
14883 if (explicit_targs
== error_mark_node
)
14884 return error_mark_node
;
14887 /* In C++0x, it's possible to have a function template whose type depends
14888 on itself recursively. This is most obvious with decltype, but can also
14889 occur with enumeration scope (c++/48969). So we need to catch infinite
14890 recursion and reject the substitution at deduction time; this function
14891 will return error_mark_node for any repeated substitution.
14893 This also catches excessive recursion such as when f<N> depends on
14894 f<N-1> across all integers, and returns error_mark_node for all the
14895 substitutions back up to the initial one.
14897 This is, of course, not reentrant. */
14898 if (excessive_deduction_depth
)
14899 return error_mark_node
;
14900 tinst
= build_tree_list (fn
, targs
);
14901 if (!push_tinst_level (tinst
))
14903 excessive_deduction_depth
= true;
14905 return error_mark_node
;
14908 push_deferring_access_checks (dk_deferred
);
14910 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
14912 fntype
= TREE_TYPE (fn
);
14913 if (explicit_targs
)
14917 The specified template arguments must match the template
14918 parameters in kind (i.e., type, nontype, template), and there
14919 must not be more arguments than there are parameters;
14920 otherwise type deduction fails.
14922 Nontype arguments must match the types of the corresponding
14923 nontype template parameters, or must be convertible to the
14924 types of the corresponding nontype parameters as specified in
14925 _temp.arg.nontype_, otherwise type deduction fails.
14927 All references in the function type of the function template
14928 to the corresponding template parameters are replaced by the
14929 specified template argument values. If a substitution in a
14930 template parameter or in the function type of the function
14931 template results in an invalid type, type deduction fails. */
14932 int i
, len
= TREE_VEC_LENGTH (tparms
);
14933 location_t loc
= input_location
;
14934 bool incomplete
= false;
14936 /* Substitute the explicit args into the function type. This is
14937 necessary so that, for instance, explicitly declared function
14938 arguments can match null pointed constants. If we were given
14939 an incomplete set of explicit args, we must not do semantic
14940 processing during substitution as we could create partial
14942 for (i
= 0; i
< len
; i
++)
14944 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
14945 bool parameter_pack
= false;
14946 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
14948 /* Dig out the actual parm. */
14949 if (TREE_CODE (parm
) == TYPE_DECL
14950 || TREE_CODE (parm
) == TEMPLATE_DECL
)
14952 parm
= TREE_TYPE (parm
);
14953 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
14955 else if (TREE_CODE (parm
) == PARM_DECL
)
14957 parm
= DECL_INITIAL (parm
);
14958 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
14961 if (!parameter_pack
&& targ
== NULL_TREE
)
14962 /* No explicit argument for this template parameter. */
14965 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
14967 /* Mark the argument pack as "incomplete". We could
14968 still deduce more arguments during unification.
14969 We remove this mark in type_unification_real. */
14972 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
14973 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
14974 = ARGUMENT_PACK_ARGS (targ
);
14977 /* We have some incomplete argument packs. */
14982 processing_template_decl
+= incomplete
;
14983 input_location
= DECL_SOURCE_LOCATION (fn
);
14984 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
14985 complain
| tf_partial
, NULL_TREE
);
14986 input_location
= loc
;
14987 processing_template_decl
-= incomplete
;
14989 if (fntype
== error_mark_node
)
14992 /* Throw away these access checks; we'll see them again in
14993 instantiate_template and they might have the wrong
14994 access path at this point. */
14995 pop_deferring_access_checks ();
14996 push_deferring_access_checks (dk_deferred
);
14998 /* Place the explicitly specified arguments in TARGS. */
14999 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
15000 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
15003 /* Never do unification on the 'this' parameter. */
15004 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
15010 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
15011 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
15012 new_args
[0] = return_type
;
15013 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
15018 /* We allow incomplete unification without an error message here
15019 because the standard doesn't seem to explicitly prohibit it. Our
15020 callers must be ready to deal with unification failures in any
15023 pop_tinst_level ();
15024 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
15025 targs
, parms
, args
, nargs
, /*subr=*/0,
15026 strict
, flags
, explain_p
);
15027 push_tinst_level (tinst
);
15031 /* Now that we have bindings for all of the template arguments,
15032 ensure that the arguments deduced for the template template
15033 parameters have compatible template parameter lists. We cannot
15034 check this property before we have deduced all template
15035 arguments, because the template parameter types of a template
15036 template parameter might depend on prior template parameters
15037 deduced after the template template parameter. The following
15038 ill-formed example illustrates this issue:
15040 template<typename T, template<T> class C> void f(C<5>, T);
15042 template<int N> struct X {};
15045 f(X<5>(), 5l); // error: template argument deduction fails
15048 The template parameter list of 'C' depends on the template type
15049 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
15050 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
15051 time that we deduce 'C'. */
15052 if (!template_template_parm_bindings_ok_p
15053 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
15055 unify_inconsistent_template_template_parameters (explain_p
);
15059 /* All is well so far. Now, check:
15063 When all template arguments have been deduced, all uses of
15064 template parameters in nondeduced contexts are replaced with
15065 the corresponding deduced argument values. If the
15066 substitution results in an invalid type, as described above,
15067 type deduction fails. */
15068 decl
= instantiate_template (fn
, targs
, complain
);
15069 if (decl
== error_mark_node
)
15072 /* Now perform any access checks encountered during deduction, such as
15073 for default template arguments. */
15074 push_access_scope (decl
);
15075 ok
= perform_deferred_access_checks (complain
);
15076 pop_access_scope (decl
);
15080 /* If we're looking for an exact match, check that what we got
15081 is indeed an exact match. It might not be if some template
15082 parameters are used in non-deduced contexts. */
15083 if (strict
== DEDUCE_EXACT
)
15085 tree substed
= TREE_TYPE (decl
);
15089 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
15091 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
15092 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
15093 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
15095 unify_type_mismatch (explain_p
, args
[i
],
15096 TREE_VALUE (sarg
));
15104 pop_deferring_access_checks ();
15106 if (excessive_deduction_depth
)
15108 if (deduction_depth
== 0)
15109 /* Reset once we're all the way out. */
15110 excessive_deduction_depth
= false;
15113 pop_tinst_level ();
15114 /* We can't free this if a pending_template entry or last_error_tinst_level
15115 is pointing at it. */
15116 if (last_pending_template
== old_last_pend
15117 && last_error_tinst_level
== old_error_tinst
)
15123 /* Adjust types before performing type deduction, as described in
15124 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
15125 sections are symmetric. PARM is the type of a function parameter
15126 or the return type of the conversion function. ARG is the type of
15127 the argument passed to the call, or the type of the value
15128 initialized with the result of the conversion function.
15129 ARG_EXPR is the original argument expression, which may be null. */
15132 maybe_adjust_types_for_deduction (unification_kind_t strict
,
15146 /* Swap PARM and ARG throughout the remainder of this
15147 function; the handling is precisely symmetric since PARM
15148 will initialize ARG rather than vice versa. */
15156 /* Core issue #873: Do the DR606 thing (see below) for these cases,
15157 too, but here handle it by stripping the reference from PARM
15158 rather than by adding it to ARG. */
15159 if (TREE_CODE (*parm
) == REFERENCE_TYPE
15160 && TYPE_REF_IS_RVALUE (*parm
)
15161 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
15162 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
15163 && TREE_CODE (*arg
) == REFERENCE_TYPE
15164 && !TYPE_REF_IS_RVALUE (*arg
))
15165 *parm
= TREE_TYPE (*parm
);
15166 /* Nothing else to do in this case. */
15170 gcc_unreachable ();
15173 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
15175 /* [temp.deduct.call]
15177 If P is not a reference type:
15179 --If A is an array type, the pointer type produced by the
15180 array-to-pointer standard conversion (_conv.array_) is
15181 used in place of A for type deduction; otherwise,
15183 --If A is a function type, the pointer type produced by
15184 the function-to-pointer standard conversion
15185 (_conv.func_) is used in place of A for type deduction;
15188 --If A is a cv-qualified type, the top level
15189 cv-qualifiers of A's type are ignored for type
15191 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
15192 *arg
= build_pointer_type (TREE_TYPE (*arg
));
15193 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
15194 *arg
= build_pointer_type (*arg
);
15196 *arg
= TYPE_MAIN_VARIANT (*arg
);
15199 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
15200 of the form T&&, where T is a template parameter, and the argument
15201 is an lvalue, T is deduced as A& */
15202 if (TREE_CODE (*parm
) == REFERENCE_TYPE
15203 && TYPE_REF_IS_RVALUE (*parm
)
15204 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
15205 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
15206 && (arg_expr
? real_lvalue_p (arg_expr
)
15207 /* try_one_overload doesn't provide an arg_expr, but
15208 functions are always lvalues. */
15209 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
15210 *arg
= build_reference_type (*arg
);
15212 /* [temp.deduct.call]
15214 If P is a cv-qualified type, the top level cv-qualifiers
15215 of P's type are ignored for type deduction. If P is a
15216 reference type, the type referred to by P is used for
15218 *parm
= TYPE_MAIN_VARIANT (*parm
);
15219 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
15221 *parm
= TREE_TYPE (*parm
);
15222 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
15225 /* DR 322. For conversion deduction, remove a reference type on parm
15226 too (which has been swapped into ARG). */
15227 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
15228 *arg
= TREE_TYPE (*arg
);
15233 /* Subroutine of unify_one_argument. PARM is a function parameter of a
15234 template which does contain any deducible template parameters; check if
15235 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
15236 unify_one_argument. */
15239 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
15240 int flags
, bool explain_p
)
15245 type
= TREE_TYPE (arg
);
15249 if (same_type_p (parm
, type
))
15250 return unify_success (explain_p
);
15252 if (strict
== DEDUCE_CONV
)
15254 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
15255 explain_p
? tf_warning_or_error
: tf_none
))
15256 return unify_success (explain_p
);
15258 else if (strict
!= DEDUCE_EXACT
)
15260 if (can_convert_arg (parm
, type
,
15261 TYPE_P (arg
) ? NULL_TREE
: arg
,
15262 flags
, explain_p
? tf_warning_or_error
: tf_none
))
15263 return unify_success (explain_p
);
15266 if (strict
== DEDUCE_EXACT
)
15267 return unify_type_mismatch (explain_p
, parm
, arg
);
15269 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
15272 /* Subroutine of type_unification_real and unify_pack_expansion to
15273 handle unification of a single P/A pair. Parameters are as
15274 for those functions. */
15277 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
15278 int subr
, unification_kind_t strict
, int flags
,
15281 tree arg_expr
= NULL_TREE
;
15284 if (arg
== error_mark_node
|| parm
== error_mark_node
)
15285 return unify_invalid (explain_p
);
15286 if (arg
== unknown_type_node
)
15287 /* We can't deduce anything from this, but we might get all the
15288 template args from other function args. */
15289 return unify_success (explain_p
);
15291 /* FIXME uses_deducible_template_parms */
15292 if (TYPE_P (parm
) && !uses_template_parms (parm
))
15293 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
15299 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
15300 | UNIFY_ALLOW_MORE_CV_QUAL
15301 | UNIFY_ALLOW_DERIVED
);
15305 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
15309 arg_strict
= UNIFY_ALLOW_NONE
;
15313 gcc_unreachable ();
15316 /* We only do these transformations if this is the top-level
15317 parameter_type_list in a call or declaration matching; in other
15318 situations (nested function declarators, template argument lists) we
15319 won't be comparing a type to an expression, and we don't do any type
15325 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
15326 if (type_unknown_p (arg
))
15328 /* [temp.deduct.type] A template-argument can be
15329 deduced from a pointer to function or pointer
15330 to member function argument if the set of
15331 overloaded functions does not contain function
15332 templates and at most one of a set of
15333 overloaded functions provides a unique
15336 if (resolve_overloaded_unification
15337 (tparms
, targs
, parm
, arg
, strict
,
15338 arg_strict
, explain_p
))
15339 return unify_success (explain_p
);
15340 return unify_overload_resolution_failure (explain_p
, arg
);
15344 arg
= unlowered_expr_type (arg
);
15345 if (arg
== error_mark_node
)
15346 return unify_invalid (explain_p
);
15350 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
15353 gcc_assert ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
15354 == (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
));
15356 /* For deduction from an init-list we need the actual list. */
15357 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
15359 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
15362 /* Most parms like fn_type_unification.
15364 If SUBR is 1, we're being called recursively (to unify the
15365 arguments of a function or method parameter of a function
15369 type_unification_real (tree tparms
,
15373 unsigned int xnargs
,
15375 unification_kind_t strict
,
15381 int ntparms
= TREE_VEC_LENGTH (tparms
);
15382 int saw_undeduced
= 0;
15385 unsigned int nargs
;
15388 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
15389 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
15390 gcc_assert (ntparms
> 0);
15392 /* Reset the number of non-defaulted template arguments contained
15394 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
15402 while (parms
&& parms
!= void_list_node
15405 parm
= TREE_VALUE (parms
);
15407 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
15408 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
15409 /* For a function parameter pack that occurs at the end of the
15410 parameter-declaration-list, the type A of each remaining
15411 argument of the call is compared with the type P of the
15412 declarator-id of the function parameter pack. */
15415 parms
= TREE_CHAIN (parms
);
15417 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
15418 /* For a function parameter pack that does not occur at the
15419 end of the parameter-declaration-list, the type of the
15420 parameter pack is a non-deduced context. */
15426 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
15432 && parms
!= void_list_node
15433 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
15435 /* Unify the remaining arguments with the pack expansion type. */
15437 tree parmvec
= make_tree_vec (1);
15439 /* Allocate a TREE_VEC and copy in all of the arguments */
15440 argvec
= make_tree_vec (nargs
- ia
);
15441 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
15442 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
15444 /* Copy the parameter into parmvec. */
15445 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
15446 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
15447 /*subr=*/subr
, explain_p
))
15450 /* Advance to the end of the list of parameters. */
15451 parms
= TREE_CHAIN (parms
);
15454 /* Fail if we've reached the end of the parm list, and more args
15455 are present, and the parm list isn't variadic. */
15456 if (ia
< nargs
&& parms
== void_list_node
)
15457 return unify_too_many_arguments (explain_p
, nargs
, ia
);
15458 /* Fail if parms are left and they don't have default values. */
15459 if (parms
&& parms
!= void_list_node
15460 && TREE_PURPOSE (parms
) == NULL_TREE
)
15462 unsigned int count
= nargs
;
15464 while (p
&& p
!= void_list_node
)
15467 p
= TREE_CHAIN (p
);
15469 return unify_too_few_arguments (explain_p
, ia
, count
);
15474 tsubst_flags_t complain
= (explain_p
15475 ? tf_warning_or_error
15478 for (i
= 0; i
< ntparms
; i
++)
15480 tree targ
= TREE_VEC_ELT (targs
, i
);
15481 tree tparm
= TREE_VEC_ELT (tparms
, i
);
15483 /* Clear the "incomplete" flags on all argument packs now so that
15484 substituting them into later default arguments works. */
15485 if (targ
&& ARGUMENT_PACK_P (targ
))
15487 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
15488 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
15491 if (targ
|| tparm
== error_mark_node
)
15493 tparm
= TREE_VALUE (tparm
);
15495 /* If this is an undeduced nontype parameter that depends on
15496 a type parameter, try another pass; its type may have been
15497 deduced from a later argument than the one from which
15498 this parameter can be deduced. */
15499 if (TREE_CODE (tparm
) == PARM_DECL
15500 && uses_template_parms (TREE_TYPE (tparm
))
15501 && !saw_undeduced
++)
15504 /* Core issue #226 (C++0x) [temp.deduct]:
15506 If a template argument has not been deduced, its
15507 default template argument, if any, is used.
15509 When we are in C++98 mode, TREE_PURPOSE will either
15510 be NULL_TREE or ERROR_MARK_NODE, so we do not need
15511 to explicitly check cxx_dialect here. */
15512 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
15514 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
15515 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
15516 location_t save_loc
= input_location
;
15518 input_location
= DECL_SOURCE_LOCATION (parm
);
15519 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
15520 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
15522 input_location
= save_loc
;
15523 if (arg
== error_mark_node
)
15527 TREE_VEC_ELT (targs
, i
) = arg
;
15528 /* The position of the first default template argument,
15529 is also the number of non-defaulted arguments in TARGS.
15531 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
15532 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
15537 /* If the type parameter is a parameter pack, then it will
15538 be deduced to an empty parameter pack. */
15539 if (template_parameter_pack_p (tparm
))
15543 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
15545 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
15546 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
15547 TREE_CONSTANT (arg
) = 1;
15550 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
15552 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
15554 TREE_VEC_ELT (targs
, i
) = arg
;
15558 return unify_parameter_deduction_failure (explain_p
, tparm
);
15561 #ifdef ENABLE_CHECKING
15562 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
15563 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
15566 return unify_success (explain_p
);
15569 /* Subroutine of type_unification_real. Args are like the variables
15570 at the call site. ARG is an overloaded function (or template-id);
15571 we try deducing template args from each of the overloads, and if
15572 only one succeeds, we go with that. Modifies TARGS and returns
15573 true on success. */
15576 resolve_overloaded_unification (tree tparms
,
15580 unification_kind_t strict
,
15584 tree tempargs
= copy_node (targs
);
15586 tree goodfn
= NULL_TREE
;
15589 if (TREE_CODE (arg
) == ADDR_EXPR
)
15591 arg
= TREE_OPERAND (arg
, 0);
15597 if (TREE_CODE (arg
) == COMPONENT_REF
)
15598 /* Handle `&x' where `x' is some static or non-static member
15600 arg
= TREE_OPERAND (arg
, 1);
15602 if (TREE_CODE (arg
) == OFFSET_REF
)
15603 arg
= TREE_OPERAND (arg
, 1);
15605 /* Strip baselink information. */
15606 if (BASELINK_P (arg
))
15607 arg
= BASELINK_FUNCTIONS (arg
);
15609 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
15611 /* If we got some explicit template args, we need to plug them into
15612 the affected templates before we try to unify, in case the
15613 explicit args will completely resolve the templates in question. */
15616 tree expl_subargs
= TREE_OPERAND (arg
, 1);
15617 arg
= TREE_OPERAND (arg
, 0);
15619 for (; arg
; arg
= OVL_NEXT (arg
))
15621 tree fn
= OVL_CURRENT (arg
);
15622 tree subargs
, elem
;
15624 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
15627 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
15628 expl_subargs
, NULL_TREE
, tf_none
,
15629 /*require_all_args=*/true,
15630 /*use_default_args=*/true);
15631 if (subargs
!= error_mark_node
15632 && !any_dependent_template_arguments_p (subargs
))
15634 elem
= tsubst (TREE_TYPE (fn
), subargs
, tf_none
, NULL_TREE
);
15635 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
15636 elem
, strict
, sub_strict
, addr_p
, explain_p
)
15637 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
15646 /* If no templates (or more than one) are fully resolved by the
15647 explicit arguments, this template-id is a non-deduced context; it
15648 could still be OK if we deduce all template arguments for the
15649 enclosing call through other arguments. */
15653 else if (TREE_CODE (arg
) != OVERLOAD
15654 && TREE_CODE (arg
) != FUNCTION_DECL
)
15655 /* If ARG is, for example, "(0, &f)" then its type will be unknown
15656 -- but the deduction does not succeed because the expression is
15657 not just the function on its own. */
15660 for (; arg
; arg
= OVL_NEXT (arg
))
15661 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
15662 TREE_TYPE (OVL_CURRENT (arg
)),
15663 strict
, sub_strict
, addr_p
, explain_p
)
15664 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
15666 goodfn
= OVL_CURRENT (arg
);
15670 /* [temp.deduct.type] A template-argument can be deduced from a pointer
15671 to function or pointer to member function argument if the set of
15672 overloaded functions does not contain function templates and at most
15673 one of a set of overloaded functions provides a unique match.
15675 So if we found multiple possibilities, we return success but don't
15676 deduce anything. */
15680 int i
= TREE_VEC_LENGTH (targs
);
15682 if (TREE_VEC_ELT (tempargs
, i
))
15683 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
15691 /* Core DR 115: In contexts where deduction is done and fails, or in
15692 contexts where deduction is not done, if a template argument list is
15693 specified and it, along with any default template arguments, identifies
15694 a single function template specialization, then the template-id is an
15695 lvalue for the function template specialization. */
15698 resolve_nondeduced_context (tree orig_expr
)
15700 tree expr
, offset
, baselink
;
15703 if (!type_unknown_p (orig_expr
))
15708 offset
= NULL_TREE
;
15709 baselink
= NULL_TREE
;
15711 if (TREE_CODE (expr
) == ADDR_EXPR
)
15713 expr
= TREE_OPERAND (expr
, 0);
15716 if (TREE_CODE (expr
) == OFFSET_REF
)
15719 expr
= TREE_OPERAND (expr
, 1);
15721 if (BASELINK_P (expr
))
15724 expr
= BASELINK_FUNCTIONS (expr
);
15727 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
15730 tree goodfn
= NULL_TREE
;
15732 /* If we got some explicit template args, we need to plug them into
15733 the affected templates before we try to unify, in case the
15734 explicit args will completely resolve the templates in question. */
15736 tree expl_subargs
= TREE_OPERAND (expr
, 1);
15737 tree arg
= TREE_OPERAND (expr
, 0);
15738 tree badfn
= NULL_TREE
;
15739 tree badargs
= NULL_TREE
;
15741 for (; arg
; arg
= OVL_NEXT (arg
))
15743 tree fn
= OVL_CURRENT (arg
);
15744 tree subargs
, elem
;
15746 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
15749 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
15750 expl_subargs
, NULL_TREE
, tf_none
,
15751 /*require_all_args=*/true,
15752 /*use_default_args=*/true);
15753 if (subargs
!= error_mark_node
15754 && !any_dependent_template_arguments_p (subargs
))
15756 elem
= instantiate_template (fn
, subargs
, tf_none
);
15757 if (elem
== error_mark_node
)
15762 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
15771 mark_used (goodfn
);
15774 expr
= build_baselink (BASELINK_BINFO (baselink
),
15775 BASELINK_ACCESS_BINFO (baselink
),
15776 expr
, BASELINK_OPTYPE (baselink
));
15780 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
15781 expr
= build_offset_ref (base
, expr
, addr
);
15784 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
15787 else if (good
== 0 && badargs
)
15788 /* There were no good options and at least one bad one, so let the
15789 user know what the problem is. */
15790 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
15795 /* Subroutine of resolve_overloaded_unification; does deduction for a single
15796 overload. Fills TARGS with any deduced arguments, or error_mark_node if
15797 different overloads deduce different arguments for a given parm.
15798 ADDR_P is true if the expression for which deduction is being
15799 performed was of the form "& fn" rather than simply "fn".
15801 Returns 1 on success. */
15804 try_one_overload (tree tparms
,
15809 unification_kind_t strict
,
15818 if (arg
== error_mark_node
)
15821 /* [temp.deduct.type] A template-argument can be deduced from a pointer
15822 to function or pointer to member function argument if the set of
15823 overloaded functions does not contain function templates and at most
15824 one of a set of overloaded functions provides a unique match.
15826 So if this is a template, just return success. */
15828 if (uses_template_parms (arg
))
15831 if (TREE_CODE (arg
) == METHOD_TYPE
)
15832 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
15834 arg
= build_pointer_type (arg
);
15836 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
15838 /* We don't copy orig_targs for this because if we have already deduced
15839 some template args from previous args, unify would complain when we
15840 try to deduce a template parameter for the same argument, even though
15841 there isn't really a conflict. */
15842 nargs
= TREE_VEC_LENGTH (targs
);
15843 tempargs
= make_tree_vec (nargs
);
15845 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
15848 /* First make sure we didn't deduce anything that conflicts with
15849 explicitly specified args. */
15850 for (i
= nargs
; i
--; )
15852 tree elt
= TREE_VEC_ELT (tempargs
, i
);
15853 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
15857 else if (uses_template_parms (elt
))
15858 /* Since we're unifying against ourselves, we will fill in
15859 template args used in the function parm list with our own
15860 template parms. Discard them. */
15861 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
15862 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
15866 for (i
= nargs
; i
--; )
15868 tree elt
= TREE_VEC_ELT (tempargs
, i
);
15871 TREE_VEC_ELT (targs
, i
) = elt
;
15877 /* PARM is a template class (perhaps with unbound template
15878 parameters). ARG is a fully instantiated type. If ARG can be
15879 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
15880 TARGS are as for unify. */
15883 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
15886 tree copy_of_targs
;
15888 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
15889 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
15890 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
15893 /* We need to make a new template argument vector for the call to
15894 unify. If we used TARGS, we'd clutter it up with the result of
15895 the attempted unification, even if this class didn't work out.
15896 We also don't want to commit ourselves to all the unifications
15897 we've already done, since unification is supposed to be done on
15898 an argument-by-argument basis. In other words, consider the
15899 following pathological case:
15901 template <int I, int J, int K>
15904 template <int I, int J>
15905 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
15907 template <int I, int J, int K>
15908 void f(S<I, J, K>, S<I, I, I>);
15917 Now, by the time we consider the unification involving `s2', we
15918 already know that we must have `f<0, 0, 0>'. But, even though
15919 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
15920 because there are two ways to unify base classes of S<0, 1, 2>
15921 with S<I, I, I>. If we kept the already deduced knowledge, we
15922 would reject the possibility I=1. */
15923 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
15925 /* If unification failed, we're done. */
15926 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
15927 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
15933 /* Given a template type PARM and a class type ARG, find the unique
15934 base type in ARG that is an instance of PARM. We do not examine
15935 ARG itself; only its base-classes. If there is not exactly one
15936 appropriate base class, return NULL_TREE. PARM may be the type of
15937 a partial specialization, as well as a plain template type. Used
15940 static enum template_base_result
15941 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
15942 bool explain_p
, tree
*result
)
15944 tree rval
= NULL_TREE
;
15947 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
15949 binfo
= TYPE_BINFO (complete_type (arg
));
15952 /* The type could not be completed. */
15953 *result
= NULL_TREE
;
15954 return tbr_incomplete_type
;
15957 /* Walk in inheritance graph order. The search order is not
15958 important, and this avoids multiple walks of virtual bases. */
15959 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
15961 tree r
= try_class_unification (tparms
, targs
, parm
,
15962 BINFO_TYPE (binfo
), explain_p
);
15966 /* If there is more than one satisfactory baseclass, then:
15970 If they yield more than one possible deduced A, the type
15974 if (rval
&& !same_type_p (r
, rval
))
15976 *result
= NULL_TREE
;
15977 return tbr_ambiguous_baseclass
;
15985 return tbr_success
;
15988 /* Returns the level of DECL, which declares a template parameter. */
15991 template_decl_level (tree decl
)
15993 switch (TREE_CODE (decl
))
15996 case TEMPLATE_DECL
:
15997 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
16000 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
16003 gcc_unreachable ();
16008 /* Decide whether ARG can be unified with PARM, considering only the
16009 cv-qualifiers of each type, given STRICT as documented for unify.
16010 Returns nonzero iff the unification is OK on that basis. */
16013 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
16015 int arg_quals
= cp_type_quals (arg
);
16016 int parm_quals
= cp_type_quals (parm
);
16018 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
16019 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
16021 /* Although a CVR qualifier is ignored when being applied to a
16022 substituted template parameter ([8.3.2]/1 for example), that
16023 does not allow us to unify "const T" with "int&" because both
16024 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
16025 It is ok when we're allowing additional CV qualifiers
16026 at the outer level [14.8.2.1]/3,1st bullet. */
16027 if ((TREE_CODE (arg
) == REFERENCE_TYPE
16028 || TREE_CODE (arg
) == FUNCTION_TYPE
16029 || TREE_CODE (arg
) == METHOD_TYPE
)
16030 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
16033 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
16034 && (parm_quals
& TYPE_QUAL_RESTRICT
))
16038 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
16039 && (arg_quals
& parm_quals
) != parm_quals
)
16042 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
16043 && (parm_quals
& arg_quals
) != arg_quals
)
16049 /* Determines the LEVEL and INDEX for the template parameter PARM. */
16051 template_parm_level_and_index (tree parm
, int* level
, int* index
)
16053 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
16054 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
16055 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16057 *index
= TEMPLATE_TYPE_IDX (parm
);
16058 *level
= TEMPLATE_TYPE_LEVEL (parm
);
16062 *index
= TEMPLATE_PARM_IDX (parm
);
16063 *level
= TEMPLATE_PARM_LEVEL (parm
);
16067 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
16069 if (unify (TP, TA, P, A, S, EP)) \
16073 /* Unifies the remaining arguments in PACKED_ARGS with the pack
16074 expansion at the end of PACKED_PARMS. Returns 0 if the type
16075 deduction succeeds, 1 otherwise. STRICT is the same as in
16076 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
16077 call argument list. We'll need to adjust the arguments to make them
16078 types. SUBR tells us if this is from a recursive call to
16079 type_unification_real, or for comparing two template argument
16083 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
16084 tree packed_args
, unification_kind_t strict
,
16085 bool subr
, bool explain_p
)
16088 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
16089 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
16090 tree pack
, packs
= NULL_TREE
;
16091 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
16092 int len
= TREE_VEC_LENGTH (packed_args
);
16094 /* Determine the parameter packs we will be deducing from the
16095 pattern, and record their current deductions. */
16096 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
16097 pack
; pack
= TREE_CHAIN (pack
))
16099 tree parm_pack
= TREE_VALUE (pack
);
16102 /* Determine the index and level of this parameter pack. */
16103 template_parm_level_and_index (parm_pack
, &level
, &idx
);
16105 /* Keep track of the parameter packs and their corresponding
16107 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
16108 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
16111 /* Loop through all of the arguments that have not yet been
16112 unified and unify each with the pattern. */
16113 for (i
= start
; i
< len
; i
++)
16116 bool any_explicit
= false;
16117 tree arg
= TREE_VEC_ELT (packed_args
, i
);
16119 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
16120 or the element of its argument pack at the current index if
16121 this argument was explicitly specified. */
16122 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
16126 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
16129 if (TREE_VALUE (pack
)
16130 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
16131 && (i
< TREE_VEC_LENGTH (pargs
)))
16133 any_explicit
= true;
16134 arg
= TREE_VEC_ELT (pargs
, i
);
16136 TMPL_ARG (targs
, level
, idx
) = arg
;
16139 /* If we had explicit template arguments, substitute them into the
16140 pattern before deduction. */
16143 /* Some arguments might still be unspecified or dependent. */
16145 ++processing_template_decl
;
16146 dependent
= any_dependent_template_arguments_p (targs
);
16148 --processing_template_decl
;
16149 parm
= tsubst (pattern
, targs
,
16150 explain_p
? tf_warning_or_error
: tf_none
,
16153 --processing_template_decl
;
16154 if (parm
== error_mark_node
)
16160 /* Unify the pattern with the current argument. */
16161 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16162 LOOKUP_IMPLICIT
, explain_p
))
16165 /* For each parameter pack, collect the deduced value. */
16166 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
16169 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
16171 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
16172 TMPL_ARG (targs
, level
, idx
);
16176 /* Verify that the results of unification with the parameter packs
16177 produce results consistent with what we've seen before, and make
16178 the deduced argument packs available. */
16179 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
16181 tree old_pack
= TREE_VALUE (pack
);
16182 tree new_args
= TREE_TYPE (pack
);
16183 int i
, len
= TREE_VEC_LENGTH (new_args
);
16185 bool nondeduced_p
= false;
16187 /* By default keep the original deduced argument pack.
16188 If necessary, more specific code is going to update the
16189 resulting deduced argument later down in this function. */
16190 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
16191 TMPL_ARG (targs
, level
, idx
) = old_pack
;
16193 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
16194 actually deduce anything. */
16195 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
16196 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
16197 nondeduced_p
= true;
16201 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
16203 /* If we had fewer function args than explicit template args,
16204 just use the explicits. */
16205 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
16206 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
16207 if (len
< explicit_len
)
16208 new_args
= explicit_args
;
16214 /* Build the deduced *_ARGUMENT_PACK. */
16215 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
16217 result
= make_node (NONTYPE_ARGUMENT_PACK
);
16218 TREE_TYPE (result
) =
16219 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
16220 TREE_CONSTANT (result
) = 1;
16223 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16225 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
16227 /* Note the deduced argument packs for this parameter
16229 TMPL_ARG (targs
, level
, idx
) = result
;
16231 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
16232 && (ARGUMENT_PACK_ARGS (old_pack
)
16233 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
16235 /* We only had the explicitly-provided arguments before, but
16236 now we have a complete set of arguments. */
16237 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
16239 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
16240 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
16241 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
16245 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
16246 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
16248 if (!comp_template_args_with_info (old_args
, new_args
,
16249 &bad_old_arg
, &bad_new_arg
))
16250 /* Inconsistent unification of this parameter pack. */
16251 return unify_parameter_pack_inconsistent (explain_p
,
16257 return unify_success (explain_p
);
16260 /* Deduce the value of template parameters. TPARMS is the (innermost)
16261 set of template parameters to a template. TARGS is the bindings
16262 for those template parameters, as determined thus far; TARGS may
16263 include template arguments for outer levels of template parameters
16264 as well. PARM is a parameter to a template function, or a
16265 subcomponent of that parameter; ARG is the corresponding argument.
16266 This function attempts to match PARM with ARG in a manner
16267 consistent with the existing assignments in TARGS. If more values
16268 are deduced, then TARGS is updated.
16270 Returns 0 if the type deduction succeeds, 1 otherwise. The
16271 parameter STRICT is a bitwise or of the following flags:
16274 Require an exact match between PARM and ARG.
16275 UNIFY_ALLOW_MORE_CV_QUAL:
16276 Allow the deduced ARG to be more cv-qualified (by qualification
16277 conversion) than ARG.
16278 UNIFY_ALLOW_LESS_CV_QUAL:
16279 Allow the deduced ARG to be less cv-qualified than ARG.
16280 UNIFY_ALLOW_DERIVED:
16281 Allow the deduced ARG to be a template base class of ARG,
16282 or a pointer to a template base class of the type pointed to by
16284 UNIFY_ALLOW_INTEGER:
16285 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
16286 case for more information.
16287 UNIFY_ALLOW_OUTER_LEVEL:
16288 This is the outermost level of a deduction. Used to determine validity
16289 of qualification conversions. A valid qualification conversion must
16290 have const qualified pointers leading up to the inner type which
16291 requires additional CV quals, except at the outer level, where const
16292 is not required [conv.qual]. It would be normal to set this flag in
16293 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
16294 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
16295 This is the outermost level of a deduction, and PARM can be more CV
16296 qualified at this point.
16297 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
16298 This is the outermost level of a deduction, and PARM can be less CV
16299 qualified at this point. */
16302 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
16308 int strict_in
= strict
;
16310 /* I don't think this will do the right thing with respect to types.
16311 But the only case I've seen it in so far has been array bounds, where
16312 signedness is the only information lost, and I think that will be
16314 while (TREE_CODE (parm
) == NOP_EXPR
)
16315 parm
= TREE_OPERAND (parm
, 0);
16317 if (arg
== error_mark_node
)
16318 return unify_invalid (explain_p
);
16319 if (arg
== unknown_type_node
16320 || arg
== init_list_type_node
)
16321 /* We can't deduce anything from this, but we might get all the
16322 template args from other function args. */
16323 return unify_success (explain_p
);
16325 /* If PARM uses template parameters, then we can't bail out here,
16326 even if ARG == PARM, since we won't record unifications for the
16327 template parameters. We might need them if we're trying to
16328 figure out which of two things is more specialized. */
16329 if (arg
== parm
&& !uses_template_parms (parm
))
16330 return unify_success (explain_p
);
16332 /* Handle init lists early, so the rest of the function can assume
16333 we're dealing with a type. */
16334 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
16338 tree orig_parm
= parm
;
16340 /* Replace T with std::initializer_list<T> for deduction. */
16341 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
16342 && flag_deduce_init_list
)
16343 parm
= listify (parm
);
16345 if (!is_std_init_list (parm
))
16346 /* We can only deduce from an initializer list argument if the
16347 parameter is std::initializer_list; otherwise this is a
16348 non-deduced context. */
16349 return unify_success (explain_p
);
16351 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
16353 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
16355 int elt_strict
= strict
;
16357 if (elt
== error_mark_node
)
16358 return unify_invalid (explain_p
);
16360 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
16362 tree type
= TREE_TYPE (elt
);
16363 /* It should only be possible to get here for a call. */
16364 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
16365 elt_strict
|= maybe_adjust_types_for_deduction
16366 (DEDUCE_CALL
, &elttype
, &type
, elt
);
16370 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
16374 /* If the std::initializer_list<T> deduction worked, replace the
16375 deduced A with std::initializer_list<A>. */
16376 if (orig_parm
!= parm
)
16378 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
16379 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
16380 targ
= listify (targ
);
16381 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
16383 return unify_success (explain_p
);
16386 /* Immediately reject some pairs that won't unify because of
16387 cv-qualification mismatches. */
16388 if (TREE_CODE (arg
) == TREE_CODE (parm
)
16390 /* It is the elements of the array which hold the cv quals of an array
16391 type, and the elements might be template type parms. We'll check
16392 when we recurse. */
16393 && TREE_CODE (arg
) != ARRAY_TYPE
16394 /* We check the cv-qualifiers when unifying with template type
16395 parameters below. We want to allow ARG `const T' to unify with
16396 PARM `T' for example, when computing which of two templates
16397 is more specialized, for example. */
16398 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
16399 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
16400 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
16402 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
16403 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
16404 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
16405 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
16406 strict
&= ~UNIFY_ALLOW_DERIVED
;
16407 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16408 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
16410 switch (TREE_CODE (parm
))
16412 case TYPENAME_TYPE
:
16414 case UNBOUND_CLASS_TEMPLATE
:
16415 /* In a type which contains a nested-name-specifier, template
16416 argument values cannot be deduced for template parameters used
16417 within the nested-name-specifier. */
16418 return unify_success (explain_p
);
16420 case TEMPLATE_TYPE_PARM
:
16421 case TEMPLATE_TEMPLATE_PARM
:
16422 case BOUND_TEMPLATE_TEMPLATE_PARM
:
16423 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
16424 if (tparm
== error_mark_node
)
16425 return unify_invalid (explain_p
);
16427 if (TEMPLATE_TYPE_LEVEL (parm
)
16428 != template_decl_level (tparm
))
16429 /* The PARM is not one we're trying to unify. Just check
16430 to see if it matches ARG. */
16432 if (TREE_CODE (arg
) == TREE_CODE (parm
)
16433 && (is_auto (parm
) ? is_auto (arg
)
16434 : same_type_p (parm
, arg
)))
16435 return unify_success (explain_p
);
16437 return unify_type_mismatch (explain_p
, parm
, arg
);
16439 idx
= TEMPLATE_TYPE_IDX (parm
);
16440 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
16441 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
16442 if (tparm
== error_mark_node
)
16443 return unify_invalid (explain_p
);
16445 /* Check for mixed types and values. */
16446 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
16447 && TREE_CODE (tparm
) != TYPE_DECL
)
16448 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
16449 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
16450 gcc_unreachable ();
16452 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16454 /* ARG must be constructed from a template class or a template
16455 template parameter. */
16456 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
16457 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
16458 return unify_template_deduction_failure (explain_p
, parm
, arg
);
16461 tree parmvec
= TYPE_TI_ARGS (parm
);
16462 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
16463 tree full_argvec
= add_to_template_args (targs
, argvec
);
16465 = DECL_INNERMOST_TEMPLATE_PARMS
16466 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
16468 int parm_variadic_p
= 0;
16470 /* The resolution to DR150 makes clear that default
16471 arguments for an N-argument may not be used to bind T
16472 to a template template parameter with fewer than N
16473 parameters. It is not safe to permit the binding of
16474 default arguments as an extension, as that may change
16475 the meaning of a conforming program. Consider:
16477 struct Dense { static const unsigned int dim = 1; };
16479 template <template <typename> class View,
16481 void operator+(float, View<Block> const&);
16483 template <typename Block,
16484 unsigned int Dim = Block::dim>
16485 struct Lvalue_proxy { operator float() const; };
16489 Lvalue_proxy<Dense> p;
16494 Here, if Lvalue_proxy is permitted to bind to View, then
16495 the global operator+ will be used; if they are not, the
16496 Lvalue_proxy will be converted to float. */
16497 if (coerce_template_parms (parm_parms
,
16499 TYPE_TI_TEMPLATE (parm
),
16501 ? tf_warning_or_error
16503 /*require_all_args=*/true,
16504 /*use_default_args=*/false)
16505 == error_mark_node
)
16508 /* Deduce arguments T, i from TT<T> or TT<i>.
16509 We check each element of PARMVEC and ARGVEC individually
16510 rather than the whole TREE_VEC since they can have
16511 different number of elements. */
16513 parmvec
= expand_template_argument_pack (parmvec
);
16514 argvec
= expand_template_argument_pack (argvec
);
16516 len
= TREE_VEC_LENGTH (parmvec
);
16518 /* Check if the parameters end in a pack, making them
16521 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
16522 parm_variadic_p
= 1;
16524 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
16525 return unify_too_few_arguments (explain_p
,
16526 TREE_VEC_LENGTH (argvec
), len
);
16528 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
16530 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
16531 TREE_VEC_ELT (parmvec
, i
),
16532 TREE_VEC_ELT (argvec
, i
),
16533 UNIFY_ALLOW_NONE
, explain_p
);
16536 if (parm_variadic_p
16537 && unify_pack_expansion (tparms
, targs
,
16540 /*subr=*/true, explain_p
))
16543 arg
= TYPE_TI_TEMPLATE (arg
);
16545 /* Fall through to deduce template name. */
16548 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
16549 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16551 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
16553 /* Simple cases: Value already set, does match or doesn't. */
16554 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
16555 return unify_success (explain_p
);
16557 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
16561 /* If PARM is `const T' and ARG is only `int', we don't have
16562 a match unless we are allowing additional qualification.
16563 If ARG is `const int' and PARM is just `T' that's OK;
16564 that binds `const int' to `T'. */
16565 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
16567 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
16569 /* Consider the case where ARG is `const volatile int' and
16570 PARM is `const T'. Then, T should be `volatile int'. */
16571 arg
= cp_build_qualified_type_real
16572 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
16573 if (arg
== error_mark_node
)
16574 return unify_invalid (explain_p
);
16576 /* Simple cases: Value already set, does match or doesn't. */
16577 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
16578 return unify_success (explain_p
);
16580 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
16582 /* Make sure that ARG is not a variable-sized array. (Note
16583 that were talking about variable-sized arrays (like
16584 `int[n]'), rather than arrays of unknown size (like
16585 `int[]').) We'll get very confused by such a type since
16586 the bound of the array is not constant, and therefore
16587 not mangleable. Besides, such types are not allowed in
16588 ISO C++, so we can do as we please here. We do allow
16589 them for 'auto' deduction, since that isn't ABI-exposed. */
16590 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
16591 return unify_vla_arg (explain_p
, arg
);
16593 /* Strip typedefs as in convert_template_argument. */
16594 arg
= canonicalize_type_argument (arg
, tf_none
);
16597 /* If ARG is a parameter pack or an expansion, we cannot unify
16598 against it unless PARM is also a parameter pack. */
16599 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
16600 && !template_parameter_pack_p (parm
))
16601 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
16603 /* If the argument deduction results is a METHOD_TYPE,
16604 then there is a problem.
16605 METHOD_TYPE doesn't map to any real C++ type the result of
16606 the deduction can not be of that type. */
16607 if (TREE_CODE (arg
) == METHOD_TYPE
)
16608 return unify_method_type_error (explain_p
, arg
);
16610 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
16611 return unify_success (explain_p
);
16613 case TEMPLATE_PARM_INDEX
:
16614 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
16615 if (tparm
== error_mark_node
)
16616 return unify_invalid (explain_p
);
16618 if (TEMPLATE_PARM_LEVEL (parm
)
16619 != template_decl_level (tparm
))
16621 /* The PARM is not one we're trying to unify. Just check
16622 to see if it matches ARG. */
16623 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
16624 && cp_tree_equal (parm
, arg
));
16626 unify_expression_unequal (explain_p
, parm
, arg
);
16630 idx
= TEMPLATE_PARM_IDX (parm
);
16631 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
16635 int x
= !cp_tree_equal (targ
, arg
);
16637 unify_inconsistency (explain_p
, parm
, targ
, arg
);
16641 /* [temp.deduct.type] If, in the declaration of a function template
16642 with a non-type template-parameter, the non-type
16643 template-parameter is used in an expression in the function
16644 parameter-list and, if the corresponding template-argument is
16645 deduced, the template-argument type shall match the type of the
16646 template-parameter exactly, except that a template-argument
16647 deduced from an array bound may be of any integral type.
16648 The non-type parameter might use already deduced type parameters. */
16649 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
16650 if (!TREE_TYPE (arg
))
16651 /* Template-parameter dependent expression. Just accept it for now.
16652 It will later be processed in convert_template_argument. */
16654 else if (same_type_p (TREE_TYPE (arg
), tparm
))
16656 else if ((strict
& UNIFY_ALLOW_INTEGER
)
16657 && (TREE_CODE (tparm
) == INTEGER_TYPE
16658 || TREE_CODE (tparm
) == BOOLEAN_TYPE
))
16659 /* Convert the ARG to the type of PARM; the deduced non-type
16660 template argument must exactly match the types of the
16661 corresponding parameter. */
16662 arg
= fold (build_nop (tparm
, arg
));
16663 else if (uses_template_parms (tparm
))
16664 /* We haven't deduced the type of this parameter yet. Try again
16666 return unify_success (explain_p
);
16668 return unify_type_mismatch (explain_p
, tparm
, arg
);
16670 /* If ARG is a parameter pack or an expansion, we cannot unify
16671 against it unless PARM is also a parameter pack. */
16672 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
16673 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
16674 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
16676 arg
= strip_typedefs_expr (arg
);
16677 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
16678 return unify_success (explain_p
);
16682 /* A pointer-to-member constant can be unified only with
16683 another constant. */
16684 if (TREE_CODE (arg
) != PTRMEM_CST
)
16685 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
16687 /* Just unify the class member. It would be useless (and possibly
16688 wrong, depending on the strict flags) to unify also
16689 PTRMEM_CST_CLASS, because we want to be sure that both parm and
16690 arg refer to the same variable, even if through different
16691 classes. For instance:
16693 struct A { int x; };
16696 Unification of &A::x and &B::x must succeed. */
16697 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
16698 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
16703 if (TREE_CODE (arg
) != POINTER_TYPE
)
16704 return unify_type_mismatch (explain_p
, parm
, arg
);
16706 /* [temp.deduct.call]
16708 A can be another pointer or pointer to member type that can
16709 be converted to the deduced A via a qualification
16710 conversion (_conv.qual_).
16712 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
16713 This will allow for additional cv-qualification of the
16714 pointed-to types if appropriate. */
16716 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
16717 /* The derived-to-base conversion only persists through one
16718 level of pointers. */
16719 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
16721 return unify (tparms
, targs
, TREE_TYPE (parm
),
16722 TREE_TYPE (arg
), strict
, explain_p
);
16725 case REFERENCE_TYPE
:
16726 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
16727 return unify_type_mismatch (explain_p
, parm
, arg
);
16728 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
16729 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
16732 if (TREE_CODE (arg
) != ARRAY_TYPE
)
16733 return unify_type_mismatch (explain_p
, parm
, arg
);
16734 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
16735 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
16736 return unify_type_mismatch (explain_p
, parm
, arg
);
16737 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
16738 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
16739 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
16746 /* Our representation of array types uses "N - 1" as the
16747 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
16748 not an integer constant. We cannot unify arbitrarily
16749 complex expressions, so we eliminate the MINUS_EXPRs
16751 parm_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (parm
));
16752 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
16755 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
16756 parm_max
= TREE_OPERAND (parm_max
, 0);
16758 arg_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (arg
));
16759 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
16762 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
16763 trying to unify the type of a variable with the type
16764 of a template parameter. For example:
16766 template <unsigned int N>
16767 void f (char (&) [N]);
16774 Here, the type of the ARG will be "int [g(i)]", and
16775 may be a SAVE_EXPR, etc. */
16776 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
16777 return unify_vla_arg (explain_p
, arg
);
16778 arg_max
= TREE_OPERAND (arg_max
, 0);
16781 /* If only one of the bounds used a MINUS_EXPR, compensate
16782 by adding one to the other bound. */
16783 if (parm_cst
&& !arg_cst
)
16784 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
16788 else if (arg_cst
&& !parm_cst
)
16789 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
16794 RECUR_AND_CHECK_FAILURE (tparms
, targs
, parm_max
, arg_max
,
16795 UNIFY_ALLOW_INTEGER
, explain_p
);
16797 return unify_success (explain_p
);
16804 case ENUMERAL_TYPE
:
16807 if (TREE_CODE (arg
) != TREE_CODE (parm
))
16808 return unify_type_mismatch (explain_p
, parm
, arg
);
16810 /* We have already checked cv-qualification at the top of the
16812 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
16813 return unify_type_mismatch (explain_p
, parm
, arg
);
16815 /* As far as unification is concerned, this wins. Later checks
16816 will invalidate it if necessary. */
16817 return unify_success (explain_p
);
16819 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
16820 /* Type INTEGER_CST can come from ordinary constant template args. */
16822 while (TREE_CODE (arg
) == NOP_EXPR
)
16823 arg
= TREE_OPERAND (arg
, 0);
16825 if (TREE_CODE (arg
) != INTEGER_CST
)
16826 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16827 return (tree_int_cst_equal (parm
, arg
)
16828 ? unify_success (explain_p
)
16829 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
16833 int i
, len
, argslen
;
16834 int parm_variadic_p
= 0;
16836 if (TREE_CODE (arg
) != TREE_VEC
)
16837 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16839 len
= TREE_VEC_LENGTH (parm
);
16840 argslen
= TREE_VEC_LENGTH (arg
);
16842 /* Check for pack expansions in the parameters. */
16843 for (i
= 0; i
< len
; ++i
)
16845 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
16848 /* We can unify against something with a trailing
16850 parm_variadic_p
= 1;
16852 /* [temp.deduct.type]/9: If the template argument list of
16853 P contains a pack expansion that is not the last
16854 template argument, the entire template argument list
16855 is a non-deduced context. */
16856 return unify_success (explain_p
);
16860 /* If we don't have enough arguments to satisfy the parameters
16861 (not counting the pack expression at the end), or we have
16862 too many arguments for a parameter list that doesn't end in
16863 a pack expression, we can't unify. */
16864 if (parm_variadic_p
16865 ? argslen
< len
- parm_variadic_p
16867 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
16869 /* Unify all of the parameters that precede the (optional)
16870 pack expression. */
16871 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
16873 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
16874 TREE_VEC_ELT (parm
, i
),
16875 TREE_VEC_ELT (arg
, i
),
16876 UNIFY_ALLOW_NONE
, explain_p
);
16878 if (parm_variadic_p
)
16879 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
16881 /*subr=*/true, explain_p
);
16882 return unify_success (explain_p
);
16887 if (TREE_CODE (arg
) != TREE_CODE (parm
))
16888 return unify_type_mismatch (explain_p
, parm
, arg
);
16890 if (TYPE_PTRMEMFUNC_P (parm
))
16892 if (!TYPE_PTRMEMFUNC_P (arg
))
16893 return unify_type_mismatch (explain_p
, parm
, arg
);
16895 return unify (tparms
, targs
,
16896 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
16897 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
16898 strict
, explain_p
);
16901 if (CLASSTYPE_TEMPLATE_INFO (parm
))
16903 tree t
= NULL_TREE
;
16905 if (strict_in
& UNIFY_ALLOW_DERIVED
)
16907 /* First, we try to unify the PARM and ARG directly. */
16908 t
= try_class_unification (tparms
, targs
,
16909 parm
, arg
, explain_p
);
16913 /* Fallback to the special case allowed in
16914 [temp.deduct.call]:
16916 If P is a class, and P has the form
16917 template-id, then A can be a derived class of
16918 the deduced A. Likewise, if P is a pointer to
16919 a class of the form template-id, A can be a
16920 pointer to a derived class pointed to by the
16922 enum template_base_result r
;
16923 r
= get_template_base (tparms
, targs
, parm
, arg
,
16927 return unify_no_common_base (explain_p
, r
, parm
, arg
);
16930 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
16931 && (CLASSTYPE_TI_TEMPLATE (parm
)
16932 == CLASSTYPE_TI_TEMPLATE (arg
)))
16933 /* Perhaps PARM is something like S<U> and ARG is S<int>.
16934 Then, we should unify `int' and `U'. */
16937 /* There's no chance of unification succeeding. */
16938 return unify_type_mismatch (explain_p
, parm
, arg
);
16940 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
16941 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
16943 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
16944 return unify_type_mismatch (explain_p
, parm
, arg
);
16945 return unify_success (explain_p
);
16948 case FUNCTION_TYPE
:
16950 unsigned int nargs
;
16955 if (TREE_CODE (arg
) != TREE_CODE (parm
))
16956 return unify_type_mismatch (explain_p
, parm
, arg
);
16958 /* CV qualifications for methods can never be deduced, they must
16959 match exactly. We need to check them explicitly here,
16960 because type_unification_real treats them as any other
16961 cv-qualified parameter. */
16962 if (TREE_CODE (parm
) == METHOD_TYPE
16963 && (!check_cv_quals_for_unify
16965 class_of_this_parm (arg
),
16966 class_of_this_parm (parm
))))
16967 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
16969 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
16970 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
16972 nargs
= list_length (TYPE_ARG_TYPES (arg
));
16973 args
= XALLOCAVEC (tree
, nargs
);
16974 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
16975 a
!= NULL_TREE
&& a
!= void_list_node
;
16976 a
= TREE_CHAIN (a
), ++i
)
16977 args
[i
] = TREE_VALUE (a
);
16980 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
16981 args
, nargs
, 1, DEDUCE_EXACT
,
16982 LOOKUP_NORMAL
, explain_p
);
16986 /* Unify a pointer to member with a pointer to member function, which
16987 deduces the type of the member as a function type. */
16988 if (TYPE_PTRMEMFUNC_P (arg
))
16993 /* Check top-level cv qualifiers */
16994 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
16995 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
16997 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
16998 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
16999 UNIFY_ALLOW_NONE
, explain_p
);
17001 /* Determine the type of the function we are unifying against. */
17002 method_type
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg
));
17004 build_function_type (TREE_TYPE (method_type
),
17005 TREE_CHAIN (TYPE_ARG_TYPES (method_type
)));
17007 /* Extract the cv-qualifiers of the member function from the
17008 implicit object parameter and place them on the function
17009 type to be restored later. */
17010 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (method_type
));
17011 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
17014 if (TREE_CODE (arg
) != OFFSET_TYPE
)
17015 return unify_type_mismatch (explain_p
, parm
, arg
);
17016 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
17017 TYPE_OFFSET_BASETYPE (arg
),
17018 UNIFY_ALLOW_NONE
, explain_p
);
17019 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
17020 strict
, explain_p
);
17023 if (DECL_TEMPLATE_PARM_P (parm
))
17024 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
17025 if (arg
!= integral_constant_value (parm
))
17026 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
17027 return unify_success (explain_p
);
17030 case TEMPLATE_DECL
:
17031 /* Matched cases are handled by the ARG == PARM test above. */
17032 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
17035 /* A non-type template parameter that is a variable should be a
17036 an integral constant, in which case, it whould have been
17037 folded into its (constant) value. So we should not be getting
17038 a variable here. */
17039 gcc_unreachable ();
17041 case TYPE_ARGUMENT_PACK
:
17042 case NONTYPE_ARGUMENT_PACK
:
17043 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
17044 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
17047 case DECLTYPE_TYPE
:
17048 case UNDERLYING_TYPE
:
17049 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
17050 or UNDERLYING_TYPE nodes. */
17051 return unify_success (explain_p
);
17054 /* Unification fails if we hit an error node. */
17055 return unify_invalid (explain_p
);
17058 /* An unresolved overload is a nondeduced context. */
17059 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
17060 return unify_success (explain_p
);
17061 gcc_assert (EXPR_P (parm
));
17063 /* We must be looking at an expression. This can happen with
17067 void foo(S<I>, S<I + 2>);
17069 This is a "nondeduced context":
17073 The nondeduced contexts are:
17075 --A type that is a template-id in which one or more of
17076 the template-arguments is an expression that references
17077 a template-parameter.
17079 In these cases, we assume deduction succeeded, but don't
17080 actually infer any unifications. */
17082 if (!uses_template_parms (parm
)
17083 && !template_args_equal (parm
, arg
))
17084 return unify_expression_unequal (explain_p
, parm
, arg
);
17086 return unify_success (explain_p
);
17089 #undef RECUR_AND_CHECK_FAILURE
17091 /* Note that DECL can be defined in this translation unit, if
17095 mark_definable (tree decl
)
17098 DECL_NOT_REALLY_EXTERN (decl
) = 1;
17099 FOR_EACH_CLONE (clone
, decl
)
17100 DECL_NOT_REALLY_EXTERN (clone
) = 1;
17103 /* Called if RESULT is explicitly instantiated, or is a member of an
17104 explicitly instantiated class. */
17107 mark_decl_instantiated (tree result
, int extern_p
)
17109 SET_DECL_EXPLICIT_INSTANTIATION (result
);
17111 /* If this entity has already been written out, it's too late to
17112 make any modifications. */
17113 if (TREE_ASM_WRITTEN (result
))
17116 if (TREE_CODE (result
) != FUNCTION_DECL
)
17117 /* The TREE_PUBLIC flag for function declarations will have been
17118 set correctly by tsubst. */
17119 TREE_PUBLIC (result
) = 1;
17121 /* This might have been set by an earlier implicit instantiation. */
17122 DECL_COMDAT (result
) = 0;
17125 DECL_NOT_REALLY_EXTERN (result
) = 0;
17128 mark_definable (result
);
17129 /* Always make artificials weak. */
17130 if (DECL_ARTIFICIAL (result
) && flag_weak
)
17131 comdat_linkage (result
);
17132 /* For WIN32 we also want to put explicit instantiations in
17133 linkonce sections. */
17134 else if (TREE_PUBLIC (result
))
17135 maybe_make_one_only (result
);
17138 /* If EXTERN_P, then this function will not be emitted -- unless
17139 followed by an explicit instantiation, at which point its linkage
17140 will be adjusted. If !EXTERN_P, then this function will be
17141 emitted here. In neither circumstance do we want
17142 import_export_decl to adjust the linkage. */
17143 DECL_INTERFACE_KNOWN (result
) = 1;
17146 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
17147 important template arguments. If any are missing, we check whether
17148 they're important by using error_mark_node for substituting into any
17149 args that were used for partial ordering (the ones between ARGS and END)
17150 and seeing if it bubbles up. */
17153 check_undeduced_parms (tree targs
, tree args
, tree end
)
17155 bool found
= false;
17157 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
17158 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
17161 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
17165 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
17166 if (substed
== error_mark_node
)
17172 /* Given two function templates PAT1 and PAT2, return:
17174 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
17175 -1 if PAT2 is more specialized than PAT1.
17176 0 if neither is more specialized.
17178 LEN indicates the number of parameters we should consider
17179 (defaulted parameters should not be considered).
17181 The 1998 std underspecified function template partial ordering, and
17182 DR214 addresses the issue. We take pairs of arguments, one from
17183 each of the templates, and deduce them against each other. One of
17184 the templates will be more specialized if all the *other*
17185 template's arguments deduce against its arguments and at least one
17186 of its arguments *does* *not* deduce against the other template's
17187 corresponding argument. Deduction is done as for class templates.
17188 The arguments used in deduction have reference and top level cv
17189 qualifiers removed. Iff both arguments were originally reference
17190 types *and* deduction succeeds in both directions, the template
17191 with the more cv-qualified argument wins for that pairing (if
17192 neither is more cv-qualified, they both are equal). Unlike regular
17193 deduction, after all the arguments have been deduced in this way,
17194 we do *not* verify the deduced template argument values can be
17195 substituted into non-deduced contexts.
17197 The logic can be a bit confusing here, because we look at deduce1 and
17198 targs1 to see if pat2 is at least as specialized, and vice versa; if we
17199 can find template arguments for pat1 to make arg1 look like arg2, that
17200 means that arg2 is at least as specialized as arg1. */
17203 more_specialized_fn (tree pat1
, tree pat2
, int len
)
17205 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
17206 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
17207 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
17208 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
17209 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
17210 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
17211 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
17212 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
17213 tree origs1
, origs2
;
17214 bool lose1
= false;
17215 bool lose2
= false;
17217 /* Remove the this parameter from non-static member functions. If
17218 one is a non-static member function and the other is not a static
17219 member function, remove the first parameter from that function
17220 also. This situation occurs for operator functions where we
17221 locate both a member function (with this pointer) and non-member
17222 operator (with explicit first operand). */
17223 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
17225 len
--; /* LEN is the number of significant arguments for DECL1 */
17226 args1
= TREE_CHAIN (args1
);
17227 if (!DECL_STATIC_FUNCTION_P (decl2
))
17228 args2
= TREE_CHAIN (args2
);
17230 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
17232 args2
= TREE_CHAIN (args2
);
17233 if (!DECL_STATIC_FUNCTION_P (decl1
))
17236 args1
= TREE_CHAIN (args1
);
17240 /* If only one is a conversion operator, they are unordered. */
17241 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
17244 /* Consider the return type for a conversion function */
17245 if (DECL_CONV_FN_P (decl1
))
17247 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
17248 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
17252 processing_template_decl
++;
17258 /* Stop when an ellipsis is seen. */
17259 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
17261 tree arg1
= TREE_VALUE (args1
);
17262 tree arg2
= TREE_VALUE (args2
);
17263 int deduce1
, deduce2
;
17267 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
17268 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
17270 /* When both arguments are pack expansions, we need only
17271 unify the patterns themselves. */
17272 arg1
= PACK_EXPANSION_PATTERN (arg1
);
17273 arg2
= PACK_EXPANSION_PATTERN (arg2
);
17275 /* This is the last comparison we need to do. */
17279 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
17281 arg1
= TREE_TYPE (arg1
);
17282 quals1
= cp_type_quals (arg1
);
17285 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
17287 arg2
= TREE_TYPE (arg2
);
17288 quals2
= cp_type_quals (arg2
);
17291 arg1
= TYPE_MAIN_VARIANT (arg1
);
17292 arg2
= TYPE_MAIN_VARIANT (arg2
);
17294 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
17296 int i
, len2
= list_length (args2
);
17297 tree parmvec
= make_tree_vec (1);
17298 tree argvec
= make_tree_vec (len2
);
17301 /* Setup the parameter vector, which contains only ARG1. */
17302 TREE_VEC_ELT (parmvec
, 0) = arg1
;
17304 /* Setup the argument vector, which contains the remaining
17306 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
17307 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
17309 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
17310 argvec
, DEDUCE_EXACT
,
17311 /*subr=*/true, /*explain_p=*/false)
17314 /* We cannot deduce in the other direction, because ARG1 is
17315 a pack expansion but ARG2 is not. */
17318 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
17320 int i
, len1
= list_length (args1
);
17321 tree parmvec
= make_tree_vec (1);
17322 tree argvec
= make_tree_vec (len1
);
17325 /* Setup the parameter vector, which contains only ARG1. */
17326 TREE_VEC_ELT (parmvec
, 0) = arg2
;
17328 /* Setup the argument vector, which contains the remaining
17330 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
17331 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
17333 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
17334 argvec
, DEDUCE_EXACT
,
17335 /*subr=*/true, /*explain_p=*/false)
17338 /* We cannot deduce in the other direction, because ARG2 is
17339 a pack expansion but ARG1 is not.*/
17345 /* The normal case, where neither argument is a pack
17347 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
17348 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
17350 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
17351 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
17355 /* If we couldn't deduce arguments for tparms1 to make arg1 match
17356 arg2, then arg2 is not as specialized as arg1. */
17362 /* "If, for a given type, deduction succeeds in both directions
17363 (i.e., the types are identical after the transformations above)
17364 and if the type from the argument template is more cv-qualified
17365 than the type from the parameter template (as described above)
17366 that type is considered to be more specialized than the other. If
17367 neither type is more cv-qualified than the other then neither type
17368 is more specialized than the other." */
17370 if (deduce1
&& deduce2
17371 && quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
17373 if ((quals1
& quals2
) == quals2
)
17375 if ((quals1
& quals2
) == quals1
)
17379 if (lose1
&& lose2
)
17380 /* We've failed to deduce something in either direction.
17381 These must be unordered. */
17384 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
17385 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
17386 /* We have already processed all of the arguments in our
17387 handing of the pack expansion type. */
17390 args1
= TREE_CHAIN (args1
);
17391 args2
= TREE_CHAIN (args2
);
17394 /* "In most cases, all template parameters must have values in order for
17395 deduction to succeed, but for partial ordering purposes a template
17396 parameter may remain without a value provided it is not used in the
17397 types being used for partial ordering."
17399 Thus, if we are missing any of the targs1 we need to substitute into
17400 origs1, then pat2 is not as specialized as pat1. This can happen when
17401 there is a nondeduced context. */
17402 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
17404 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
17407 processing_template_decl
--;
17409 /* All things being equal, if the next argument is a pack expansion
17410 for one function but not for the other, prefer the
17411 non-variadic function. FIXME this is bogus; see c++/41958. */
17413 && args1
&& TREE_VALUE (args1
)
17414 && args2
&& TREE_VALUE (args2
))
17416 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
17417 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
17420 if (lose1
== lose2
)
17428 /* Determine which of two partial specializations of MAIN_TMPL is more
17431 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
17432 to the first partial specialization. The TREE_VALUE is the
17433 innermost set of template parameters for the partial
17434 specialization. PAT2 is similar, but for the second template.
17436 Return 1 if the first partial specialization is more specialized;
17437 -1 if the second is more specialized; 0 if neither is more
17440 See [temp.class.order] for information about determining which of
17441 two templates is more specialized. */
17444 more_specialized_class (tree main_tmpl
, tree pat1
, tree pat2
)
17449 bool any_deductions
= false;
17451 tmpl1
= TREE_TYPE (pat1
);
17452 tmpl2
= TREE_TYPE (pat2
);
17454 /* Just like what happens for functions, if we are ordering between
17455 different class template specializations, we may encounter dependent
17456 types in the arguments, and we need our dependency check functions
17457 to behave correctly. */
17458 ++processing_template_decl
;
17459 targs
= get_class_bindings (main_tmpl
, TREE_VALUE (pat1
),
17460 CLASSTYPE_TI_ARGS (tmpl1
),
17461 CLASSTYPE_TI_ARGS (tmpl2
));
17465 any_deductions
= true;
17468 targs
= get_class_bindings (main_tmpl
, TREE_VALUE (pat2
),
17469 CLASSTYPE_TI_ARGS (tmpl2
),
17470 CLASSTYPE_TI_ARGS (tmpl1
));
17474 any_deductions
= true;
17476 --processing_template_decl
;
17478 /* In the case of a tie where at least one of the class templates
17479 has a parameter pack at the end, the template with the most
17480 non-packed parameters wins. */
17483 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
17484 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
17486 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
17487 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
17488 int len1
= TREE_VEC_LENGTH (args1
);
17489 int len2
= TREE_VEC_LENGTH (args2
);
17491 /* We don't count the pack expansion at the end. */
17492 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
17494 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
17499 else if (len1
< len2
)
17506 /* Return the template arguments that will produce the function signature
17507 DECL from the function template FN, with the explicit template
17508 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
17509 also match. Return NULL_TREE if no satisfactory arguments could be
17513 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
17515 int ntparms
= DECL_NTPARMS (fn
);
17516 tree targs
= make_tree_vec (ntparms
);
17517 tree decl_type
= TREE_TYPE (decl
);
17518 tree decl_arg_types
;
17520 unsigned int nargs
, ix
;
17523 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
17525 /* Never do unification on the 'this' parameter. */
17526 decl_arg_types
= skip_artificial_parms_for (decl
,
17527 TYPE_ARG_TYPES (decl_type
));
17529 nargs
= list_length (decl_arg_types
);
17530 args
= XALLOCAVEC (tree
, nargs
);
17531 for (arg
= decl_arg_types
, ix
= 0;
17532 arg
!= NULL_TREE
&& arg
!= void_list_node
;
17533 arg
= TREE_CHAIN (arg
), ++ix
)
17534 args
[ix
] = TREE_VALUE (arg
);
17536 if (fn_type_unification (fn
, explicit_args
, targs
,
17538 (check_rettype
|| DECL_CONV_FN_P (fn
)
17539 ? TREE_TYPE (decl_type
) : NULL_TREE
),
17540 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false)
17541 == error_mark_node
)
17547 /* Return the innermost template arguments that, when applied to a partial
17548 specialization of MAIN_TMPL whose innermost template parameters are
17549 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
17552 For example, suppose we have:
17554 template <class T, class U> struct S {};
17555 template <class T> struct S<T*, int> {};
17557 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
17558 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
17559 int}. The resulting vector will be {double}, indicating that `T'
17560 is bound to `double'. */
17563 get_class_bindings (tree main_tmpl
, tree tparms
, tree spec_args
, tree args
)
17565 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
17567 tree innermost_deduced_args
;
17569 innermost_deduced_args
= make_tree_vec (ntparms
);
17570 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
17572 deduced_args
= copy_node (args
);
17573 SET_TMPL_ARGS_LEVEL (deduced_args
,
17574 TMPL_ARGS_DEPTH (deduced_args
),
17575 innermost_deduced_args
);
17578 deduced_args
= innermost_deduced_args
;
17580 if (unify (tparms
, deduced_args
,
17581 INNERMOST_TEMPLATE_ARGS (spec_args
),
17582 INNERMOST_TEMPLATE_ARGS (args
),
17583 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
17586 for (i
= 0; i
< ntparms
; ++i
)
17587 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
17590 /* Verify that nondeduced template arguments agree with the type
17591 obtained from argument deduction.
17595 struct A { typedef int X; };
17596 template <class T, class U> struct C {};
17597 template <class T> struct C<T, typename T::X> {};
17599 Then with the instantiation `C<A, int>', we can deduce that
17600 `T' is `A' but unify () does not check whether `typename T::X'
17602 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
17603 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (main_tmpl
),
17604 spec_args
, main_tmpl
,
17605 tf_none
, false, false);
17606 if (spec_args
== error_mark_node
17607 /* We only need to check the innermost arguments; the other
17608 arguments will always agree. */
17609 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
17610 INNERMOST_TEMPLATE_ARGS (args
)))
17613 /* Now that we have bindings for all of the template arguments,
17614 ensure that the arguments deduced for the template template
17615 parameters have compatible template parameter lists. See the use
17616 of template_template_parm_bindings_ok_p in fn_type_unification
17617 for more information. */
17618 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
17621 return deduced_args
;
17624 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
17625 Return the TREE_LIST node with the most specialized template, if
17626 any. If there is no most specialized template, the error_mark_node
17629 Note that this function does not look at, or modify, the
17630 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
17631 returned is one of the elements of INSTANTIATIONS, callers may
17632 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
17633 and retrieve it from the value returned. */
17636 most_specialized_instantiation (tree templates
)
17640 ++processing_template_decl
;
17643 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
17647 if (get_bindings (TREE_VALUE (champ
),
17648 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
17649 NULL_TREE
, /*check_ret=*/true))
17652 if (get_bindings (TREE_VALUE (fn
),
17653 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
17654 NULL_TREE
, /*check_ret=*/true))
17661 /* Equally specialized, move to next function. If there
17662 is no next function, nothing's most specialized. */
17663 fn
= TREE_CHAIN (fn
);
17671 /* Now verify that champ is better than everything earlier in the
17672 instantiation list. */
17673 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
17674 if (get_bindings (TREE_VALUE (champ
),
17675 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
17676 NULL_TREE
, /*check_ret=*/true)
17677 || !get_bindings (TREE_VALUE (fn
),
17678 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
17679 NULL_TREE
, /*check_ret=*/true))
17685 processing_template_decl
--;
17688 return error_mark_node
;
17693 /* If DECL is a specialization of some template, return the most
17694 general such template. Otherwise, returns NULL_TREE.
17696 For example, given:
17698 template <class T> struct S { template <class U> void f(U); };
17700 if TMPL is `template <class U> void S<int>::f(U)' this will return
17701 the full template. This function will not trace past partial
17702 specializations, however. For example, given in addition:
17704 template <class T> struct S<T*> { template <class U> void f(U); };
17706 if TMPL is `template <class U> void S<int*>::f(U)' this will return
17707 `template <class T> template <class U> S<T*>::f(U)'. */
17710 most_general_template (tree decl
)
17712 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
17713 an immediate specialization. */
17714 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17716 if (DECL_TEMPLATE_INFO (decl
)) {
17717 decl
= DECL_TI_TEMPLATE (decl
);
17719 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
17720 template friend. */
17721 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
17727 /* Look for more and more general templates. */
17728 while (DECL_TEMPLATE_INFO (decl
))
17730 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
17731 (See cp-tree.h for details.) */
17732 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
17735 if (CLASS_TYPE_P (TREE_TYPE (decl
))
17736 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
17739 /* Stop if we run into an explicitly specialized class template. */
17740 if (!DECL_NAMESPACE_SCOPE_P (decl
)
17741 && DECL_CONTEXT (decl
)
17742 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
17745 decl
= DECL_TI_TEMPLATE (decl
);
17751 /* Return the most specialized of the class template partial
17752 specializations of TMPL which can produce TYPE, a specialization of
17753 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
17754 a _TYPE node corresponding to the partial specialization, while the
17755 TREE_PURPOSE is the set of template arguments that must be
17756 substituted into the TREE_TYPE in order to generate TYPE.
17758 If the choice of partial specialization is ambiguous, a diagnostic
17759 is issued, and the error_mark_node is returned. If there are no
17760 partial specializations of TMPL matching TYPE, then NULL_TREE is
17764 most_specialized_class (tree type
, tree tmpl
, tsubst_flags_t complain
)
17766 tree list
= NULL_TREE
;
17772 tree outer_args
= NULL_TREE
;
17774 tmpl
= most_general_template (tmpl
);
17775 args
= CLASSTYPE_TI_ARGS (type
);
17777 /* For determining which partial specialization to use, only the
17778 innermost args are interesting. */
17779 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
17781 outer_args
= strip_innermost_template_args (args
, 1);
17782 args
= INNERMOST_TEMPLATE_ARGS (args
);
17785 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
); t
; t
= TREE_CHAIN (t
))
17787 tree partial_spec_args
;
17789 tree parms
= TREE_VALUE (t
);
17791 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
17793 ++processing_template_decl
;
17799 /* Discard the outer levels of args, and then substitute in the
17800 template args from the enclosing class. */
17801 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
17802 partial_spec_args
= tsubst_template_args
17803 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
17805 /* PARMS already refers to just the innermost parms, but the
17806 template parms in partial_spec_args had their levels lowered
17807 by tsubst, so we need to do the same for the parm list. We
17808 can't just tsubst the TREE_VEC itself, as tsubst wants to
17809 treat a TREE_VEC as an argument vector. */
17810 parms
= copy_node (parms
);
17811 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
17812 TREE_VEC_ELT (parms
, i
) =
17813 tsubst (TREE_VEC_ELT (parms
, i
), outer_args
, tf_none
, NULL_TREE
);
17817 partial_spec_args
=
17818 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
17819 add_to_template_args (outer_args
,
17820 partial_spec_args
),
17822 /*require_all_args=*/true,
17823 /*use_default_args=*/true);
17825 --processing_template_decl
;
17827 if (partial_spec_args
== error_mark_node
)
17828 return error_mark_node
;
17830 spec_args
= get_class_bindings (tmpl
, parms
,
17836 spec_args
= add_to_template_args (outer_args
, spec_args
);
17837 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
17838 TREE_TYPE (list
) = TREE_TYPE (t
);
17845 ambiguous_p
= false;
17848 t
= TREE_CHAIN (t
);
17849 for (; t
; t
= TREE_CHAIN (t
))
17851 fate
= more_specialized_class (tmpl
, champ
, t
);
17858 t
= TREE_CHAIN (t
);
17861 ambiguous_p
= true;
17870 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
17872 fate
= more_specialized_class (tmpl
, champ
, t
);
17875 ambiguous_p
= true;
17883 char *spaces
= NULL
;
17884 if (!(complain
& tf_error
))
17885 return error_mark_node
;
17886 error ("ambiguous class template instantiation for %q#T", type
);
17887 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
17888 for (t
= list
; t
; t
= TREE_CHAIN (t
))
17890 error ("%s %+#T", spaces
? spaces
: str
, TREE_TYPE (t
));
17891 spaces
= spaces
? spaces
: get_spaces (str
);
17894 return error_mark_node
;
17900 /* Explicitly instantiate DECL. */
17903 do_decl_instantiation (tree decl
, tree storage
)
17905 tree result
= NULL_TREE
;
17908 if (!decl
|| decl
== error_mark_node
)
17909 /* An error occurred, for which grokdeclarator has already issued
17910 an appropriate message. */
17912 else if (! DECL_LANG_SPECIFIC (decl
))
17914 error ("explicit instantiation of non-template %q#D", decl
);
17917 else if (TREE_CODE (decl
) == VAR_DECL
)
17919 /* There is an asymmetry here in the way VAR_DECLs and
17920 FUNCTION_DECLs are handled by grokdeclarator. In the case of
17921 the latter, the DECL we get back will be marked as a
17922 template instantiation, and the appropriate
17923 DECL_TEMPLATE_INFO will be set up. This does not happen for
17924 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
17925 should handle VAR_DECLs as it currently handles
17927 if (!DECL_CLASS_SCOPE_P (decl
))
17929 error ("%qD is not a static data member of a class template", decl
);
17932 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
17933 if (!result
|| TREE_CODE (result
) != VAR_DECL
)
17935 error ("no matching template for %qD found", decl
);
17938 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
17940 error ("type %qT for explicit instantiation %qD does not match "
17941 "declared type %qT", TREE_TYPE (result
), decl
,
17946 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
17948 error ("explicit instantiation of %q#D", decl
);
17954 /* Check for various error cases. Note that if the explicit
17955 instantiation is valid the RESULT will currently be marked as an
17956 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
17957 until we get here. */
17959 if (DECL_TEMPLATE_SPECIALIZATION (result
))
17961 /* DR 259 [temp.spec].
17963 Both an explicit instantiation and a declaration of an explicit
17964 specialization shall not appear in a program unless the explicit
17965 instantiation follows a declaration of the explicit specialization.
17967 For a given set of template parameters, if an explicit
17968 instantiation of a template appears after a declaration of an
17969 explicit specialization for that template, the explicit
17970 instantiation has no effect. */
17973 else if (DECL_EXPLICIT_INSTANTIATION (result
))
17977 No program shall explicitly instantiate any template more
17980 We check DECL_NOT_REALLY_EXTERN so as not to complain when
17981 the first instantiation was `extern' and the second is not,
17982 and EXTERN_P for the opposite case. */
17983 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
17984 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
17985 /* If an "extern" explicit instantiation follows an ordinary
17986 explicit instantiation, the template is instantiated. */
17990 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
17992 error ("no matching template for %qD found", result
);
17995 else if (!DECL_TEMPLATE_INFO (result
))
17997 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
18001 if (storage
== NULL_TREE
)
18003 else if (storage
== ridpointers
[(int) RID_EXTERN
])
18005 if (!in_system_header
&& (cxx_dialect
== cxx98
))
18006 pedwarn (input_location
, OPT_Wpedantic
,
18007 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
18012 error ("storage class %qD applied to template instantiation", storage
);
18014 check_explicit_instantiation_namespace (result
);
18015 mark_decl_instantiated (result
, extern_p
);
18017 instantiate_decl (result
, /*defer_ok=*/1,
18018 /*expl_inst_class_mem_p=*/false);
18022 mark_class_instantiated (tree t
, int extern_p
)
18024 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
18025 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
18026 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
18027 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
18030 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
18031 rest_of_type_compilation (t
, 1);
18035 /* Called from do_type_instantiation through binding_table_foreach to
18036 do recursive instantiation for the type bound in ENTRY. */
18038 bt_instantiate_type_proc (binding_entry entry
, void *data
)
18040 tree storage
= *(tree
*) data
;
18042 if (MAYBE_CLASS_TYPE_P (entry
->type
)
18043 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
18044 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
18047 /* Called from do_type_instantiation to instantiate a member
18048 (a member function or a static member variable) of an
18049 explicitly instantiated class template. */
18051 instantiate_class_member (tree decl
, int extern_p
)
18053 mark_decl_instantiated (decl
, extern_p
);
18055 instantiate_decl (decl
, /*defer_ok=*/1,
18056 /*expl_inst_class_mem_p=*/true);
18059 /* Perform an explicit instantiation of template class T. STORAGE, if
18060 non-null, is the RID for extern, inline or static. COMPLAIN is
18061 nonzero if this is called from the parser, zero if called recursively,
18062 since the standard is unclear (as detailed below). */
18065 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
18070 int previous_instantiation_extern_p
= 0;
18072 if (TREE_CODE (t
) == TYPE_DECL
)
18075 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
18078 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
18080 error ("explicit instantiation of non-class template %qD", tmpl
);
18082 error ("explicit instantiation of non-template type %qT", t
);
18088 if (!COMPLETE_TYPE_P (t
))
18090 if (complain
& tf_error
)
18091 error ("explicit instantiation of %q#T before definition of template",
18096 if (storage
!= NULL_TREE
)
18098 if (!in_system_header
)
18100 if (storage
== ridpointers
[(int) RID_EXTERN
])
18102 if (cxx_dialect
== cxx98
)
18103 pedwarn (input_location
, OPT_Wpedantic
,
18104 "ISO C++ 1998 forbids the use of %<extern%> on "
18105 "explicit instantiations");
18108 pedwarn (input_location
, OPT_Wpedantic
,
18109 "ISO C++ forbids the use of %qE"
18110 " on explicit instantiations", storage
);
18113 if (storage
== ridpointers
[(int) RID_INLINE
])
18115 else if (storage
== ridpointers
[(int) RID_EXTERN
])
18117 else if (storage
== ridpointers
[(int) RID_STATIC
])
18121 error ("storage class %qD applied to template instantiation",
18127 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
18129 /* DR 259 [temp.spec].
18131 Both an explicit instantiation and a declaration of an explicit
18132 specialization shall not appear in a program unless the explicit
18133 instantiation follows a declaration of the explicit specialization.
18135 For a given set of template parameters, if an explicit
18136 instantiation of a template appears after a declaration of an
18137 explicit specialization for that template, the explicit
18138 instantiation has no effect. */
18141 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
18145 No program shall explicitly instantiate any template more
18148 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
18149 instantiation was `extern'. If EXTERN_P then the second is.
18150 These cases are OK. */
18151 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
18153 if (!previous_instantiation_extern_p
&& !extern_p
18154 && (complain
& tf_error
))
18155 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
18157 /* If we've already instantiated the template, just return now. */
18158 if (!CLASSTYPE_INTERFACE_ONLY (t
))
18162 check_explicit_instantiation_namespace (TYPE_NAME (t
));
18163 mark_class_instantiated (t
, extern_p
);
18171 /* In contrast to implicit instantiation, where only the
18172 declarations, and not the definitions, of members are
18173 instantiated, we have here:
18177 The explicit instantiation of a class template specialization
18178 implies the instantiation of all of its members not
18179 previously explicitly specialized in the translation unit
18180 containing the explicit instantiation.
18182 Of course, we can't instantiate member template classes, since
18183 we don't have any arguments for them. Note that the standard
18184 is unclear on whether the instantiation of the members are
18185 *explicit* instantiations or not. However, the most natural
18186 interpretation is that it should be an explicit instantiation. */
18189 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
18190 if (TREE_CODE (tmp
) == FUNCTION_DECL
18191 && DECL_TEMPLATE_INSTANTIATION (tmp
))
18192 instantiate_class_member (tmp
, extern_p
);
18194 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
18195 if (TREE_CODE (tmp
) == VAR_DECL
&& DECL_TEMPLATE_INSTANTIATION (tmp
))
18196 instantiate_class_member (tmp
, extern_p
);
18198 if (CLASSTYPE_NESTED_UTDS (t
))
18199 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
18200 bt_instantiate_type_proc
, &storage
);
18204 /* Given a function DECL, which is a specialization of TMPL, modify
18205 DECL to be a re-instantiation of TMPL with the same template
18206 arguments. TMPL should be the template into which tsubst'ing
18207 should occur for DECL, not the most general template.
18209 One reason for doing this is a scenario like this:
18212 void f(const T&, int i);
18214 void g() { f(3, 7); }
18217 void f(const T& t, const int i) { }
18219 Note that when the template is first instantiated, with
18220 instantiate_template, the resulting DECL will have no name for the
18221 first parameter, and the wrong type for the second. So, when we go
18222 to instantiate the DECL, we regenerate it. */
18225 regenerate_decl_from_template (tree decl
, tree tmpl
)
18227 /* The arguments used to instantiate DECL, from the most general
18232 args
= DECL_TI_ARGS (decl
);
18233 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
18235 /* Make sure that we can see identifiers, and compute access
18237 push_access_scope (decl
);
18239 if (TREE_CODE (decl
) == FUNCTION_DECL
)
18247 args_depth
= TMPL_ARGS_DEPTH (args
);
18248 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
18249 if (args_depth
> parms_depth
)
18250 args
= get_innermost_template_args (args
, parms_depth
);
18252 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
18253 args
, tf_error
, NULL_TREE
,
18254 /*defer_ok*/false);
18255 if (specs
&& specs
!= error_mark_node
)
18256 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
18259 /* Merge parameter declarations. */
18260 decl_parm
= skip_artificial_parms_for (decl
,
18261 DECL_ARGUMENTS (decl
));
18263 = skip_artificial_parms_for (code_pattern
,
18264 DECL_ARGUMENTS (code_pattern
));
18265 while (decl_parm
&& !FUNCTION_PARAMETER_PACK_P (pattern_parm
))
18270 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
18271 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
18272 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
18274 parm_type
= type_decays_to (parm_type
);
18275 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
18276 TREE_TYPE (decl_parm
) = parm_type
;
18277 attributes
= DECL_ATTRIBUTES (pattern_parm
);
18278 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
18280 DECL_ATTRIBUTES (decl_parm
) = attributes
;
18281 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
18283 decl_parm
= DECL_CHAIN (decl_parm
);
18284 pattern_parm
= DECL_CHAIN (pattern_parm
);
18286 /* Merge any parameters that match with the function parameter
18288 if (pattern_parm
&& FUNCTION_PARAMETER_PACK_P (pattern_parm
))
18291 tree expanded_types
;
18292 /* Expand the TYPE_PACK_EXPANSION that provides the types for
18293 the parameters in this function parameter pack. */
18294 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
18295 args
, tf_error
, NULL_TREE
);
18296 len
= TREE_VEC_LENGTH (expanded_types
);
18297 for (i
= 0; i
< len
; i
++)
18302 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
18303 /* Rename the parameter to include the index. */
18304 DECL_NAME (decl_parm
) =
18305 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
18306 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
18307 parm_type
= type_decays_to (parm_type
);
18308 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
18309 TREE_TYPE (decl_parm
) = parm_type
;
18310 attributes
= DECL_ATTRIBUTES (pattern_parm
);
18311 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
18313 DECL_ATTRIBUTES (decl_parm
) = attributes
;
18314 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
18316 decl_parm
= DECL_CHAIN (decl_parm
);
18319 /* Merge additional specifiers from the CODE_PATTERN. */
18320 if (DECL_DECLARED_INLINE_P (code_pattern
)
18321 && !DECL_DECLARED_INLINE_P (decl
))
18322 DECL_DECLARED_INLINE_P (decl
) = 1;
18324 else if (TREE_CODE (decl
) == VAR_DECL
)
18326 DECL_INITIAL (decl
) =
18327 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
18328 tf_error
, DECL_TI_TEMPLATE (decl
),
18329 /*integral_constant_expression_p=*/false);
18330 if (VAR_HAD_UNKNOWN_BOUND (decl
))
18331 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
18332 tf_error
, DECL_TI_TEMPLATE (decl
));
18335 gcc_unreachable ();
18337 pop_access_scope (decl
);
18340 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
18341 substituted to get DECL. */
18344 template_for_substitution (tree decl
)
18346 tree tmpl
= DECL_TI_TEMPLATE (decl
);
18348 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
18349 for the instantiation. This is not always the most general
18350 template. Consider, for example:
18353 struct S { template <class U> void f();
18354 template <> void f<int>(); };
18356 and an instantiation of S<double>::f<int>. We want TD to be the
18357 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
18358 while (/* An instantiation cannot have a definition, so we need a
18359 more general template. */
18360 DECL_TEMPLATE_INSTANTIATION (tmpl
)
18361 /* We must also deal with friend templates. Given:
18363 template <class T> struct S {
18364 template <class U> friend void f() {};
18367 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
18368 so far as the language is concerned, but that's still
18369 where we get the pattern for the instantiation from. On
18370 other hand, if the definition comes outside the class, say:
18372 template <class T> struct S {
18373 template <class U> friend void f();
18375 template <class U> friend void f() {}
18377 we don't need to look any further. That's what the check for
18378 DECL_INITIAL is for. */
18379 || (TREE_CODE (decl
) == FUNCTION_DECL
18380 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
18381 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
18383 /* The present template, TD, should not be a definition. If it
18384 were a definition, we should be using it! Note that we
18385 cannot restructure the loop to just keep going until we find
18386 a template with a definition, since that might go too far if
18387 a specialization was declared, but not defined. */
18388 gcc_assert (TREE_CODE (decl
) != VAR_DECL
18389 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl
)));
18391 /* Fetch the more general template. */
18392 tmpl
= DECL_TI_TEMPLATE (tmpl
);
18398 /* Returns true if we need to instantiate this template instance even if we
18399 know we aren't going to emit it.. */
18402 always_instantiate_p (tree decl
)
18404 /* We always instantiate inline functions so that we can inline them. An
18405 explicit instantiation declaration prohibits implicit instantiation of
18406 non-inline functions. With high levels of optimization, we would
18407 normally inline non-inline functions -- but we're not allowed to do
18408 that for "extern template" functions. Therefore, we check
18409 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
18410 return ((TREE_CODE (decl
) == FUNCTION_DECL
18411 && (DECL_DECLARED_INLINE_P (decl
)
18412 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
18413 /* And we need to instantiate static data members so that
18414 their initializers are available in integral constant
18416 || (TREE_CODE (decl
) == VAR_DECL
18417 && decl_maybe_constant_var_p (decl
)));
18420 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
18421 instantiate it now, modifying TREE_TYPE (fn). */
18424 maybe_instantiate_noexcept (tree fn
)
18426 tree fntype
, spec
, noex
, clone
;
18428 if (DECL_CLONED_FUNCTION_P (fn
))
18429 fn
= DECL_CLONED_FUNCTION (fn
);
18430 fntype
= TREE_TYPE (fn
);
18431 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
18433 if (!DEFERRED_NOEXCEPT_SPEC_P (spec
))
18436 noex
= TREE_PURPOSE (spec
);
18438 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
18440 if (push_tinst_level (fn
))
18442 push_access_scope (fn
);
18443 push_deferring_access_checks (dk_no_deferred
);
18444 input_location
= DECL_SOURCE_LOCATION (fn
);
18445 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
18446 DEFERRED_NOEXCEPT_ARGS (noex
),
18447 tf_warning_or_error
, fn
,
18448 /*function_p=*/false,
18449 /*integral_constant_expression_p=*/true);
18450 pop_deferring_access_checks ();
18451 pop_access_scope (fn
);
18452 pop_tinst_level ();
18453 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
18454 if (spec
== error_mark_node
)
18455 spec
= noexcept_false_spec
;
18458 spec
= noexcept_false_spec
;
18462 /* This is an implicitly declared function, so NOEX is a list of
18463 other functions to evaluate and merge. */
18465 spec
= noexcept_true_spec
;
18466 for (elt
= noex
; elt
; elt
= OVL_NEXT (elt
))
18468 tree fn
= OVL_CURRENT (elt
);
18470 maybe_instantiate_noexcept (fn
);
18471 subspec
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
18472 spec
= merge_exception_specifiers (spec
, subspec
, NULL_TREE
);
18476 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
18478 FOR_EACH_CLONE (clone
, fn
)
18480 if (TREE_TYPE (clone
) == fntype
)
18481 TREE_TYPE (clone
) = TREE_TYPE (fn
);
18483 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
18487 /* Produce the definition of D, a _DECL generated from a template. If
18488 DEFER_OK is nonzero, then we don't have to actually do the
18489 instantiation now; we just have to do it sometime. Normally it is
18490 an error if this is an explicit instantiation but D is undefined.
18491 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
18492 explicitly instantiated class template. */
18495 instantiate_decl (tree d
, int defer_ok
,
18496 bool expl_inst_class_mem_p
)
18498 tree tmpl
= DECL_TI_TEMPLATE (d
);
18505 bool pattern_defined
;
18506 location_t saved_loc
= input_location
;
18511 /* This function should only be used to instantiate templates for
18512 functions and static member variables. */
18513 gcc_assert (TREE_CODE (d
) == FUNCTION_DECL
18514 || TREE_CODE (d
) == VAR_DECL
);
18516 /* Variables are never deferred; if instantiation is required, they
18517 are instantiated right away. That allows for better code in the
18518 case that an expression refers to the value of the variable --
18519 if the variable has a constant value the referring expression can
18520 take advantage of that fact. */
18521 if (TREE_CODE (d
) == VAR_DECL
18522 || DECL_DECLARED_CONSTEXPR_P (d
))
18525 /* Don't instantiate cloned functions. Instead, instantiate the
18526 functions they cloned. */
18527 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
18528 d
= DECL_CLONED_FUNCTION (d
);
18530 if (DECL_TEMPLATE_INSTANTIATED (d
)
18531 || (TREE_CODE (d
) == FUNCTION_DECL
18532 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
18533 || DECL_TEMPLATE_SPECIALIZATION (d
))
18534 /* D has already been instantiated or explicitly specialized, so
18535 there's nothing for us to do here.
18537 It might seem reasonable to check whether or not D is an explicit
18538 instantiation, and, if so, stop here. But when an explicit
18539 instantiation is deferred until the end of the compilation,
18540 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
18541 the instantiation. */
18544 /* Check to see whether we know that this template will be
18545 instantiated in some other file, as with "extern template"
18547 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
18549 /* In general, we do not instantiate such templates. */
18550 if (external_p
&& !always_instantiate_p (d
))
18553 gen_tmpl
= most_general_template (tmpl
);
18554 gen_args
= DECL_TI_ARGS (d
);
18556 if (tmpl
!= gen_tmpl
)
18557 /* We should already have the extra args. */
18558 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
18559 == TMPL_ARGS_DEPTH (gen_args
));
18560 /* And what's in the hash table should match D. */
18561 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
18562 || spec
== NULL_TREE
);
18564 /* This needs to happen before any tsubsting. */
18565 if (! push_tinst_level (d
))
18568 timevar_push (TV_TEMPLATE_INST
);
18570 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
18571 for the instantiation. */
18572 td
= template_for_substitution (d
);
18573 code_pattern
= DECL_TEMPLATE_RESULT (td
);
18575 /* We should never be trying to instantiate a member of a class
18576 template or partial specialization. */
18577 gcc_assert (d
!= code_pattern
);
18579 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
18580 || DECL_TEMPLATE_SPECIALIZATION (td
))
18581 /* In the case of a friend template whose definition is provided
18582 outside the class, we may have too many arguments. Drop the
18583 ones we don't need. The same is true for specializations. */
18584 args
= get_innermost_template_args
18585 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
18589 if (TREE_CODE (d
) == FUNCTION_DECL
)
18590 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
18591 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
));
18593 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
18595 /* We may be in the middle of deferred access check. Disable it now. */
18596 push_deferring_access_checks (dk_no_deferred
);
18598 /* Unless an explicit instantiation directive has already determined
18599 the linkage of D, remember that a definition is available for
18601 if (pattern_defined
18602 && !DECL_INTERFACE_KNOWN (d
)
18603 && !DECL_NOT_REALLY_EXTERN (d
))
18604 mark_definable (d
);
18606 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
18607 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
18608 input_location
= DECL_SOURCE_LOCATION (d
);
18610 /* If D is a member of an explicitly instantiated class template,
18611 and no definition is available, treat it like an implicit
18613 if (!pattern_defined
&& expl_inst_class_mem_p
18614 && DECL_EXPLICIT_INSTANTIATION (d
))
18616 /* Leave linkage flags alone on instantiations with anonymous
18618 if (TREE_PUBLIC (d
))
18620 DECL_NOT_REALLY_EXTERN (d
) = 0;
18621 DECL_INTERFACE_KNOWN (d
) = 0;
18623 SET_DECL_IMPLICIT_INSTANTIATION (d
);
18626 if (TREE_CODE (d
) == FUNCTION_DECL
)
18627 maybe_instantiate_noexcept (d
);
18629 /* Defer all other templates, unless we have been explicitly
18630 forbidden from doing so. */
18631 if (/* If there is no definition, we cannot instantiate the
18634 /* If it's OK to postpone instantiation, do so. */
18636 /* If this is a static data member that will be defined
18637 elsewhere, we don't want to instantiate the entire data
18638 member, but we do want to instantiate the initializer so that
18639 we can substitute that elsewhere. */
18640 || (external_p
&& TREE_CODE (d
) == VAR_DECL
))
18642 /* The definition of the static data member is now required so
18643 we must substitute the initializer. */
18644 if (TREE_CODE (d
) == VAR_DECL
18645 && !DECL_INITIAL (d
)
18646 && DECL_INITIAL (code_pattern
))
18650 bool const_init
= false;
18652 ns
= decl_namespace_context (d
);
18653 push_nested_namespace (ns
);
18654 push_nested_class (DECL_CONTEXT (d
));
18655 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
18657 tf_warning_or_error
, NULL_TREE
,
18658 /*integral_constant_expression_p=*/false);
18659 /* Make sure the initializer is still constant, in case of
18660 circular dependency (template/instantiate6.C). */
18662 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
18663 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
18664 /*asmspec_tree=*/NULL_TREE
,
18665 LOOKUP_ONLYCONVERTING
);
18666 pop_nested_class ();
18667 pop_nested_namespace (ns
);
18670 /* We restore the source position here because it's used by
18671 add_pending_template. */
18672 input_location
= saved_loc
;
18674 if (at_eof
&& !pattern_defined
18675 && DECL_EXPLICIT_INSTANTIATION (d
)
18676 && DECL_NOT_REALLY_EXTERN (d
))
18679 The definition of a non-exported function template, a
18680 non-exported member function template, or a non-exported
18681 member function or static data member of a class template
18682 shall be present in every translation unit in which it is
18683 explicitly instantiated. */
18684 permerror (input_location
, "explicit instantiation of %qD "
18685 "but no definition available", d
);
18687 /* If we're in unevaluated context, we just wanted to get the
18688 constant value; this isn't an odr use, so don't queue
18689 a full instantiation. */
18690 if (cp_unevaluated_operand
!= 0)
18692 /* ??? Historically, we have instantiated inline functions, even
18693 when marked as "extern template". */
18694 if (!(external_p
&& TREE_CODE (d
) == VAR_DECL
))
18695 add_pending_template (d
);
18698 /* Tell the repository that D is available in this translation unit
18699 -- and see if it is supposed to be instantiated here. */
18700 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
18702 /* In a PCH file, despite the fact that the repository hasn't
18703 requested instantiation in the PCH it is still possible that
18704 an instantiation will be required in a file that includes the
18707 add_pending_template (d
);
18708 /* Instantiate inline functions so that the inliner can do its
18709 job, even though we'll not be emitting a copy of this
18711 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
18715 fn_context
= decl_function_context (d
);
18716 nested
= (current_function_decl
!= NULL_TREE
);
18718 push_to_top_level ();
18720 push_function_context ();
18722 /* Mark D as instantiated so that recursive calls to
18723 instantiate_decl do not try to instantiate it again. */
18724 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
18726 /* Regenerate the declaration in case the template has been modified
18727 by a subsequent redeclaration. */
18728 regenerate_decl_from_template (d
, td
);
18730 /* We already set the file and line above. Reset them now in case
18731 they changed as a result of calling regenerate_decl_from_template. */
18732 input_location
= DECL_SOURCE_LOCATION (d
);
18734 if (TREE_CODE (d
) == VAR_DECL
)
18737 bool const_init
= false;
18739 /* Clear out DECL_RTL; whatever was there before may not be right
18740 since we've reset the type of the declaration. */
18741 SET_DECL_RTL (d
, NULL
);
18742 DECL_IN_AGGR_P (d
) = 0;
18744 /* The initializer is placed in DECL_INITIAL by
18745 regenerate_decl_from_template so we don't need to
18746 push/pop_access_scope again here. Pull it out so that
18747 cp_finish_decl can process it. */
18748 init
= DECL_INITIAL (d
);
18749 DECL_INITIAL (d
) = NULL_TREE
;
18750 DECL_INITIALIZED_P (d
) = 0;
18752 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
18753 initializer. That function will defer actual emission until
18754 we have a chance to determine linkage. */
18755 DECL_EXTERNAL (d
) = 0;
18757 /* Enter the scope of D so that access-checking works correctly. */
18758 push_nested_class (DECL_CONTEXT (d
));
18759 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
18760 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
18761 pop_nested_class ();
18763 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
18764 synthesize_method (d
);
18765 else if (TREE_CODE (d
) == FUNCTION_DECL
)
18767 struct pointer_map_t
*saved_local_specializations
;
18772 /* Save away the current list, in case we are instantiating one
18773 template from within the body of another. */
18774 saved_local_specializations
= local_specializations
;
18776 /* Set up the list of local specializations. */
18777 local_specializations
= pointer_map_create ();
18779 /* Set up context. */
18780 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
18782 /* Some typedefs referenced from within the template code need to be
18783 access checked at template instantiation time, i.e now. These
18784 types were added to the template at parsing time. Let's get those
18785 and perform the access checks then. */
18786 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
18789 /* Create substitution entries for the parameters. */
18790 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
18791 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
18792 spec_parm
= DECL_ARGUMENTS (d
);
18793 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
18795 register_local_specialization (spec_parm
, tmpl_parm
);
18796 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
18797 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
18799 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
18801 if (!FUNCTION_PARAMETER_PACK_P (tmpl_parm
))
18803 register_local_specialization (spec_parm
, tmpl_parm
);
18804 spec_parm
= DECL_CHAIN (spec_parm
);
18808 /* Register the (value) argument pack as a specialization of
18809 TMPL_PARM, then move on. */
18810 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
18811 register_local_specialization (argpack
, tmpl_parm
);
18814 gcc_assert (!spec_parm
);
18816 /* Substitute into the body of the function. */
18817 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
18818 tf_warning_or_error
, tmpl
,
18819 /*integral_constant_expression_p=*/false);
18821 /* Set the current input_location to the end of the function
18822 so that finish_function knows where we are. */
18823 input_location
= DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
18825 /* We don't need the local specializations any more. */
18826 pointer_map_destroy (local_specializations
);
18827 local_specializations
= saved_local_specializations
;
18829 /* Finish the function. */
18830 d
= finish_function (0);
18831 expand_or_defer_fn (d
);
18834 /* We're not deferring instantiation any more. */
18835 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
18838 pop_from_top_level ();
18840 pop_function_context ();
18843 input_location
= saved_loc
;
18844 pop_deferring_access_checks ();
18845 pop_tinst_level ();
18847 timevar_pop (TV_TEMPLATE_INST
);
18852 /* Run through the list of templates that we wish we could
18853 instantiate, and instantiate any we can. RETRIES is the
18854 number of times we retry pending template instantiation. */
18857 instantiate_pending_templates (int retries
)
18860 location_t saved_loc
= input_location
;
18862 /* Instantiating templates may trigger vtable generation. This in turn
18863 may require further template instantiations. We place a limit here
18864 to avoid infinite loop. */
18865 if (pending_templates
&& retries
>= max_tinst_depth
)
18867 tree decl
= pending_templates
->tinst
->decl
;
18869 error ("template instantiation depth exceeds maximum of %d"
18870 " instantiating %q+D, possibly from virtual table generation"
18871 " (use -ftemplate-depth= to increase the maximum)",
18872 max_tinst_depth
, decl
);
18873 if (TREE_CODE (decl
) == FUNCTION_DECL
)
18874 /* Pretend that we defined it. */
18875 DECL_INITIAL (decl
) = error_mark_node
;
18881 struct pending_template
**t
= &pending_templates
;
18882 struct pending_template
*last
= NULL
;
18886 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
18887 bool complete
= false;
18889 if (TYPE_P (instantiation
))
18893 if (!COMPLETE_TYPE_P (instantiation
))
18895 instantiate_class_template (instantiation
);
18896 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
18897 for (fn
= TYPE_METHODS (instantiation
);
18899 fn
= TREE_CHAIN (fn
))
18900 if (! DECL_ARTIFICIAL (fn
))
18901 instantiate_decl (fn
,
18903 /*expl_inst_class_mem_p=*/false);
18904 if (COMPLETE_TYPE_P (instantiation
))
18908 complete
= COMPLETE_TYPE_P (instantiation
);
18912 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
18913 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
18916 = instantiate_decl (instantiation
,
18918 /*expl_inst_class_mem_p=*/false);
18919 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
18923 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
18924 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
18928 /* If INSTANTIATION has been instantiated, then we don't
18929 need to consider it again in the future. */
18937 current_tinst_level
= NULL
;
18939 last_pending_template
= last
;
18941 while (reconsider
);
18943 input_location
= saved_loc
;
18946 /* Substitute ARGVEC into T, which is a list of initializers for
18947 either base class or a non-static data member. The TREE_PURPOSEs
18948 are DECLs, and the TREE_VALUEs are the initializer values. Used by
18949 instantiate_decl. */
18952 tsubst_initializer_list (tree t
, tree argvec
)
18954 tree inits
= NULL_TREE
;
18956 for (; t
; t
= TREE_CHAIN (t
))
18960 tree expanded_bases
= NULL_TREE
;
18961 tree expanded_arguments
= NULL_TREE
;
18964 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
18969 /* Expand the base class expansion type into separate base
18971 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
18972 tf_warning_or_error
,
18974 if (expanded_bases
== error_mark_node
)
18977 /* We'll be building separate TREE_LISTs of arguments for
18979 len
= TREE_VEC_LENGTH (expanded_bases
);
18980 expanded_arguments
= make_tree_vec (len
);
18981 for (i
= 0; i
< len
; i
++)
18982 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
18984 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
18985 expand each argument in the TREE_VALUE of t. */
18986 expr
= make_node (EXPR_PACK_EXPANSION
);
18987 PACK_EXPANSION_LOCAL_P (expr
) = true;
18988 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
18989 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
18991 if (TREE_VALUE (t
) == void_type_node
)
18992 /* VOID_TYPE_NODE is used to indicate
18993 value-initialization. */
18995 for (i
= 0; i
< len
; i
++)
18996 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
19000 /* Substitute parameter packs into each argument in the
19002 in_base_initializer
= 1;
19003 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
19005 tree expanded_exprs
;
19007 /* Expand the argument. */
19008 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
19010 = tsubst_pack_expansion (expr
, argvec
,
19011 tf_warning_or_error
,
19013 if (expanded_exprs
== error_mark_node
)
19016 /* Prepend each of the expanded expressions to the
19017 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
19018 for (i
= 0; i
< len
; i
++)
19020 TREE_VEC_ELT (expanded_arguments
, i
) =
19021 tree_cons (NULL_TREE
,
19022 TREE_VEC_ELT (expanded_exprs
, i
),
19023 TREE_VEC_ELT (expanded_arguments
, i
));
19026 in_base_initializer
= 0;
19028 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
19029 since we built them backwards. */
19030 for (i
= 0; i
< len
; i
++)
19032 TREE_VEC_ELT (expanded_arguments
, i
) =
19033 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
19038 for (i
= 0; i
< len
; ++i
)
19040 if (expanded_bases
)
19042 decl
= TREE_VEC_ELT (expanded_bases
, i
);
19043 decl
= expand_member_init (decl
);
19044 init
= TREE_VEC_ELT (expanded_arguments
, i
);
19049 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
19050 tf_warning_or_error
, NULL_TREE
);
19052 decl
= expand_member_init (decl
);
19053 if (decl
&& !DECL_P (decl
))
19054 in_base_initializer
= 1;
19056 init
= TREE_VALUE (t
);
19058 if (init
!= void_type_node
)
19059 init
= tsubst_expr (init
, argvec
,
19060 tf_warning_or_error
, NULL_TREE
,
19061 /*integral_constant_expression_p=*/false);
19062 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
19063 /* If we had an initializer but it instantiated to nothing,
19064 value-initialize the object. This will only occur when
19065 the initializer was a pack expansion where the parameter
19066 packs used in that expansion were of length zero. */
19067 init
= void_type_node
;
19068 in_base_initializer
= 0;
19073 init
= build_tree_list (decl
, init
);
19074 TREE_CHAIN (init
) = inits
;
19082 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
19085 set_current_access_from_decl (tree decl
)
19087 if (TREE_PRIVATE (decl
))
19088 current_access_specifier
= access_private_node
;
19089 else if (TREE_PROTECTED (decl
))
19090 current_access_specifier
= access_protected_node
;
19092 current_access_specifier
= access_public_node
;
19095 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
19096 is the instantiation (which should have been created with
19097 start_enum) and ARGS are the template arguments to use. */
19100 tsubst_enum (tree tag
, tree newtag
, tree args
)
19104 if (SCOPED_ENUM_P (newtag
))
19105 begin_scope (sk_scoped_enum
, newtag
);
19107 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
19112 decl
= TREE_VALUE (e
);
19113 /* Note that in a template enum, the TREE_VALUE is the
19114 CONST_DECL, not the corresponding INTEGER_CST. */
19115 value
= tsubst_expr (DECL_INITIAL (decl
),
19116 args
, tf_warning_or_error
, NULL_TREE
,
19117 /*integral_constant_expression_p=*/true);
19119 /* Give this enumeration constant the correct access. */
19120 set_current_access_from_decl (decl
);
19122 /* Actually build the enumerator itself. */
19124 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
19127 if (SCOPED_ENUM_P (newtag
))
19130 finish_enum_value_list (newtag
);
19131 finish_enum (newtag
);
19133 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
19134 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
19137 /* DECL is a FUNCTION_DECL that is a template specialization. Return
19138 its type -- but without substituting the innermost set of template
19139 arguments. So, innermost set of template parameters will appear in
19143 get_mostly_instantiated_function_type (tree decl
)
19151 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
19152 targs
= DECL_TI_ARGS (decl
);
19153 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
19154 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
19156 /* There should be as many levels of arguments as there are levels
19158 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
19160 fn_type
= TREE_TYPE (tmpl
);
19162 if (parm_depth
== 1)
19163 /* No substitution is necessary. */
19170 /* Replace the innermost level of the TARGS with NULL_TREEs to
19171 let tsubst know not to substitute for those parameters. */
19172 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
19173 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
19174 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
19175 TMPL_ARGS_LEVEL (targs
, i
));
19176 SET_TMPL_ARGS_LEVEL (partial_args
,
19177 TMPL_ARGS_DEPTH (targs
),
19178 make_tree_vec (DECL_NTPARMS (tmpl
)));
19180 /* Make sure that we can see identifiers, and compute access
19182 push_access_scope (decl
);
19184 ++processing_template_decl
;
19185 /* Now, do the (partial) substitution to figure out the
19186 appropriate function type. */
19187 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
19188 --processing_template_decl
;
19190 /* Substitute into the template parameters to obtain the real
19191 innermost set of parameters. This step is important if the
19192 innermost set of template parameters contains value
19193 parameters whose types depend on outer template parameters. */
19194 TREE_VEC_LENGTH (partial_args
)--;
19195 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
19197 pop_access_scope (decl
);
19203 /* Return truthvalue if we're processing a template different from
19204 the last one involved in diagnostics. */
19206 problematic_instantiation_changed (void)
19208 return current_tinst_level
!= last_error_tinst_level
;
19211 /* Remember current template involved in diagnostics. */
19213 record_last_problematic_instantiation (void)
19215 last_error_tinst_level
= current_tinst_level
;
19218 struct tinst_level
*
19219 current_instantiation (void)
19221 return current_tinst_level
;
19224 /* [temp.param] Check that template non-type parm TYPE is of an allowable
19225 type. Return zero for ok, nonzero for disallowed. Issue error and
19226 warning messages under control of COMPLAIN. */
19229 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
19231 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
19233 else if (POINTER_TYPE_P (type
))
19235 else if (TYPE_PTRMEM_P (type
))
19237 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
19239 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
19241 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
19243 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
19246 if (complain
& tf_error
)
19248 if (type
== error_mark_node
)
19249 inform (input_location
, "invalid template non-type parameter");
19251 error ("%q#T is not a valid type for a template non-type parameter",
19257 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
19258 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
19261 dependent_type_p_r (tree type
)
19267 A type is dependent if it is:
19269 -- a template parameter. Template template parameters are types
19270 for us (since TYPE_P holds true for them) so we handle
19272 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
19273 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
19275 /* -- a qualified-id with a nested-name-specifier which contains a
19276 class-name that names a dependent type or whose unqualified-id
19277 names a dependent type. */
19278 if (TREE_CODE (type
) == TYPENAME_TYPE
)
19280 /* -- a cv-qualified type where the cv-unqualified type is
19282 type
= TYPE_MAIN_VARIANT (type
);
19283 /* -- a compound type constructed from any dependent type. */
19284 if (TYPE_PTRMEM_P (type
))
19285 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
19286 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
19288 else if (TREE_CODE (type
) == POINTER_TYPE
19289 || TREE_CODE (type
) == REFERENCE_TYPE
)
19290 return dependent_type_p (TREE_TYPE (type
));
19291 else if (TREE_CODE (type
) == FUNCTION_TYPE
19292 || TREE_CODE (type
) == METHOD_TYPE
)
19296 if (dependent_type_p (TREE_TYPE (type
)))
19298 for (arg_type
= TYPE_ARG_TYPES (type
);
19300 arg_type
= TREE_CHAIN (arg_type
))
19301 if (dependent_type_p (TREE_VALUE (arg_type
)))
19305 /* -- an array type constructed from any dependent type or whose
19306 size is specified by a constant expression that is
19309 We checked for type- and value-dependence of the bounds in
19310 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
19311 if (TREE_CODE (type
) == ARRAY_TYPE
)
19313 if (TYPE_DOMAIN (type
)
19314 && dependent_type_p (TYPE_DOMAIN (type
)))
19316 return dependent_type_p (TREE_TYPE (type
));
19319 /* -- a template-id in which either the template name is a template
19321 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
19323 /* ... or any of the template arguments is a dependent type or
19324 an expression that is type-dependent or value-dependent. */
19325 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
19326 && (any_dependent_template_arguments_p
19327 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
19330 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
19331 dependent; if the argument of the `typeof' expression is not
19332 type-dependent, then it should already been have resolved. */
19333 if (TREE_CODE (type
) == TYPEOF_TYPE
19334 || TREE_CODE (type
) == DECLTYPE_TYPE
19335 || TREE_CODE (type
) == UNDERLYING_TYPE
)
19338 /* A template argument pack is dependent if any of its packed
19340 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
19342 tree args
= ARGUMENT_PACK_ARGS (type
);
19343 int i
, len
= TREE_VEC_LENGTH (args
);
19344 for (i
= 0; i
< len
; ++i
)
19345 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
19349 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
19350 be template parameters. */
19351 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
19354 /* The standard does not specifically mention types that are local
19355 to template functions or local classes, but they should be
19356 considered dependent too. For example:
19358 template <int I> void f() {
19363 The size of `E' cannot be known until the value of `I' has been
19364 determined. Therefore, `E' must be considered dependent. */
19365 scope
= TYPE_CONTEXT (type
);
19366 if (scope
&& TYPE_P (scope
))
19367 return dependent_type_p (scope
);
19368 /* Don't use type_dependent_expression_p here, as it can lead
19369 to infinite recursion trying to determine whether a lambda
19370 nested in a lambda is dependent (c++/47687). */
19371 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
19372 && DECL_LANG_SPECIFIC (scope
)
19373 && DECL_TEMPLATE_INFO (scope
)
19374 && (any_dependent_template_arguments_p
19375 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
19378 /* Other types are non-dependent. */
19382 /* Returns TRUE if TYPE is dependent, in the sense of
19383 [temp.dep.type]. Note that a NULL type is considered dependent. */
19386 dependent_type_p (tree type
)
19388 /* If there are no template parameters in scope, then there can't be
19389 any dependent types. */
19390 if (!processing_template_decl
)
19392 /* If we are not processing a template, then nobody should be
19393 providing us with a dependent type. */
19395 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
19399 /* If the type is NULL, we have not computed a type for the entity
19400 in question; in that case, the type is dependent. */
19404 /* Erroneous types can be considered non-dependent. */
19405 if (type
== error_mark_node
)
19408 /* If we have not already computed the appropriate value for TYPE,
19410 if (!TYPE_DEPENDENT_P_VALID (type
))
19412 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
19413 TYPE_DEPENDENT_P_VALID (type
) = 1;
19416 return TYPE_DEPENDENT_P (type
);
19419 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
19420 lookup. In other words, a dependent type that is not the current
19424 dependent_scope_p (tree scope
)
19426 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
19427 && !currently_open_class (scope
));
19430 /* T is a SCOPE_REF; return whether we need to consider it
19431 instantiation-dependent so that we can check access at instantiation
19432 time even though we know which member it resolves to. */
19435 instantiation_dependent_scope_ref_p (tree t
)
19437 if (DECL_P (TREE_OPERAND (t
, 1))
19438 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
19439 && accessible_in_template_p (TREE_OPERAND (t
, 0),
19440 TREE_OPERAND (t
, 1)))
19446 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
19447 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
19450 /* Note that this predicate is not appropriate for general expressions;
19451 only constant expressions (that satisfy potential_constant_expression)
19452 can be tested for value dependence. */
19455 value_dependent_expression_p (tree expression
)
19457 if (!processing_template_decl
)
19460 /* A name declared with a dependent type. */
19461 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
19464 switch (TREE_CODE (expression
))
19466 case IDENTIFIER_NODE
:
19467 /* A name that has not been looked up -- must be dependent. */
19470 case TEMPLATE_PARM_INDEX
:
19471 /* A non-type template parm. */
19475 /* A non-type template parm. */
19476 if (DECL_TEMPLATE_PARM_P (expression
))
19478 return value_dependent_expression_p (DECL_INITIAL (expression
));
19481 /* A constant with literal type and is initialized
19482 with an expression that is value-dependent.
19484 Note that a non-dependent parenthesized initializer will have
19485 already been replaced with its constant value, so if we see
19486 a TREE_LIST it must be dependent. */
19487 if (DECL_INITIAL (expression
)
19488 && decl_constant_var_p (expression
)
19489 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
19490 || value_dependent_expression_p (DECL_INITIAL (expression
))))
19494 case DYNAMIC_CAST_EXPR
:
19495 case STATIC_CAST_EXPR
:
19496 case CONST_CAST_EXPR
:
19497 case REINTERPRET_CAST_EXPR
:
19499 /* These expressions are value-dependent if the type to which
19500 the cast occurs is dependent or the expression being casted
19501 is value-dependent. */
19503 tree type
= TREE_TYPE (expression
);
19505 if (dependent_type_p (type
))
19508 /* A functional cast has a list of operands. */
19509 expression
= TREE_OPERAND (expression
, 0);
19512 /* If there are no operands, it must be an expression such
19513 as "int()". This should not happen for aggregate types
19514 because it would form non-constant expressions. */
19515 gcc_assert (cxx_dialect
>= cxx0x
19516 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
19521 if (TREE_CODE (expression
) == TREE_LIST
)
19522 return any_value_dependent_elements_p (expression
);
19524 return value_dependent_expression_p (expression
);
19528 if (SIZEOF_EXPR_TYPE_P (expression
))
19529 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
19533 /* A `sizeof' expression is value-dependent if the operand is
19534 type-dependent or is a pack expansion. */
19535 expression
= TREE_OPERAND (expression
, 0);
19536 if (PACK_EXPANSION_P (expression
))
19538 else if (TYPE_P (expression
))
19539 return dependent_type_p (expression
);
19540 return instantiation_dependent_expression_p (expression
);
19542 case AT_ENCODE_EXPR
:
19543 /* An 'encode' expression is value-dependent if the operand is
19545 expression
= TREE_OPERAND (expression
, 0);
19546 return dependent_type_p (expression
);
19548 case NOEXCEPT_EXPR
:
19549 expression
= TREE_OPERAND (expression
, 0);
19550 return instantiation_dependent_expression_p (expression
);
19553 /* All instantiation-dependent expressions should also be considered
19554 value-dependent. */
19555 return instantiation_dependent_scope_ref_p (expression
);
19557 case COMPONENT_REF
:
19558 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
19559 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
19561 case NONTYPE_ARGUMENT_PACK
:
19562 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
19563 is value-dependent. */
19565 tree values
= ARGUMENT_PACK_ARGS (expression
);
19566 int i
, len
= TREE_VEC_LENGTH (values
);
19568 for (i
= 0; i
< len
; ++i
)
19569 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
19577 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
19578 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
19579 || (type2
? dependent_type_p (type2
) : false));
19583 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
19584 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
19587 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
19588 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
19592 tree op
= TREE_OPERAND (expression
, 0);
19593 return (value_dependent_expression_p (op
)
19594 || has_value_dependent_address (op
));
19599 tree fn
= get_callee_fndecl (expression
);
19601 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
19603 nargs
= call_expr_nargs (expression
);
19604 for (i
= 0; i
< nargs
; ++i
)
19606 tree op
= CALL_EXPR_ARG (expression
, i
);
19607 /* In a call to a constexpr member function, look through the
19608 implicit ADDR_EXPR on the object argument so that it doesn't
19609 cause the call to be considered value-dependent. We also
19610 look through it in potential_constant_expression. */
19611 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
19612 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
19613 && TREE_CODE (op
) == ADDR_EXPR
)
19614 op
= TREE_OPERAND (op
, 0);
19615 if (value_dependent_expression_p (op
))
19621 case TEMPLATE_ID_EXPR
:
19622 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
19624 return type_dependent_expression_p (expression
);
19630 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
19631 if (value_dependent_expression_p (val
))
19637 /* Treat a GNU statement expression as dependent to avoid crashing
19638 under fold_non_dependent_expr; it can't be constant. */
19642 /* A constant expression is value-dependent if any subexpression is
19643 value-dependent. */
19644 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
19646 case tcc_reference
:
19648 case tcc_comparison
:
19650 case tcc_expression
:
19653 int i
, len
= cp_tree_operand_length (expression
);
19655 for (i
= 0; i
< len
; i
++)
19657 tree t
= TREE_OPERAND (expression
, i
);
19659 /* In some cases, some of the operands may be missing.l
19660 (For example, in the case of PREDECREMENT_EXPR, the
19661 amount to increment by may be missing.) That doesn't
19662 make the expression dependent. */
19663 if (t
&& value_dependent_expression_p (t
))
19674 /* The expression is not value-dependent. */
19678 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
19679 [temp.dep.expr]. Note that an expression with no type is
19680 considered dependent. Other parts of the compiler arrange for an
19681 expression with type-dependent subexpressions to have no type, so
19682 this function doesn't have to be fully recursive. */
19685 type_dependent_expression_p (tree expression
)
19687 if (!processing_template_decl
)
19690 if (expression
== error_mark_node
)
19693 /* An unresolved name is always dependent. */
19694 if (TREE_CODE (expression
) == IDENTIFIER_NODE
19695 || TREE_CODE (expression
) == USING_DECL
)
19698 /* Some expression forms are never type-dependent. */
19699 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
19700 || TREE_CODE (expression
) == SIZEOF_EXPR
19701 || TREE_CODE (expression
) == ALIGNOF_EXPR
19702 || TREE_CODE (expression
) == AT_ENCODE_EXPR
19703 || TREE_CODE (expression
) == NOEXCEPT_EXPR
19704 || TREE_CODE (expression
) == TRAIT_EXPR
19705 || TREE_CODE (expression
) == TYPEID_EXPR
19706 || TREE_CODE (expression
) == DELETE_EXPR
19707 || TREE_CODE (expression
) == VEC_DELETE_EXPR
19708 || TREE_CODE (expression
) == THROW_EXPR
)
19711 /* The types of these expressions depends only on the type to which
19712 the cast occurs. */
19713 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
19714 || TREE_CODE (expression
) == STATIC_CAST_EXPR
19715 || TREE_CODE (expression
) == CONST_CAST_EXPR
19716 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
19717 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
19718 || TREE_CODE (expression
) == CAST_EXPR
)
19719 return dependent_type_p (TREE_TYPE (expression
));
19721 /* The types of these expressions depends only on the type created
19722 by the expression. */
19723 if (TREE_CODE (expression
) == NEW_EXPR
19724 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
19726 /* For NEW_EXPR tree nodes created inside a template, either
19727 the object type itself or a TREE_LIST may appear as the
19729 tree type
= TREE_OPERAND (expression
, 1);
19730 if (TREE_CODE (type
) == TREE_LIST
)
19731 /* This is an array type. We need to check array dimensions
19733 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
19734 || value_dependent_expression_p
19735 (TREE_OPERAND (TREE_VALUE (type
), 1));
19737 return dependent_type_p (type
);
19740 if (TREE_CODE (expression
) == SCOPE_REF
)
19742 tree scope
= TREE_OPERAND (expression
, 0);
19743 tree name
= TREE_OPERAND (expression
, 1);
19745 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
19746 contains an identifier associated by name lookup with one or more
19747 declarations declared with a dependent type, or...a
19748 nested-name-specifier or qualified-id that names a member of an
19749 unknown specialization. */
19750 return (type_dependent_expression_p (name
)
19751 || dependent_scope_p (scope
));
19754 if (TREE_CODE (expression
) == FUNCTION_DECL
19755 && DECL_LANG_SPECIFIC (expression
)
19756 && DECL_TEMPLATE_INFO (expression
)
19757 && (any_dependent_template_arguments_p
19758 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
19761 if (TREE_CODE (expression
) == TEMPLATE_DECL
19762 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
19765 if (TREE_CODE (expression
) == STMT_EXPR
)
19766 expression
= stmt_expr_value_expr (expression
);
19768 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
19773 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
19775 if (type_dependent_expression_p (elt
))
19781 /* A static data member of the current instantiation with incomplete
19782 array type is type-dependent, as the definition and specializations
19783 can have different bounds. */
19784 if (TREE_CODE (expression
) == VAR_DECL
19785 && DECL_CLASS_SCOPE_P (expression
)
19786 && dependent_type_p (DECL_CONTEXT (expression
))
19787 && VAR_HAD_UNKNOWN_BOUND (expression
))
19790 if (TREE_TYPE (expression
) == unknown_type_node
)
19792 if (TREE_CODE (expression
) == ADDR_EXPR
)
19793 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
19794 if (TREE_CODE (expression
) == COMPONENT_REF
19795 || TREE_CODE (expression
) == OFFSET_REF
)
19797 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
19799 expression
= TREE_OPERAND (expression
, 1);
19800 if (TREE_CODE (expression
) == IDENTIFIER_NODE
)
19803 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
19804 if (TREE_CODE (expression
) == SCOPE_REF
)
19807 if (BASELINK_P (expression
))
19808 expression
= BASELINK_FUNCTIONS (expression
);
19810 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
19812 if (any_dependent_template_arguments_p
19813 (TREE_OPERAND (expression
, 1)))
19815 expression
= TREE_OPERAND (expression
, 0);
19817 gcc_assert (TREE_CODE (expression
) == OVERLOAD
19818 || TREE_CODE (expression
) == FUNCTION_DECL
);
19822 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
19824 expression
= OVL_NEXT (expression
);
19829 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
19831 return (dependent_type_p (TREE_TYPE (expression
)));
19834 /* walk_tree callback function for instantiation_dependent_expression_p,
19835 below. Returns non-zero if a dependent subexpression is found. */
19838 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
19843 /* We don't have to worry about decltype currently because decltype
19844 of an instantiation-dependent expr is a dependent type. This
19845 might change depending on the resolution of DR 1172. */
19846 *walk_subtrees
= false;
19849 enum tree_code code
= TREE_CODE (*tp
);
19852 /* Don't treat an argument list as dependent just because it has no
19858 case TEMPLATE_PARM_INDEX
:
19861 /* Handle expressions with type operands. */
19865 case AT_ENCODE_EXPR
:
19868 tree op
= TREE_OPERAND (*tp
, 0);
19869 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
19870 op
= TREE_TYPE (op
);
19873 if (dependent_type_p (op
)
19874 || (code
== TRAIT_EXPR
19875 && dependent_type_p (TREE_OPERAND (*tp
, 1))))
19879 *walk_subtrees
= false;
19886 case COMPONENT_REF
:
19887 if (TREE_CODE (TREE_OPERAND (*tp
, 1)) == IDENTIFIER_NODE
)
19888 /* In a template, finish_class_member_access_expr creates a
19889 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
19890 type-dependent, so that we can check access control at
19891 instantiation time (PR 42277). See also Core issue 1273. */
19896 if (instantiation_dependent_scope_ref_p (*tp
))
19905 if (type_dependent_expression_p (*tp
))
19911 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
19912 sense defined by the ABI:
19914 "An expression is instantiation-dependent if it is type-dependent
19915 or value-dependent, or it has a subexpression that is type-dependent
19916 or value-dependent." */
19919 instantiation_dependent_expression_p (tree expression
)
19923 if (!processing_template_decl
)
19926 if (expression
== error_mark_node
)
19929 result
= cp_walk_tree_without_duplicates (&expression
,
19930 instantiation_dependent_r
, NULL
);
19931 return result
!= NULL_TREE
;
19934 /* Like type_dependent_expression_p, but it also works while not processing
19935 a template definition, i.e. during substitution or mangling. */
19938 type_dependent_expression_p_push (tree expr
)
19941 ++processing_template_decl
;
19942 b
= type_dependent_expression_p (expr
);
19943 --processing_template_decl
;
19947 /* Returns TRUE if ARGS contains a type-dependent expression. */
19950 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
19955 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
19957 if (type_dependent_expression_p (arg
))
19963 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
19964 expressions) contains any type-dependent expressions. */
19967 any_type_dependent_elements_p (const_tree list
)
19969 for (; list
; list
= TREE_CHAIN (list
))
19970 if (value_dependent_expression_p (TREE_VALUE (list
)))
19976 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
19977 expressions) contains any value-dependent expressions. */
19980 any_value_dependent_elements_p (const_tree list
)
19982 for (; list
; list
= TREE_CHAIN (list
))
19983 if (value_dependent_expression_p (TREE_VALUE (list
)))
19989 /* Returns TRUE if the ARG (a template argument) is dependent. */
19992 dependent_template_arg_p (tree arg
)
19994 if (!processing_template_decl
)
19997 /* Assume a template argument that was wrongly written by the user
19998 is dependent. This is consistent with what
19999 any_dependent_template_arguments_p [that calls this function]
20001 if (!arg
|| arg
== error_mark_node
)
20004 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
20005 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
20007 if (TREE_CODE (arg
) == TEMPLATE_DECL
20008 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
20009 return dependent_template_p (arg
);
20010 else if (ARGUMENT_PACK_P (arg
))
20012 tree args
= ARGUMENT_PACK_ARGS (arg
);
20013 int i
, len
= TREE_VEC_LENGTH (args
);
20014 for (i
= 0; i
< len
; ++i
)
20016 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20022 else if (TYPE_P (arg
))
20023 return dependent_type_p (arg
);
20025 return (type_dependent_expression_p (arg
)
20026 || value_dependent_expression_p (arg
));
20029 /* Returns true if ARGS (a collection of template arguments) contains
20030 any types that require structural equality testing. */
20033 any_template_arguments_need_structural_equality_p (tree args
)
20040 if (args
== error_mark_node
)
20043 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
20045 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
20046 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
20048 tree arg
= TREE_VEC_ELT (level
, j
);
20049 tree packed_args
= NULL_TREE
;
20052 if (ARGUMENT_PACK_P (arg
))
20054 /* Look inside the argument pack. */
20055 packed_args
= ARGUMENT_PACK_ARGS (arg
);
20056 len
= TREE_VEC_LENGTH (packed_args
);
20059 for (k
= 0; k
< len
; ++k
)
20062 arg
= TREE_VEC_ELT (packed_args
, k
);
20064 if (error_operand_p (arg
))
20066 else if (TREE_CODE (arg
) == TEMPLATE_DECL
20067 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
20069 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
20071 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
20072 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
20081 /* Returns true if ARGS (a collection of template arguments) contains
20082 any dependent arguments. */
20085 any_dependent_template_arguments_p (const_tree args
)
20092 if (args
== error_mark_node
)
20095 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
20097 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
20098 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
20099 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
20106 /* Returns TRUE if the template TMPL is dependent. */
20109 dependent_template_p (tree tmpl
)
20111 if (TREE_CODE (tmpl
) == OVERLOAD
)
20115 if (dependent_template_p (OVL_CURRENT (tmpl
)))
20117 tmpl
= OVL_NEXT (tmpl
);
20122 /* Template template parameters are dependent. */
20123 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
20124 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
20126 /* So are names that have not been looked up. */
20127 if (TREE_CODE (tmpl
) == SCOPE_REF
20128 || TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
20130 /* So are member templates of dependent classes. */
20131 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
20132 return dependent_type_p (DECL_CONTEXT (tmpl
));
20136 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
20139 dependent_template_id_p (tree tmpl
, tree args
)
20141 return (dependent_template_p (tmpl
)
20142 || any_dependent_template_arguments_p (args
));
20145 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
20149 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
20153 if (!processing_template_decl
)
20156 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
20158 tree decl
= TREE_VEC_ELT (declv
, i
);
20159 tree init
= TREE_VEC_ELT (initv
, i
);
20160 tree cond
= TREE_VEC_ELT (condv
, i
);
20161 tree incr
= TREE_VEC_ELT (incrv
, i
);
20163 if (type_dependent_expression_p (decl
))
20166 if (init
&& type_dependent_expression_p (init
))
20169 if (type_dependent_expression_p (cond
))
20172 if (COMPARISON_CLASS_P (cond
)
20173 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
20174 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
20177 if (TREE_CODE (incr
) == MODOP_EXPR
)
20179 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
20180 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
20183 else if (type_dependent_expression_p (incr
))
20185 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
20187 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
20189 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
20191 tree t
= TREE_OPERAND (incr
, 1);
20192 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
20193 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
20202 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
20203 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
20204 no such TYPE can be found. Note that this function peers inside
20205 uninstantiated templates and therefore should be used only in
20206 extremely limited situations. ONLY_CURRENT_P restricts this
20207 peering to the currently open classes hierarchy (which is required
20208 when comparing types). */
20211 resolve_typename_type (tree type
, bool only_current_p
)
20220 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
20222 scope
= TYPE_CONTEXT (type
);
20223 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
20224 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
20225 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
20226 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
20227 identifier of the TYPENAME_TYPE anymore.
20228 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
20229 TYPENAME_TYPE instead, we avoid messing up with a possible
20230 typedef variant case. */
20231 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
20233 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
20234 it first before we can figure out what NAME refers to. */
20235 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
20237 if (TYPENAME_IS_RESOLVING_P (scope
))
20238 /* Given a class template A with a dependent base with nested type C,
20239 typedef typename A::C::C C will land us here, as trying to resolve
20240 the initial A::C leads to the local C typedef, which leads back to
20241 A::C::C. So we break the recursion now. */
20244 scope
= resolve_typename_type (scope
, only_current_p
);
20246 /* If we don't know what SCOPE refers to, then we cannot resolve the
20248 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
20250 /* If the SCOPE is a template type parameter, we have no way of
20251 resolving the name. */
20252 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
20254 /* If the SCOPE is not the current instantiation, there's no reason
20255 to look inside it. */
20256 if (only_current_p
&& !currently_open_class (scope
))
20258 /* If this is a typedef, we don't want to look inside (c++/11987). */
20259 if (typedef_variant_p (type
))
20261 /* If SCOPE isn't the template itself, it will not have a valid
20262 TYPE_FIELDS list. */
20263 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
20264 /* scope is either the template itself or a compatible instantiation
20265 like X<T>, so look up the name in the original template. */
20266 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
20268 /* scope is a partial instantiation, so we can't do the lookup or we
20269 will lose the template arguments. */
20271 /* Enter the SCOPE so that name lookup will be resolved as if we
20272 were in the class definition. In particular, SCOPE will no
20273 longer be considered a dependent type. */
20274 pushed_scope
= push_scope (scope
);
20275 /* Look up the declaration. */
20276 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
20277 tf_warning_or_error
);
20279 result
= NULL_TREE
;
20281 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
20282 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
20285 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == IDENTIFIER_NODE
20286 && TREE_CODE (decl
) == TYPE_DECL
)
20288 result
= TREE_TYPE (decl
);
20289 if (result
== error_mark_node
)
20290 result
= NULL_TREE
;
20292 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
20293 && DECL_CLASS_TEMPLATE_P (decl
))
20297 /* Obtain the template and the arguments. */
20298 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
20299 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
20300 /* Instantiate the template. */
20301 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
20302 /*entering_scope=*/0,
20303 tf_error
| tf_user
);
20304 if (result
== error_mark_node
)
20305 result
= NULL_TREE
;
20308 /* Leave the SCOPE. */
20310 pop_scope (pushed_scope
);
20312 /* If we failed to resolve it, return the original typename. */
20316 /* If lookup found a typename type, resolve that too. */
20317 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
20319 /* Ill-formed programs can cause infinite recursion here, so we
20320 must catch that. */
20321 TYPENAME_IS_RESOLVING_P (type
) = 1;
20322 result
= resolve_typename_type (result
, only_current_p
);
20323 TYPENAME_IS_RESOLVING_P (type
) = 0;
20326 /* Qualify the resulting type. */
20327 quals
= cp_type_quals (type
);
20329 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
20334 /* EXPR is an expression which is not type-dependent. Return a proxy
20335 for EXPR that can be used to compute the types of larger
20336 expressions containing EXPR. */
20339 build_non_dependent_expr (tree expr
)
20343 #ifdef ENABLE_CHECKING
20344 /* Try to get a constant value for all non-type-dependent expressions in
20345 order to expose bugs in *_dependent_expression_p and constexpr. */
20346 if (cxx_dialect
>= cxx0x
)
20347 maybe_constant_value (fold_non_dependent_expr_sfinae (expr
, tf_none
));
20350 /* Preserve OVERLOADs; the functions must be available to resolve
20353 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
20354 inner_expr
= stmt_expr_value_expr (inner_expr
);
20355 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
20356 inner_expr
= TREE_OPERAND (inner_expr
, 0);
20357 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
20358 inner_expr
= TREE_OPERAND (inner_expr
, 1);
20359 if (is_overloaded_fn (inner_expr
)
20360 || TREE_CODE (inner_expr
) == OFFSET_REF
)
20362 /* There is no need to return a proxy for a variable. */
20363 if (TREE_CODE (expr
) == VAR_DECL
)
20365 /* Preserve string constants; conversions from string constants to
20366 "char *" are allowed, even though normally a "const char *"
20367 cannot be used to initialize a "char *". */
20368 if (TREE_CODE (expr
) == STRING_CST
)
20370 /* Preserve arithmetic constants, as an optimization -- there is no
20371 reason to create a new node. */
20372 if (TREE_CODE (expr
) == INTEGER_CST
|| TREE_CODE (expr
) == REAL_CST
)
20374 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
20375 There is at least one place where we want to know that a
20376 particular expression is a throw-expression: when checking a ?:
20377 expression, there are special rules if the second or third
20378 argument is a throw-expression. */
20379 if (TREE_CODE (expr
) == THROW_EXPR
)
20382 /* Don't wrap an initializer list, we need to be able to look inside. */
20383 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
20386 /* Don't wrap a dummy object, we need to be able to test for it. */
20387 if (is_dummy_object (expr
))
20390 if (TREE_CODE (expr
) == COND_EXPR
)
20391 return build3 (COND_EXPR
,
20393 TREE_OPERAND (expr
, 0),
20394 (TREE_OPERAND (expr
, 1)
20395 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
20396 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
20397 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
20398 if (TREE_CODE (expr
) == COMPOUND_EXPR
20399 && !COMPOUND_EXPR_OVERLOADED (expr
))
20400 return build2 (COMPOUND_EXPR
,
20402 TREE_OPERAND (expr
, 0),
20403 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
20405 /* If the type is unknown, it can't really be non-dependent */
20406 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
20408 /* Otherwise, build a NON_DEPENDENT_EXPR. */
20409 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
20412 /* ARGS is a vector of expressions as arguments to a function call.
20413 Replace the arguments with equivalent non-dependent expressions.
20414 This modifies ARGS in place. */
20417 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
20422 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
20424 tree newarg
= build_non_dependent_expr (arg
);
20426 (*args
)[ix
] = newarg
;
20430 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
20431 with a level one deeper than the actual template parms. */
20436 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
20437 TYPE_NAME (au
) = build_decl (BUILTINS_LOCATION
,
20438 TYPE_DECL
, get_identifier ("auto"), au
);
20439 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
20440 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
20441 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
20442 TYPE_NAME (au
), NULL_TREE
);
20443 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
20444 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
20445 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
20450 /* Given type ARG, return std::initializer_list<ARG>. */
20455 tree std_init_list
= namespace_binding
20456 (get_identifier ("initializer_list"), std_node
);
20458 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
20460 error ("deducing from brace-enclosed initializer list requires "
20461 "#include <initializer_list>");
20462 return error_mark_node
;
20464 argvec
= make_tree_vec (1);
20465 TREE_VEC_ELT (argvec
, 0) = arg
;
20466 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
20467 NULL_TREE
, 0, tf_warning_or_error
);
20470 /* Replace auto in TYPE with std::initializer_list<auto>. */
20473 listify_autos (tree type
, tree auto_node
)
20475 tree init_auto
= listify (auto_node
);
20476 tree argvec
= make_tree_vec (1);
20477 TREE_VEC_ELT (argvec
, 0) = init_auto
;
20478 if (processing_template_decl
)
20479 argvec
= add_to_template_args (current_template_args (), argvec
);
20480 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
20483 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
20484 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
20487 do_auto_deduction (tree type
, tree init
, tree auto_node
)
20489 tree parms
, tparms
, targs
;
20493 if (init
== error_mark_node
)
20494 return error_mark_node
;
20496 if (type_dependent_expression_p (init
))
20497 /* Defining a subset of type-dependent expressions that we can deduce
20498 from ahead of time isn't worth the trouble. */
20501 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
20502 with either a new invented type template parameter U or, if the
20503 initializer is a braced-init-list (8.5.4), with
20504 std::initializer_list<U>. */
20505 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
20506 type
= listify_autos (type
, auto_node
);
20508 init
= resolve_nondeduced_context (init
);
20510 parms
= build_tree_list (NULL_TREE
, type
);
20512 tparms
= make_tree_vec (1);
20513 targs
= make_tree_vec (1);
20514 TREE_VEC_ELT (tparms
, 0)
20515 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
20516 val
= type_unification_real (tparms
, targs
, parms
, args
, 1, 0,
20517 DEDUCE_CALL
, LOOKUP_NORMAL
,
20518 /*explain_p=*/false);
20521 if (processing_template_decl
)
20522 /* Try again at instantiation time. */
20524 if (type
&& type
!= error_mark_node
)
20525 /* If type is error_mark_node a diagnostic must have been
20526 emitted by now. Also, having a mention to '<type error>'
20527 in the diagnostic is not really useful to the user. */
20529 if (cfun
&& auto_node
== current_function_auto_return_pattern
20530 && LAMBDA_FUNCTION_P (current_function_decl
))
20531 error ("unable to deduce lambda return type from %qE", init
);
20533 error ("unable to deduce %qT from %qE", type
, init
);
20535 return error_mark_node
;
20538 /* If the list of declarators contains more than one declarator, the type
20539 of each declared variable is determined as described above. If the
20540 type deduced for the template parameter U is not the same in each
20541 deduction, the program is ill-formed. */
20542 if (TREE_TYPE (auto_node
)
20543 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
20545 if (cfun
&& auto_node
== current_function_auto_return_pattern
20546 && LAMBDA_FUNCTION_P (current_function_decl
))
20547 error ("inconsistent types %qT and %qT deduced for "
20548 "lambda return type", TREE_TYPE (auto_node
),
20549 TREE_VEC_ELT (targs
, 0));
20551 error ("inconsistent deduction for %qT: %qT and then %qT",
20552 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
20553 return error_mark_node
;
20555 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
20557 if (processing_template_decl
)
20558 targs
= add_to_template_args (current_template_args (), targs
);
20559 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
20562 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
20566 splice_late_return_type (tree type
, tree late_return_type
)
20570 if (late_return_type
== NULL_TREE
)
20572 argvec
= make_tree_vec (1);
20573 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
20574 if (processing_template_parmlist
)
20575 /* For a late-specified return type in a template type-parameter, we
20576 need to add a dummy argument level for its parmlist. */
20577 argvec
= add_to_template_args
20578 (make_tree_vec (processing_template_parmlist
), argvec
);
20579 if (current_template_parms
)
20580 argvec
= add_to_template_args (current_template_args (), argvec
);
20581 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
20584 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
20587 is_auto (const_tree type
)
20589 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20590 && TYPE_IDENTIFIER (type
) == get_identifier ("auto"))
20596 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
20597 appear as a type-specifier for the declaration in question, we don't
20598 have to look through the whole type. */
20601 type_uses_auto (tree type
)
20603 enum tree_code code
;
20604 if (is_auto (type
))
20607 code
= TREE_CODE (type
);
20609 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
20610 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
20611 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
20612 return type_uses_auto (TREE_TYPE (type
));
20614 if (TYPE_PTRMEMFUNC_P (type
))
20615 return type_uses_auto (TREE_TYPE (TREE_TYPE
20616 (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
20621 /* For a given template T, return the vector of typedefs referenced
20622 in T for which access check is needed at T instantiation time.
20623 T is either a FUNCTION_DECL or a RECORD_TYPE.
20624 Those typedefs were added to T by the function
20625 append_type_to_template_for_access_check. */
20627 vec
<qualified_typedef_usage_t
, va_gc
> *
20628 get_types_needing_access_check (tree t
)
20631 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
20633 if (!t
|| t
== error_mark_node
)
20636 if (!(ti
= get_template_info (t
)))
20639 if (CLASS_TYPE_P (t
)
20640 || TREE_CODE (t
) == FUNCTION_DECL
)
20642 if (!TI_TEMPLATE (ti
))
20645 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
20651 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
20652 tied to T. That list of typedefs will be access checked at
20653 T instantiation time.
20654 T is either a FUNCTION_DECL or a RECORD_TYPE.
20655 TYPE_DECL is a TYPE_DECL node representing a typedef.
20656 SCOPE is the scope through which TYPE_DECL is accessed.
20657 LOCATION is the location of the usage point of TYPE_DECL.
20659 This function is a subroutine of
20660 append_type_to_template_for_access_check. */
20663 append_type_to_template_for_access_check_1 (tree t
,
20666 location_t location
)
20668 qualified_typedef_usage_t typedef_usage
;
20671 if (!t
|| t
== error_mark_node
)
20674 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
20675 || CLASS_TYPE_P (t
))
20677 && TREE_CODE (type_decl
) == TYPE_DECL
20680 if (!(ti
= get_template_info (t
)))
20683 gcc_assert (TI_TEMPLATE (ti
));
20685 typedef_usage
.typedef_decl
= type_decl
;
20686 typedef_usage
.context
= scope
;
20687 typedef_usage
.locus
= location
;
20689 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
20692 /* Append TYPE_DECL to the template TEMPL.
20693 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
20694 At TEMPL instanciation time, TYPE_DECL will be checked to see
20695 if it can be accessed through SCOPE.
20696 LOCATION is the location of the usage point of TYPE_DECL.
20698 e.g. consider the following code snippet:
20705 template<class U> struct S
20707 C::myint mi; // <-- usage point of the typedef C::myint
20712 At S<char> instantiation time, we need to check the access of C::myint
20713 In other words, we need to check the access of the myint typedef through
20714 the C scope. For that purpose, this function will add the myint typedef
20715 and the scope C through which its being accessed to a list of typedefs
20716 tied to the template S. That list will be walked at template instantiation
20717 time and access check performed on each typedefs it contains.
20718 Note that this particular code snippet should yield an error because
20719 myint is private to C. */
20722 append_type_to_template_for_access_check (tree templ
,
20725 location_t location
)
20727 qualified_typedef_usage_t
*iter
;
20730 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
20732 /* Make sure we don't append the type to the template twice. */
20733 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
20734 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
20737 append_type_to_template_for_access_check_1 (templ
, type_decl
,
20741 /* Set up the hash tables for template instantiations. */
20744 init_template_processing (void)
20746 decl_specializations
= htab_create_ggc (37,
20747 hash_specialization
,
20748 eq_specializations
,
20750 type_specializations
= htab_create_ggc (37,
20751 hash_specialization
,
20752 eq_specializations
,
20756 /* Print stats about the template hash tables for -fstats. */
20759 print_template_statistics (void)
20761 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
20762 "%f collisions\n", (long) htab_size (decl_specializations
),
20763 (long) htab_elements (decl_specializations
),
20764 htab_collisions (decl_specializations
));
20765 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
20766 "%f collisions\n", (long) htab_size (type_specializations
),
20767 (long) htab_elements (type_specializations
),
20768 htab_collisions (type_specializations
));
20771 #include "gt-cp-pt.h"