1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2015 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"
34 #include "double-int.h"
41 #include "stringpool.h"
44 #include "stor-layout.h"
48 #include "c-family/c-common.h"
49 #include "c-family/c-objc.h"
50 #include "cp-objcp-common.h"
51 #include "tree-inline.h"
55 #include "tree-iterator.h"
56 #include "type-utils.h"
59 /* The type of functions taking a tree, and some additional data, and
61 typedef int (*tree_fn_t
) (tree
, void*);
63 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
64 instantiations have been deferred, either because their definitions
65 were not yet available, or because we were putting off doing the work. */
66 struct GTY ((chain_next ("%h.next"))) pending_template
{
67 struct pending_template
*next
;
68 struct tinst_level
*tinst
;
71 static GTY(()) struct pending_template
*pending_templates
;
72 static GTY(()) struct pending_template
*last_pending_template
;
74 int processing_template_parmlist
;
75 static int template_header_count
;
77 static GTY(()) tree saved_trees
;
78 static vec
<int> inline_parm_levels
;
80 static GTY(()) struct tinst_level
*current_tinst_level
;
82 static GTY(()) tree saved_access_scope
;
84 /* Live only within one (recursive) call to tsubst_expr. We use
85 this to pass the statement expression node from the STMT_EXPR
86 to the EXPR_STMT that is its result. */
87 static tree cur_stmt_expr
;
89 /* True if we've recursed into fn_type_unification too many times. */
90 static bool excessive_deduction_depth
;
92 struct GTY((for_user
)) spec_entry
99 struct spec_hasher
: ggc_hasher
<spec_entry
*>
101 static hashval_t
hash (spec_entry
*);
102 static bool equal (spec_entry
*, spec_entry
*);
105 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
107 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
109 /* Contains canonical template parameter types. The vector is indexed by
110 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
111 TREE_LIST, whose TREE_VALUEs contain the canonical template
112 parameters of various types and levels. */
113 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
115 #define UNIFY_ALLOW_NONE 0
116 #define UNIFY_ALLOW_MORE_CV_QUAL 1
117 #define UNIFY_ALLOW_LESS_CV_QUAL 2
118 #define UNIFY_ALLOW_DERIVED 4
119 #define UNIFY_ALLOW_INTEGER 8
120 #define UNIFY_ALLOW_OUTER_LEVEL 16
121 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
122 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
124 enum template_base_result
{
126 tbr_ambiguous_baseclass
,
130 static void push_access_scope (tree
);
131 static void pop_access_scope (tree
);
132 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
133 unification_kind_t
, int,
135 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
136 unification_kind_t
, int, bool, bool);
137 static int unify (tree
, tree
, tree
, tree
, int, bool);
138 static void add_pending_template (tree
);
139 static tree
reopen_tinst_level (struct tinst_level
*);
140 static tree
tsubst_initializer_list (tree
, tree
);
141 static tree
get_partial_spec_bindings (tree
, tree
, tree
, tree
);
142 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
144 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
146 static void tsubst_enum (tree
, tree
, tree
);
147 static tree
add_to_template_args (tree
, tree
);
148 static tree
add_outermost_template_args (tree
, tree
);
149 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
150 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
152 static int type_unification_real (tree
, tree
, tree
, const tree
*,
153 unsigned int, int, unification_kind_t
, int,
154 vec
<deferred_access_check
, va_gc
> **,
156 static void note_template_header (int);
157 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
158 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
159 static tree
convert_template_argument (tree
, tree
, tree
,
160 tsubst_flags_t
, int, tree
);
161 static int for_each_template_parm (tree
, tree_fn_t
, void*,
162 hash_set
<tree
> *, bool);
163 static tree
expand_template_argument_pack (tree
);
164 static tree
build_template_parm_index (int, int, int, tree
, tree
);
165 static bool inline_needs_template_parms (tree
, bool);
166 static void push_inline_template_parms_recursive (tree
, int);
167 static tree
retrieve_local_specialization (tree
);
168 static void register_local_specialization (tree
, tree
);
169 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
170 static int mark_template_parm (tree
, void *);
171 static int template_parm_this_level_p (tree
, void *);
172 static tree
tsubst_friend_function (tree
, tree
);
173 static tree
tsubst_friend_class (tree
, tree
);
174 static int can_complete_type_without_circularity (tree
);
175 static tree
get_bindings (tree
, tree
, tree
, bool);
176 static int template_decl_level (tree
);
177 static int check_cv_quals_for_unify (int, tree
, tree
);
178 static void template_parm_level_and_index (tree
, int*, int*);
179 static int unify_pack_expansion (tree
, tree
, tree
,
180 tree
, unification_kind_t
, bool, bool);
181 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
182 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
183 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
184 static void regenerate_decl_from_template (tree
, tree
);
185 static tree
most_specialized_partial_spec (tree
, tsubst_flags_t
);
186 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
187 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
188 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
189 static bool check_specialization_scope (void);
190 static tree
process_partial_specialization (tree
);
191 static void set_current_access_from_decl (tree
);
192 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
194 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
195 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
197 static bool template_template_parm_bindings_ok_p (tree
, tree
);
198 static int template_args_equal (tree
, tree
);
199 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
200 static tree
for_each_template_parm_r (tree
*, int *, void *);
201 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
202 static void copy_default_args_to_explicit_spec (tree
);
203 static int invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
204 static bool dependent_template_arg_p (tree
);
205 static bool any_template_arguments_need_structural_equality_p (tree
);
206 static bool dependent_type_p_r (tree
);
207 static tree
tsubst_expr (tree
, tree
, tsubst_flags_t
, tree
, bool);
208 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
209 static tree
tsubst_pack_expansion (tree
, tree
, tsubst_flags_t
, tree
);
210 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
211 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
212 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
214 static tree
listify (tree
);
215 static tree
listify_autos (tree
, tree
);
216 static tree
template_parm_to_arg (tree t
);
217 static tree
current_template_args (void);
218 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
219 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
221 /* Make the current scope suitable for access checking when we are
222 processing T. T can be FUNCTION_DECL for instantiated function
223 template, VAR_DECL for static member variable, or TYPE_DECL for
224 alias template (needed by instantiate_decl). */
227 push_access_scope (tree t
)
229 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
230 || TREE_CODE (t
) == TYPE_DECL
);
232 if (DECL_FRIEND_CONTEXT (t
))
233 push_nested_class (DECL_FRIEND_CONTEXT (t
));
234 else if (DECL_CLASS_SCOPE_P (t
))
235 push_nested_class (DECL_CONTEXT (t
));
237 push_to_top_level ();
239 if (TREE_CODE (t
) == FUNCTION_DECL
)
241 saved_access_scope
= tree_cons
242 (NULL_TREE
, current_function_decl
, saved_access_scope
);
243 current_function_decl
= t
;
247 /* Restore the scope set up by push_access_scope. T is the node we
251 pop_access_scope (tree t
)
253 if (TREE_CODE (t
) == FUNCTION_DECL
)
255 current_function_decl
= TREE_VALUE (saved_access_scope
);
256 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
259 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
262 pop_from_top_level ();
265 /* Do any processing required when DECL (a member template
266 declaration) is finished. Returns the TEMPLATE_DECL corresponding
267 to DECL, unless it is a specialization, in which case the DECL
268 itself is returned. */
271 finish_member_template_decl (tree decl
)
273 if (decl
== error_mark_node
)
274 return error_mark_node
;
276 gcc_assert (DECL_P (decl
));
278 if (TREE_CODE (decl
) == TYPE_DECL
)
282 type
= TREE_TYPE (decl
);
283 if (type
== error_mark_node
)
284 return error_mark_node
;
285 if (MAYBE_CLASS_TYPE_P (type
)
286 && CLASSTYPE_TEMPLATE_INFO (type
)
287 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
289 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
290 check_member_template (tmpl
);
295 else if (TREE_CODE (decl
) == FIELD_DECL
)
296 error ("data member %qD cannot be a member template", decl
);
297 else if (DECL_TEMPLATE_INFO (decl
))
299 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
301 check_member_template (DECL_TI_TEMPLATE (decl
));
302 return DECL_TI_TEMPLATE (decl
);
308 error ("invalid member template declaration %qD", decl
);
310 return error_mark_node
;
313 /* Create a template info node. */
316 build_template_info (tree template_decl
, tree template_args
)
318 tree result
= make_node (TEMPLATE_INFO
);
319 TI_TEMPLATE (result
) = template_decl
;
320 TI_ARGS (result
) = template_args
;
324 /* Return the template info node corresponding to T, whatever T is. */
327 get_template_info (const_tree t
)
329 tree tinfo
= NULL_TREE
;
331 if (!t
|| t
== error_mark_node
)
334 if (TREE_CODE (t
) == NAMESPACE_DECL
)
337 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
338 tinfo
= DECL_TEMPLATE_INFO (t
);
340 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
343 if (OVERLOAD_TYPE_P (t
))
344 tinfo
= TYPE_TEMPLATE_INFO (t
);
345 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
346 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
351 /* Returns the template nesting level of the indicated class TYPE.
361 A<T>::B<U> has depth two, while A<T> has depth one.
362 Both A<T>::B<int> and A<int>::B<U> have depth one, if
363 they are instantiations, not specializations.
365 This function is guaranteed to return 0 if passed NULL_TREE so
366 that, for example, `template_class_depth (current_class_type)' is
370 template_class_depth (tree type
)
375 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
376 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
377 ? CP_DECL_CONTEXT (type
) : CP_TYPE_CONTEXT (type
))
379 tree tinfo
= get_template_info (type
);
381 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
382 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
389 /* Subroutine of maybe_begin_member_template_processing.
390 Returns true if processing DECL needs us to push template parms. */
393 inline_needs_template_parms (tree decl
, bool nsdmi
)
395 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
398 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
399 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
402 /* Subroutine of maybe_begin_member_template_processing.
403 Push the template parms in PARMS, starting from LEVELS steps into the
404 chain, and ending at the beginning, since template parms are listed
408 push_inline_template_parms_recursive (tree parmlist
, int levels
)
410 tree parms
= TREE_VALUE (parmlist
);
414 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
416 ++processing_template_decl
;
417 current_template_parms
418 = tree_cons (size_int (processing_template_decl
),
419 parms
, current_template_parms
);
420 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
422 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
424 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
426 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
428 if (error_operand_p (parm
))
431 gcc_assert (DECL_P (parm
));
433 switch (TREE_CODE (parm
))
442 /* Make a CONST_DECL as is done in process_template_parm.
443 It is ugly that we recreate this here; the original
444 version built in process_template_parm is no longer
446 tree decl
= build_decl (DECL_SOURCE_LOCATION (parm
),
447 CONST_DECL
, DECL_NAME (parm
),
449 DECL_ARTIFICIAL (decl
) = 1;
450 TREE_CONSTANT (decl
) = 1;
451 TREE_READONLY (decl
) = 1;
452 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
453 SET_DECL_TEMPLATE_PARM_P (decl
);
464 /* Restore the template parameter context for a member template, a
465 friend template defined in a class definition, or a non-template
466 member of template class. */
469 maybe_begin_member_template_processing (tree decl
)
473 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
477 tree ctx
= DECL_CONTEXT (decl
);
478 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
479 /* Disregard full specializations (c++/60999). */
480 && uses_template_parms (ctx
)
481 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
484 if (inline_needs_template_parms (decl
, nsdmi
))
486 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
487 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
489 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
492 parms
= TREE_CHAIN (parms
);
495 push_inline_template_parms_recursive (parms
, levels
);
498 /* Remember how many levels of template parameters we pushed so that
499 we can pop them later. */
500 inline_parm_levels
.safe_push (levels
);
503 /* Undo the effects of maybe_begin_member_template_processing. */
506 maybe_end_member_template_processing (void)
511 if (inline_parm_levels
.length () == 0)
514 last
= inline_parm_levels
.pop ();
515 for (i
= 0; i
< last
; ++i
)
517 --processing_template_decl
;
518 current_template_parms
= TREE_CHAIN (current_template_parms
);
523 /* Return a new template argument vector which contains all of ARGS,
524 but has as its innermost set of arguments the EXTRA_ARGS. */
527 add_to_template_args (tree args
, tree extra_args
)
534 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
537 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
538 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
540 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
541 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
543 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
544 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
549 /* Like add_to_template_args, but only the outermost ARGS are added to
550 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
551 (EXTRA_ARGS) levels are added. This function is used to combine
552 the template arguments from a partial instantiation with the
553 template arguments used to attain the full instantiation from the
554 partial instantiation. */
557 add_outermost_template_args (tree args
, tree extra_args
)
561 /* If there are more levels of EXTRA_ARGS than there are ARGS,
562 something very fishy is going on. */
563 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
565 /* If *all* the new arguments will be the EXTRA_ARGS, just return
567 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
570 /* For the moment, we make ARGS look like it contains fewer levels. */
571 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
573 new_args
= add_to_template_args (args
, extra_args
);
575 /* Now, we restore ARGS to its full dimensions. */
576 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
581 /* Return the N levels of innermost template arguments from the ARGS. */
584 get_innermost_template_args (tree args
, int n
)
592 /* If N is 1, just return the innermost set of template arguments. */
594 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
596 /* If we're not removing anything, just return the arguments we were
598 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
599 gcc_assert (extra_levels
>= 0);
600 if (extra_levels
== 0)
603 /* Make a new set of arguments, not containing the outer arguments. */
604 new_args
= make_tree_vec (n
);
605 for (i
= 1; i
<= n
; ++i
)
606 SET_TMPL_ARGS_LEVEL (new_args
, i
,
607 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
612 /* The inverse of get_innermost_template_args: Return all but the innermost
613 EXTRA_LEVELS levels of template arguments from the ARGS. */
616 strip_innermost_template_args (tree args
, int extra_levels
)
619 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
624 /* If N is 1, just return the outermost set of template arguments. */
626 return TMPL_ARGS_LEVEL (args
, 1);
628 /* If we're not removing anything, just return the arguments we were
630 gcc_assert (extra_levels
>= 0);
631 if (extra_levels
== 0)
634 /* Make a new set of arguments, not containing the inner arguments. */
635 new_args
= make_tree_vec (n
);
636 for (i
= 1; i
<= n
; ++i
)
637 SET_TMPL_ARGS_LEVEL (new_args
, i
,
638 TMPL_ARGS_LEVEL (args
, i
));
643 /* We've got a template header coming up; push to a new level for storing
647 begin_template_parm_list (void)
649 /* We use a non-tag-transparent scope here, which causes pushtag to
650 put tags in this scope, rather than in the enclosing class or
651 namespace scope. This is the right thing, since we want
652 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
653 global template class, push_template_decl handles putting the
654 TEMPLATE_DECL into top-level scope. For a nested template class,
657 template <class T> struct S1 {
658 template <class T> struct S2 {};
661 pushtag contains special code to call pushdecl_with_scope on the
662 TEMPLATE_DECL for S2. */
663 begin_scope (sk_template_parms
, NULL
);
664 ++processing_template_decl
;
665 ++processing_template_parmlist
;
666 note_template_header (0);
669 /* This routine is called when a specialization is declared. If it is
670 invalid to declare a specialization here, an error is reported and
671 false is returned, otherwise this routine will return true. */
674 check_specialization_scope (void)
676 tree scope
= current_scope ();
680 An explicit specialization shall be declared in the namespace of
681 which the template is a member, or, for member templates, in the
682 namespace of which the enclosing class or enclosing class
683 template is a member. An explicit specialization of a member
684 function, member class or static data member of a class template
685 shall be declared in the namespace of which the class template
687 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
689 error ("explicit specialization in non-namespace scope %qD", scope
);
695 In an explicit specialization declaration for a member of a class
696 template or a member template that appears in namespace scope,
697 the member template and some of its enclosing class templates may
698 remain unspecialized, except that the declaration shall not
699 explicitly specialize a class member template if its enclosing
700 class templates are not explicitly specialized as well. */
701 if (current_template_parms
)
703 error ("enclosing class templates are not explicitly specialized");
710 /* We've just seen template <>. */
713 begin_specialization (void)
715 begin_scope (sk_template_spec
, NULL
);
716 note_template_header (1);
717 return check_specialization_scope ();
720 /* Called at then end of processing a declaration preceded by
724 end_specialization (void)
727 reset_specialization ();
730 /* Any template <>'s that we have seen thus far are not referring to a
731 function specialization. */
734 reset_specialization (void)
736 processing_specialization
= 0;
737 template_header_count
= 0;
740 /* We've just seen a template header. If SPECIALIZATION is nonzero,
741 it was of the form template <>. */
744 note_template_header (int specialization
)
746 processing_specialization
= specialization
;
747 template_header_count
++;
750 /* We're beginning an explicit instantiation. */
753 begin_explicit_instantiation (void)
755 gcc_assert (!processing_explicit_instantiation
);
756 processing_explicit_instantiation
= true;
761 end_explicit_instantiation (void)
763 gcc_assert (processing_explicit_instantiation
);
764 processing_explicit_instantiation
= false;
767 /* An explicit specialization or partial specialization of TMPL is being
768 declared. Check that the namespace in which the specialization is
769 occurring is permissible. Returns false iff it is invalid to
770 specialize TMPL in the current namespace. */
773 check_specialization_namespace (tree tmpl
)
775 tree tpl_ns
= decl_namespace_context (tmpl
);
779 An explicit specialization shall be declared in the namespace of
780 which the template is a member, or, for member templates, in the
781 namespace of which the enclosing class or enclosing class
782 template is a member. An explicit specialization of a member
783 function, member class or static data member of a class template
784 shall be declared in the namespace of which the class template is
786 if (current_scope() != DECL_CONTEXT (tmpl
)
787 && !at_namespace_scope_p ())
789 error ("specialization of %qD must appear at namespace scope", tmpl
);
792 if (is_associated_namespace (current_namespace
, tpl_ns
))
793 /* Same or super-using namespace. */
797 permerror (input_location
, "specialization of %qD in different namespace", tmpl
);
798 permerror (input_location
, " from definition of %q+#D", tmpl
);
803 /* SPEC is an explicit instantiation. Check that it is valid to
804 perform this explicit instantiation in the current namespace. */
807 check_explicit_instantiation_namespace (tree spec
)
811 /* DR 275: An explicit instantiation shall appear in an enclosing
812 namespace of its template. */
813 ns
= decl_namespace_context (spec
);
814 if (!is_ancestor (current_namespace
, ns
))
815 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
816 "(which does not enclose namespace %qD)",
817 spec
, current_namespace
, ns
);
820 /* The TYPE is being declared. If it is a template type, that means it
821 is a partial specialization. Do appropriate error-checking. */
824 maybe_process_partial_specialization (tree type
)
828 if (type
== error_mark_node
)
829 return error_mark_node
;
831 /* A lambda that appears in specialization context is not itself a
833 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
836 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
838 error ("name of class shadows template template parameter %qD",
840 return error_mark_node
;
843 context
= TYPE_CONTEXT (type
);
845 if (TYPE_ALIAS_P (type
))
847 if (TYPE_TEMPLATE_INFO (type
)
848 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type
)))
849 error ("specialization of alias template %qD",
850 TYPE_TI_TEMPLATE (type
));
852 error ("explicit specialization of non-template %qT", type
);
853 return error_mark_node
;
855 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
857 /* This is for ordinary explicit specialization and partial
858 specialization of a template class such as:
860 template <> class C<int>;
864 template <class T> class C<T*>;
866 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
868 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
869 && !COMPLETE_TYPE_P (type
))
871 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type
))
872 && !at_namespace_scope_p ())
873 return error_mark_node
;
874 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
875 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
876 if (processing_template_decl
)
878 if (push_template_decl (TYPE_MAIN_DECL (type
))
880 return error_mark_node
;
883 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
884 error ("specialization of %qT after instantiation", type
);
885 else if (errorcount
&& !processing_specialization
886 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
887 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
888 /* Trying to define a specialization either without a template<> header
889 or in an inappropriate place. We've already given an error, so just
890 bail now so we don't actually define the specialization. */
891 return error_mark_node
;
893 else if (CLASS_TYPE_P (type
)
894 && !CLASSTYPE_USE_TEMPLATE (type
)
895 && CLASSTYPE_TEMPLATE_INFO (type
)
896 && context
&& CLASS_TYPE_P (context
)
897 && CLASSTYPE_TEMPLATE_INFO (context
))
899 /* This is for an explicit specialization of member class
900 template according to [temp.expl.spec/18]:
902 template <> template <class U> class C<int>::D;
904 The context `C<int>' must be an implicit instantiation.
905 Otherwise this is just a member class template declared
908 template <> class C<int> { template <class U> class D; };
909 template <> template <class U> class C<int>::D;
911 In the first case, `C<int>::D' is a specialization of `C<T>::D'
912 while in the second case, `C<int>::D' is a primary template
913 and `C<T>::D' may not exist. */
915 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
916 && !COMPLETE_TYPE_P (type
))
919 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
921 if (current_namespace
922 != decl_namespace_context (tmpl
))
924 permerror (input_location
, "specializing %q#T in different namespace", type
);
925 permerror (input_location
, " from definition of %q+#D", tmpl
);
928 /* Check for invalid specialization after instantiation:
930 template <> template <> class C<int>::D<int>;
931 template <> template <class U> class C<int>::D; */
933 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
934 t
; t
= TREE_CHAIN (t
))
936 tree inst
= TREE_VALUE (t
);
937 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
938 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
940 /* We already have a full specialization of this partial
941 instantiation, or a full specialization has been
942 looked up but not instantiated. Reassign it to the
943 new member specialization template. */
947 elt
.tmpl
= most_general_template (tmpl
);
948 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
951 type_specializations
->remove_elt (&elt
);
954 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
957 = type_specializations
->find_slot (&elt
, INSERT
);
958 entry
= ggc_alloc
<spec_entry
> ();
963 /* But if we've had an implicit instantiation, that's a
964 problem ([temp.expl.spec]/6). */
965 error ("specialization %qT after instantiation %qT",
969 /* Mark TYPE as a specialization. And as a result, we only
970 have one level of template argument for the innermost
972 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
973 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
974 CLASSTYPE_TI_ARGS (type
)
975 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
978 else if (processing_specialization
)
980 /* Someday C++0x may allow for enum template specialization. */
981 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
982 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
983 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
984 "of %qD not allowed by ISO C++", type
);
987 error ("explicit specialization of non-template %qT", type
);
988 return error_mark_node
;
995 /* Returns nonzero if we can optimize the retrieval of specializations
996 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
997 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1000 optimize_specialization_lookup_p (tree tmpl
)
1002 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
1003 && DECL_CLASS_SCOPE_P (tmpl
)
1004 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1006 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1007 /* The optimized lookup depends on the fact that the
1008 template arguments for the member function template apply
1009 purely to the containing class, which is not true if the
1010 containing class is an explicit or partial
1012 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1013 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1014 && !DECL_CONV_FN_P (tmpl
)
1015 /* It is possible to have a template that is not a member
1016 template and is not a member of a template class:
1018 template <typename T>
1019 struct S { friend A::f(); };
1021 Here, the friend function is a template, but the context does
1022 not have template information. The optimized lookup relies
1023 on having ARGS be the template arguments for both the class
1024 and the function template. */
1025 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1028 /* Retrieve the specialization (in the sense of [temp.spec] - a
1029 specialization is either an instantiation or an explicit
1030 specialization) of TMPL for the given template ARGS. If there is
1031 no such specialization, return NULL_TREE. The ARGS are a vector of
1032 arguments, or a vector of vectors of arguments, in the case of
1033 templates with more than one level of parameters.
1035 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1036 then we search for a partial specialization matching ARGS. This
1037 parameter is ignored if TMPL is not a class template.
1039 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1040 result is a NONTYPE_ARGUMENT_PACK. */
1043 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1045 if (tmpl
== NULL_TREE
)
1048 if (args
== error_mark_node
)
1051 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1052 || TREE_CODE (tmpl
) == FIELD_DECL
);
1054 /* There should be as many levels of arguments as there are
1055 levels of parameters. */
1056 gcc_assert (TMPL_ARGS_DEPTH (args
)
1057 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1058 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1059 : template_class_depth (DECL_CONTEXT (tmpl
))));
1061 if (optimize_specialization_lookup_p (tmpl
))
1063 tree class_template
;
1064 tree class_specialization
;
1065 vec
<tree
, va_gc
> *methods
;
1069 /* The template arguments actually apply to the containing
1070 class. Find the class specialization with those
1072 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1073 class_specialization
1074 = retrieve_specialization (class_template
, args
, 0);
1075 if (!class_specialization
)
1077 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1078 for the specialization. */
1079 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
1082 /* Iterate through the methods with the indicated name, looking
1083 for the one that has an instance of TMPL. */
1084 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
1085 for (fns
= (*methods
)[idx
]; fns
; fns
= OVL_NEXT (fns
))
1087 tree fn
= OVL_CURRENT (fns
);
1088 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1089 /* using-declarations can add base methods to the method vec,
1090 and we don't want those here. */
1091 && DECL_CONTEXT (fn
) == class_specialization
)
1100 hash_table
<spec_hasher
> *specializations
;
1104 elt
.spec
= NULL_TREE
;
1106 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1107 specializations
= type_specializations
;
1109 specializations
= decl_specializations
;
1112 hash
= spec_hasher::hash (&elt
);
1113 found
= specializations
->find_with_hash (&elt
, hash
);
1121 /* Like retrieve_specialization, but for local declarations. */
1124 retrieve_local_specialization (tree tmpl
)
1126 if (local_specializations
== NULL
)
1129 tree
*slot
= local_specializations
->get (tmpl
);
1130 return slot
? *slot
: NULL_TREE
;
1133 /* Returns nonzero iff DECL is a specialization of TMPL. */
1136 is_specialization_of (tree decl
, tree tmpl
)
1140 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1144 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1150 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1152 for (t
= TREE_TYPE (decl
);
1154 t
= CLASSTYPE_USE_TEMPLATE (t
)
1155 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1156 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1163 /* Returns nonzero iff DECL is a specialization of friend declaration
1164 FRIEND_DECL according to [temp.friend]. */
1167 is_specialization_of_friend (tree decl
, tree friend_decl
)
1169 bool need_template
= true;
1172 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1173 || TREE_CODE (decl
) == TYPE_DECL
);
1175 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1176 of a template class, we want to check if DECL is a specialization
1178 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1179 && DECL_TEMPLATE_INFO (friend_decl
)
1180 && !DECL_USE_TEMPLATE (friend_decl
))
1182 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1183 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1184 need_template
= false;
1186 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1187 && !PRIMARY_TEMPLATE_P (friend_decl
))
1188 need_template
= false;
1190 /* There is nothing to do if this is not a template friend. */
1191 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1194 if (is_specialization_of (decl
, friend_decl
))
1198 A member of a class template may be declared to be a friend of a
1199 non-template class. In this case, the corresponding member of
1200 every specialization of the class template is a friend of the
1201 class granting friendship.
1203 For example, given a template friend declaration
1205 template <class T> friend void A<T>::f();
1207 the member function below is considered a friend
1209 template <> struct A<int> {
1213 For this type of template friend, TEMPLATE_DEPTH below will be
1214 nonzero. To determine if DECL is a friend of FRIEND, we first
1215 check if the enclosing class is a specialization of another. */
1217 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1219 && DECL_CLASS_SCOPE_P (decl
)
1220 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1221 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1223 /* Next, we check the members themselves. In order to handle
1224 a few tricky cases, such as when FRIEND_DECL's are
1226 template <class T> friend void A<T>::g(T t);
1227 template <class T> template <T t> friend void A<T>::h();
1231 void A<int>::g(int);
1232 template <int> void A<int>::h();
1234 we need to figure out ARGS, the template arguments from
1235 the context of DECL. This is required for template substitution
1236 of `T' in the function parameter of `g' and template parameter
1237 of `h' in the above examples. Here ARGS corresponds to `int'. */
1239 tree context
= DECL_CONTEXT (decl
);
1240 tree args
= NULL_TREE
;
1241 int current_depth
= 0;
1243 while (current_depth
< template_depth
)
1245 if (CLASSTYPE_TEMPLATE_INFO (context
))
1247 if (current_depth
== 0)
1248 args
= TYPE_TI_ARGS (context
);
1250 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1253 context
= TYPE_CONTEXT (context
);
1256 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1261 tree friend_args_type
;
1262 tree decl_args_type
;
1264 /* Make sure that both DECL and FRIEND_DECL are templates or
1266 is_template
= DECL_TEMPLATE_INFO (decl
)
1267 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1268 if (need_template
^ is_template
)
1270 else if (is_template
)
1272 /* If both are templates, check template parameter list. */
1274 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1276 if (!comp_template_parms
1277 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1281 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1284 decl_type
= TREE_TYPE (decl
);
1286 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1287 tf_none
, NULL_TREE
);
1288 if (friend_type
== error_mark_node
)
1291 /* Check if return types match. */
1292 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1295 /* Check if function parameter types match, ignoring the
1296 `this' parameter. */
1297 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1298 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1299 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1300 friend_args_type
= TREE_CHAIN (friend_args_type
);
1301 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1302 decl_args_type
= TREE_CHAIN (decl_args_type
);
1304 return compparms (decl_args_type
, friend_args_type
);
1308 /* DECL is a TYPE_DECL */
1310 tree decl_type
= TREE_TYPE (decl
);
1312 /* Make sure that both DECL and FRIEND_DECL are templates or
1315 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1316 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1318 if (need_template
^ is_template
)
1320 else if (is_template
)
1323 /* If both are templates, check the name of the two
1324 TEMPLATE_DECL's first because is_friend didn't. */
1325 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1326 != DECL_NAME (friend_decl
))
1329 /* Now check template parameter list. */
1331 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1333 return comp_template_parms
1334 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1338 return (DECL_NAME (decl
)
1339 == DECL_NAME (friend_decl
));
1345 /* Register the specialization SPEC as a specialization of TMPL with
1346 the indicated ARGS. IS_FRIEND indicates whether the specialization
1347 is actually just a friend declaration. Returns SPEC, or an
1348 equivalent prior declaration, if available.
1350 We also store instantiations of field packs in the hash table, even
1351 though they are not themselves templates, to make lookup easier. */
1354 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1358 spec_entry
**slot
= NULL
;
1361 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1362 || (TREE_CODE (tmpl
) == FIELD_DECL
1363 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1365 if (TREE_CODE (spec
) == FUNCTION_DECL
1366 && uses_template_parms (DECL_TI_ARGS (spec
)))
1367 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1368 register it; we want the corresponding TEMPLATE_DECL instead.
1369 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1370 the more obvious `uses_template_parms (spec)' to avoid problems
1371 with default function arguments. In particular, given
1372 something like this:
1374 template <class T> void f(T t1, T t = T())
1376 the default argument expression is not substituted for in an
1377 instantiation unless and until it is actually needed. */
1380 if (optimize_specialization_lookup_p (tmpl
))
1381 /* We don't put these specializations in the hash table, but we might
1382 want to give an error about a mismatch. */
1383 fn
= retrieve_specialization (tmpl
, args
, 0);
1391 hash
= spec_hasher::hash (&elt
);
1394 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1396 fn
= ((spec_entry
*) *slot
)->spec
;
1401 /* We can sometimes try to re-register a specialization that we've
1402 already got. In particular, regenerate_decl_from_template calls
1403 duplicate_decls which will update the specialization list. But,
1404 we'll still get called again here anyhow. It's more convenient
1405 to simply allow this than to try to prevent it. */
1408 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1410 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1412 if (DECL_ODR_USED (fn
)
1413 || DECL_EXPLICIT_INSTANTIATION (fn
))
1415 error ("specialization of %qD after instantiation",
1417 return error_mark_node
;
1422 /* This situation should occur only if the first
1423 specialization is an implicit instantiation, the
1424 second is an explicit specialization, and the
1425 implicit instantiation has not yet been used. That
1426 situation can occur if we have implicitly
1427 instantiated a member function and then specialized
1430 We can also wind up here if a friend declaration that
1431 looked like an instantiation turns out to be a
1434 template <class T> void foo(T);
1435 class S { friend void foo<>(int) };
1436 template <> void foo(int);
1438 We transform the existing DECL in place so that any
1439 pointers to it become pointers to the updated
1442 If there was a definition for the template, but not
1443 for the specialization, we want this to look as if
1444 there were no definition, and vice versa. */
1445 DECL_INITIAL (fn
) = NULL_TREE
;
1446 duplicate_decls (spec
, fn
, is_friend
);
1447 /* The call to duplicate_decls will have applied
1450 An explicit specialization of a function template
1451 is inline only if it is explicitly declared to be,
1452 and independently of whether its function template
1455 to the primary function; now copy the inline bits to
1456 the various clones. */
1457 FOR_EACH_CLONE (clone
, fn
)
1459 DECL_DECLARED_INLINE_P (clone
)
1460 = DECL_DECLARED_INLINE_P (fn
);
1461 DECL_SOURCE_LOCATION (clone
)
1462 = DECL_SOURCE_LOCATION (fn
);
1463 DECL_DELETED_FN (clone
)
1464 = DECL_DELETED_FN (fn
);
1466 check_specialization_namespace (tmpl
);
1471 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1473 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1474 /* Dup decl failed, but this is a new definition. Set the
1475 line number so any errors match this new
1477 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1483 return duplicate_decls (spec
, fn
, is_friend
);
1485 /* A specialization must be declared in the same namespace as the
1486 template it is specializing. */
1487 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1488 && !check_specialization_namespace (tmpl
))
1489 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1491 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1493 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1494 gcc_assert (tmpl
&& args
&& spec
);
1497 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1498 && PRIMARY_TEMPLATE_P (tmpl
)
1499 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1500 || variable_template_p (tmpl
))
1501 /* If TMPL is a forward declaration of a template function, keep a list
1502 of all specializations in case we need to reassign them to a friend
1503 template later in tsubst_friend_function.
1505 Also keep a list of all variable template instantiations so that
1506 process_partial_specialization can check whether a later partial
1507 specialization would have used it. */
1508 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1509 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1515 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1516 TMPL and ARGS members, ignores SPEC. */
1518 int comparing_specializations
;
1521 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1525 ++comparing_specializations
;
1526 equal
= (e1
->tmpl
== e2
->tmpl
1527 && comp_template_args (e1
->args
, e2
->args
));
1528 --comparing_specializations
;
1533 /* Returns a hash for a template TMPL and template arguments ARGS. */
1536 hash_tmpl_and_args (tree tmpl
, tree args
)
1538 hashval_t val
= DECL_UID (tmpl
);
1539 return iterative_hash_template_arg (args
, val
);
1542 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1546 spec_hasher::hash (spec_entry
*e
)
1548 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1551 /* Recursively calculate a hash value for a template argument ARG, for use
1552 in the hash tables of template specializations. */
1555 iterative_hash_template_arg (tree arg
, hashval_t val
)
1557 unsigned HOST_WIDE_INT i
;
1558 enum tree_code code
;
1561 if (arg
== NULL_TREE
)
1562 return iterative_hash_object (arg
, val
);
1567 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1568 /* We can get one of these when re-hashing a previous entry in the middle
1569 of substituting into a pack expansion. Just look through it. */
1570 arg
= ARGUMENT_PACK_SELECT_FROM_PACK (arg
);
1572 code
= TREE_CODE (arg
);
1573 tclass
= TREE_CODE_CLASS (code
);
1575 val
= iterative_hash_object (code
, val
);
1582 case IDENTIFIER_NODE
:
1583 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1587 int i
, len
= TREE_VEC_LENGTH (arg
);
1588 for (i
= 0; i
< len
; ++i
)
1589 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1593 case TYPE_PACK_EXPANSION
:
1594 case EXPR_PACK_EXPANSION
:
1595 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1596 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1598 case TYPE_ARGUMENT_PACK
:
1599 case NONTYPE_ARGUMENT_PACK
:
1600 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1603 for (; arg
; arg
= TREE_CHAIN (arg
))
1604 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1608 for (; arg
; arg
= OVL_NEXT (arg
))
1609 val
= iterative_hash_template_arg (OVL_CURRENT (arg
), val
);
1615 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1616 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1618 val
= iterative_hash_template_arg (field
, val
);
1619 val
= iterative_hash_template_arg (value
, val
);
1625 if (!DECL_ARTIFICIAL (arg
))
1627 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1628 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1630 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1633 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1636 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1637 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1639 case TEMPLATE_PARM_INDEX
:
1640 val
= iterative_hash_template_arg
1641 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1642 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1643 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1646 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1647 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1648 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1651 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1653 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1657 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1658 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1659 val
= iterative_hash_object (code
, val
);
1660 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1663 /* A lambda can't appear in a template arg, but don't crash on
1665 gcc_assert (seen_error ());
1669 case IMPLICIT_CONV_EXPR
:
1670 case STATIC_CAST_EXPR
:
1671 case REINTERPRET_CAST_EXPR
:
1672 case CONST_CAST_EXPR
:
1673 case DYNAMIC_CAST_EXPR
:
1675 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1676 /* Now hash operands as usual. */
1686 if (alias_template_specialization_p (arg
))
1688 // We want an alias specialization that survived strip_typedefs
1689 // to hash differently from its TYPE_CANONICAL, to avoid hash
1690 // collisions that compare as different in template_args_equal.
1691 // These could be dependent specializations that strip_typedefs
1692 // left alone, or untouched specializations because
1693 // coerce_template_parms returns the unconverted template
1694 // arguments if it sees incomplete argument packs.
1695 tree ti
= TYPE_TEMPLATE_INFO (arg
);
1696 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1698 if (TYPE_CANONICAL (arg
))
1699 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1701 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1702 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1703 /* Otherwise just compare the types during lookup. */
1706 case tcc_declaration
:
1708 return iterative_hash_expr (arg
, val
);
1711 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1713 unsigned n
= cp_tree_operand_length (arg
);
1714 for (i
= 0; i
< n
; ++i
)
1715 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1723 /* Unregister the specialization SPEC as a specialization of TMPL.
1724 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1725 if the SPEC was listed as a specialization of TMPL.
1727 Note that SPEC has been ggc_freed, so we can't look inside it. */
1730 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1735 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1736 elt
.args
= TI_ARGS (tinfo
);
1737 elt
.spec
= NULL_TREE
;
1739 entry
= decl_specializations
->find (&elt
);
1742 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1743 gcc_assert (new_spec
!= NULL_TREE
);
1744 entry
->spec
= new_spec
;
1751 /* Like register_specialization, but for local declarations. We are
1752 registering SPEC, an instantiation of TMPL. */
1755 register_local_specialization (tree spec
, tree tmpl
)
1757 local_specializations
->put (tmpl
, spec
);
1760 /* TYPE is a class type. Returns true if TYPE is an explicitly
1761 specialized class. */
1764 explicit_class_specialization_p (tree type
)
1766 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1768 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1771 /* Print the list of functions at FNS, going through all the overloads
1772 for each element of the list. Alternatively, FNS can not be a
1773 TREE_LIST, in which case it will be printed together with all the
1776 MORE and *STR should respectively be FALSE and NULL when the function
1777 is called from the outside. They are used internally on recursive
1778 calls. print_candidates manages the two parameters and leaves NULL
1779 in *STR when it ends. */
1782 print_candidates_1 (tree fns
, bool more
, const char **str
)
1785 char *spaces
= NULL
;
1787 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
1788 if (TREE_CODE (fn
) == TREE_LIST
)
1790 for (fn2
= fn
; fn2
!= NULL_TREE
; fn2
= TREE_CHAIN (fn2
))
1791 print_candidates_1 (TREE_VALUE (fn2
),
1792 TREE_CHAIN (fn2
) || more
, str
);
1796 tree cand
= OVL_CURRENT (fn
);
1799 /* Pick the prefix string. */
1800 if (!more
&& !OVL_NEXT (fns
))
1802 inform (DECL_SOURCE_LOCATION (cand
),
1803 "candidate is: %#D", cand
);
1807 *str
= _("candidates are:");
1808 spaces
= get_spaces (*str
);
1810 inform (DECL_SOURCE_LOCATION (cand
), "%s %#D", *str
, cand
);
1811 *str
= spaces
? spaces
: *str
;
1821 /* Print the list of candidate FNS in an error message. FNS can also
1822 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1825 print_candidates (tree fns
)
1827 const char *str
= NULL
;
1828 print_candidates_1 (fns
, false, &str
);
1829 gcc_assert (str
== NULL
);
1832 /* Returns the template (one of the functions given by TEMPLATE_ID)
1833 which can be specialized to match the indicated DECL with the
1834 explicit template args given in TEMPLATE_ID. The DECL may be
1835 NULL_TREE if none is available. In that case, the functions in
1836 TEMPLATE_ID are non-members.
1838 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1839 specialization of a member template.
1841 The TEMPLATE_COUNT is the number of references to qualifying
1842 template classes that appeared in the name of the function. See
1843 check_explicit_specialization for a more accurate description.
1845 TSK indicates what kind of template declaration (if any) is being
1846 declared. TSK_TEMPLATE indicates that the declaration given by
1847 DECL, though a FUNCTION_DECL, has template parameters, and is
1848 therefore a template function.
1850 The template args (those explicitly specified and those deduced)
1851 are output in a newly created vector *TARGS_OUT.
1853 If it is impossible to determine the result, an error message is
1854 issued. The error_mark_node is returned to indicate failure. */
1857 determine_specialization (tree template_id
,
1860 int need_member_template
,
1866 tree explicit_targs
;
1867 tree candidates
= NULL_TREE
;
1868 /* A TREE_LIST of templates of which DECL may be a specialization.
1869 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1870 corresponding TREE_PURPOSE is the set of template arguments that,
1871 when used to instantiate the template, would produce a function
1872 with the signature of DECL. */
1873 tree templates
= NULL_TREE
;
1875 cp_binding_level
*b
;
1877 *targs_out
= NULL_TREE
;
1879 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
1880 return error_mark_node
;
1882 /* We shouldn't be specializing a member template of an
1883 unspecialized class template; we already gave an error in
1884 check_specialization_scope, now avoid crashing. */
1885 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
1886 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
1888 gcc_assert (errorcount
);
1889 return error_mark_node
;
1892 fns
= TREE_OPERAND (template_id
, 0);
1893 explicit_targs
= TREE_OPERAND (template_id
, 1);
1895 if (fns
== error_mark_node
)
1896 return error_mark_node
;
1898 /* Check for baselinks. */
1899 if (BASELINK_P (fns
))
1900 fns
= BASELINK_FUNCTIONS (fns
);
1902 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
1904 error ("%qD is not a function template", fns
);
1905 return error_mark_node
;
1907 else if (VAR_P (decl
) && !variable_template_p (fns
))
1909 error ("%qD is not a variable template", fns
);
1910 return error_mark_node
;
1913 /* Count the number of template headers specified for this
1916 for (b
= current_binding_level
;
1917 b
->kind
== sk_template_parms
;
1921 if (variable_template_p (fns
))
1922 templates
= tree_cons (explicit_targs
, fns
, templates
);
1923 else for (; fns
; fns
= OVL_NEXT (fns
))
1925 tree fn
= OVL_CURRENT (fns
);
1927 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1929 tree decl_arg_types
;
1933 /* In case of explicit specialization, we need to check if
1934 the number of template headers appearing in the specialization
1935 is correct. This is usually done in check_explicit_specialization,
1936 but the check done there cannot be exhaustive when specializing
1937 member functions. Consider the following code:
1939 template <> void A<int>::f(int);
1940 template <> template <> void A<int>::f(int);
1942 Assuming that A<int> is not itself an explicit specialization
1943 already, the first line specializes "f" which is a non-template
1944 member function, whilst the second line specializes "f" which
1945 is a template member function. So both lines are syntactically
1946 correct, and check_explicit_specialization does not reject
1949 Here, we can do better, as we are matching the specialization
1950 against the declarations. We count the number of template
1951 headers, and we check if they match TEMPLATE_COUNT + 1
1952 (TEMPLATE_COUNT is the number of qualifying template classes,
1953 plus there must be another header for the member template
1956 Notice that if header_count is zero, this is not a
1957 specialization but rather a template instantiation, so there
1958 is no check we can perform here. */
1959 if (header_count
&& header_count
!= template_count
+ 1)
1962 /* Check that the number of template arguments at the
1963 innermost level for DECL is the same as for FN. */
1964 if (current_binding_level
->kind
== sk_template_parms
1965 && !current_binding_level
->explicit_spec_p
1966 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
1967 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1968 (current_template_parms
))))
1971 /* DECL might be a specialization of FN. */
1972 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1973 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1975 /* For a non-static member function, we need to make sure
1976 that the const qualification is the same. Since
1977 get_bindings does not try to merge the "this" parameter,
1978 we must do the comparison explicitly. */
1979 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1980 && !same_type_p (TREE_VALUE (fn_arg_types
),
1981 TREE_VALUE (decl_arg_types
)))
1984 /* Skip the "this" parameter and, for constructors of
1985 classes with virtual bases, the VTT parameter. A
1986 full specialization of a constructor will have a VTT
1987 parameter, but a template never will. */
1989 = skip_artificial_parms_for (decl
, decl_arg_types
);
1991 = skip_artificial_parms_for (fn
, fn_arg_types
);
1993 /* Function templates cannot be specializations; there are
1994 no partial specializations of functions. Therefore, if
1995 the type of DECL does not match FN, there is no
1997 if (tsk
== tsk_template
)
1999 if (compparms (fn_arg_types
, decl_arg_types
))
2000 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2004 /* See whether this function might be a specialization of this
2005 template. Suppress access control because we might be trying
2006 to make this specialization a friend, and we have already done
2007 access control for the declaration of the specialization. */
2008 push_deferring_access_checks (dk_no_check
);
2009 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2010 pop_deferring_access_checks ();
2013 /* We cannot deduce template arguments that when used to
2014 specialize TMPL will produce DECL. */
2017 /* Make sure that the deduced arguments actually work. */
2018 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
);
2019 if (insttype
== error_mark_node
)
2022 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2023 if (!compparms (fn_arg_types
, decl_arg_types
))
2026 /* Save this template, and the arguments deduced. */
2027 templates
= tree_cons (targs
, fn
, templates
);
2029 else if (need_member_template
)
2030 /* FN is an ordinary member function, and we need a
2031 specialization of a member template. */
2033 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2034 /* We can get IDENTIFIER_NODEs here in certain erroneous
2037 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2038 /* This is just an ordinary non-member function. Nothing can
2039 be a specialization of that. */
2041 else if (DECL_ARTIFICIAL (fn
))
2042 /* Cannot specialize functions that are created implicitly. */
2046 tree decl_arg_types
;
2048 /* This is an ordinary member function. However, since
2049 we're here, we can assume its enclosing class is a
2050 template class. For example,
2052 template <typename T> struct S { void f(); };
2053 template <> void S<int>::f() {}
2055 Here, S<int>::f is a non-template, but S<int> is a
2056 template class. If FN has the same type as DECL, we
2057 might be in business. */
2059 if (!DECL_TEMPLATE_INFO (fn
))
2060 /* Its enclosing class is an explicit specialization
2061 of a template class. This is not a candidate. */
2064 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2065 TREE_TYPE (TREE_TYPE (fn
))))
2066 /* The return types differ. */
2069 /* Adjust the type of DECL in case FN is a static member. */
2070 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2071 if (DECL_STATIC_FUNCTION_P (fn
)
2072 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2073 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2075 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2078 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2082 if (templates
&& TREE_CHAIN (templates
))
2088 It is possible for a specialization with a given function
2089 signature to be instantiated from more than one function
2090 template. In such cases, explicit specification of the
2091 template arguments must be used to uniquely identify the
2092 function template specialization being specialized.
2094 Note that here, there's no suggestion that we're supposed to
2095 determine which of the candidate templates is most
2096 specialized. However, we, also have:
2100 Partial ordering of overloaded function template
2101 declarations is used in the following contexts to select
2102 the function template to which a function template
2103 specialization refers:
2105 -- when an explicit specialization refers to a function
2108 So, we do use the partial ordering rules, at least for now.
2109 This extension can only serve to make invalid programs valid,
2110 so it's safe. And, there is strong anecdotal evidence that
2111 the committee intended the partial ordering rules to apply;
2112 the EDG front end has that behavior, and John Spicer claims
2113 that the committee simply forgot to delete the wording in
2114 [temp.expl.spec]. */
2115 tree tmpl
= most_specialized_instantiation (templates
);
2116 if (tmpl
!= error_mark_node
)
2119 TREE_CHAIN (templates
) = NULL_TREE
;
2123 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2125 error ("template-id %qD for %q+D does not match any template "
2126 "declaration", template_id
, decl
);
2127 if (header_count
&& header_count
!= template_count
+ 1)
2128 inform (input_location
, "saw %d %<template<>%>, need %d for "
2129 "specializing a member function template",
2130 header_count
, template_count
+ 1);
2131 return error_mark_node
;
2133 else if ((templates
&& TREE_CHAIN (templates
))
2134 || (candidates
&& TREE_CHAIN (candidates
))
2135 || (templates
&& candidates
))
2137 error ("ambiguous template specialization %qD for %q+D",
2139 candidates
= chainon (candidates
, templates
);
2140 print_candidates (candidates
);
2141 return error_mark_node
;
2144 /* We have one, and exactly one, match. */
2147 tree fn
= TREE_VALUE (candidates
);
2148 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2149 /* DECL is a re-declaration or partial instantiation of a template
2151 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2153 /* It was a specialization of an ordinary member function in a
2155 return DECL_TI_TEMPLATE (fn
);
2158 /* It was a specialization of a template. */
2159 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2160 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2162 *targs_out
= copy_node (targs
);
2163 SET_TMPL_ARGS_LEVEL (*targs_out
,
2164 TMPL_ARGS_DEPTH (*targs_out
),
2165 TREE_PURPOSE (templates
));
2168 *targs_out
= TREE_PURPOSE (templates
);
2169 return TREE_VALUE (templates
);
2172 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2173 but with the default argument values filled in from those in the
2177 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2180 tree new_spec_types
;
2185 if (spec_types
== void_list_node
)
2186 return void_list_node
;
2188 /* Substitute into the rest of the list. */
2190 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2191 TREE_CHAIN (tmpl_types
));
2193 /* Add the default argument for this parameter. */
2194 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2195 TREE_VALUE (spec_types
),
2199 /* DECL is an explicit specialization. Replicate default arguments
2200 from the template it specializes. (That way, code like:
2202 template <class T> void f(T = 3);
2203 template <> void f(double);
2206 works, as required.) An alternative approach would be to look up
2207 the correct default arguments at the call-site, but this approach
2208 is consistent with how implicit instantiations are handled. */
2211 copy_default_args_to_explicit_spec (tree decl
)
2216 tree new_spec_types
;
2220 tree object_type
= NULL_TREE
;
2221 tree in_charge
= NULL_TREE
;
2222 tree vtt
= NULL_TREE
;
2224 /* See if there's anything we need to do. */
2225 tmpl
= DECL_TI_TEMPLATE (decl
);
2226 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2227 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2228 if (TREE_PURPOSE (t
))
2233 old_type
= TREE_TYPE (decl
);
2234 spec_types
= TYPE_ARG_TYPES (old_type
);
2236 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2238 /* Remove the this pointer, but remember the object's type for
2240 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2241 spec_types
= TREE_CHAIN (spec_types
);
2242 tmpl_types
= TREE_CHAIN (tmpl_types
);
2244 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2246 /* DECL may contain more parameters than TMPL due to the extra
2247 in-charge parameter in constructors and destructors. */
2248 in_charge
= spec_types
;
2249 spec_types
= TREE_CHAIN (spec_types
);
2251 if (DECL_HAS_VTT_PARM_P (decl
))
2254 spec_types
= TREE_CHAIN (spec_types
);
2258 /* Compute the merged default arguments. */
2260 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2262 /* Compute the new FUNCTION_TYPE. */
2266 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2271 /* Put the in-charge parameter back. */
2272 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2273 TREE_VALUE (in_charge
),
2276 new_type
= build_method_type_directly (object_type
,
2277 TREE_TYPE (old_type
),
2281 new_type
= build_function_type (TREE_TYPE (old_type
),
2283 new_type
= cp_build_type_attribute_variant (new_type
,
2284 TYPE_ATTRIBUTES (old_type
));
2285 new_type
= build_exception_variant (new_type
,
2286 TYPE_RAISES_EXCEPTIONS (old_type
));
2288 if (TYPE_HAS_LATE_RETURN_TYPE (old_type
))
2289 TYPE_HAS_LATE_RETURN_TYPE (new_type
) = 1;
2291 TREE_TYPE (decl
) = new_type
;
2294 /* Return the number of template headers we expect to see for a definition
2295 or specialization of CTYPE or one of its non-template members. */
2298 num_template_headers_for_class (tree ctype
)
2300 int num_templates
= 0;
2302 while (ctype
&& CLASS_TYPE_P (ctype
))
2304 /* You're supposed to have one `template <...>' for every
2305 template class, but you don't need one for a full
2306 specialization. For example:
2308 template <class T> struct S{};
2309 template <> struct S<int> { void f(); };
2310 void S<int>::f () {}
2312 is correct; there shouldn't be a `template <>' for the
2313 definition of `S<int>::f'. */
2314 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2315 /* If CTYPE does not have template information of any
2316 kind, then it is not a template, nor is it nested
2317 within a template. */
2319 if (explicit_class_specialization_p (ctype
))
2321 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2324 ctype
= TYPE_CONTEXT (ctype
);
2327 return num_templates
;
2330 /* Do a simple sanity check on the template headers that precede the
2331 variable declaration DECL. */
2334 check_template_variable (tree decl
)
2336 tree ctx
= CP_DECL_CONTEXT (decl
);
2337 int wanted
= num_template_headers_for_class (ctx
);
2338 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2339 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2341 if (cxx_dialect
< cxx14
)
2342 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2343 "variable templates only available with "
2344 "-std=c++14 or -std=gnu++14");
2346 // Namespace-scope variable templates should have a template header.
2349 if (template_header_count
> wanted
)
2351 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2352 "too many template headers for %D (should be %d)",
2354 if (warned
&& CLASS_TYPE_P (ctx
)
2355 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2356 inform (DECL_SOURCE_LOCATION (decl
),
2357 "members of an explicitly specialized class are defined "
2358 "without a template header");
2362 /* Check to see if the function just declared, as indicated in
2363 DECLARATOR, and in DECL, is a specialization of a function
2364 template. We may also discover that the declaration is an explicit
2365 instantiation at this point.
2367 Returns DECL, or an equivalent declaration that should be used
2368 instead if all goes well. Issues an error message if something is
2369 amiss. Returns error_mark_node if the error is not easily
2372 FLAGS is a bitmask consisting of the following flags:
2374 2: The function has a definition.
2375 4: The function is a friend.
2377 The TEMPLATE_COUNT is the number of references to qualifying
2378 template classes that appeared in the name of the function. For
2381 template <class T> struct S { void f(); };
2384 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2385 classes are not counted in the TEMPLATE_COUNT, so that in
2387 template <class T> struct S {};
2388 template <> struct S<int> { void f(); }
2389 template <> void S<int>::f();
2391 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2392 invalid; there should be no template <>.)
2394 If the function is a specialization, it is marked as such via
2395 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2396 is set up correctly, and it is added to the list of specializations
2397 for that template. */
2400 check_explicit_specialization (tree declarator
,
2405 int have_def
= flags
& 2;
2406 int is_friend
= flags
& 4;
2407 int specialization
= 0;
2408 int explicit_instantiation
= 0;
2409 int member_specialization
= 0;
2410 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2411 tree dname
= DECL_NAME (decl
);
2416 if (!processing_specialization
)
2419 tsk
= tsk_excessive_parms
;
2422 tsk
= current_tmpl_spec_kind (template_count
);
2427 if (processing_specialization
&& TREE_CODE (decl
) != VAR_DECL
)
2430 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2432 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2435 /* This could be something like:
2437 template <class T> void f(T);
2438 class S { friend void f<>(int); } */
2442 /* This case handles bogus declarations like template <>
2443 template <class T> void f<int>(); */
2445 error ("template-id %qD in declaration of primary template",
2452 case tsk_invalid_member_spec
:
2453 /* The error has already been reported in
2454 check_specialization_scope. */
2455 return error_mark_node
;
2457 case tsk_invalid_expl_inst
:
2458 error ("template parameter list used in explicit instantiation");
2464 error ("definition provided for explicit instantiation");
2466 explicit_instantiation
= 1;
2469 case tsk_excessive_parms
:
2470 case tsk_insufficient_parms
:
2471 if (tsk
== tsk_excessive_parms
)
2472 error ("too many template parameter lists in declaration of %qD",
2474 else if (template_header_count
)
2475 error("too few template parameter lists in declaration of %qD", decl
);
2477 error("explicit specialization of %qD must be introduced by "
2478 "%<template <>%>", decl
);
2482 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2483 /* In cases like template<> constexpr bool v = true;
2484 We'll give an error in check_template_variable. */
2487 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2489 member_specialization
= 1;
2495 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2497 /* This case handles bogus declarations like template <>
2498 template <class T> void f<int>(); */
2500 if (!uses_template_parms (declarator
))
2501 error ("template-id %qD in declaration of primary template",
2503 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2505 /* Partial specialization of variable template. */
2506 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2510 else if (cxx_dialect
< cxx14
)
2511 error ("non-type partial specialization %qD "
2512 "is not allowed", declarator
);
2514 error ("non-class, non-variable partial specialization %qD "
2515 "is not allowed", declarator
);
2520 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2521 /* This is a specialization of a member template, without
2522 specialization the containing class. Something like:
2524 template <class T> struct S {
2525 template <class U> void f (U);
2527 template <> template <class U> void S<int>::f(U) {}
2529 That's a specialization -- but of the entire template. */
2537 if ((specialization
|| member_specialization
)
2538 /* This doesn't apply to variable templates. */
2539 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2540 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
2542 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2543 for (; t
; t
= TREE_CHAIN (t
))
2544 if (TREE_PURPOSE (t
))
2546 permerror (input_location
,
2547 "default argument specified in explicit specialization");
2552 if (specialization
|| member_specialization
|| explicit_instantiation
)
2554 tree tmpl
= NULL_TREE
;
2555 tree targs
= NULL_TREE
;
2556 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2558 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2559 if (!was_template_id
)
2563 gcc_assert (identifier_p (declarator
));
2568 /* If there is no class context, the explicit instantiation
2569 must be at namespace scope. */
2570 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2572 /* Find the namespace binding, using the declaration
2574 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2576 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2578 error ("%qD is not a template function", dname
);
2579 fns
= error_mark_node
;
2583 tree fn
= OVL_CURRENT (fns
);
2584 if (!is_associated_namespace (CP_DECL_CONTEXT (decl
),
2585 CP_DECL_CONTEXT (fn
)))
2586 error ("%qD is not declared in %qD",
2587 decl
, current_namespace
);
2591 declarator
= lookup_template_function (fns
, NULL_TREE
);
2594 if (declarator
== error_mark_node
)
2595 return error_mark_node
;
2597 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2599 if (!explicit_instantiation
)
2600 /* A specialization in class scope. This is invalid,
2601 but the error will already have been flagged by
2602 check_specialization_scope. */
2603 return error_mark_node
;
2606 /* It's not valid to write an explicit instantiation in
2609 class C { template void f(); }
2611 This case is caught by the parser. However, on
2614 template class C { void f(); };
2616 (which is invalid) we can get here. The error will be
2623 else if (ctype
!= NULL_TREE
2624 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2626 // We'll match variable templates in start_decl.
2630 /* Find the list of functions in ctype that have the same
2631 name as the declared function. */
2632 tree name
= TREE_OPERAND (declarator
, 0);
2633 tree fns
= NULL_TREE
;
2636 if (constructor_name_p (name
, ctype
))
2638 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2640 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2641 : !CLASSTYPE_DESTRUCTORS (ctype
))
2643 /* From [temp.expl.spec]:
2645 If such an explicit specialization for the member
2646 of a class template names an implicitly-declared
2647 special member function (clause _special_), the
2648 program is ill-formed.
2650 Similar language is found in [temp.explicit]. */
2651 error ("specialization of implicitly-declared special member function");
2652 return error_mark_node
;
2655 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2658 if (!DECL_CONV_FN_P (decl
))
2660 idx
= lookup_fnfields_1 (ctype
, name
);
2662 fns
= (*CLASSTYPE_METHOD_VEC (ctype
))[idx
];
2666 vec
<tree
, va_gc
> *methods
;
2669 /* For a type-conversion operator, we cannot do a
2670 name-based lookup. We might be looking for `operator
2671 int' which will be a specialization of `operator T'.
2672 So, we find *all* the conversion operators, and then
2673 select from them. */
2676 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2678 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2679 methods
->iterate (idx
, &ovl
);
2682 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2683 /* There are no more conversion functions. */
2686 /* Glue all these conversion functions together
2687 with those we already have. */
2688 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2689 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2693 if (fns
== NULL_TREE
)
2695 error ("no member function %qD declared in %qT", name
, ctype
);
2696 return error_mark_node
;
2699 TREE_OPERAND (declarator
, 0) = fns
;
2702 /* Figure out what exactly is being specialized at this point.
2703 Note that for an explicit instantiation, even one for a
2704 member function, we cannot tell apriori whether the
2705 instantiation is for a member template, or just a member
2706 function of a template class. Even if a member template is
2707 being instantiated, the member template arguments may be
2708 elided if they can be deduced from the rest of the
2710 tmpl
= determine_specialization (declarator
, decl
,
2712 member_specialization
,
2716 if (!tmpl
|| tmpl
== error_mark_node
)
2717 /* We couldn't figure out what this declaration was
2719 return error_mark_node
;
2722 tree gen_tmpl
= most_general_template (tmpl
);
2724 if (explicit_instantiation
)
2726 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2727 is done by do_decl_instantiation later. */
2729 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2730 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2732 if (arg_depth
> parm_depth
)
2734 /* If TMPL is not the most general template (for
2735 example, if TMPL is a friend template that is
2736 injected into namespace scope), then there will
2737 be too many levels of TARGS. Remove some of them
2742 new_targs
= make_tree_vec (parm_depth
);
2743 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2744 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2745 = TREE_VEC_ELT (targs
, i
);
2749 return instantiate_template (tmpl
, targs
, tf_error
);
2752 /* If we thought that the DECL was a member function, but it
2753 turns out to be specializing a static member function,
2754 make DECL a static member function as well. */
2755 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
2756 && DECL_STATIC_FUNCTION_P (tmpl
)
2757 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2758 revert_static_member_fn (decl
);
2760 /* If this is a specialization of a member template of a
2761 template class, we want to return the TEMPLATE_DECL, not
2762 the specialization of it. */
2763 if (tsk
== tsk_template
&& !was_template_id
)
2765 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
2766 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2767 DECL_INITIAL (result
) = NULL_TREE
;
2771 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2772 DECL_SOURCE_LOCATION (result
)
2773 = DECL_SOURCE_LOCATION (decl
);
2774 /* We want to use the argument list specified in the
2775 definition, not in the original declaration. */
2776 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
2777 for (parm
= DECL_ARGUMENTS (result
); parm
;
2778 parm
= DECL_CHAIN (parm
))
2779 DECL_CONTEXT (parm
) = result
;
2781 return register_specialization (tmpl
, gen_tmpl
, targs
,
2785 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2786 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
2788 if (was_template_id
)
2789 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
)) = true;
2791 /* Inherit default function arguments from the template
2792 DECL is specializing. */
2793 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
2794 copy_default_args_to_explicit_spec (decl
);
2796 /* This specialization has the same protection as the
2797 template it specializes. */
2798 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
2799 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
2801 /* 7.1.1-1 [dcl.stc]
2803 A storage-class-specifier shall not be specified in an
2804 explicit specialization...
2806 The parser rejects these, so unless action is taken here,
2807 explicit function specializations will always appear with
2810 The action recommended by the C++ CWG in response to C++
2811 defect report 605 is to make the storage class and linkage
2812 of the explicit specialization match the templated function:
2814 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2816 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
2818 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
2819 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
2821 /* This specialization has the same linkage and visibility as
2822 the function template it specializes. */
2823 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
2824 if (! TREE_PUBLIC (decl
))
2826 DECL_INTERFACE_KNOWN (decl
) = 1;
2827 DECL_NOT_REALLY_EXTERN (decl
) = 1;
2829 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
2830 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
2832 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
2833 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
2837 /* If DECL is a friend declaration, declared using an
2838 unqualified name, the namespace associated with DECL may
2839 have been set incorrectly. For example, in:
2841 template <typename T> void f(T);
2843 struct S { friend void f<int>(int); }
2846 we will have set the DECL_CONTEXT for the friend
2847 declaration to N, rather than to the global namespace. */
2848 if (DECL_NAMESPACE_SCOPE_P (decl
))
2849 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
2851 if (is_friend
&& !have_def
)
2852 /* This is not really a declaration of a specialization.
2853 It's just the name of an instantiation. But, it's not
2854 a request for an instantiation, either. */
2855 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
2856 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2857 /* A specialization is not necessarily COMDAT. */
2858 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
2859 && DECL_DECLARED_INLINE_P (decl
));
2860 else if (TREE_CODE (decl
) == VAR_DECL
)
2861 DECL_COMDAT (decl
) = false;
2863 /* Register this specialization so that we can find it
2865 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
, 0);
2867 /* A 'structor should already have clones. */
2868 gcc_assert (decl
== error_mark_node
2869 || variable_template_p (tmpl
)
2870 || !(DECL_CONSTRUCTOR_P (decl
)
2871 || DECL_DESTRUCTOR_P (decl
))
2872 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
2879 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2880 parameters. These are represented in the same format used for
2881 DECL_TEMPLATE_PARMS. */
2884 comp_template_parms (const_tree parms1
, const_tree parms2
)
2889 if (parms1
== parms2
)
2892 for (p1
= parms1
, p2
= parms2
;
2893 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2894 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2896 tree t1
= TREE_VALUE (p1
);
2897 tree t2
= TREE_VALUE (p2
);
2900 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2901 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2903 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2906 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2908 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2909 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2911 /* If either of the template parameters are invalid, assume
2912 they match for the sake of error recovery. */
2913 if (error_operand_p (parm1
) || error_operand_p (parm2
))
2916 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2919 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2920 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2921 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2923 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2928 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2929 /* One set of parameters has more parameters lists than the
2936 /* Determine whether PARM is a parameter pack. */
2939 template_parameter_pack_p (const_tree parm
)
2941 /* Determine if we have a non-type template parameter pack. */
2942 if (TREE_CODE (parm
) == PARM_DECL
)
2943 return (DECL_TEMPLATE_PARM_P (parm
)
2944 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2945 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
2946 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
2948 /* If this is a list of template parameters, we could get a
2949 TYPE_DECL or a TEMPLATE_DECL. */
2950 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2951 parm
= TREE_TYPE (parm
);
2953 /* Otherwise it must be a type template parameter. */
2954 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2955 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2956 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2959 /* Determine if T is a function parameter pack. */
2962 function_parameter_pack_p (const_tree t
)
2964 if (t
&& TREE_CODE (t
) == PARM_DECL
)
2965 return DECL_PACK_P (t
);
2969 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2970 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2973 get_function_template_decl (const_tree primary_func_tmpl_inst
)
2975 if (! primary_func_tmpl_inst
2976 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
2977 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
2980 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
2983 /* Return true iff the function parameter PARAM_DECL was expanded
2984 from the function parameter pack PACK. */
2987 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
2989 if (DECL_ARTIFICIAL (param_decl
)
2990 || !function_parameter_pack_p (pack
))
2993 /* The parameter pack and its pack arguments have the same
2995 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
2998 /* Determine whether ARGS describes a variadic template args list,
2999 i.e., one that is terminated by a template argument pack. */
3002 template_args_variadic_p (tree args
)
3007 if (args
== NULL_TREE
)
3010 args
= INNERMOST_TEMPLATE_ARGS (args
);
3011 nargs
= TREE_VEC_LENGTH (args
);
3016 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
3018 return ARGUMENT_PACK_P (last_parm
);
3021 /* Generate a new name for the parameter pack name NAME (an
3022 IDENTIFIER_NODE) that incorporates its */
3025 make_ith_pack_parameter_name (tree name
, int i
)
3027 /* Munge the name to include the parameter index. */
3028 #define NUMBUF_LEN 128
3029 char numbuf
[NUMBUF_LEN
];
3033 if (name
== NULL_TREE
)
3035 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
3036 newname_len
= IDENTIFIER_LENGTH (name
)
3037 + strlen (numbuf
) + 2;
3038 newname
= (char*)alloca (newname_len
);
3039 snprintf (newname
, newname_len
,
3040 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3041 return get_identifier (newname
);
3044 /* Return true if T is a primary function, class or alias template
3048 primary_template_instantiation_p (const_tree t
)
3053 if (TREE_CODE (t
) == FUNCTION_DECL
)
3054 return DECL_LANG_SPECIFIC (t
)
3055 && DECL_TEMPLATE_INSTANTIATION (t
)
3056 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
3057 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3058 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
3059 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
3060 else if (alias_template_specialization_p (t
))
3065 /* Return true if PARM is a template template parameter. */
3068 template_template_parameter_p (const_tree parm
)
3070 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3073 /* Return true iff PARM is a DECL representing a type template
3077 template_type_parameter_p (const_tree parm
)
3080 && (TREE_CODE (parm
) == TYPE_DECL
3081 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3082 && DECL_TEMPLATE_PARM_P (parm
));
3085 /* Return the template parameters of T if T is a
3086 primary template instantiation, NULL otherwise. */
3089 get_primary_template_innermost_parameters (const_tree t
)
3091 tree parms
= NULL
, template_info
= NULL
;
3093 if ((template_info
= get_template_info (t
))
3094 && primary_template_instantiation_p (t
))
3095 parms
= INNERMOST_TEMPLATE_PARMS
3096 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3101 /* Return the template parameters of the LEVELth level from the full list
3102 of template parameters PARMS. */
3105 get_template_parms_at_level (tree parms
, int level
)
3109 || TREE_CODE (parms
) != TREE_LIST
3110 || level
> TMPL_PARMS_DEPTH (parms
))
3113 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3114 if (TMPL_PARMS_DEPTH (p
) == level
)
3120 /* Returns the template arguments of T if T is a template instantiation,
3124 get_template_innermost_arguments (const_tree t
)
3126 tree args
= NULL
, template_info
= NULL
;
3128 if ((template_info
= get_template_info (t
))
3129 && TI_ARGS (template_info
))
3130 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3135 /* Return the argument pack elements of T if T is a template argument pack,
3139 get_template_argument_pack_elems (const_tree t
)
3141 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3142 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3145 return ARGUMENT_PACK_ARGS (t
);
3148 /* Structure used to track the progress of find_parameter_packs_r. */
3149 struct find_parameter_pack_data
3151 /* TREE_LIST that will contain all of the parameter packs found by
3153 tree
* parameter_packs
;
3155 /* Set of AST nodes that have been visited by the traversal. */
3156 hash_set
<tree
> *visited
;
3159 /* Identifies all of the argument packs that occur in a template
3160 argument and appends them to the TREE_LIST inside DATA, which is a
3161 find_parameter_pack_data structure. This is a subroutine of
3162 make_pack_expansion and uses_parameter_packs. */
3164 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3167 struct find_parameter_pack_data
* ppd
=
3168 (struct find_parameter_pack_data
*)data
;
3169 bool parameter_pack_p
= false;
3171 /* Handle type aliases/typedefs. */
3172 if (TYPE_ALIAS_P (t
))
3174 if (TYPE_TEMPLATE_INFO (t
))
3175 cp_walk_tree (&TYPE_TI_ARGS (t
),
3176 &find_parameter_packs_r
,
3182 /* Identify whether this is a parameter pack or not. */
3183 switch (TREE_CODE (t
))
3185 case TEMPLATE_PARM_INDEX
:
3186 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3187 parameter_pack_p
= true;
3190 case TEMPLATE_TYPE_PARM
:
3191 t
= TYPE_MAIN_VARIANT (t
);
3192 case TEMPLATE_TEMPLATE_PARM
:
3193 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3194 parameter_pack_p
= true;
3199 if (DECL_PACK_P (t
))
3201 /* We don't want to walk into the type of a PARM_DECL,
3202 because we don't want to see the type parameter pack. */
3204 parameter_pack_p
= true;
3208 /* Look through a lambda capture proxy to the field pack. */
3210 if (DECL_HAS_VALUE_EXPR_P (t
))
3212 tree v
= DECL_VALUE_EXPR (t
);
3214 &find_parameter_packs_r
,
3221 parameter_pack_p
= true;
3224 /* Not a parameter pack. */
3228 if (parameter_pack_p
)
3230 /* Add this parameter pack to the list. */
3231 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3235 cp_walk_tree (&TYPE_CONTEXT (t
),
3236 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3238 /* This switch statement will return immediately if we don't find a
3240 switch (TREE_CODE (t
))
3242 case TEMPLATE_PARM_INDEX
:
3245 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3246 /* Check the template itself. */
3247 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3248 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3249 /* Check the template arguments. */
3250 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3255 case TEMPLATE_TYPE_PARM
:
3256 case TEMPLATE_TEMPLATE_PARM
:
3263 if (TYPE_PTRMEMFUNC_P (t
))
3269 if (TYPE_TEMPLATE_INFO (t
))
3270 cp_walk_tree (&TYPE_TI_ARGS (t
),
3271 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3278 cp_walk_tree (&TREE_TYPE (t
),
3279 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3283 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3288 case TYPE_PACK_EXPANSION
:
3289 case EXPR_PACK_EXPANSION
:
3294 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3299 case IDENTIFIER_NODE
:
3300 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3312 /* Determines if the expression or type T uses any parameter packs. */
3314 uses_parameter_packs (tree t
)
3316 tree parameter_packs
= NULL_TREE
;
3317 struct find_parameter_pack_data ppd
;
3318 ppd
.parameter_packs
= ¶meter_packs
;
3319 ppd
.visited
= new hash_set
<tree
>;
3320 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3322 return parameter_packs
!= NULL_TREE
;
3325 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3326 representation a base-class initializer into a parameter pack
3327 expansion. If all goes well, the resulting node will be an
3328 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3331 make_pack_expansion (tree arg
)
3334 tree parameter_packs
= NULL_TREE
;
3335 bool for_types
= false;
3336 struct find_parameter_pack_data ppd
;
3338 if (!arg
|| arg
== error_mark_node
)
3341 if (TREE_CODE (arg
) == TREE_LIST
)
3343 /* The only time we will see a TREE_LIST here is for a base
3344 class initializer. In this case, the TREE_PURPOSE will be a
3345 _TYPE node (representing the base class expansion we're
3346 initializing) and the TREE_VALUE will be a TREE_LIST
3347 containing the initialization arguments.
3349 The resulting expansion looks somewhat different from most
3350 expansions. Rather than returning just one _EXPANSION, we
3351 return a TREE_LIST whose TREE_PURPOSE is a
3352 TYPE_PACK_EXPANSION containing the bases that will be
3353 initialized. The TREE_VALUE will be identical to the
3354 original TREE_VALUE, which is a list of arguments that will
3355 be passed to each base. We do not introduce any new pack
3356 expansion nodes into the TREE_VALUE (although it is possible
3357 that some already exist), because the TREE_PURPOSE and
3358 TREE_VALUE all need to be expanded together with the same
3359 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3360 resulting TREE_PURPOSE will mention the parameter packs in
3361 both the bases and the arguments to the bases. */
3364 tree parameter_packs
= NULL_TREE
;
3366 /* Determine which parameter packs will be used by the base
3368 ppd
.visited
= new hash_set
<tree
>;
3369 ppd
.parameter_packs
= ¶meter_packs
;
3370 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3373 if (parameter_packs
== NULL_TREE
)
3375 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3377 return error_mark_node
;
3380 if (TREE_VALUE (arg
) != void_type_node
)
3382 /* Collect the sets of parameter packs used in each of the
3383 initialization arguments. */
3384 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3386 /* Determine which parameter packs will be expanded in this
3388 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3395 /* Create the pack expansion type for the base type. */
3396 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3397 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3398 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3400 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3401 they will rarely be compared to anything. */
3402 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3404 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3407 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3410 /* Build the PACK_EXPANSION_* node. */
3412 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3413 : make_node (EXPR_PACK_EXPANSION
);
3414 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3415 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3417 /* Propagate type and const-expression information. */
3418 TREE_TYPE (result
) = TREE_TYPE (arg
);
3419 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3422 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3423 they will rarely be compared to anything. */
3424 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3426 /* Determine which parameter packs will be expanded. */
3427 ppd
.parameter_packs
= ¶meter_packs
;
3428 ppd
.visited
= new hash_set
<tree
>;
3429 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3432 /* Make sure we found some parameter packs. */
3433 if (parameter_packs
== NULL_TREE
)
3436 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3438 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3439 return error_mark_node
;
3441 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3443 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3448 /* Checks T for any "bare" parameter packs, which have not yet been
3449 expanded, and issues an error if any are found. This operation can
3450 only be done on full expressions or types (e.g., an expression
3451 statement, "if" condition, etc.), because we could have expressions like:
3453 foo(f(g(h(args)))...)
3455 where "args" is a parameter pack. check_for_bare_parameter_packs
3456 should not be called for the subexpressions args, h(args),
3457 g(h(args)), or f(g(h(args))), because we would produce erroneous
3460 Returns TRUE and emits an error if there were bare parameter packs,
3461 returns FALSE otherwise. */
3463 check_for_bare_parameter_packs (tree t
)
3465 tree parameter_packs
= NULL_TREE
;
3466 struct find_parameter_pack_data ppd
;
3468 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3471 if (TREE_CODE (t
) == TYPE_DECL
)
3474 ppd
.parameter_packs
= ¶meter_packs
;
3475 ppd
.visited
= new hash_set
<tree
>;
3476 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3479 if (parameter_packs
)
3481 error ("parameter packs not expanded with %<...%>:");
3482 while (parameter_packs
)
3484 tree pack
= TREE_VALUE (parameter_packs
);
3485 tree name
= NULL_TREE
;
3487 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3488 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3489 name
= TYPE_NAME (pack
);
3490 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3491 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3493 name
= DECL_NAME (pack
);
3496 inform (input_location
, " %qD", name
);
3498 inform (input_location
, " <anonymous>");
3500 parameter_packs
= TREE_CHAIN (parameter_packs
);
3509 /* Expand any parameter packs that occur in the template arguments in
3512 expand_template_argument_pack (tree args
)
3514 tree result_args
= NULL_TREE
;
3515 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3516 int num_result_args
= -1;
3517 int non_default_args_count
= -1;
3519 /* First, determine if we need to expand anything, and the number of
3520 slots we'll need. */
3521 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3523 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3524 if (arg
== NULL_TREE
)
3526 if (ARGUMENT_PACK_P (arg
))
3528 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3529 if (num_result_args
< 0)
3530 num_result_args
= in_arg
+ num_packed
;
3532 num_result_args
+= num_packed
;
3536 if (num_result_args
>= 0)
3541 /* If no expansion is necessary, we're done. */
3542 if (num_result_args
< 0)
3545 /* Expand arguments. */
3546 result_args
= make_tree_vec (num_result_args
);
3547 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3548 non_default_args_count
=
3549 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3550 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3552 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3553 if (ARGUMENT_PACK_P (arg
))
3555 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3556 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3557 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3558 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3559 if (non_default_args_count
> 0)
3560 non_default_args_count
+= num_packed
- 1;
3564 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3568 if (non_default_args_count
>= 0)
3569 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3573 /* Checks if DECL shadows a template parameter.
3575 [temp.local]: A template-parameter shall not be redeclared within its
3576 scope (including nested scopes).
3578 Emits an error and returns TRUE if the DECL shadows a parameter,
3579 returns FALSE otherwise. */
3582 check_template_shadow (tree decl
)
3586 /* If we're not in a template, we can't possibly shadow a template
3588 if (!current_template_parms
)
3591 /* Figure out what we're shadowing. */
3592 if (TREE_CODE (decl
) == OVERLOAD
)
3593 decl
= OVL_CURRENT (decl
);
3594 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3596 /* If there's no previous binding for this name, we're not shadowing
3597 anything, let alone a template parameter. */
3601 /* If we're not shadowing a template parameter, we're done. Note
3602 that OLDDECL might be an OVERLOAD (or perhaps even an
3603 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3605 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3608 /* We check for decl != olddecl to avoid bogus errors for using a
3609 name inside a class. We check TPFI to avoid duplicate errors for
3610 inline member templates. */
3612 || (DECL_TEMPLATE_PARM_P (decl
)
3613 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
3616 /* Don't complain about the injected class name, as we've already
3617 complained about the class itself. */
3618 if (DECL_SELF_REFERENCE_P (decl
))
3621 error ("declaration of %q+#D", decl
);
3622 error (" shadows template parm %q+#D", olddecl
);
3626 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3627 ORIG_LEVEL, DECL, and TYPE. */
3630 build_template_parm_index (int index
,
3636 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3637 TEMPLATE_PARM_IDX (t
) = index
;
3638 TEMPLATE_PARM_LEVEL (t
) = level
;
3639 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3640 TEMPLATE_PARM_DECL (t
) = decl
;
3641 TREE_TYPE (t
) = type
;
3642 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3643 TREE_READONLY (t
) = TREE_READONLY (decl
);
3648 /* Find the canonical type parameter for the given template type
3649 parameter. Returns the canonical type parameter, which may be TYPE
3650 if no such parameter existed. */
3653 canonical_type_parameter (tree type
)
3656 int idx
= TEMPLATE_TYPE_IDX (type
);
3657 if (!canonical_template_parms
)
3658 vec_alloc (canonical_template_parms
, idx
+1);
3660 while (canonical_template_parms
->length () <= (unsigned)idx
)
3661 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3663 list
= (*canonical_template_parms
)[idx
];
3664 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3665 list
= TREE_CHAIN (list
);
3668 return TREE_VALUE (list
);
3671 (*canonical_template_parms
)[idx
]
3672 = tree_cons (NULL_TREE
, type
,
3673 (*canonical_template_parms
)[idx
]);
3678 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3679 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3680 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3681 new one is created. */
3684 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3685 tsubst_flags_t complain
)
3687 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3688 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3689 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3690 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3692 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3695 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3696 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3697 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3698 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3699 DECL_ARTIFICIAL (decl
) = 1;
3700 SET_DECL_TEMPLATE_PARM_P (decl
);
3702 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3703 TEMPLATE_PARM_LEVEL (index
) - levels
,
3704 TEMPLATE_PARM_ORIG_LEVEL (index
),
3706 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3707 TEMPLATE_PARM_PARAMETER_PACK (t
)
3708 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3710 /* Template template parameters need this. */
3711 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3712 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3713 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
)),
3717 return TEMPLATE_PARM_DESCENDANTS (index
);
3720 /* Process information from new template parameter PARM and append it
3721 to the LIST being built. This new parameter is a non-type
3722 parameter iff IS_NON_TYPE is true. This new parameter is a
3723 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3727 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
3728 bool is_non_type
, bool is_parameter_pack
)
3734 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
3735 defval
= TREE_PURPOSE (parm
);
3739 tree p
= tree_last (list
);
3741 if (p
&& TREE_VALUE (p
) != error_mark_node
)
3744 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
3745 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
3747 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
3755 parm
= TREE_VALUE (parm
);
3757 SET_DECL_TEMPLATE_PARM_P (parm
);
3759 if (TREE_TYPE (parm
) != error_mark_node
)
3763 The top-level cv-qualifiers on the template-parameter are
3764 ignored when determining its type. */
3765 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
3766 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
3767 TREE_TYPE (parm
) = error_mark_node
;
3768 else if (uses_parameter_packs (TREE_TYPE (parm
))
3769 && !is_parameter_pack
3770 /* If we're in a nested template parameter list, the template
3771 template parameter could be a parameter pack. */
3772 && processing_template_parmlist
== 1)
3774 /* This template parameter is not a parameter pack, but it
3775 should be. Complain about "bare" parameter packs. */
3776 check_for_bare_parameter_packs (TREE_TYPE (parm
));
3778 /* Recover by calling this a parameter pack. */
3779 is_parameter_pack
= true;
3783 /* A template parameter is not modifiable. */
3784 TREE_CONSTANT (parm
) = 1;
3785 TREE_READONLY (parm
) = 1;
3786 decl
= build_decl (parm_loc
,
3787 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
3788 TREE_CONSTANT (decl
) = 1;
3789 TREE_READONLY (decl
) = 1;
3790 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
3791 = build_template_parm_index (idx
, processing_template_decl
,
3792 processing_template_decl
,
3793 decl
, TREE_TYPE (parm
));
3795 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
3796 = is_parameter_pack
;
3801 parm
= TREE_VALUE (TREE_VALUE (parm
));
3803 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
3805 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
3806 /* This is for distinguishing between real templates and template
3807 template parameters */
3808 TREE_TYPE (parm
) = t
;
3809 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
3814 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
3815 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3816 decl
= build_decl (parm_loc
,
3817 TYPE_DECL
, parm
, t
);
3820 TYPE_NAME (t
) = decl
;
3821 TYPE_STUB_DECL (t
) = decl
;
3823 TEMPLATE_TYPE_PARM_INDEX (t
)
3824 = build_template_parm_index (idx
, processing_template_decl
,
3825 processing_template_decl
,
3826 decl
, TREE_TYPE (parm
));
3827 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
3828 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
3830 DECL_ARTIFICIAL (decl
) = 1;
3831 SET_DECL_TEMPLATE_PARM_P (decl
);
3833 parm
= build_tree_list (defval
, parm
);
3834 return chainon (list
, parm
);
3837 /* The end of a template parameter list has been reached. Process the
3838 tree list into a parameter vector, converting each parameter into a more
3839 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3843 end_template_parm_list (tree parms
)
3847 tree saved_parmlist
= make_tree_vec (list_length (parms
));
3849 current_template_parms
3850 = tree_cons (size_int (processing_template_decl
),
3851 saved_parmlist
, current_template_parms
);
3853 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3855 next
= TREE_CHAIN (parm
);
3856 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3857 TREE_CHAIN (parm
) = NULL_TREE
;
3860 --processing_template_parmlist
;
3862 return saved_parmlist
;
3865 /* end_template_decl is called after a template declaration is seen. */
3868 end_template_decl (void)
3870 reset_specialization ();
3872 if (! processing_template_decl
)
3875 /* This matches the pushlevel in begin_template_parm_list. */
3878 --processing_template_decl
;
3879 current_template_parms
= TREE_CHAIN (current_template_parms
);
3882 /* Takes a TREE_LIST representing a template parameter and convert it
3883 into an argument suitable to be passed to the type substitution
3884 functions. Note that If the TREE_LIST contains an error_mark
3885 node, the returned argument is error_mark_node. */
3888 template_parm_to_arg (tree t
)
3892 || TREE_CODE (t
) != TREE_LIST
)
3895 if (error_operand_p (TREE_VALUE (t
)))
3896 return error_mark_node
;
3900 if (TREE_CODE (t
) == TYPE_DECL
3901 || TREE_CODE (t
) == TEMPLATE_DECL
)
3905 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3907 /* Turn this argument into a TYPE_ARGUMENT_PACK
3908 with a single element, which expands T. */
3909 tree vec
= make_tree_vec (1);
3910 #ifdef ENABLE_CHECKING
3911 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3912 (vec
, TREE_VEC_LENGTH (vec
));
3914 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3916 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
3917 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3922 t
= DECL_INITIAL (t
);
3924 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3926 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3927 with a single element, which expands T. */
3928 tree vec
= make_tree_vec (1);
3929 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3930 #ifdef ENABLE_CHECKING
3931 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3932 (vec
, TREE_VEC_LENGTH (vec
));
3934 t
= convert_from_reference (t
);
3935 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3937 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3938 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3939 TREE_TYPE (t
) = type
;
3942 t
= convert_from_reference (t
);
3947 /* Given a set of template parameters, return them as a set of template
3948 arguments. The template parameters are represented as a TREE_VEC, in
3949 the form documented in cp-tree.h for template arguments. */
3952 template_parms_to_args (tree parms
)
3955 tree args
= NULL_TREE
;
3956 int length
= TMPL_PARMS_DEPTH (parms
);
3959 /* If there is only one level of template parameters, we do not
3960 create a TREE_VEC of TREE_VECs. Instead, we return a single
3961 TREE_VEC containing the arguments. */
3963 args
= make_tree_vec (length
);
3965 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
3967 tree a
= copy_node (TREE_VALUE (header
));
3970 TREE_TYPE (a
) = NULL_TREE
;
3971 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
3972 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
3974 #ifdef ENABLE_CHECKING
3975 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
3979 TREE_VEC_ELT (args
, --l
) = a
;
3984 if (length
> 1 && TREE_VEC_ELT (args
, 0) == NULL_TREE
)
3985 /* This can happen for template parms of a template template
3988 template<template<class T, class U> class TT> struct S;
3990 Consider the level of the parms of TT; T and U both have
3991 level 2; TT has no template parm of level 1. So in this case
3992 the first element of full_template_args is NULL_TREE. If we
3993 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
3994 of 2. This will make tsubst wrongly consider that T and U
3995 have level 1. Instead, let's create a dummy vector as the
3996 first element of full_template_args so that TMPL_ARGS_DEPTH
3997 returns the correct depth for args. */
3998 TREE_VEC_ELT (args
, 0) = make_tree_vec (1);
4002 /* Within the declaration of a template, return the currently active
4003 template parameters as an argument TREE_VEC. */
4006 current_template_args (void)
4008 return template_parms_to_args (current_template_parms
);
4011 /* Update the declared TYPE by doing any lookups which were thought to be
4012 dependent, but are not now that we know the SCOPE of the declarator. */
4015 maybe_update_decl_type (tree orig_type
, tree scope
)
4017 tree type
= orig_type
;
4019 if (type
== NULL_TREE
)
4022 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4023 type
= TREE_TYPE (type
);
4025 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4026 && dependent_type_p (type
)
4027 /* Don't bother building up the args in this case. */
4028 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4030 /* tsubst in the args corresponding to the template parameters,
4031 including auto if present. Most things will be unchanged, but
4032 make_typename_type and tsubst_qualified_id will resolve
4033 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4034 tree args
= current_template_args ();
4035 tree auto_node
= type_uses_auto (type
);
4039 tree auto_vec
= make_tree_vec (1);
4040 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4041 args
= add_to_template_args (args
, auto_vec
);
4043 pushed
= push_scope (scope
);
4044 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4049 if (type
== error_mark_node
)
4052 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4054 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4057 type
= TYPE_NAME (type
);
4062 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4063 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
4064 a member template. Used by push_template_decl below. */
4067 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4069 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4070 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4071 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4072 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4073 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4078 struct template_parm_data
4080 /* The level of the template parameters we are currently
4084 /* The index of the specialization argument we are currently
4088 /* An array whose size is the number of template parameters. The
4089 elements are nonzero if the parameter has been used in any one
4090 of the arguments processed so far. */
4093 /* An array whose size is the number of template arguments. The
4094 elements are nonzero if the argument makes use of template
4095 parameters of this level. */
4096 int* arg_uses_template_parms
;
4099 /* Subroutine of push_template_decl used to see if each template
4100 parameter in a partial specialization is used in the explicit
4101 argument list. If T is of the LEVEL given in DATA (which is
4102 treated as a template_parm_data*), then DATA->PARMS is marked
4106 mark_template_parm (tree t
, void* data
)
4110 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4112 template_parm_level_and_index (t
, &level
, &idx
);
4114 if (level
== tpd
->level
)
4116 tpd
->parms
[idx
] = 1;
4117 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4120 /* Return zero so that for_each_template_parm will continue the
4121 traversal of the tree; we want to mark *every* template parm. */
4125 /* Process the partial specialization DECL. */
4128 process_partial_specialization (tree decl
)
4130 tree type
= TREE_TYPE (decl
);
4131 tree tinfo
= get_template_info (decl
);
4132 tree maintmpl
= TI_TEMPLATE (tinfo
);
4133 tree specargs
= TI_ARGS (tinfo
);
4134 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4135 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4138 int nargs
= TREE_VEC_LENGTH (inner_args
);
4141 bool did_error_intro
= false;
4142 struct template_parm_data tpd
;
4143 struct template_parm_data tpd2
;
4145 gcc_assert (current_template_parms
);
4147 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4148 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4150 /* We check that each of the template parameters given in the
4151 partial specialization is used in the argument list to the
4152 specialization. For example:
4154 template <class T> struct S;
4155 template <class T> struct S<T*>;
4157 The second declaration is OK because `T*' uses the template
4158 parameter T, whereas
4160 template <class T> struct S<int>;
4162 is no good. Even trickier is:
4173 The S2<T> declaration is actually invalid; it is a
4174 full-specialization. Of course,
4177 struct S2<T (*)(U)>;
4179 or some such would have been OK. */
4180 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4181 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4182 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4184 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4185 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4186 for (i
= 0; i
< nargs
; ++i
)
4188 tpd
.current_arg
= i
;
4189 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4190 &mark_template_parm
,
4193 /*include_nondeduced_p=*/false);
4195 for (i
= 0; i
< ntparms
; ++i
)
4196 if (tpd
.parms
[i
] == 0)
4198 /* One of the template parms was not used in a deduced context in the
4200 if (!did_error_intro
)
4202 error ("template parameters not deducible in "
4203 "partial specialization:");
4204 did_error_intro
= true;
4207 inform (input_location
, " %qD",
4208 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4211 if (did_error_intro
)
4212 return error_mark_node
;
4214 /* [temp.class.spec]
4216 The argument list of the specialization shall not be identical to
4217 the implicit argument list of the primary template. */
4219 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4220 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
)))
4221 error ("partial specialization %qD does not specialize "
4222 "any template arguments", decl
);
4224 /* A partial specialization that replaces multiple parameters of the
4225 primary template with a pack expansion is less specialized for those
4227 if (nargs
< DECL_NTPARMS (maintmpl
))
4229 error ("partial specialization is not more specialized than the "
4230 "primary template because it replaces multiple parameters "
4231 "with a pack expansion");
4232 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4236 /* [temp.class.spec]
4238 A partially specialized non-type argument expression shall not
4239 involve template parameters of the partial specialization except
4240 when the argument expression is a simple identifier.
4242 The type of a template parameter corresponding to a specialized
4243 non-type argument shall not be dependent on a parameter of the
4246 Also, we verify that pack expansions only occur at the
4247 end of the argument list. */
4248 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4250 for (i
= 0; i
< nargs
; ++i
)
4252 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4253 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4254 tree packed_args
= NULL_TREE
;
4257 if (ARGUMENT_PACK_P (arg
))
4259 /* Extract the arguments from the argument pack. We'll be
4260 iterating over these in the following loop. */
4261 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4262 len
= TREE_VEC_LENGTH (packed_args
);
4265 for (j
= 0; j
< len
; j
++)
4268 /* Get the Jth argument in the parameter pack. */
4269 arg
= TREE_VEC_ELT (packed_args
, j
);
4271 if (PACK_EXPANSION_P (arg
))
4273 /* Pack expansions must come at the end of the
4275 if ((packed_args
&& j
< len
- 1)
4276 || (!packed_args
&& i
< nargs
- 1))
4278 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4279 error ("parameter pack argument %qE must be at the "
4280 "end of the template argument list", arg
);
4282 error ("parameter pack argument %qT must be at the "
4283 "end of the template argument list", arg
);
4287 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4288 /* We only care about the pattern. */
4289 arg
= PACK_EXPANSION_PATTERN (arg
);
4291 if (/* These first two lines are the `non-type' bit. */
4293 && TREE_CODE (arg
) != TEMPLATE_DECL
4294 /* This next two lines are the `argument expression is not just a
4295 simple identifier' condition and also the `specialized
4296 non-type argument' bit. */
4297 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4298 && !(REFERENCE_REF_P (arg
)
4299 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4301 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4302 || (packed_args
&& uses_template_parms (arg
)))
4303 error ("template argument %qE involves template parameter(s)",
4307 /* Look at the corresponding template parameter,
4308 marking which template parameters its type depends
4310 tree type
= TREE_TYPE (parm
);
4314 /* We haven't yet initialized TPD2. Do so now. */
4315 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4316 /* The number of parameters here is the number in the
4317 main template, which, as checked in the assertion
4319 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4321 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4324 /* Mark the template parameters. But this time, we're
4325 looking for the template parameters of the main
4326 template, not in the specialization. */
4327 tpd2
.current_arg
= i
;
4328 tpd2
.arg_uses_template_parms
[i
] = 0;
4329 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4330 for_each_template_parm (type
,
4331 &mark_template_parm
,
4334 /*include_nondeduced_p=*/false);
4336 if (tpd2
.arg_uses_template_parms
[i
])
4338 /* The type depended on some template parameters.
4339 If they are fully specialized in the
4340 specialization, that's OK. */
4343 for (j
= 0; j
< nargs
; ++j
)
4344 if (tpd2
.parms
[j
] != 0
4345 && tpd
.arg_uses_template_parms
[j
])
4348 error_n (input_location
, count
,
4349 "type %qT of template argument %qE depends "
4350 "on a template parameter",
4351 "type %qT of template argument %qE depends "
4352 "on template parameters",
4361 /* We should only get here once. */
4362 if (TREE_CODE (decl
) == TYPE_DECL
)
4363 gcc_assert (!COMPLETE_TYPE_P (type
));
4365 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4366 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4367 TREE_TYPE (tmpl
) = type
;
4368 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4369 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4370 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4371 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4373 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4374 = tree_cons (specargs
, tmpl
,
4375 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4376 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4378 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4379 inst
= TREE_CHAIN (inst
))
4381 tree instance
= TREE_VALUE (inst
);
4382 if (TYPE_P (instance
)
4383 ? (COMPLETE_TYPE_P (instance
)
4384 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
4385 : DECL_TEMPLATE_INSTANTIATION (instance
))
4387 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
4388 if (spec
&& TREE_VALUE (spec
) == tmpl
)
4390 tree inst_decl
= (DECL_P (instance
)
4391 ? instance
: TYPE_NAME (instance
));
4392 permerror (input_location
,
4393 "partial specialization of %qD after instantiation "
4394 "of %qD", decl
, inst_decl
);
4402 /* PARM is a template parameter of some form; return the corresponding
4403 TEMPLATE_PARM_INDEX. */
4406 get_template_parm_index (tree parm
)
4408 if (TREE_CODE (parm
) == PARM_DECL
4409 || TREE_CODE (parm
) == CONST_DECL
)
4410 parm
= DECL_INITIAL (parm
);
4411 else if (TREE_CODE (parm
) == TYPE_DECL
4412 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4413 parm
= TREE_TYPE (parm
);
4414 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4415 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4416 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4417 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4421 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4422 parameter packs used by the template parameter PARM. */
4425 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4427 /* A type parm can't refer to another parm. */
4428 if (TREE_CODE (parm
) == TYPE_DECL
)
4430 else if (TREE_CODE (parm
) == PARM_DECL
)
4432 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4437 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4439 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4440 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4441 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4444 /* PARM is a template parameter pack. Return any parameter packs used in
4445 its type or the type of any of its template parameters. If there are
4446 any such packs, it will be instantiated into a fixed template parameter
4447 list by partial instantiation rather than be fully deduced. */
4450 fixed_parameter_pack_p (tree parm
)
4452 /* This can only be true in a member template. */
4453 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4455 /* This can only be true for a parameter pack. */
4456 if (!template_parameter_pack_p (parm
))
4458 /* A type parm can't refer to another parm. */
4459 if (TREE_CODE (parm
) == TYPE_DECL
)
4462 tree parameter_packs
= NULL_TREE
;
4463 struct find_parameter_pack_data ppd
;
4464 ppd
.parameter_packs
= ¶meter_packs
;
4465 ppd
.visited
= new hash_set
<tree
>;
4467 fixed_parameter_pack_p_1 (parm
, &ppd
);
4470 return parameter_packs
;
4473 /* Check that a template declaration's use of default arguments and
4474 parameter packs is not invalid. Here, PARMS are the template
4475 parameters. IS_PRIMARY is true if DECL is the thing declared by
4476 a primary template. IS_PARTIAL is true if DECL is a partial
4479 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4480 declaration (but not a definition); 1 indicates a declaration, 2
4481 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4482 emitted for extraneous default arguments.
4484 Returns TRUE if there were no errors found, FALSE otherwise. */
4487 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4488 bool is_partial
, int is_friend_decl
)
4491 int last_level_to_check
;
4493 bool no_errors
= true;
4497 A default template-argument shall not be specified in a
4498 function template declaration or a function template definition, nor
4499 in the template-parameter-list of the definition of a member of a
4502 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
4503 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
4504 /* You can't have a function template declaration in a local
4505 scope, nor you can you define a member of a class template in a
4509 if ((TREE_CODE (decl
) == TYPE_DECL
4511 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4512 || (TREE_CODE (decl
) == FUNCTION_DECL
4513 && LAMBDA_FUNCTION_P (decl
)))
4514 /* A lambda doesn't have an explicit declaration; don't complain
4515 about the parms of the enclosing class. */
4518 if (current_class_type
4519 && !TYPE_BEING_DEFINED (current_class_type
)
4520 && DECL_LANG_SPECIFIC (decl
)
4521 && DECL_DECLARES_FUNCTION_P (decl
)
4522 /* If this is either a friend defined in the scope of the class
4523 or a member function. */
4524 && (DECL_FUNCTION_MEMBER_P (decl
)
4525 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4526 : DECL_FRIEND_CONTEXT (decl
)
4527 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4529 /* And, if it was a member function, it really was defined in
4530 the scope of the class. */
4531 && (!DECL_FUNCTION_MEMBER_P (decl
)
4532 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4533 /* We already checked these parameters when the template was
4534 declared, so there's no need to do it again now. This function
4535 was defined in class scope, but we're processing its body now
4536 that the class is complete. */
4539 /* Core issue 226 (C++0x only): the following only applies to class
4542 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4546 If a template-parameter has a default template-argument, all
4547 subsequent template-parameters shall have a default
4548 template-argument supplied. */
4549 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4551 tree inner_parms
= TREE_VALUE (parm_level
);
4552 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4553 int seen_def_arg_p
= 0;
4556 for (i
= 0; i
< ntparms
; ++i
)
4558 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4560 if (parm
== error_mark_node
)
4563 if (TREE_PURPOSE (parm
))
4565 else if (seen_def_arg_p
4566 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4568 error ("no default argument for %qD", TREE_VALUE (parm
));
4569 /* For better subsequent error-recovery, we indicate that
4570 there should have been a default argument. */
4571 TREE_PURPOSE (parm
) = error_mark_node
;
4574 else if (!is_partial
4576 /* Don't complain about an enclosing partial
4578 && parm_level
== parms
4579 && TREE_CODE (decl
) == TYPE_DECL
4581 && template_parameter_pack_p (TREE_VALUE (parm
))
4582 /* A fixed parameter pack will be partially
4583 instantiated into a fixed length list. */
4584 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4586 /* A primary class template can only have one
4587 parameter pack, at the end of the template
4590 error ("parameter pack %q+D must be at the end of the"
4591 " template parameter list", TREE_VALUE (parm
));
4593 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4601 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4605 /* For an ordinary class template, default template arguments are
4606 allowed at the innermost level, e.g.:
4607 template <class T = int>
4609 but, in a partial specialization, they're not allowed even
4610 there, as we have in [temp.class.spec]:
4612 The template parameter list of a specialization shall not
4613 contain default template argument values.
4615 So, for a partial specialization, or for a function template
4616 (in C++98/C++03), we look at all of them. */
4619 /* But, for a primary class template that is not a partial
4620 specialization we look at all template parameters except the
4622 parms
= TREE_CHAIN (parms
);
4624 /* Figure out what error message to issue. */
4625 if (is_friend_decl
== 2)
4626 msg
= G_("default template arguments may not be used in function template "
4627 "friend re-declaration");
4628 else if (is_friend_decl
)
4629 msg
= G_("default template arguments may not be used in function template "
4630 "friend declarations");
4631 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4632 msg
= G_("default template arguments may not be used in function templates "
4633 "without -std=c++11 or -std=gnu++11");
4634 else if (is_partial
)
4635 msg
= G_("default template arguments may not be used in "
4636 "partial specializations");
4638 msg
= G_("default argument for template parameter for class enclosing %qD");
4640 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4641 /* If we're inside a class definition, there's no need to
4642 examine the parameters to the class itself. On the one
4643 hand, they will be checked when the class is defined, and,
4644 on the other, default arguments are valid in things like:
4645 template <class T = double>
4646 struct S { template <class U> void f(U); };
4647 Here the default argument for `S' has no bearing on the
4648 declaration of `f'. */
4649 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4651 /* Check everything. */
4652 last_level_to_check
= 0;
4654 for (parm_level
= parms
;
4655 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4656 parm_level
= TREE_CHAIN (parm_level
))
4658 tree inner_parms
= TREE_VALUE (parm_level
);
4662 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4663 for (i
= 0; i
< ntparms
; ++i
)
4665 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4668 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4673 if (is_friend_decl
== 2)
4680 /* Clear out the default argument so that we are not
4682 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
4686 /* At this point, if we're still interested in issuing messages,
4687 they must apply to classes surrounding the object declared. */
4689 msg
= G_("default argument for template parameter for class "
4696 /* Worker for push_template_decl_real, called via
4697 for_each_template_parm. DATA is really an int, indicating the
4698 level of the parameters we are interested in. If T is a template
4699 parameter of that level, return nonzero. */
4702 template_parm_this_level_p (tree t
, void* data
)
4704 int this_level
= *(int *)data
;
4707 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4708 level
= TEMPLATE_PARM_LEVEL (t
);
4710 level
= TEMPLATE_TYPE_LEVEL (t
);
4711 return level
== this_level
;
4714 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4715 parameters given by current_template_args, or reuses a
4716 previously existing one, if appropriate. Returns the DECL, or an
4717 equivalent one, if it is replaced via a call to duplicate_decls.
4719 If IS_FRIEND is true, DECL is a friend declaration. */
4722 push_template_decl_real (tree decl
, bool is_friend
)
4730 int new_template_p
= 0;
4731 /* True if the template is a member template, in the sense of
4733 bool member_template_p
= false;
4735 if (decl
== error_mark_node
|| !current_template_parms
)
4736 return error_mark_node
;
4738 /* See if this is a partial specialization. */
4739 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
4740 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
4741 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
4742 || (TREE_CODE (decl
) == VAR_DECL
4743 && DECL_LANG_SPECIFIC (decl
)
4744 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4745 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
4747 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
4751 /* For a friend, we want the context of the friend function, not
4752 the type of which it is a friend. */
4753 ctx
= CP_DECL_CONTEXT (decl
);
4754 else if (CP_DECL_CONTEXT (decl
)
4755 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4756 /* In the case of a virtual function, we want the class in which
4758 ctx
= CP_DECL_CONTEXT (decl
);
4760 /* Otherwise, if we're currently defining some class, the DECL
4761 is assumed to be a member of the class. */
4762 ctx
= current_scope ();
4764 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
4767 if (!DECL_CONTEXT (decl
))
4768 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
4770 /* See if this is a primary template. */
4771 if (is_friend
&& ctx
4772 && uses_template_parms_level (ctx
, processing_template_decl
))
4773 /* A friend template that specifies a class context, i.e.
4774 template <typename T> friend void A<T>::f();
4777 else if (TREE_CODE (decl
) == TYPE_DECL
4778 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4781 is_primary
= template_parm_scope_p ();
4785 if (DECL_CLASS_SCOPE_P (decl
))
4786 member_template_p
= true;
4787 if (TREE_CODE (decl
) == TYPE_DECL
4788 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
4790 error ("template class without a name");
4791 return error_mark_node
;
4793 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
4795 if (member_template_p
)
4797 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
4798 error ("member template %qD may not have virt-specifiers", decl
);
4800 if (DECL_DESTRUCTOR_P (decl
))
4804 A destructor shall not be a member template. */
4805 error ("destructor %qD declared as member template", decl
);
4806 return error_mark_node
;
4808 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
4809 && (!prototype_p (TREE_TYPE (decl
))
4810 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
4811 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
4812 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
4813 == void_list_node
)))
4815 /* [basic.stc.dynamic.allocation]
4817 An allocation function can be a function
4818 template. ... Template allocation functions shall
4819 have two or more parameters. */
4820 error ("invalid template declaration of %qD", decl
);
4821 return error_mark_node
;
4824 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4825 && CLASS_TYPE_P (TREE_TYPE (decl
)))
4827 else if (TREE_CODE (decl
) == TYPE_DECL
4828 && TYPE_DECL_ALIAS_P (decl
))
4829 /* alias-declaration */
4830 gcc_assert (!DECL_ARTIFICIAL (decl
));
4831 else if (VAR_P (decl
))
4832 /* C++14 variable template. */;
4835 error ("template declaration of %q#D", decl
);
4836 return error_mark_node
;
4840 /* Check to see that the rules regarding the use of default
4841 arguments are not being violated. */
4842 check_default_tmpl_args (decl
, current_template_parms
,
4843 is_primary
, is_partial
, /*is_friend_decl=*/0);
4845 /* Ensure that there are no parameter packs in the type of this
4846 declaration that have not been expanded. */
4847 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4849 /* Check each of the arguments individually to see if there are
4850 any bare parameter packs. */
4851 tree type
= TREE_TYPE (decl
);
4852 tree arg
= DECL_ARGUMENTS (decl
);
4853 tree argtype
= TYPE_ARG_TYPES (type
);
4855 while (arg
&& argtype
)
4857 if (!DECL_PACK_P (arg
)
4858 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
4860 /* This is a PARM_DECL that contains unexpanded parameter
4861 packs. We have already complained about this in the
4862 check_for_bare_parameter_packs call, so just replace
4863 these types with ERROR_MARK_NODE. */
4864 TREE_TYPE (arg
) = error_mark_node
;
4865 TREE_VALUE (argtype
) = error_mark_node
;
4868 arg
= DECL_CHAIN (arg
);
4869 argtype
= TREE_CHAIN (argtype
);
4872 /* Check for bare parameter packs in the return type and the
4873 exception specifiers. */
4874 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
4875 /* Errors were already issued, set return type to int
4876 as the frontend doesn't expect error_mark_node as
4878 TREE_TYPE (type
) = integer_type_node
;
4879 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
4880 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
4882 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
4883 && TYPE_DECL_ALIAS_P (decl
))
4884 ? DECL_ORIGINAL_TYPE (decl
)
4885 : TREE_TYPE (decl
)))
4887 TREE_TYPE (decl
) = error_mark_node
;
4888 return error_mark_node
;
4892 return process_partial_specialization (decl
);
4894 args
= current_template_args ();
4897 || TREE_CODE (ctx
) == FUNCTION_DECL
4898 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
4899 || (TREE_CODE (decl
) == TYPE_DECL
4900 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4901 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
4903 if (DECL_LANG_SPECIFIC (decl
)
4904 && DECL_TEMPLATE_INFO (decl
)
4905 && DECL_TI_TEMPLATE (decl
))
4906 tmpl
= DECL_TI_TEMPLATE (decl
);
4907 /* If DECL is a TYPE_DECL for a class-template, then there won't
4908 be DECL_LANG_SPECIFIC. The information equivalent to
4909 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4910 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4911 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
4912 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
4914 /* Since a template declaration already existed for this
4915 class-type, we must be redeclaring it here. Make sure
4916 that the redeclaration is valid. */
4917 redeclare_class_template (TREE_TYPE (decl
),
4918 current_template_parms
);
4919 /* We don't need to create a new TEMPLATE_DECL; just use the
4920 one we already had. */
4921 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
4925 tmpl
= build_template_decl (decl
, current_template_parms
,
4929 if (DECL_LANG_SPECIFIC (decl
)
4930 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4932 /* A specialization of a member template of a template
4934 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4935 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
4936 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
4942 tree a
, t
, current
, parms
;
4944 tree tinfo
= get_template_info (decl
);
4948 error ("template definition of non-template %q#D", decl
);
4949 return error_mark_node
;
4952 tmpl
= TI_TEMPLATE (tinfo
);
4954 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
4955 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
4956 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4957 && DECL_MEMBER_TEMPLATE_P (tmpl
))
4961 /* The declaration is a specialization of a member
4962 template, declared outside the class. Therefore, the
4963 innermost template arguments will be NULL, so we
4964 replace them with the arguments determined by the
4965 earlier call to check_explicit_specialization. */
4966 args
= DECL_TI_ARGS (decl
);
4969 = build_template_decl (decl
, current_template_parms
,
4971 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
4972 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
4973 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
4974 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
4975 DECL_TEMPLATE_INFO (new_tmpl
)
4976 = build_template_info (tmpl
, args
);
4978 register_specialization (new_tmpl
,
4979 most_general_template (tmpl
),
4985 /* Make sure the template headers we got make sense. */
4987 parms
= DECL_TEMPLATE_PARMS (tmpl
);
4988 i
= TMPL_PARMS_DEPTH (parms
);
4989 if (TMPL_ARGS_DEPTH (args
) != i
)
4991 error ("expected %d levels of template parms for %q#D, got %d",
4992 i
, decl
, TMPL_ARGS_DEPTH (args
));
4993 DECL_INTERFACE_KNOWN (decl
) = 1;
4994 return error_mark_node
;
4997 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
4999 a
= TMPL_ARGS_LEVEL (args
, i
);
5000 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5002 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5004 if (current
== decl
)
5005 error ("got %d template parameters for %q#D",
5006 TREE_VEC_LENGTH (a
), decl
);
5008 error ("got %d template parameters for %q#T",
5009 TREE_VEC_LENGTH (a
), current
);
5010 error (" but %d required", TREE_VEC_LENGTH (t
));
5011 /* Avoid crash in import_export_decl. */
5012 DECL_INTERFACE_KNOWN (decl
) = 1;
5013 return error_mark_node
;
5016 if (current
== decl
)
5018 else if (current
== NULL_TREE
)
5019 /* Can happen in erroneous input. */
5022 current
= get_containing_scope (current
);
5025 /* Check that the parms are used in the appropriate qualifying scopes
5026 in the declarator. */
5027 if (!comp_template_args
5029 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5032 template arguments to %qD do not match original template %qD",
5033 decl
, DECL_TEMPLATE_RESULT (tmpl
));
5034 if (!uses_template_parms (TI_ARGS (tinfo
)))
5035 inform (input_location
, "use template<> for an explicit specialization");
5036 /* Avoid crash in import_export_decl. */
5037 DECL_INTERFACE_KNOWN (decl
) = 1;
5038 return error_mark_node
;
5042 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5043 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5045 /* Push template declarations for global functions and types. Note
5046 that we do not try to push a global template friend declared in a
5047 template class; such a thing may well depend on the template
5048 parameters of the class. */
5049 if (new_template_p
&& !ctx
5050 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5052 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5053 if (tmpl
== error_mark_node
)
5054 return error_mark_node
;
5056 /* Hide template friend classes that haven't been declared yet. */
5057 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5059 DECL_ANTICIPATED (tmpl
) = 1;
5060 DECL_FRIEND_P (tmpl
) = 1;
5066 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5069 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5070 if (DECL_CONV_FN_P (tmpl
))
5072 int depth
= TMPL_PARMS_DEPTH (parms
);
5074 /* It is a conversion operator. See if the type converted to
5075 depends on innermost template operands. */
5077 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
5079 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
5082 /* Give template template parms a DECL_CONTEXT of the template
5083 for which they are a parameter. */
5084 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5085 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5087 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5088 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5089 DECL_CONTEXT (parm
) = tmpl
;
5093 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5094 back to its most general template. If TMPL is a specialization,
5095 ARGS may only have the innermost set of arguments. Add the missing
5096 argument levels if necessary. */
5097 if (DECL_TEMPLATE_INFO (tmpl
))
5098 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5100 info
= build_template_info (tmpl
, args
);
5102 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5103 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5106 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5107 retrofit_lang_decl (decl
);
5108 if (DECL_LANG_SPECIFIC (decl
))
5109 DECL_TEMPLATE_INFO (decl
) = info
;
5112 if (flag_implicit_templates
5114 && TREE_PUBLIC (decl
)
5115 && VAR_OR_FUNCTION_DECL_P (decl
))
5116 /* Set DECL_COMDAT on template instantiations; if we force
5117 them to be emitted by explicit instantiation or -frepo,
5118 mark_needed will tell cgraph to do the right thing. */
5119 DECL_COMDAT (decl
) = true;
5121 return DECL_TEMPLATE_RESULT (tmpl
);
5125 push_template_decl (tree decl
)
5127 return push_template_decl_real (decl
, false);
5130 /* FN is an inheriting constructor that inherits from the constructor
5131 template INHERITED; turn FN into a constructor template with a matching
5135 add_inherited_template_parms (tree fn
, tree inherited
)
5138 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5139 inner_parms
= copy_node (inner_parms
);
5141 = tree_cons (size_int (processing_template_decl
+ 1),
5142 inner_parms
, current_template_parms
);
5143 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5144 tree args
= template_parms_to_args (parms
);
5145 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5146 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5147 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5148 DECL_ARTIFICIAL (tmpl
) = true;
5149 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5153 /* Called when a class template TYPE is redeclared with the indicated
5154 template PARMS, e.g.:
5156 template <class T> struct S;
5157 template <class T> struct S {}; */
5160 redeclare_class_template (tree type
, tree parms
)
5166 if (!TYPE_TEMPLATE_INFO (type
))
5168 error ("%qT is not a template type", type
);
5172 tmpl
= TYPE_TI_TEMPLATE (type
);
5173 if (!PRIMARY_TEMPLATE_P (tmpl
))
5174 /* The type is nested in some template class. Nothing to worry
5175 about here; there are no new template parameters for the nested
5181 error ("template specifiers not specified in declaration of %qD",
5186 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5187 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5189 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5191 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5192 "redeclared with %d template parameter",
5193 "redeclared with %d template parameters",
5194 TREE_VEC_LENGTH (parms
));
5195 inform_n (input_location
, TREE_VEC_LENGTH (tmpl_parms
),
5196 "previous declaration %q+D used %d template parameter",
5197 "previous declaration %q+D used %d template parameters",
5198 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5202 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5209 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5210 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5213 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5214 if (error_operand_p (tmpl_parm
))
5217 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5218 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5219 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5221 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5223 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5224 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5225 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5226 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5227 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5228 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5229 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5230 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5231 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5233 error ("template parameter %q+#D", tmpl_parm
);
5234 error ("redeclared here as %q#D", parm
);
5238 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5240 /* We have in [temp.param]:
5242 A template-parameter may not be given default arguments
5243 by two different declarations in the same scope. */
5244 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5245 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5246 "original definition appeared here");
5250 if (parm_default
!= NULL_TREE
)
5251 /* Update the previous template parameters (which are the ones
5252 that will really count) with the new default value. */
5253 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5254 else if (tmpl_default
!= NULL_TREE
)
5255 /* Update the new parameters, too; they'll be used as the
5256 parameters for any members. */
5257 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5263 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5264 to be used when the caller has already checked
5265 (processing_template_decl
5266 && !instantiation_dependent_expression_p (expr)
5267 && potential_constant_expression (expr))
5268 and cleared processing_template_decl. */
5271 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
5273 return tsubst_copy_and_build (expr
,
5276 /*in_decl=*/NULL_TREE
,
5277 /*function_p=*/false,
5278 /*integral_constant_expression_p=*/true);
5281 /* Simplify EXPR if it is a non-dependent expression. Returns the
5282 (possibly simplified) expression. */
5285 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5287 if (expr
== NULL_TREE
)
5290 /* If we're in a template, but EXPR isn't value dependent, simplify
5291 it. We're supposed to treat:
5293 template <typename T> void f(T[1 + 1]);
5294 template <typename T> void f(T[2]);
5296 as two declarations of the same function, for example. */
5297 if (processing_template_decl
5298 && !instantiation_dependent_expression_p (expr
)
5299 && potential_constant_expression (expr
))
5301 processing_template_decl_sentinel s
;
5302 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
5308 instantiate_non_dependent_expr (tree expr
)
5310 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
5313 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5314 template declaration, or a TYPE_DECL for an alias declaration. */
5317 alias_type_or_template_p (tree t
)
5321 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5324 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5325 || DECL_ALIAS_TEMPLATE_P (t
));
5328 /* Return TRUE iff T is a specialization of an alias template. */
5331 alias_template_specialization_p (const_tree t
)
5333 /* It's an alias template specialization if it's an alias and its
5334 TYPE_NAME is a specialization of a primary template. */
5335 if (TYPE_ALIAS_P (t
))
5337 tree name
= TYPE_NAME (t
);
5338 if (DECL_LANG_SPECIFIC (name
))
5339 if (tree ti
= DECL_TEMPLATE_INFO (name
))
5341 tree tmpl
= TI_TEMPLATE (ti
);
5342 return PRIMARY_TEMPLATE_P (tmpl
);
5348 /* Return TRUE iff T is a specialization of an alias template with
5349 dependent template-arguments. */
5352 dependent_alias_template_spec_p (const_tree t
)
5354 return (alias_template_specialization_p (t
)
5355 && (any_dependent_template_arguments_p
5356 (INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (t
)))));
5359 /* Return the number of innermost template parameters in TMPL. */
5362 num_innermost_template_parms (tree tmpl
)
5364 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5365 return TREE_VEC_LENGTH (parms
);
5368 /* Return either TMPL or another template that it is equivalent to under DR
5369 1286: An alias that just changes the name of a template is equivalent to
5370 the other template. */
5373 get_underlying_template (tree tmpl
)
5375 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5376 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5378 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5379 if (TYPE_TEMPLATE_INFO (result
))
5381 tree sub
= TYPE_TI_TEMPLATE (result
);
5382 if (PRIMARY_TEMPLATE_P (sub
)
5383 && (num_innermost_template_parms (tmpl
)
5384 == num_innermost_template_parms (sub
)))
5386 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5387 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5388 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5390 /* The alias type is equivalent to the pattern of the
5391 underlying template, so strip the alias. */
5401 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5402 must be a function or a pointer-to-function type, as specified
5403 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5404 and check that the resulting function has external linkage. */
5407 convert_nontype_argument_function (tree type
, tree expr
,
5408 tsubst_flags_t complain
)
5412 linkage_kind linkage
;
5414 fn
= instantiate_type (type
, fns
, tf_none
);
5415 if (fn
== error_mark_node
)
5416 return error_mark_node
;
5419 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5420 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5421 if (BASELINK_P (fn_no_ptr
))
5422 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5424 /* [temp.arg.nontype]/1
5426 A template-argument for a non-type, non-template template-parameter
5429 -- the address of an object or function with external [C++11: or
5430 internal] linkage. */
5432 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5434 if (complain
& tf_error
)
5436 error ("%qE is not a valid template argument for type %qT",
5438 if (TYPE_PTR_P (type
))
5439 error ("it must be the address of a function with "
5440 "external linkage");
5442 error ("it must be the name of a function with "
5443 "external linkage");
5448 linkage
= decl_linkage (fn_no_ptr
);
5449 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5451 if (complain
& tf_error
)
5453 if (cxx_dialect
>= cxx11
)
5454 error ("%qE is not a valid template argument for type %qT "
5455 "because %qD has no linkage",
5456 expr
, type
, fn_no_ptr
);
5458 error ("%qE is not a valid template argument for type %qT "
5459 "because %qD does not have external linkage",
5460 expr
, type
, fn_no_ptr
);
5468 /* Subroutine of convert_nontype_argument.
5469 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5470 Emit an error otherwise. */
5473 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5474 tsubst_flags_t complain
)
5477 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5479 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5481 if (processing_template_decl
5482 && TREE_CODE (expr
) == ADDR_EXPR
5483 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
5485 if (complain
& tf_error
)
5487 error ("%qE is not a valid template argument for type %qT",
5489 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5494 /* Returns TRUE iff the address of OP is value-dependent.
5496 14.6.2.4 [temp.dep.temp]:
5497 A non-integral non-type template-argument is dependent if its type is
5498 dependent or it has either of the following forms
5501 and contains a nested-name-specifier which specifies a class-name that
5502 names a dependent type.
5504 We generalize this to just say that the address of a member of a
5505 dependent class is value-dependent; the above doesn't cover the
5506 address of a static data member named with an unqualified-id. */
5509 has_value_dependent_address (tree op
)
5511 /* We could use get_inner_reference here, but there's no need;
5512 this is only relevant for template non-type arguments, which
5513 can only be expressed as &id-expression. */
5516 tree ctx
= CP_DECL_CONTEXT (op
);
5517 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5524 /* The next set of functions are used for providing helpful explanatory
5525 diagnostics for failed overload resolution. Their messages should be
5526 indented by two spaces for consistency with the messages in
5530 unify_success (bool /*explain_p*/)
5536 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5539 inform (input_location
,
5540 " couldn't deduce template parameter %qD", parm
);
5545 unify_invalid (bool /*explain_p*/)
5551 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5554 inform (input_location
,
5555 " types %qT and %qT have incompatible cv-qualifiers",
5561 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5564 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5569 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5572 inform (input_location
,
5573 " template parameter %qD is not a parameter pack, but "
5580 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5583 inform (input_location
,
5584 " template argument %qE does not match "
5585 "pointer-to-member constant %qE",
5591 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5594 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5599 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5602 inform (input_location
,
5603 " inconsistent parameter pack deduction with %qT and %qT",
5609 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5614 inform (input_location
,
5615 " deduced conflicting types for parameter %qT (%qT and %qT)",
5616 parm
, first
, second
);
5618 inform (input_location
,
5619 " deduced conflicting values for non-type parameter "
5620 "%qE (%qE and %qE)", parm
, first
, second
);
5626 unify_vla_arg (bool explain_p
, tree arg
)
5629 inform (input_location
,
5630 " variable-sized array type %qT is not "
5631 "a valid template argument",
5637 unify_method_type_error (bool explain_p
, tree arg
)
5640 inform (input_location
,
5641 " member function type %qT is not a valid template argument",
5647 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
5652 inform_n (input_location
, wanted
,
5653 " candidate expects at least %d argument, %d provided",
5654 " candidate expects at least %d arguments, %d provided",
5657 inform_n (input_location
, wanted
,
5658 " candidate expects %d argument, %d provided",
5659 " candidate expects %d arguments, %d provided",
5666 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5668 return unify_arity (explain_p
, have
, wanted
);
5672 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
5673 bool least_p
= false)
5675 return unify_arity (explain_p
, have
, wanted
, least_p
);
5679 unify_arg_conversion (bool explain_p
, tree to_type
,
5680 tree from_type
, tree arg
)
5683 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5684 " cannot convert %qE (type %qT) to type %qT",
5685 arg
, from_type
, to_type
);
5690 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5691 tree parm
, tree arg
)
5696 case tbr_ambiguous_baseclass
:
5697 inform (input_location
, " %qT is an ambiguous base class of %qT",
5701 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5708 unify_inconsistent_template_template_parameters (bool explain_p
)
5711 inform (input_location
,
5712 " template parameters of a template template argument are "
5713 "inconsistent with other deduced template arguments");
5718 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5721 inform (input_location
,
5722 " can't deduce a template for %qT from non-template type %qT",
5728 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5731 inform (input_location
,
5732 " template argument %qE does not match %qD", arg
, parm
);
5737 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5740 inform (input_location
,
5741 " could not resolve address from overloaded function %qE",
5746 /* Attempt to convert the non-type template parameter EXPR to the
5747 indicated TYPE. If the conversion is successful, return the
5748 converted value. If the conversion is unsuccessful, return
5749 NULL_TREE if we issued an error message, or error_mark_node if we
5750 did not. We issue error messages for out-and-out bad template
5751 parameters, but not simply because the conversion failed, since we
5752 might be just trying to do argument deduction. Both TYPE and EXPR
5753 must be non-dependent.
5755 The conversion follows the special rules described in
5756 [temp.arg.nontype], and it is much more strict than an implicit
5759 This function is called twice for each template argument (see
5760 lookup_template_class for a more accurate description of this
5761 problem). This means that we need to handle expressions which
5762 are not valid in a C++ source, but can be created from the
5763 first call (for instance, casts to perform conversions). These
5764 hacks can go away after we fix the double coercion problem. */
5767 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5771 /* Detect immediately string literals as invalid non-type argument.
5772 This special-case is not needed for correctness (we would easily
5773 catch this later), but only to provide better diagnostic for this
5774 common user mistake. As suggested by DR 100, we do not mention
5775 linkage issues in the diagnostic as this is not the point. */
5776 /* FIXME we're making this OK. */
5777 if (TREE_CODE (expr
) == STRING_CST
)
5779 if (complain
& tf_error
)
5780 error ("%qE is not a valid template argument for type %qT "
5781 "because string literals can never be used in this context",
5786 /* Add the ADDR_EXPR now for the benefit of
5787 value_dependent_expression_p. */
5788 if (TYPE_PTROBV_P (type
)
5789 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5791 expr
= decay_conversion (expr
, complain
);
5792 if (expr
== error_mark_node
)
5793 return error_mark_node
;
5796 /* If we are in a template, EXPR may be non-dependent, but still
5797 have a syntactic, rather than semantic, form. For example, EXPR
5798 might be a SCOPE_REF, rather than the VAR_DECL to which the
5799 SCOPE_REF refers. Preserving the qualifying scope is necessary
5800 so that access checking can be performed when the template is
5801 instantiated -- but here we need the resolved form so that we can
5802 convert the argument. */
5803 bool non_dep
= false;
5804 if (TYPE_REF_OBJ_P (type
)
5805 && has_value_dependent_address (expr
))
5806 /* If we want the address and it's value-dependent, don't fold. */;
5807 else if (!type_unknown_p (expr
)
5808 && processing_template_decl
5809 && !instantiation_dependent_expression_p (expr
)
5810 && potential_constant_expression (expr
))
5812 if (error_operand_p (expr
))
5813 return error_mark_node
;
5814 expr_type
= TREE_TYPE (expr
);
5815 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5816 expr
= mark_lvalue_use (expr
);
5818 expr
= mark_rvalue_use (expr
);
5820 /* If the argument is non-dependent, perform any conversions in
5821 non-dependent context as well. */
5822 processing_template_decl_sentinel
s (non_dep
);
5824 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
5826 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5827 to a non-type argument of "nullptr". */
5828 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5829 expr
= convert (type
, expr
);
5831 /* In C++11, integral or enumeration non-type template arguments can be
5832 arbitrary constant expressions. Pointer and pointer to
5833 member arguments can be general constant expressions that evaluate
5834 to a null value, but otherwise still need to be of a specific form. */
5835 if (cxx_dialect
>= cxx11
)
5837 if (TREE_CODE (expr
) == PTRMEM_CST
)
5838 /* A PTRMEM_CST is already constant, and a valid template
5839 argument for a parameter of pointer to member type, we just want
5840 to leave it in that form rather than lower it to a
5842 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5843 expr
= maybe_constant_value (expr
);
5844 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5846 tree folded
= maybe_constant_value (expr
);
5847 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5848 : null_member_pointer_value_p (folded
))
5853 /* HACK: Due to double coercion, we can get a
5854 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5855 which is the tree that we built on the first call (see
5856 below when coercing to reference to object or to reference to
5857 function). We just strip everything and get to the arg.
5858 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5860 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5862 tree probe_type
, probe
= expr
;
5863 if (REFERENCE_REF_P (probe
))
5864 probe
= TREE_OPERAND (probe
, 0);
5865 probe_type
= TREE_TYPE (probe
);
5866 if (TREE_CODE (probe
) == NOP_EXPR
)
5868 /* ??? Maybe we could use convert_from_reference here, but we
5869 would need to relax its constraints because the NOP_EXPR
5870 could actually change the type to something more cv-qualified,
5871 and this is not folded by convert_from_reference. */
5872 tree addr
= TREE_OPERAND (probe
, 0);
5873 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5874 && TREE_CODE (addr
) == ADDR_EXPR
5875 && TYPE_PTR_P (TREE_TYPE (addr
))
5876 && (same_type_ignoring_top_level_qualifiers_p
5877 (TREE_TYPE (probe_type
),
5878 TREE_TYPE (TREE_TYPE (addr
)))))
5880 expr
= TREE_OPERAND (addr
, 0);
5881 expr_type
= TREE_TYPE (probe_type
);
5886 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5887 parameter is a pointer to object, through decay and
5888 qualification conversion. Let's strip everything. */
5889 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5893 if (TREE_CODE (probe
) == ADDR_EXPR
5894 && TYPE_PTR_P (TREE_TYPE (probe
)))
5896 /* Skip the ADDR_EXPR only if it is part of the decay for
5897 an array. Otherwise, it is part of the original argument
5898 in the source code. */
5899 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5900 probe
= TREE_OPERAND (probe
, 0);
5902 expr_type
= TREE_TYPE (expr
);
5906 /* [temp.arg.nontype]/5, bullet 1
5908 For a non-type template-parameter of integral or enumeration type,
5909 integral promotions (_conv.prom_) and integral conversions
5910 (_conv.integral_) are applied. */
5911 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5913 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5914 t
= maybe_constant_value (t
);
5915 if (t
!= error_mark_node
)
5918 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5919 return error_mark_node
;
5921 /* Notice that there are constant expressions like '4 % 0' which
5922 do not fold into integer constants. */
5923 if (TREE_CODE (expr
) != INTEGER_CST
)
5925 if (complain
& tf_error
)
5927 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
5928 if (processing_template_decl
5929 && !require_potential_constant_expression (expr
))
5931 expr
= cxx_constant_value (expr
);
5932 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
5933 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
5934 "in template argument for type %qT ", type
);
5935 if (expr
== error_mark_node
)
5937 /* else cxx_constant_value complained but gave us
5938 a real constant, so go ahead. */
5939 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
5945 /* Avoid typedef problems. */
5946 if (TREE_TYPE (expr
) != type
)
5947 expr
= fold_convert (type
, expr
);
5949 /* [temp.arg.nontype]/5, bullet 2
5951 For a non-type template-parameter of type pointer to object,
5952 qualification conversions (_conv.qual_) and the array-to-pointer
5953 conversion (_conv.array_) are applied. */
5954 else if (TYPE_PTROBV_P (type
))
5956 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5958 A template-argument for a non-type, non-template template-parameter
5959 shall be one of: [...]
5961 -- the name of a non-type template-parameter;
5962 -- the address of an object or function with external linkage, [...]
5963 expressed as "& id-expression" where the & is optional if the name
5964 refers to a function or array, or if the corresponding
5965 template-parameter is a reference.
5967 Here, we do not care about functions, as they are invalid anyway
5968 for a parameter of type pointer-to-object. */
5970 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
5971 /* Non-type template parameters are OK. */
5973 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5974 /* Null pointer values are OK in C++11. */;
5975 else if (TREE_CODE (expr
) != ADDR_EXPR
5976 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
5980 if (complain
& tf_error
)
5981 error ("%qD is not a valid template argument "
5982 "because %qD is a variable, not the address of "
5983 "a variable", expr
, expr
);
5986 if (POINTER_TYPE_P (expr_type
))
5988 if (complain
& tf_error
)
5989 error ("%qE is not a valid template argument for %qT "
5990 "because it is not the address of a variable",
5994 /* Other values, like integer constants, might be valid
5995 non-type arguments of some other type. */
5996 return error_mark_node
;
6002 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
6003 ? TREE_OPERAND (expr
, 0) : expr
);
6006 if (complain
& tf_error
)
6007 error ("%qE is not a valid template argument of type %qT "
6008 "because %qE is not a variable", expr
, type
, decl
);
6011 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6013 if (complain
& tf_error
)
6014 error ("%qE is not a valid template argument of type %qT "
6015 "because %qD does not have external linkage",
6019 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
6021 if (complain
& tf_error
)
6022 error ("%qE is not a valid template argument of type %qT "
6023 "because %qD has no linkage", expr
, type
, decl
);
6028 expr
= decay_conversion (expr
, complain
);
6029 if (expr
== error_mark_node
)
6030 return error_mark_node
;
6032 expr
= perform_qualification_conversions (type
, expr
);
6033 if (expr
== error_mark_node
)
6034 return error_mark_node
;
6036 /* [temp.arg.nontype]/5, bullet 3
6038 For a non-type template-parameter of type reference to object, no
6039 conversions apply. The type referred to by the reference may be more
6040 cv-qualified than the (otherwise identical) type of the
6041 template-argument. The template-parameter is bound directly to the
6042 template-argument, which must be an lvalue. */
6043 else if (TYPE_REF_OBJ_P (type
))
6045 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
6047 return error_mark_node
;
6049 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
6051 if (complain
& tf_error
)
6052 error ("%qE is not a valid template argument for type %qT "
6053 "because of conflicts in cv-qualification", expr
, type
);
6057 if (!real_lvalue_p (expr
))
6059 if (complain
& tf_error
)
6060 error ("%qE is not a valid template argument for type %qT "
6061 "because it is not an lvalue", expr
, type
);
6065 /* [temp.arg.nontype]/1
6067 A template-argument for a non-type, non-template template-parameter
6068 shall be one of: [...]
6070 -- the address of an object or function with external linkage. */
6071 if (INDIRECT_REF_P (expr
)
6072 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
6074 expr
= TREE_OPERAND (expr
, 0);
6077 if (complain
& tf_error
)
6078 error ("%q#D is not a valid template argument for type %qT "
6079 "because a reference variable does not have a constant "
6080 "address", expr
, type
);
6087 if (complain
& tf_error
)
6088 error ("%qE is not a valid template argument for type %qT "
6089 "because it is not an object with external linkage",
6094 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
6096 if (complain
& tf_error
)
6097 error ("%qE is not a valid template argument for type %qT "
6098 "because object %qD has not external linkage",
6103 expr
= build_nop (type
, build_address (expr
));
6105 /* [temp.arg.nontype]/5, bullet 4
6107 For a non-type template-parameter of type pointer to function, only
6108 the function-to-pointer conversion (_conv.func_) is applied. If the
6109 template-argument represents a set of overloaded functions (or a
6110 pointer to such), the matching function is selected from the set
6112 else if (TYPE_PTRFN_P (type
))
6114 /* If the argument is a template-id, we might not have enough
6115 context information to decay the pointer. */
6116 if (!type_unknown_p (expr_type
))
6118 expr
= decay_conversion (expr
, complain
);
6119 if (expr
== error_mark_node
)
6120 return error_mark_node
;
6123 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6124 /* Null pointer values are OK in C++11. */
6125 return perform_qualification_conversions (type
, expr
);
6127 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6128 if (!expr
|| expr
== error_mark_node
)
6131 /* [temp.arg.nontype]/5, bullet 5
6133 For a non-type template-parameter of type reference to function, no
6134 conversions apply. If the template-argument represents a set of
6135 overloaded functions, the matching function is selected from the set
6137 else if (TYPE_REFFN_P (type
))
6139 if (TREE_CODE (expr
) == ADDR_EXPR
)
6141 if (complain
& tf_error
)
6143 error ("%qE is not a valid template argument for type %qT "
6144 "because it is a pointer", expr
, type
);
6145 inform (input_location
, "try using %qE instead",
6146 TREE_OPERAND (expr
, 0));
6151 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6152 if (!expr
|| expr
== error_mark_node
)
6155 expr
= build_nop (type
, build_address (expr
));
6157 /* [temp.arg.nontype]/5, bullet 6
6159 For a non-type template-parameter of type pointer to member function,
6160 no conversions apply. If the template-argument represents a set of
6161 overloaded member functions, the matching member function is selected
6162 from the set (_over.over_). */
6163 else if (TYPE_PTRMEMFUNC_P (type
))
6165 expr
= instantiate_type (type
, expr
, tf_none
);
6166 if (expr
== error_mark_node
)
6167 return error_mark_node
;
6169 /* [temp.arg.nontype] bullet 1 says the pointer to member
6170 expression must be a pointer-to-member constant. */
6171 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6172 return error_mark_node
;
6174 /* There is no way to disable standard conversions in
6175 resolve_address_of_overloaded_function (called by
6176 instantiate_type). It is possible that the call succeeded by
6177 converting &B::I to &D::I (where B is a base of D), so we need
6178 to reject this conversion here.
6180 Actually, even if there was a way to disable standard conversions,
6181 it would still be better to reject them here so that we can
6182 provide a superior diagnostic. */
6183 if (!same_type_p (TREE_TYPE (expr
), type
))
6185 if (complain
& tf_error
)
6187 error ("%qE is not a valid template argument for type %qT "
6188 "because it is of type %qT", expr
, type
,
6190 /* If we are just one standard conversion off, explain. */
6191 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6192 inform (input_location
,
6193 "standard conversions are not allowed in this context");
6198 /* [temp.arg.nontype]/5, bullet 7
6200 For a non-type template-parameter of type pointer to data member,
6201 qualification conversions (_conv.qual_) are applied. */
6202 else if (TYPE_PTRDATAMEM_P (type
))
6204 /* [temp.arg.nontype] bullet 1 says the pointer to member
6205 expression must be a pointer-to-member constant. */
6206 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6207 return error_mark_node
;
6209 expr
= perform_qualification_conversions (type
, expr
);
6210 if (expr
== error_mark_node
)
6213 else if (NULLPTR_TYPE_P (type
))
6215 if (expr
!= nullptr_node
)
6217 if (complain
& tf_error
)
6218 error ("%qE is not a valid template argument for type %qT "
6219 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6224 /* A template non-type parameter must be one of the above. */
6228 /* Sanity check: did we actually convert the argument to the
6230 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6231 (type
, TREE_TYPE (expr
)));
6232 return convert_from_reference (expr
);
6235 /* Subroutine of coerce_template_template_parms, which returns 1 if
6236 PARM_PARM and ARG_PARM match using the rule for the template
6237 parameters of template template parameters. Both PARM and ARG are
6238 template parameters; the rest of the arguments are the same as for
6239 coerce_template_template_parms.
6242 coerce_template_template_parm (tree parm
,
6244 tsubst_flags_t complain
,
6248 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6249 || parm
== NULL_TREE
|| error_operand_p (parm
))
6252 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6255 switch (TREE_CODE (parm
))
6258 /* We encounter instantiations of templates like
6259 template <template <template <class> class> class TT>
6262 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6263 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6265 if (!coerce_template_template_parms
6266 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6272 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6273 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6274 /* Argument is a parameter pack but parameter is not. */
6279 /* The tsubst call is used to handle cases such as
6281 template <int> class C {};
6282 template <class T, template <T> class TT> class D {};
6285 i.e. the parameter list of TT depends on earlier parameters. */
6286 if (!uses_template_parms (TREE_TYPE (arg
))
6288 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6292 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6293 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6294 /* Argument is a parameter pack but parameter is not. */
6307 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6308 template template parameters. Both PARM_PARMS and ARG_PARMS are
6309 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6312 Consider the example:
6313 template <class T> class A;
6314 template<template <class U> class TT> class B;
6316 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6317 the parameters to A, and OUTER_ARGS contains A. */
6320 coerce_template_template_parms (tree parm_parms
,
6322 tsubst_flags_t complain
,
6326 int nparms
, nargs
, i
;
6330 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6331 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6333 nparms
= TREE_VEC_LENGTH (parm_parms
);
6334 nargs
= TREE_VEC_LENGTH (arg_parms
);
6336 /* Determine whether we have a parameter pack at the end of the
6337 template template parameter's template parameter list. */
6338 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6340 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6342 if (error_operand_p (parm
))
6345 switch (TREE_CODE (parm
))
6349 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6354 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6364 && !(variadic_p
&& nargs
>= nparms
- 1))
6367 /* Check all of the template parameters except the parameter pack at
6368 the end (if any). */
6369 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6371 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6372 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6375 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6376 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6378 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6386 /* Check each of the template parameters in the template
6387 argument against the template parameter pack at the end of
6388 the template template parameter. */
6389 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6392 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6394 for (; i
< nargs
; ++i
)
6396 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6399 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6401 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6410 /* Verifies that the deduced template arguments (in TARGS) for the
6411 template template parameters (in TPARMS) represent valid bindings,
6412 by comparing the template parameter list of each template argument
6413 to the template parameter list of its corresponding template
6414 template parameter, in accordance with DR150. This
6415 routine can only be called after all template arguments have been
6416 deduced. It will return TRUE if all of the template template
6417 parameter bindings are okay, FALSE otherwise. */
6419 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6421 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6424 /* We're dealing with template parms in this process. */
6425 ++processing_template_decl
;
6427 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6429 for (i
= 0; i
< ntparms
; ++i
)
6431 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6432 tree targ
= TREE_VEC_ELT (targs
, i
);
6434 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6436 tree packed_args
= NULL_TREE
;
6439 if (ARGUMENT_PACK_P (targ
))
6441 /* Look inside the argument pack. */
6442 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6443 len
= TREE_VEC_LENGTH (packed_args
);
6446 for (idx
= 0; idx
< len
; ++idx
)
6448 tree targ_parms
= NULL_TREE
;
6451 /* Extract the next argument from the argument
6453 targ
= TREE_VEC_ELT (packed_args
, idx
);
6455 if (PACK_EXPANSION_P (targ
))
6456 /* Look at the pattern of the pack expansion. */
6457 targ
= PACK_EXPANSION_PATTERN (targ
);
6459 /* Extract the template parameters from the template
6461 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6462 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6463 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6464 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6466 /* Verify that we can coerce the template template
6467 parameters from the template argument to the template
6468 parameter. This requires an exact match. */
6470 && !coerce_template_template_parms
6471 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6486 --processing_template_decl
;
6490 /* Since type attributes aren't mangled, we need to strip them from
6491 template type arguments. */
6494 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6497 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6499 mv
= TYPE_MAIN_VARIANT (arg
);
6500 arg
= strip_typedefs (arg
);
6501 if (TYPE_ALIGN (arg
) != TYPE_ALIGN (mv
)
6502 || TYPE_ATTRIBUTES (arg
) != TYPE_ATTRIBUTES (mv
))
6504 if (complain
& tf_warning
)
6505 warning (0, "ignoring attributes on template argument %qT", arg
);
6506 arg
= build_aligned_type (arg
, TYPE_ALIGN (mv
));
6507 arg
= cp_build_type_attribute_variant (arg
, TYPE_ATTRIBUTES (mv
));
6512 /* Convert the indicated template ARG as necessary to match the
6513 indicated template PARM. Returns the converted ARG, or
6514 error_mark_node if the conversion was unsuccessful. Error and
6515 warning messages are issued under control of COMPLAIN. This
6516 conversion is for the Ith parameter in the parameter list. ARGS is
6517 the full set of template arguments deduced so far. */
6520 convert_template_argument (tree parm
,
6523 tsubst_flags_t complain
,
6529 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6531 if (parm
== error_mark_node
)
6532 return error_mark_node
;
6534 if (TREE_CODE (arg
) == TREE_LIST
6535 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6537 /* The template argument was the name of some
6538 member function. That's usually
6539 invalid, but static members are OK. In any
6540 case, grab the underlying fields/functions
6541 and issue an error later if required. */
6542 orig_arg
= TREE_VALUE (arg
);
6543 TREE_TYPE (arg
) = unknown_type_node
;
6548 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6549 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6550 || requires_tmpl_type
);
6552 /* When determining whether an argument pack expansion is a template,
6553 look at the pattern. */
6554 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6555 arg
= PACK_EXPANSION_PATTERN (arg
);
6557 /* Deal with an injected-class-name used as a template template arg. */
6558 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6560 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6561 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6563 if (cxx_dialect
>= cxx11
)
6564 /* OK under DR 1004. */;
6565 else if (complain
& tf_warning_or_error
)
6566 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6567 " used as template template argument", TYPE_NAME (arg
));
6568 else if (flag_pedantic_errors
)
6576 ((TREE_CODE (arg
) == TEMPLATE_DECL
6577 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6578 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6579 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6580 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6583 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6584 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6585 arg
= TYPE_STUB_DECL (arg
);
6587 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6589 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6590 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6592 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6594 if (complain
& tf_error
)
6595 error ("invalid use of destructor %qE as a type", orig_arg
);
6596 return error_mark_node
;
6599 permerror (input_location
,
6600 "to refer to a type member of a template parameter, "
6601 "use %<typename %E%>", orig_arg
);
6603 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6604 TREE_OPERAND (arg
, 1),
6610 if (is_type
!= requires_type
)
6614 if (complain
& tf_error
)
6616 error ("type/value mismatch at argument %d in template "
6617 "parameter list for %qD",
6620 inform (input_location
,
6621 " expected a constant of type %qT, got %qT",
6623 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6624 else if (requires_tmpl_type
)
6625 inform (input_location
,
6626 " expected a class template, got %qE", orig_arg
);
6628 inform (input_location
,
6629 " expected a type, got %qE", orig_arg
);
6632 return error_mark_node
;
6634 if (is_tmpl_type
^ requires_tmpl_type
)
6636 if (in_decl
&& (complain
& tf_error
))
6638 error ("type/value mismatch at argument %d in template "
6639 "parameter list for %qD",
6642 inform (input_location
,
6643 " expected a type, got %qT", DECL_NAME (arg
));
6645 inform (input_location
,
6646 " expected a class template, got %qT", orig_arg
);
6648 return error_mark_node
;
6653 if (requires_tmpl_type
)
6655 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6657 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6658 /* The number of argument required is not known yet.
6659 Just accept it for now. */
6660 val
= TREE_TYPE (arg
);
6663 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6666 /* Strip alias templates that are equivalent to another
6668 arg
= get_underlying_template (arg
);
6669 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6671 if (coerce_template_template_parms (parmparm
, argparm
,
6677 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6679 if (val
!= error_mark_node
)
6681 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6682 val
= TREE_TYPE (val
);
6683 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6684 val
= make_pack_expansion (val
);
6689 if (in_decl
&& (complain
& tf_error
))
6691 error ("type/value mismatch at argument %d in "
6692 "template parameter list for %qD",
6694 inform (input_location
,
6695 " expected a template of type %qD, got %qT",
6699 val
= error_mark_node
;
6705 /* We only form one instance of each template specialization.
6706 Therefore, if we use a non-canonical variant (i.e., a
6707 typedef), any future messages referring to the type will use
6708 the typedef, which is confusing if those future uses do not
6709 themselves also use the typedef. */
6711 val
= canonicalize_type_argument (val
, complain
);
6715 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6717 if (invalid_nontype_parm_type_p (t
, complain
))
6718 return error_mark_node
;
6720 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6722 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6726 /* Not sure if this is reachable, but it doesn't hurt
6728 error ("type mismatch in nontype parameter pack");
6729 val
= error_mark_node
;
6732 else if (!dependent_template_arg_p (orig_arg
)
6733 && !uses_template_parms (t
))
6734 /* We used to call digest_init here. However, digest_init
6735 will report errors, which we don't want when complain
6736 is zero. More importantly, digest_init will try too
6737 hard to convert things: for example, `0' should not be
6738 converted to pointer type at this point according to
6739 the standard. Accepting this is not merely an
6740 extension, since deciding whether or not these
6741 conversions can occur is part of determining which
6742 function template to call, or whether a given explicit
6743 argument specification is valid. */
6744 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6746 val
= strip_typedefs_expr (orig_arg
);
6748 if (val
== NULL_TREE
)
6749 val
= error_mark_node
;
6750 else if (val
== error_mark_node
&& (complain
& tf_error
))
6751 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6753 if (TREE_CODE (val
) == SCOPE_REF
)
6755 /* Strip typedefs from the SCOPE_REF. */
6756 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6757 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6759 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6760 QUALIFIED_NAME_IS_TEMPLATE (val
));
6767 /* Coerces the remaining template arguments in INNER_ARGS (from
6768 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6769 Returns the coerced argument pack. PARM_IDX is the position of this
6770 parameter in the template parameter list. ARGS is the original
6771 template argument list. */
6773 coerce_template_parameter_pack (tree parms
,
6781 tsubst_flags_t complain
)
6783 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6784 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6787 tree packed_parms
= NULL_TREE
;
6789 if (arg_idx
> nargs
)
6792 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6794 /* When the template parameter is a non-type template parameter pack
6795 or template template parameter pack whose type or template
6796 parameters use parameter packs, we know exactly how many arguments
6797 we are looking for. Build a vector of the instantiated decls for
6798 these template parameters in PACKED_PARMS. */
6799 /* We can't use make_pack_expansion here because it would interpret a
6800 _DECL as a use rather than a declaration. */
6801 tree decl
= TREE_VALUE (parm
);
6802 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6803 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6804 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6805 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6807 TREE_VEC_LENGTH (args
)--;
6808 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6809 TREE_VEC_LENGTH (args
)++;
6811 if (packed_parms
== error_mark_node
)
6812 return error_mark_node
;
6814 /* If we're doing a partial instantiation of a member template,
6815 verify that all of the types used for the non-type
6816 template parameter pack are, in fact, valid for non-type
6817 template parameters. */
6819 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6821 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6822 for (j
= 0; j
< len
; ++j
)
6824 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6825 if (invalid_nontype_parm_type_p (t
, complain
))
6826 return error_mark_node
;
6828 /* We don't know how many args we have yet, just
6829 use the unconverted ones for now. */
6833 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6836 packed_args
= make_tree_vec (nargs
- arg_idx
);
6838 /* Convert the remaining arguments, which will be a part of the
6839 parameter pack "parm". */
6840 for (; arg_idx
< nargs
; ++arg_idx
)
6842 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6843 tree actual_parm
= TREE_VALUE (parm
);
6844 int pack_idx
= arg_idx
- parm_idx
;
6848 /* Once we've packed as many args as we have types, stop. */
6849 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6851 else if (PACK_EXPANSION_P (arg
))
6852 /* We don't know how many args we have yet, just
6853 use the unconverted ones for now. */
6856 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6859 if (arg
== error_mark_node
)
6861 if (complain
& tf_error
)
6862 error ("template argument %d is invalid", arg_idx
+ 1);
6865 arg
= convert_template_argument (actual_parm
,
6866 arg
, new_args
, complain
, parm_idx
,
6868 if (arg
== error_mark_node
)
6870 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6873 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6874 && TREE_VEC_LENGTH (packed_args
) > 0)
6876 if (complain
& tf_error
)
6877 error ("wrong number of template arguments (%d, should be %d)",
6878 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6879 return error_mark_node
;
6882 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6883 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6884 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6887 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6888 TREE_TYPE (argument_pack
)
6889 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6890 TREE_CONSTANT (argument_pack
) = 1;
6893 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6894 #ifdef ENABLE_CHECKING
6895 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6896 TREE_VEC_LENGTH (packed_args
));
6898 return argument_pack
;
6901 /* Returns the number of pack expansions in the template argument vector
6905 pack_expansion_args_count (tree args
)
6910 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6912 tree elt
= TREE_VEC_ELT (args
, i
);
6913 if (elt
&& PACK_EXPANSION_P (elt
))
6919 /* Convert all template arguments to their appropriate types, and
6920 return a vector containing the innermost resulting template
6921 arguments. If any error occurs, return error_mark_node. Error and
6922 warning messages are issued under control of COMPLAIN.
6924 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6925 for arguments not specified in ARGS. Otherwise, if
6926 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6927 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6928 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6932 coerce_template_parms (tree parms
,
6935 tsubst_flags_t complain
,
6936 bool require_all_args
,
6937 bool use_default_args
)
6939 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6940 tree orig_inner_args
;
6943 tree new_inner_args
;
6944 int saved_unevaluated_operand
;
6945 int saved_inhibit_evaluation_warnings
;
6947 /* When used as a boolean value, indicates whether this is a
6948 variadic template parameter list. Since it's an int, we can also
6949 subtract it from nparms to get the number of non-variadic
6952 int variadic_args_p
= 0;
6953 int post_variadic_parms
= 0;
6955 /* Likewise for parameters with default arguments. */
6958 if (args
== error_mark_node
)
6959 return error_mark_node
;
6961 nparms
= TREE_VEC_LENGTH (parms
);
6963 /* Determine if there are any parameter packs or default arguments. */
6964 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
6966 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6968 ++post_variadic_parms
;
6969 if (template_parameter_pack_p (TREE_VALUE (parm
)))
6971 if (TREE_PURPOSE (parm
))
6975 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
6976 /* If there are no parameters that follow a parameter pack, we need to
6977 expand any argument packs so that we can deduce a parameter pack from
6978 some non-packed args followed by an argument pack, as in variadic85.C.
6979 If there are such parameters, we need to leave argument packs intact
6980 so the arguments are assigned properly. This can happen when dealing
6981 with a nested class inside a partial specialization of a class
6982 template, as in variadic92.C, or when deducing a template parameter pack
6983 from a sub-declarator, as in variadic114.C. */
6984 if (!post_variadic_parms
)
6985 inner_args
= expand_template_argument_pack (inner_args
);
6987 /* Count any pack expansion args. */
6988 variadic_args_p
= pack_expansion_args_count (inner_args
);
6990 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6991 if ((nargs
> nparms
&& !variadic_p
)
6992 || (nargs
< nparms
- variadic_p
6995 && (!use_default_args
6996 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
6997 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
6999 if (complain
& tf_error
)
7001 if (variadic_p
|| default_p
)
7003 nparms
-= variadic_p
+ default_p
;
7004 error ("wrong number of template arguments "
7005 "(%d, should be at least %d)", nargs
, nparms
);
7008 error ("wrong number of template arguments "
7009 "(%d, should be %d)", nargs
, nparms
);
7012 inform (input_location
, "provided for %q+D", in_decl
);
7015 return error_mark_node
;
7017 /* We can't pass a pack expansion to a non-pack parameter of an alias
7018 template (DR 1430). */
7019 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
7021 && nargs
- variadic_args_p
< nparms
- variadic_p
)
7023 if (complain
& tf_error
)
7025 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
7027 tree arg
= TREE_VEC_ELT (inner_args
, i
);
7028 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
7030 if (PACK_EXPANSION_P (arg
)
7031 && !template_parameter_pack_p (parm
))
7033 error ("pack expansion argument for non-pack parameter "
7034 "%qD of alias template %qD", parm
, in_decl
);
7035 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
7042 return error_mark_node
;
7045 /* We need to evaluate the template arguments, even though this
7046 template-id may be nested within a "sizeof". */
7047 saved_unevaluated_operand
= cp_unevaluated_operand
;
7048 cp_unevaluated_operand
= 0;
7049 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
7050 c_inhibit_evaluation_warnings
= 0;
7051 new_inner_args
= make_tree_vec (nparms
);
7052 new_args
= add_outermost_template_args (args
, new_inner_args
);
7053 int pack_adjust
= 0;
7054 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
7059 /* Get the Ith template parameter. */
7060 parm
= TREE_VEC_ELT (parms
, parm_idx
);
7062 if (parm
== error_mark_node
)
7064 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
7068 /* Calculate the next argument. */
7069 if (arg_idx
< nargs
)
7070 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
7074 if (template_parameter_pack_p (TREE_VALUE (parm
))
7075 && !(arg
&& ARGUMENT_PACK_P (arg
)))
7077 /* Some arguments will be placed in the
7078 template parameter pack PARM. */
7079 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
7080 inner_args
, arg_idx
,
7084 if (arg
== NULL_TREE
)
7086 /* We don't know how many args we have yet, just use the
7087 unconverted (and still packed) ones for now. */
7088 new_inner_args
= orig_inner_args
;
7093 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
7095 /* Store this argument. */
7096 if (arg
== error_mark_node
)
7099 /* We are done with all of the arguments. */
7104 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
7105 arg_idx
+= pack_adjust
;
7112 if (PACK_EXPANSION_P (arg
))
7114 /* "If every valid specialization of a variadic template
7115 requires an empty template parameter pack, the template is
7116 ill-formed, no diagnostic required." So check that the
7117 pattern works with this parameter. */
7118 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
7119 tree conv
= convert_template_argument (TREE_VALUE (parm
),
7123 if (conv
== error_mark_node
)
7125 inform (input_location
, "so any instantiation with a "
7126 "non-empty parameter pack would be ill-formed");
7129 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
7130 /* Recover from missing typename. */
7131 TREE_VEC_ELT (inner_args
, arg_idx
)
7132 = make_pack_expansion (conv
);
7134 /* We don't know how many args we have yet, just
7135 use the unconverted ones for now. */
7136 new_inner_args
= inner_args
;
7141 else if (require_all_args
)
7143 /* There must be a default arg in this case. */
7144 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
7146 /* The position of the first default template argument,
7147 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7149 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7150 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7151 arg_idx
- pack_adjust
);
7156 if (arg
== error_mark_node
)
7158 if (complain
& tf_error
)
7159 error ("template argument %d is invalid", arg_idx
+ 1);
7162 /* This only occurs if there was an error in the template
7163 parameter list itself (which we would already have
7164 reported) that we are trying to recover from, e.g., a class
7165 template with a parameter list such as
7166 template<typename..., typename>. */
7169 arg
= convert_template_argument (TREE_VALUE (parm
),
7170 arg
, new_args
, complain
,
7173 if (arg
== error_mark_node
)
7175 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7177 cp_unevaluated_operand
= saved_unevaluated_operand
;
7178 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7180 if (variadic_p
&& arg_idx
< nargs
)
7182 if (complain
& tf_error
)
7184 error ("wrong number of template arguments "
7185 "(%d, should be %d)", nargs
, arg_idx
);
7187 error ("provided for %q+D", in_decl
);
7189 return error_mark_node
;
7193 return error_mark_node
;
7195 #ifdef ENABLE_CHECKING
7196 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7197 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7198 TREE_VEC_LENGTH (new_inner_args
));
7201 return new_inner_args
;
7204 /* Like coerce_template_parms. If PARMS represents all template
7205 parameters levels, this function returns a vector of vectors
7206 representing all the resulting argument levels. Note that in this
7207 case, only the innermost arguments are coerced because the
7208 outermost ones are supposed to have been coerced already.
7210 Otherwise, if PARMS represents only (the innermost) vector of
7211 parameters, this function returns a vector containing just the
7212 innermost resulting arguments. */
7215 coerce_innermost_template_parms (tree parms
,
7218 tsubst_flags_t complain
,
7219 bool require_all_args
,
7220 bool use_default_args
)
7222 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7223 int args_depth
= TMPL_ARGS_DEPTH (args
);
7226 if (parms_depth
> 1)
7228 coerced_args
= make_tree_vec (parms_depth
);
7232 for (level
= parms
, cur_depth
= parms_depth
;
7233 parms_depth
> 0 && level
!= NULL_TREE
;
7234 level
= TREE_CHAIN (level
), --cur_depth
)
7237 if (cur_depth
== args_depth
)
7238 l
= coerce_template_parms (TREE_VALUE (level
),
7239 args
, in_decl
, complain
,
7243 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7245 if (l
== error_mark_node
)
7246 return error_mark_node
;
7248 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7252 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7253 args
, in_decl
, complain
,
7256 return coerced_args
;
7259 /* Returns 1 if template args OT and NT are equivalent. */
7262 template_args_equal (tree ot
, tree nt
)
7266 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7269 if (TREE_CODE (nt
) == TREE_VEC
)
7270 /* For member templates */
7271 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7272 else if (PACK_EXPANSION_P (ot
))
7273 return (PACK_EXPANSION_P (nt
)
7274 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7275 PACK_EXPANSION_PATTERN (nt
))
7276 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7277 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7278 else if (ARGUMENT_PACK_P (ot
))
7283 if (!ARGUMENT_PACK_P (nt
))
7286 opack
= ARGUMENT_PACK_ARGS (ot
);
7287 npack
= ARGUMENT_PACK_ARGS (nt
);
7288 len
= TREE_VEC_LENGTH (opack
);
7289 if (TREE_VEC_LENGTH (npack
) != len
)
7291 for (i
= 0; i
< len
; ++i
)
7292 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7293 TREE_VEC_ELT (npack
, i
)))
7297 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7299 /* We get here probably because we are in the middle of substituting
7300 into the pattern of a pack expansion. In that case the
7301 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7302 interested in. So we want to use the initial pack argument for
7304 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7305 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7306 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7307 return template_args_equal (ot
, nt
);
7309 else if (TYPE_P (nt
))
7313 /* Don't treat an alias template specialization with dependent
7314 arguments as equivalent to its underlying type when used as a
7315 template argument; we need them to be distinct so that we
7316 substitute into the specialization arguments at instantiation
7317 time. And aliases can't be equivalent without being ==, so
7318 we don't need to look any deeper. */
7319 if (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
))
7322 return same_type_p (ot
, nt
);
7324 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7328 /* Try to treat a template non-type argument that has been converted
7329 to the parameter type as equivalent to one that hasn't yet. */
7330 for (enum tree_code code1
= TREE_CODE (ot
);
7331 CONVERT_EXPR_CODE_P (code1
)
7332 || code1
== NON_LVALUE_EXPR
;
7333 code1
= TREE_CODE (ot
))
7334 ot
= TREE_OPERAND (ot
, 0);
7335 for (enum tree_code code2
= TREE_CODE (nt
);
7336 CONVERT_EXPR_CODE_P (code2
)
7337 || code2
== NON_LVALUE_EXPR
;
7338 code2
= TREE_CODE (nt
))
7339 nt
= TREE_OPERAND (nt
, 0);
7341 return cp_tree_equal (ot
, nt
);
7345 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7346 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7347 NEWARG_PTR with the offending arguments if they are non-NULL. */
7350 comp_template_args_with_info (tree oldargs
, tree newargs
,
7351 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7355 if (oldargs
== newargs
)
7358 if (!oldargs
|| !newargs
)
7361 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7364 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7366 tree nt
= TREE_VEC_ELT (newargs
, i
);
7367 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7369 if (! template_args_equal (ot
, nt
))
7371 if (oldarg_ptr
!= NULL
)
7373 if (newarg_ptr
!= NULL
)
7381 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7382 of template arguments. Returns 0 otherwise. */
7385 comp_template_args (tree oldargs
, tree newargs
)
7387 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7391 add_pending_template (tree d
)
7393 tree ti
= (TYPE_P (d
)
7394 ? CLASSTYPE_TEMPLATE_INFO (d
)
7395 : DECL_TEMPLATE_INFO (d
));
7396 struct pending_template
*pt
;
7399 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7402 /* We are called both from instantiate_decl, where we've already had a
7403 tinst_level pushed, and instantiate_template, where we haven't.
7405 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7408 push_tinst_level (d
);
7410 pt
= ggc_alloc
<pending_template
> ();
7412 pt
->tinst
= current_tinst_level
;
7413 if (last_pending_template
)
7414 last_pending_template
->next
= pt
;
7416 pending_templates
= pt
;
7418 last_pending_template
= pt
;
7420 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7427 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7428 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7429 documentation for TEMPLATE_ID_EXPR. */
7432 lookup_template_function (tree fns
, tree arglist
)
7436 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7437 return error_mark_node
;
7439 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7441 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7443 error ("%q#D is not a function template", fns
);
7444 return error_mark_node
;
7447 if (BASELINK_P (fns
))
7449 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7451 BASELINK_FUNCTIONS (fns
),
7456 type
= TREE_TYPE (fns
);
7457 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7458 type
= unknown_type_node
;
7460 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7463 /* Within the scope of a template class S<T>, the name S gets bound
7464 (in build_self_reference) to a TYPE_DECL for the class, not a
7465 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7466 or one of its enclosing classes, and that type is a template,
7467 return the associated TEMPLATE_DECL. Otherwise, the original
7470 Also handle the case when DECL is a TREE_LIST of ambiguous
7471 injected-class-names from different bases. */
7474 maybe_get_template_decl_from_type_decl (tree decl
)
7476 if (decl
== NULL_TREE
)
7479 /* DR 176: A lookup that finds an injected-class-name (10.2
7480 [class.member.lookup]) can result in an ambiguity in certain cases
7481 (for example, if it is found in more than one base class). If all of
7482 the injected-class-names that are found refer to specializations of
7483 the same class template, and if the name is followed by a
7484 template-argument-list, the reference refers to the class template
7485 itself and not a specialization thereof, and is not ambiguous. */
7486 if (TREE_CODE (decl
) == TREE_LIST
)
7488 tree t
, tmpl
= NULL_TREE
;
7489 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7491 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7494 else if (tmpl
!= elt
)
7497 if (tmpl
&& t
== NULL_TREE
)
7503 return (decl
!= NULL_TREE
7504 && DECL_SELF_REFERENCE_P (decl
)
7505 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7506 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7509 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7510 parameters, find the desired type.
7512 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7514 IN_DECL, if non-NULL, is the template declaration we are trying to
7517 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7518 the class we are looking up.
7520 Issue error and warning messages under control of COMPLAIN.
7522 If the template class is really a local class in a template
7523 function, then the FUNCTION_CONTEXT is the function in which it is
7526 ??? Note that this function is currently called *twice* for each
7527 template-id: the first time from the parser, while creating the
7528 incomplete type (finish_template_type), and the second type during the
7529 real instantiation (instantiate_template_class). This is surely something
7530 that we want to avoid. It also causes some problems with argument
7531 coercion (see convert_nontype_argument for more information on this). */
7534 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7535 int entering_scope
, tsubst_flags_t complain
)
7537 tree templ
= NULL_TREE
, parmlist
;
7544 if (identifier_p (d1
))
7546 tree value
= innermost_non_namespace_value (d1
);
7547 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7552 push_decl_namespace (context
);
7553 templ
= lookup_name (d1
);
7554 templ
= maybe_get_template_decl_from_type_decl (templ
);
7556 pop_decl_namespace ();
7559 context
= DECL_CONTEXT (templ
);
7561 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7563 tree type
= TREE_TYPE (d1
);
7565 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7566 an implicit typename for the second A. Deal with it. */
7567 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7568 type
= TREE_TYPE (type
);
7570 if (CLASSTYPE_TEMPLATE_INFO (type
))
7572 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7573 d1
= DECL_NAME (templ
);
7576 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7577 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7579 templ
= TYPE_TI_TEMPLATE (d1
);
7580 d1
= DECL_NAME (templ
);
7582 else if (DECL_TYPE_TEMPLATE_P (d1
))
7585 d1
= DECL_NAME (templ
);
7586 context
= DECL_CONTEXT (templ
);
7588 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7591 d1
= DECL_NAME (templ
);
7594 /* Issue an error message if we didn't find a template. */
7597 if (complain
& tf_error
)
7598 error ("%qT is not a template", d1
);
7599 return error_mark_node
;
7602 if (TREE_CODE (templ
) != TEMPLATE_DECL
7603 /* Make sure it's a user visible template, if it was named by
7605 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7606 && !PRIMARY_TEMPLATE_P (templ
)))
7608 if (complain
& tf_error
)
7610 error ("non-template type %qT used as a template", d1
);
7612 error ("for template declaration %q+D", in_decl
);
7614 return error_mark_node
;
7617 complain
&= ~tf_user
;
7619 /* An alias that just changes the name of a template is equivalent to the
7620 other template, so if any of the arguments are pack expansions, strip
7621 the alias to avoid problems with a pack expansion passed to a non-pack
7622 alias template parameter (DR 1430). */
7623 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7624 templ
= get_underlying_template (templ
);
7626 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7628 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7629 template arguments */
7635 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7637 /* Consider an example where a template template parameter declared as
7639 template <class T, class U = std::allocator<T> > class TT
7641 The template parameter level of T and U are one level larger than
7642 of TT. To proper process the default argument of U, say when an
7643 instantiation `TT<int>' is seen, we need to build the full
7644 arguments containing {int} as the innermost level. Outer levels,
7645 available when not appearing as default template argument, can be
7646 obtained from the arguments of the enclosing template.
7648 Suppose that TT is later substituted with std::vector. The above
7649 instantiation is `TT<int, std::allocator<T> >' with TT at
7650 level 1, and T at level 2, while the template arguments at level 1
7651 becomes {std::vector} and the inner level 2 is {int}. */
7653 outer
= DECL_CONTEXT (templ
);
7655 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7656 else if (current_template_parms
)
7657 /* This is an argument of the current template, so we haven't set
7658 DECL_CONTEXT yet. */
7659 outer
= current_template_args ();
7662 arglist
= add_to_template_args (outer
, arglist
);
7664 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7666 /*require_all_args=*/true,
7667 /*use_default_args=*/true);
7668 if (arglist2
== error_mark_node
7669 || (!uses_template_parms (arglist2
)
7670 && check_instantiated_args (templ
, arglist2
, complain
)))
7671 return error_mark_node
;
7673 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7678 tree template_type
= TREE_TYPE (templ
);
7681 tree found
= NULL_TREE
;
7684 int is_dependent_type
;
7685 int use_partial_inst_tmpl
= false;
7687 if (template_type
== error_mark_node
)
7688 /* An error occurred while building the template TEMPL, and a
7689 diagnostic has most certainly been emitted for that
7690 already. Let's propagate that error. */
7691 return error_mark_node
;
7693 gen_tmpl
= most_general_template (templ
);
7694 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7695 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7696 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7698 if (arg_depth
== 1 && parm_depth
> 1)
7700 /* We've been given an incomplete set of template arguments.
7703 template <class T> struct S1 {
7704 template <class U> struct S2 {};
7705 template <class U> struct S2<U*> {};
7708 we will be called with an ARGLIST of `U*', but the
7709 TEMPLATE will be `template <class T> template
7710 <class U> struct S1<T>::S2'. We must fill in the missing
7713 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7715 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7718 /* Now we should have enough arguments. */
7719 gcc_assert (parm_depth
== arg_depth
);
7721 /* From here on, we're only interested in the most general
7724 /* Calculate the BOUND_ARGS. These will be the args that are
7725 actually tsubst'd into the definition to create the
7727 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
7729 /*require_all_args=*/true,
7730 /*use_default_args=*/true);
7732 if (arglist
== error_mark_node
)
7733 /* We were unable to bind the arguments. */
7734 return error_mark_node
;
7736 /* In the scope of a template class, explicit references to the
7737 template class refer to the type of the template, not any
7738 instantiation of it. For example, in:
7740 template <class T> class C { void f(C<T>); }
7742 the `C<T>' is just the same as `C'. Outside of the
7743 class, however, such a reference is an instantiation. */
7745 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7746 || currently_open_class (template_type
))
7747 /* comp_template_args is expensive, check it last. */
7748 && comp_template_args (TYPE_TI_ARGS (template_type
),
7750 return template_type
;
7752 /* If we already have this specialization, return it. */
7753 elt
.tmpl
= gen_tmpl
;
7755 hash
= spec_hasher::hash (&elt
);
7756 entry
= type_specializations
->find_with_hash (&elt
, hash
);
7761 is_dependent_type
= uses_template_parms (arglist
);
7763 /* If the deduced arguments are invalid, then the binding
7765 if (!is_dependent_type
7766 && check_instantiated_args (gen_tmpl
,
7767 INNERMOST_TEMPLATE_ARGS (arglist
),
7769 return error_mark_node
;
7771 if (!is_dependent_type
7772 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7773 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7774 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7776 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7777 DECL_NAME (gen_tmpl
),
7778 /*tag_scope=*/ts_global
);
7782 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7784 if (context
== error_mark_node
)
7785 return error_mark_node
;
7788 context
= global_namespace
;
7790 /* Create the type. */
7791 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7793 /* The user referred to a specialization of an alias
7794 template represented by GEN_TMPL.
7796 [temp.alias]/2 says:
7798 When a template-id refers to the specialization of an
7799 alias template, it is equivalent to the associated
7800 type obtained by substitution of its
7801 template-arguments for the template-parameters in the
7802 type-id of the alias template. */
7804 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7805 /* Note that the call above (by indirectly calling
7806 register_specialization in tsubst_decl) registers the
7807 TYPE_DECL representing the specialization of the alias
7808 template. So next time someone substitutes ARGLIST for
7809 the template parms into the alias template (GEN_TMPL),
7810 she'll get that TYPE_DECL back. */
7812 if (t
== error_mark_node
)
7815 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7817 if (!is_dependent_type
)
7819 set_current_access_from_decl (TYPE_NAME (template_type
));
7820 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7821 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7822 arglist
, complain
, in_decl
),
7823 SCOPED_ENUM_P (template_type
), NULL
);
7825 if (t
== error_mark_node
)
7830 /* We don't want to call start_enum for this type, since
7831 the values for the enumeration constants may involve
7832 template parameters. And, no one should be interested
7833 in the enumeration constants for such a type. */
7834 t
= cxx_make_type (ENUMERAL_TYPE
);
7835 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7837 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7838 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7839 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7841 else if (CLASS_TYPE_P (template_type
))
7843 t
= make_class_type (TREE_CODE (template_type
));
7844 CLASSTYPE_DECLARED_CLASS (t
)
7845 = CLASSTYPE_DECLARED_CLASS (template_type
);
7846 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7847 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7849 /* A local class. Make sure the decl gets registered properly. */
7850 if (context
== current_function_decl
)
7851 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7853 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7854 /* This instantiation is another name for the primary
7855 template type. Set the TYPE_CANONICAL field
7857 TYPE_CANONICAL (t
) = template_type
;
7858 else if (any_template_arguments_need_structural_equality_p (arglist
))
7859 /* Some of the template arguments require structural
7860 equality testing, so this template class requires
7861 structural equality testing. */
7862 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7867 /* If we called start_enum or pushtag above, this information
7868 will already be set up. */
7871 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7873 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7874 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7875 DECL_SOURCE_LOCATION (type_decl
)
7876 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7879 type_decl
= TYPE_NAME (t
);
7881 if (CLASS_TYPE_P (template_type
))
7883 TREE_PRIVATE (type_decl
)
7884 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7885 TREE_PROTECTED (type_decl
)
7886 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7887 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7889 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7890 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7894 if (OVERLOAD_TYPE_P (t
)
7895 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7898 = lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (template_type
)))
7900 if (!TREE_CHAIN (attributes
))
7901 TYPE_ATTRIBUTES (t
) = attributes
;
7904 = build_tree_list (TREE_PURPOSE (attributes
),
7905 TREE_VALUE (attributes
));
7909 /* Let's consider the explicit specialization of a member
7910 of a class template specialization that is implicitly instantiated,
7915 template<class U> struct M {}; //#0
7920 struct S<int>::M<char> //#1
7924 [temp.expl.spec]/4 says this is valid.
7926 In this case, when we write:
7929 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7932 When we encounter #1, we want to store the partial instantiation
7933 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7935 For all cases other than this "explicit specialization of member of a
7936 class template", we just want to store the most general template into
7937 the CLASSTYPE_TI_TEMPLATE of M.
7939 This case of "explicit specialization of member of a class template"
7941 1/ the enclosing class is an instantiation of, and therefore not
7942 the same as, the context of the most general template, and
7943 2/ we aren't looking at the partial instantiation itself, i.e.
7944 the innermost arguments are not the same as the innermost parms of
7945 the most general template.
7947 So it's only when 1/ and 2/ happens that we want to use the partial
7948 instantiation of the member template in lieu of its most general
7951 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
7952 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
7953 /* the enclosing class must be an instantiation... */
7954 && CLASS_TYPE_P (context
)
7955 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
7957 tree partial_inst_args
;
7958 TREE_VEC_LENGTH (arglist
)--;
7959 ++processing_template_decl
;
7961 tsubst (INNERMOST_TEMPLATE_ARGS
7962 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
7963 arglist
, complain
, NULL_TREE
);
7964 --processing_template_decl
;
7965 TREE_VEC_LENGTH (arglist
)++;
7966 use_partial_inst_tmpl
=
7967 /*...and we must not be looking at the partial instantiation
7969 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
7973 if (!use_partial_inst_tmpl
)
7974 /* This case is easy; there are no member templates involved. */
7978 /* This is a full instantiation of a member template. Find
7979 the partial instantiation of which this is an instance. */
7981 /* Temporarily reduce by one the number of levels in the ARGLIST
7982 so as to avoid comparing the last set of arguments. */
7983 TREE_VEC_LENGTH (arglist
)--;
7984 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
7985 TREE_VEC_LENGTH (arglist
)++;
7986 /* FOUND is either a proper class type, or an alias
7987 template specialization. In the later case, it's a
7988 TYPE_DECL, resulting from the substituting of arguments
7989 for parameters in the TYPE_DECL of the alias template
7990 done earlier. So be careful while getting the template
7992 found
= TREE_CODE (found
) == TYPE_DECL
7993 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
7994 : CLASSTYPE_TI_TEMPLATE (found
);
7997 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
8000 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
8001 entry
= ggc_alloc
<spec_entry
> ();
8005 /* Note this use of the partial instantiation so we can check it
8006 later in maybe_process_partial_specialization. */
8007 DECL_TEMPLATE_INSTANTIATIONS (found
)
8008 = tree_cons (arglist
, t
,
8009 DECL_TEMPLATE_INSTANTIATIONS (found
));
8011 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
8012 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8013 /* Now that the type has been registered on the instantiations
8014 list, we set up the enumerators. Because the enumeration
8015 constants may involve the enumeration type itself, we make
8016 sure to register the type first, and then create the
8017 constants. That way, doing tsubst_expr for the enumeration
8018 constants won't result in recursive calls here; we'll find
8019 the instantiation and exit above. */
8020 tsubst_enum (template_type
, t
, arglist
);
8022 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
8023 /* If the type makes use of template parameters, the
8024 code that generates debugging information will crash. */
8025 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
8027 /* Possibly limit visibility based on template args. */
8028 TREE_PUBLIC (type_decl
) = 1;
8029 determine_visibility (type_decl
);
8031 inherit_targ_abi_tags (t
);
8037 /* Wrapper for lookup_template_class_1. */
8040 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
8041 int entering_scope
, tsubst_flags_t complain
)
8044 timevar_push (TV_TEMPLATE_INST
);
8045 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
8046 entering_scope
, complain
);
8047 timevar_pop (TV_TEMPLATE_INST
);
8051 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST.
8052 The type of the expression is the unknown_type_node since the
8053 template-id could refer to an explicit or partial specialization. */
8056 lookup_template_variable (tree templ
, tree arglist
)
8058 tree type
= unknown_type_node
;
8059 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
8062 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
8065 finish_template_variable (tree var
)
8067 tree templ
= TREE_OPERAND (var
, 0);
8069 tree arglist
= TREE_OPERAND (var
, 1);
8070 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
8071 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
8073 tree parms
= DECL_TEMPLATE_PARMS (templ
);
8074 tsubst_flags_t complain
= tf_warning_or_error
;
8075 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
8077 /*use_default*/true);
8079 return instantiate_template (templ
, arglist
, complain
);
8086 /* True when we should also visit template parameters that occur in
8087 non-deduced contexts. */
8088 bool include_nondeduced_p
;
8089 hash_set
<tree
> *visited
;
8092 /* Called from for_each_template_parm via walk_tree. */
8095 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
8098 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
8099 tree_fn_t fn
= pfd
->fn
;
8100 void *data
= pfd
->data
;
8103 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
8104 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
8105 pfd
->include_nondeduced_p
))
8106 return error_mark_node
;
8108 switch (TREE_CODE (t
))
8111 if (TYPE_PTRMEMFUNC_P (t
))
8117 if (!TYPE_TEMPLATE_INFO (t
))
8119 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
8120 fn
, data
, pfd
->visited
,
8121 pfd
->include_nondeduced_p
))
8122 return error_mark_node
;
8126 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
8127 fn
, data
, pfd
->visited
,
8128 pfd
->include_nondeduced_p
)
8129 || for_each_template_parm (TYPE_MAX_VALUE (t
),
8130 fn
, data
, pfd
->visited
,
8131 pfd
->include_nondeduced_p
))
8132 return error_mark_node
;
8136 /* Since we're not going to walk subtrees, we have to do this
8138 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
8139 pfd
->visited
, pfd
->include_nondeduced_p
))
8140 return error_mark_node
;
8144 /* Check the return type. */
8145 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8146 pfd
->include_nondeduced_p
))
8147 return error_mark_node
;
8149 /* Check the parameter types. Since default arguments are not
8150 instantiated until they are needed, the TYPE_ARG_TYPES may
8151 contain expressions that involve template parameters. But,
8152 no-one should be looking at them yet. And, once they're
8153 instantiated, they don't contain template parameters, so
8154 there's no point in looking at them then, either. */
8158 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
8159 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
8160 pfd
->visited
, pfd
->include_nondeduced_p
))
8161 return error_mark_node
;
8163 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8164 want walk_tree walking into them itself. */
8170 case UNDERLYING_TYPE
:
8171 if (pfd
->include_nondeduced_p
8172 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
8174 pfd
->include_nondeduced_p
))
8175 return error_mark_node
;
8180 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
8181 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
8182 pfd
->visited
, pfd
->include_nondeduced_p
))
8183 return error_mark_node
;
8188 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
8189 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
8190 pfd
->visited
, pfd
->include_nondeduced_p
))
8191 return error_mark_node
;
8192 if (DECL_CONTEXT (t
)
8193 && pfd
->include_nondeduced_p
8194 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
8195 pfd
->visited
, pfd
->include_nondeduced_p
))
8196 return error_mark_node
;
8199 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8200 /* Record template parameters such as `T' inside `TT<T>'. */
8201 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
8202 pfd
->include_nondeduced_p
))
8203 return error_mark_node
;
8206 case TEMPLATE_TEMPLATE_PARM
:
8207 case TEMPLATE_TYPE_PARM
:
8208 case TEMPLATE_PARM_INDEX
:
8209 if (fn
&& (*fn
)(t
, data
))
8210 return error_mark_node
;
8212 return error_mark_node
;
8216 /* A template template parameter is encountered. */
8217 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
8218 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8219 pfd
->include_nondeduced_p
))
8220 return error_mark_node
;
8222 /* Already substituted template template parameter */
8228 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8230 pfd
->include_nondeduced_p
))
8231 return error_mark_node
;
8235 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8236 && pfd
->include_nondeduced_p
8237 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8238 (TREE_TYPE (t
)), fn
, data
,
8239 pfd
->visited
, pfd
->include_nondeduced_p
))
8240 return error_mark_node
;
8245 /* If there's no type, then this thing must be some expression
8246 involving template parameters. */
8247 if (!fn
&& !TREE_TYPE (t
))
8248 return error_mark_node
;
8253 case IMPLICIT_CONV_EXPR
:
8254 case REINTERPRET_CAST_EXPR
:
8255 case CONST_CAST_EXPR
:
8256 case STATIC_CAST_EXPR
:
8257 case DYNAMIC_CAST_EXPR
:
8261 case PSEUDO_DTOR_EXPR
:
8263 return error_mark_node
;
8270 /* We didn't find any template parameters we liked. */
8274 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8275 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8276 call FN with the parameter and the DATA.
8277 If FN returns nonzero, the iteration is terminated, and
8278 for_each_template_parm returns 1. Otherwise, the iteration
8279 continues. If FN never returns a nonzero value, the value
8280 returned by for_each_template_parm is 0. If FN is NULL, it is
8281 considered to be the function which always returns 1.
8283 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8284 parameters that occur in non-deduced contexts. When false, only
8285 visits those template parameters that can be deduced. */
8288 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8289 hash_set
<tree
> *visited
,
8290 bool include_nondeduced_p
)
8292 struct pair_fn_data pfd
;
8298 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8300 /* Walk the tree. (Conceptually, we would like to walk without
8301 duplicates, but for_each_template_parm_r recursively calls
8302 for_each_template_parm, so we would need to reorganize a fair
8303 bit to use walk_tree_without_duplicates, so we keep our own
8306 pfd
.visited
= visited
;
8308 pfd
.visited
= new hash_set
<tree
>;
8309 result
= cp_walk_tree (&t
,
8310 for_each_template_parm_r
,
8312 pfd
.visited
) != NULL_TREE
;
8324 /* Returns true if T depends on any template parameter. */
8327 uses_template_parms (tree t
)
8333 int saved_processing_template_decl
;
8335 saved_processing_template_decl
= processing_template_decl
;
8336 if (!saved_processing_template_decl
)
8337 processing_template_decl
= 1;
8339 dependent_p
= dependent_type_p (t
);
8340 else if (TREE_CODE (t
) == TREE_VEC
)
8341 dependent_p
= any_dependent_template_arguments_p (t
);
8342 else if (TREE_CODE (t
) == TREE_LIST
)
8343 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8344 || uses_template_parms (TREE_CHAIN (t
)));
8345 else if (TREE_CODE (t
) == TYPE_DECL
)
8346 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8349 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8350 || TREE_CODE (t
) == OVERLOAD
8353 || TREE_CODE (t
) == TRAIT_EXPR
8354 || TREE_CODE (t
) == CONSTRUCTOR
8355 || CONSTANT_CLASS_P (t
))
8356 dependent_p
= (type_dependent_expression_p (t
)
8357 || value_dependent_expression_p (t
));
8360 gcc_assert (t
== error_mark_node
);
8361 dependent_p
= false;
8364 processing_template_decl
= saved_processing_template_decl
;
8369 /* Returns true iff current_function_decl is an incompletely instantiated
8370 template. Useful instead of processing_template_decl because the latter
8371 is set to 0 during instantiate_non_dependent_expr. */
8374 in_template_function (void)
8376 tree fn
= current_function_decl
;
8378 ++processing_template_decl
;
8379 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8380 && DECL_TEMPLATE_INFO (fn
)
8381 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8382 --processing_template_decl
;
8386 /* Returns true if T depends on any template parameter with level LEVEL. */
8389 uses_template_parms_level (tree t
, int level
)
8391 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8392 /*include_nondeduced_p=*/true);
8395 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8396 ill-formed translation unit, i.e. a variable or function that isn't
8397 usable in a constant expression. */
8400 neglectable_inst_p (tree d
)
8403 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8404 : decl_maybe_constant_var_p (d
)));
8407 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8408 neglectable and instantiated from within an erroneous instantiation. */
8411 limit_bad_template_recursion (tree decl
)
8413 struct tinst_level
*lev
= current_tinst_level
;
8414 int errs
= errorcount
+ sorrycount
;
8415 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8418 for (; lev
; lev
= lev
->next
)
8419 if (neglectable_inst_p (lev
->decl
))
8422 return (lev
&& errs
> lev
->errors
);
8425 static int tinst_depth
;
8426 extern int max_tinst_depth
;
8429 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8431 /* We're starting to instantiate D; record the template instantiation context
8432 for diagnostics and to restore it later. */
8435 push_tinst_level (tree d
)
8437 return push_tinst_level_loc (d
, input_location
);
8440 /* We're starting to instantiate D; record the template instantiation context
8441 at LOC for diagnostics and to restore it later. */
8444 push_tinst_level_loc (tree d
, location_t loc
)
8446 struct tinst_level
*new_level
;
8448 if (tinst_depth
>= max_tinst_depth
)
8450 fatal_error (input_location
,
8451 "template instantiation depth exceeds maximum of %d"
8452 " (use -ftemplate-depth= to increase the maximum)",
8457 /* If the current instantiation caused problems, don't let it instantiate
8458 anything else. Do allow deduction substitution and decls usable in
8459 constant expressions. */
8460 if (limit_bad_template_recursion (d
))
8463 new_level
= ggc_alloc
<tinst_level
> ();
8464 new_level
->decl
= d
;
8465 new_level
->locus
= loc
;
8466 new_level
->errors
= errorcount
+sorrycount
;
8467 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8468 new_level
->next
= current_tinst_level
;
8469 current_tinst_level
= new_level
;
8472 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8473 depth_reached
= tinst_depth
;
8478 /* We're done instantiating this template; return to the instantiation
8482 pop_tinst_level (void)
8484 /* Restore the filename and line number stashed away when we started
8485 this instantiation. */
8486 input_location
= current_tinst_level
->locus
;
8487 current_tinst_level
= current_tinst_level
->next
;
8491 /* We're instantiating a deferred template; restore the template
8492 instantiation context in which the instantiation was requested, which
8493 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8496 reopen_tinst_level (struct tinst_level
*level
)
8498 struct tinst_level
*t
;
8501 for (t
= level
; t
; t
= t
->next
)
8504 current_tinst_level
= level
;
8506 if (current_tinst_level
)
8507 current_tinst_level
->errors
= errorcount
+sorrycount
;
8511 /* Returns the TINST_LEVEL which gives the original instantiation
8514 struct tinst_level
*
8515 outermost_tinst_level (void)
8517 struct tinst_level
*level
= current_tinst_level
;
8520 level
= level
->next
;
8524 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8525 vector of template arguments, as for tsubst.
8527 Returns an appropriate tsubst'd friend declaration. */
8530 tsubst_friend_function (tree decl
, tree args
)
8534 if (TREE_CODE (decl
) == FUNCTION_DECL
8535 && DECL_TEMPLATE_INSTANTIATION (decl
)
8536 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8537 /* This was a friend declared with an explicit template
8538 argument list, e.g.:
8542 to indicate that f was a template instantiation, not a new
8543 function declaration. Now, we have to figure out what
8544 instantiation of what template. */
8546 tree template_id
, arglist
, fns
;
8549 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8551 /* Friend functions are looked up in the containing namespace scope.
8552 We must enter that scope, to avoid finding member functions of the
8553 current class with same name. */
8554 push_nested_namespace (ns
);
8555 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8556 tf_warning_or_error
, NULL_TREE
,
8557 /*integral_constant_expression_p=*/false);
8558 pop_nested_namespace (ns
);
8559 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8560 tf_warning_or_error
, NULL_TREE
);
8561 template_id
= lookup_template_function (fns
, arglist
);
8563 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8564 tmpl
= determine_specialization (template_id
, new_friend
,
8566 /*need_member_template=*/0,
8567 TREE_VEC_LENGTH (args
),
8569 return instantiate_template (tmpl
, new_args
, tf_error
);
8572 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8574 /* The NEW_FRIEND will look like an instantiation, to the
8575 compiler, but is not an instantiation from the point of view of
8576 the language. For example, we might have had:
8578 template <class T> struct S {
8579 template <class U> friend void f(T, U);
8582 Then, in S<int>, template <class U> void f(int, U) is not an
8583 instantiation of anything. */
8584 if (new_friend
== error_mark_node
)
8585 return error_mark_node
;
8587 DECL_USE_TEMPLATE (new_friend
) = 0;
8588 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8590 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8591 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8592 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8595 /* The mangled name for the NEW_FRIEND is incorrect. The function
8596 is not a template instantiation and should not be mangled like
8597 one. Therefore, we forget the mangling here; we'll recompute it
8598 later if we need it. */
8599 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8601 SET_DECL_RTL (new_friend
, NULL
);
8602 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8605 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8608 tree new_friend_template_info
;
8609 tree new_friend_result_template_info
;
8611 int new_friend_is_defn
;
8613 /* We must save some information from NEW_FRIEND before calling
8614 duplicate decls since that function will free NEW_FRIEND if
8616 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8617 new_friend_is_defn
=
8618 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8619 (template_for_substitution (new_friend
)))
8621 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8623 /* This declaration is a `primary' template. */
8624 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8626 new_friend_result_template_info
8627 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8630 new_friend_result_template_info
= NULL_TREE
;
8632 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8633 if (new_friend_is_defn
)
8634 DECL_INITIAL (new_friend
) = error_mark_node
;
8636 /* Inside pushdecl_namespace_level, we will push into the
8637 current namespace. However, the friend function should go
8638 into the namespace of the template. */
8639 ns
= decl_namespace_context (new_friend
);
8640 push_nested_namespace (ns
);
8641 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8642 pop_nested_namespace (ns
);
8644 if (old_decl
== error_mark_node
)
8645 return error_mark_node
;
8647 if (old_decl
!= new_friend
)
8649 /* This new friend declaration matched an existing
8650 declaration. For example, given:
8652 template <class T> void f(T);
8653 template <class U> class C {
8654 template <class T> friend void f(T) {}
8657 the friend declaration actually provides the definition
8658 of `f', once C has been instantiated for some type. So,
8659 old_decl will be the out-of-class template declaration,
8660 while new_friend is the in-class definition.
8662 But, if `f' was called before this point, the
8663 instantiation of `f' will have DECL_TI_ARGS corresponding
8664 to `T' but not to `U', references to which might appear
8665 in the definition of `f'. Previously, the most general
8666 template for an instantiation of `f' was the out-of-class
8667 version; now it is the in-class version. Therefore, we
8668 run through all specialization of `f', adding to their
8669 DECL_TI_ARGS appropriately. In particular, they need a
8670 new set of outer arguments, corresponding to the
8671 arguments for this class instantiation.
8673 The same situation can arise with something like this:
8676 template <class T> class C {
8680 when `C<int>' is instantiated. Now, `f(int)' is defined
8683 if (!new_friend_is_defn
)
8684 /* On the other hand, if the in-class declaration does
8685 *not* provide a definition, then we don't want to alter
8686 existing definitions. We can just leave everything
8691 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8692 tree new_args
= TI_ARGS (new_friend_template_info
);
8694 /* Overwrite whatever template info was there before, if
8695 any, with the new template information pertaining to
8697 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8699 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8701 /* We should have called reregister_specialization in
8703 gcc_assert (retrieve_specialization (new_template
,
8707 /* Instantiate it if the global has already been used. */
8708 if (DECL_ODR_USED (old_decl
))
8709 instantiate_decl (old_decl
, /*defer_ok=*/true,
8710 /*expl_inst_class_mem_p=*/false);
8716 /* Indicate that the old function template is a partial
8718 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8719 = new_friend_result_template_info
;
8721 gcc_assert (new_template
8722 == most_general_template (new_template
));
8723 gcc_assert (new_template
!= old_decl
);
8725 /* Reassign any specializations already in the hash table
8726 to the new more general template, and add the
8727 additional template args. */
8728 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8732 tree spec
= TREE_VALUE (t
);
8735 elt
.tmpl
= old_decl
;
8736 elt
.args
= DECL_TI_ARGS (spec
);
8737 elt
.spec
= NULL_TREE
;
8739 decl_specializations
->remove_elt (&elt
);
8742 = add_outermost_template_args (new_args
,
8743 DECL_TI_ARGS (spec
));
8745 register_specialization
8746 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8749 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8753 /* The information from NEW_FRIEND has been merged into OLD_DECL
8754 by duplicate_decls. */
8755 new_friend
= old_decl
;
8760 tree context
= DECL_CONTEXT (new_friend
);
8764 template <class T> class C {
8765 template <class U> friend void C1<U>::f (); // case 1
8766 friend void C2<T>::f (); // case 2
8768 we only need to make sure CONTEXT is a complete type for
8769 case 2. To distinguish between the two cases, we note that
8770 CONTEXT of case 1 remains dependent type after tsubst while
8771 this isn't true for case 2. */
8772 ++processing_template_decl
;
8773 dependent_p
= dependent_type_p (context
);
8774 --processing_template_decl
;
8777 && !complete_type_or_else (context
, NULL_TREE
))
8778 return error_mark_node
;
8780 if (COMPLETE_TYPE_P (context
))
8782 tree fn
= new_friend
;
8783 /* do_friend adds the TEMPLATE_DECL for any member friend
8784 template even if it isn't a member template, i.e.
8785 template <class T> friend A<T>::f();
8786 Look through it in that case. */
8787 if (TREE_CODE (fn
) == TEMPLATE_DECL
8788 && !PRIMARY_TEMPLATE_P (fn
))
8789 fn
= DECL_TEMPLATE_RESULT (fn
);
8790 /* Check to see that the declaration is really present, and,
8791 possibly obtain an improved declaration. */
8792 fn
= check_classfn (context
, fn
, NULL_TREE
);
8802 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8803 template arguments, as for tsubst.
8805 Returns an appropriate tsubst'd friend type or error_mark_node on
8809 tsubst_friend_class (tree friend_tmpl
, tree args
)
8815 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8817 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8818 return TREE_TYPE (t
);
8821 context
= CP_DECL_CONTEXT (friend_tmpl
);
8823 if (context
!= global_namespace
)
8825 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8826 push_nested_namespace (context
);
8828 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8831 /* Look for a class template declaration. We look for hidden names
8832 because two friend declarations of the same template are the
8833 same. For example, in:
8836 template <typename> friend class F;
8838 template <typename> struct B {
8839 template <typename> friend class F;
8842 both F templates are the same. */
8843 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8844 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8846 /* But, if we don't find one, it might be because we're in a
8847 situation like this:
8855 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8856 for `S<int>', not the TEMPLATE_DECL. */
8857 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8859 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8860 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8863 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8865 /* The friend template has already been declared. Just
8866 check to see that the declarations match, and install any new
8867 default parameters. We must tsubst the default parameters,
8868 of course. We only need the innermost template parameters
8869 because that is all that redeclare_class_template will look
8871 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8872 > TMPL_ARGS_DEPTH (args
))
8875 location_t saved_input_location
;
8876 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8877 args
, tf_warning_or_error
);
8879 saved_input_location
= input_location
;
8880 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8881 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8882 input_location
= saved_input_location
;
8886 friend_type
= TREE_TYPE (tmpl
);
8890 /* The friend template has not already been declared. In this
8891 case, the instantiation of the template class will cause the
8892 injection of this template into the global scope. */
8893 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8894 if (tmpl
== error_mark_node
)
8895 return error_mark_node
;
8897 /* The new TMPL is not an instantiation of anything, so we
8898 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8899 the new type because that is supposed to be the corresponding
8900 template decl, i.e., TMPL. */
8901 DECL_USE_TEMPLATE (tmpl
) = 0;
8902 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8903 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8904 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8905 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8907 /* Inject this template into the global scope. */
8908 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8911 if (context
!= global_namespace
)
8913 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8914 pop_nested_namespace (context
);
8916 pop_nested_class ();
8922 /* Returns zero if TYPE cannot be completed later due to circularity.
8923 Otherwise returns one. */
8926 can_complete_type_without_circularity (tree type
)
8928 if (type
== NULL_TREE
|| type
== error_mark_node
)
8930 else if (COMPLETE_TYPE_P (type
))
8932 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8933 return can_complete_type_without_circularity (TREE_TYPE (type
));
8934 else if (CLASS_TYPE_P (type
)
8935 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
8941 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
8943 /* Apply any attributes which had to be deferred until instantiation
8944 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8945 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8948 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
8949 tree args
, tsubst_flags_t complain
, tree in_decl
)
8951 tree last_dep
= NULL_TREE
;
8955 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
8956 if (ATTR_IS_DEPENDENT (t
))
8959 attributes
= copy_list (attributes
);
8963 if (DECL_P (*decl_p
))
8965 if (TREE_TYPE (*decl_p
) == error_mark_node
)
8967 p
= &DECL_ATTRIBUTES (*decl_p
);
8970 p
= &TYPE_ATTRIBUTES (*decl_p
);
8974 tree late_attrs
= NULL_TREE
;
8975 tree
*q
= &late_attrs
;
8977 for (*p
= attributes
; *p
; )
8980 if (ATTR_IS_DEPENDENT (t
))
8982 *p
= TREE_CHAIN (t
);
8983 TREE_CHAIN (t
) = NULL_TREE
;
8984 if ((flag_openmp
|| flag_cilkplus
)
8985 && is_attribute_p ("omp declare simd",
8986 get_attribute_name (t
))
8989 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
8990 clauses
= tsubst_omp_clauses (clauses
, true, args
,
8992 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
8993 clauses
= finish_omp_clauses (clauses
);
8994 tree parms
= DECL_ARGUMENTS (*decl_p
);
8996 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
8998 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
9000 TREE_VALUE (t
) = NULL_TREE
;
9002 /* If the first attribute argument is an identifier, don't
9003 pass it through tsubst. Attributes like mode, format,
9004 cleanup and several target specific attributes expect it
9006 else if (attribute_takes_identifier_p (get_attribute_name (t
))
9010 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
9012 /*integral_constant_expression_p=*/false);
9013 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
9015 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
9020 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
9021 /*integral_constant_expression_p=*/false);
9023 q
= &TREE_CHAIN (t
);
9026 p
= &TREE_CHAIN (t
);
9029 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
9033 /* Perform (or defer) access check for typedefs that were referenced
9034 from within the template TMPL code.
9035 This is a subroutine of instantiate_decl and instantiate_class_template.
9036 TMPL is the template to consider and TARGS is the list of arguments of
9040 perform_typedefs_access_check (tree tmpl
, tree targs
)
9042 location_t saved_location
;
9044 qualified_typedef_usage_t
*iter
;
9047 || (!CLASS_TYPE_P (tmpl
)
9048 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
9051 saved_location
= input_location
;
9052 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
9054 tree type_decl
= iter
->typedef_decl
;
9055 tree type_scope
= iter
->context
;
9057 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
9060 if (uses_template_parms (type_decl
))
9061 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
9062 if (uses_template_parms (type_scope
))
9063 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
9065 /* Make access check error messages point to the location
9066 of the use of the typedef. */
9067 input_location
= iter
->locus
;
9068 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
9069 type_decl
, type_decl
,
9070 tf_warning_or_error
);
9072 input_location
= saved_location
;
9076 instantiate_class_template_1 (tree type
)
9078 tree templ
, args
, pattern
, t
, member
;
9082 unsigned int saved_maximum_field_alignment
;
9085 if (type
== error_mark_node
)
9086 return error_mark_node
;
9088 if (COMPLETE_OR_OPEN_TYPE_P (type
)
9089 || uses_template_parms (type
))
9092 /* Figure out which template is being instantiated. */
9093 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
9094 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
9096 /* Determine what specialization of the original template to
9098 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
9099 if (t
== error_mark_node
)
9101 TYPE_BEING_DEFINED (type
) = 1;
9102 return error_mark_node
;
9106 /* This TYPE is actually an instantiation of a partial
9107 specialization. We replace the innermost set of ARGS with
9108 the arguments appropriate for substitution. For example,
9111 template <class T> struct S {};
9112 template <class T> struct S<T*> {};
9114 and supposing that we are instantiating S<int*>, ARGS will
9115 presently be {int*} -- but we need {int}. */
9116 pattern
= TREE_TYPE (t
);
9117 args
= TREE_PURPOSE (t
);
9121 pattern
= TREE_TYPE (templ
);
9122 args
= CLASSTYPE_TI_ARGS (type
);
9125 /* If the template we're instantiating is incomplete, then clearly
9126 there's nothing we can do. */
9127 if (!COMPLETE_TYPE_P (pattern
))
9130 /* If we've recursively instantiated too many templates, stop. */
9131 if (! push_tinst_level (type
))
9134 /* Now we're really doing the instantiation. Mark the type as in
9135 the process of being defined. */
9136 TYPE_BEING_DEFINED (type
) = 1;
9138 /* We may be in the middle of deferred access check. Disable
9140 push_deferring_access_checks (dk_no_deferred
);
9142 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
9143 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9144 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
9145 fn_context
= error_mark_node
;
9147 push_to_top_level ();
9148 /* Use #pragma pack from the template context. */
9149 saved_maximum_field_alignment
= maximum_field_alignment
;
9150 maximum_field_alignment
= TYPE_PRECISION (pattern
);
9152 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
9154 /* Set the input location to the most specialized template definition.
9155 This is needed if tsubsting causes an error. */
9156 typedecl
= TYPE_MAIN_DECL (pattern
);
9157 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
9158 DECL_SOURCE_LOCATION (typedecl
);
9160 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
9161 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
9162 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
9163 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
9164 if (ANON_AGGR_TYPE_P (pattern
))
9165 SET_ANON_AGGR_TYPE_P (type
);
9166 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
9168 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
9169 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
9170 /* Adjust visibility for template arguments. */
9171 determine_visibility (TYPE_MAIN_DECL (type
));
9173 if (CLASS_TYPE_P (type
))
9174 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
9176 pbinfo
= TYPE_BINFO (pattern
);
9178 /* We should never instantiate a nested class before its enclosing
9179 class; we need to look up the nested class by name before we can
9180 instantiate it, and that lookup should instantiate the enclosing
9182 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
9183 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
9185 base_list
= NULL_TREE
;
9186 if (BINFO_N_BASE_BINFOS (pbinfo
))
9192 /* We must enter the scope containing the type, as that is where
9193 the accessibility of types named in dependent bases are
9195 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9197 /* Substitute into each of the bases to determine the actual
9199 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9202 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9203 tree expanded_bases
= NULL_TREE
;
9206 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9209 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9210 args
, tf_error
, NULL_TREE
);
9211 if (expanded_bases
== error_mark_node
)
9214 len
= TREE_VEC_LENGTH (expanded_bases
);
9217 for (idx
= 0; idx
< len
; idx
++)
9220 /* Extract the already-expanded base class. */
9221 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9223 /* Substitute to figure out the base class. */
9224 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9227 if (base
== error_mark_node
)
9230 base_list
= tree_cons (access
, base
, base_list
);
9231 if (BINFO_VIRTUAL_P (pbase_binfo
))
9232 TREE_TYPE (base_list
) = integer_type_node
;
9236 /* The list is now in reverse order; correct that. */
9237 base_list
= nreverse (base_list
);
9240 pop_scope (pushed_scope
);
9242 /* Now call xref_basetypes to set up all the base-class
9244 xref_basetypes (type
, base_list
);
9246 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9247 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9248 args
, tf_error
, NULL_TREE
);
9249 fixup_attribute_variants (type
);
9251 /* Now that our base classes are set up, enter the scope of the
9252 class, so that name lookups into base classes, etc. will work
9253 correctly. This is precisely analogous to what we do in
9254 begin_class_definition when defining an ordinary non-template
9255 class, except we also need to push the enclosing classes. */
9256 push_nested_class (type
);
9258 /* Now members are processed in the order of declaration. */
9259 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9260 member
; member
= TREE_CHAIN (member
))
9262 tree t
= TREE_VALUE (member
);
9264 if (TREE_PURPOSE (member
))
9268 /* Build new CLASSTYPE_NESTED_UTDS. */
9271 bool class_template_p
;
9273 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9274 && TYPE_LANG_SPECIFIC (t
)
9275 && CLASSTYPE_IS_TEMPLATE (t
));
9276 /* If the member is a class template, then -- even after
9277 substitution -- there may be dependent types in the
9278 template argument list for the class. We increment
9279 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9280 that function will assume that no types are dependent
9281 when outside of a template. */
9282 if (class_template_p
)
9283 ++processing_template_decl
;
9284 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9285 if (class_template_p
)
9286 --processing_template_decl
;
9287 if (newtag
== error_mark_node
)
9290 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9292 tree name
= TYPE_IDENTIFIER (t
);
9294 if (class_template_p
)
9295 /* Unfortunately, lookup_template_class sets
9296 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9297 instantiation (i.e., for the type of a member
9298 template class nested within a template class.)
9299 This behavior is required for
9300 maybe_process_partial_specialization to work
9301 correctly, but is not accurate in this case;
9302 the TAG is not an instantiation of anything.
9303 (The corresponding TEMPLATE_DECL is an
9304 instantiation, but the TYPE is not.) */
9305 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9307 /* Now, we call pushtag to put this NEWTAG into the scope of
9308 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9309 pushtag calling push_template_decl. We don't have to do
9310 this for enums because it will already have been done in
9313 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9314 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9317 else if (DECL_DECLARES_FUNCTION_P (t
))
9319 /* Build new TYPE_METHODS. */
9322 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9323 ++processing_template_decl
;
9324 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9325 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9326 --processing_template_decl
;
9327 set_current_access_from_decl (r
);
9328 finish_member_declaration (r
);
9329 /* Instantiate members marked with attribute used. */
9330 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9332 if (TREE_CODE (r
) == FUNCTION_DECL
9333 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9334 cp_check_omp_declare_reduction (r
);
9336 else if (DECL_CLASS_TEMPLATE_P (t
)
9337 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
9338 /* A closure type for a lambda in a default argument for a
9339 member template. Ignore it; it will be instantiated with
9340 the default argument. */;
9343 /* Build new TYPE_FIELDS. */
9344 if (TREE_CODE (t
) == STATIC_ASSERT
)
9348 ++c_inhibit_evaluation_warnings
;
9350 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9351 tf_warning_or_error
, NULL_TREE
,
9352 /*integral_constant_expression_p=*/true);
9353 --c_inhibit_evaluation_warnings
;
9355 finish_static_assert (condition
,
9356 STATIC_ASSERT_MESSAGE (t
),
9357 STATIC_ASSERT_SOURCE_LOCATION (t
),
9360 else if (TREE_CODE (t
) != CONST_DECL
)
9363 tree vec
= NULL_TREE
;
9366 /* The file and line for this declaration, to
9367 assist in error message reporting. Since we
9368 called push_tinst_level above, we don't need to
9370 input_location
= DECL_SOURCE_LOCATION (t
);
9372 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9373 ++processing_template_decl
;
9374 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9375 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9376 --processing_template_decl
;
9378 if (TREE_CODE (r
) == TREE_VEC
)
9380 /* A capture pack became multiple fields. */
9382 len
= TREE_VEC_LENGTH (vec
);
9385 for (int i
= 0; i
< len
; ++i
)
9388 r
= TREE_VEC_ELT (vec
, i
);
9393 [t]he initialization (and any associated
9394 side-effects) of a static data member does
9395 not occur unless the static data member is
9396 itself used in a way that requires the
9397 definition of the static data member to
9400 Therefore, we do not substitute into the
9401 initialized for the static data member here. */
9402 finish_static_data_member_decl
9405 /*init_const_expr_p=*/false,
9406 /*asmspec_tree=*/NULL_TREE
,
9408 /* Instantiate members marked with attribute used. */
9409 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9412 else if (TREE_CODE (r
) == FIELD_DECL
)
9414 /* Determine whether R has a valid type and can be
9415 completed later. If R is invalid, then its type
9416 is replaced by error_mark_node. */
9417 tree rtype
= TREE_TYPE (r
);
9418 if (can_complete_type_without_circularity (rtype
))
9419 complete_type (rtype
);
9421 if (!COMPLETE_TYPE_P (rtype
))
9423 cxx_incomplete_type_error (r
, rtype
);
9424 TREE_TYPE (r
) = error_mark_node
;
9428 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9429 such a thing will already have been added to the field
9430 list by tsubst_enum in finish_member_declaration in the
9431 CLASSTYPE_NESTED_UTDS case above. */
9432 if (!(TREE_CODE (r
) == TYPE_DECL
9433 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9434 && DECL_ARTIFICIAL (r
)))
9436 set_current_access_from_decl (r
);
9437 finish_member_declaration (r
);
9445 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9446 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9448 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9450 tree friend_type
= t
;
9451 bool adjust_processing_template_decl
= false;
9453 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9455 /* template <class T> friend class C; */
9456 friend_type
= tsubst_friend_class (friend_type
, args
);
9457 adjust_processing_template_decl
= true;
9459 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9461 /* template <class T> friend class C::D; */
9462 friend_type
= tsubst (friend_type
, args
,
9463 tf_warning_or_error
, NULL_TREE
);
9464 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9465 friend_type
= TREE_TYPE (friend_type
);
9466 adjust_processing_template_decl
= true;
9468 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9469 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9471 /* This could be either
9475 when dependent_type_p is false or
9477 template <class U> friend class T::C;
9480 friend_type
= tsubst (friend_type
, args
,
9481 tf_warning_or_error
, NULL_TREE
);
9482 /* Bump processing_template_decl for correct
9483 dependent_type_p calculation. */
9484 ++processing_template_decl
;
9485 if (dependent_type_p (friend_type
))
9486 adjust_processing_template_decl
= true;
9487 --processing_template_decl
;
9489 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9490 && hidden_name_p (TYPE_NAME (friend_type
)))
9494 where C hasn't been declared yet. Let's lookup name
9495 from namespace scope directly, bypassing any name that
9496 come from dependent base class. */
9497 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9499 /* The call to xref_tag_from_type does injection for friend
9501 push_nested_namespace (ns
);
9503 xref_tag_from_type (friend_type
, NULL_TREE
,
9504 /*tag_scope=*/ts_current
);
9505 pop_nested_namespace (ns
);
9507 else if (uses_template_parms (friend_type
))
9508 /* friend class C<T>; */
9509 friend_type
= tsubst (friend_type
, args
,
9510 tf_warning_or_error
, NULL_TREE
);
9515 where C is already declared or
9517 friend class C<int>;
9519 We don't have to do anything in these cases. */
9521 if (adjust_processing_template_decl
)
9522 /* Trick make_friend_class into realizing that the friend
9523 we're adding is a template, not an ordinary class. It's
9524 important that we use make_friend_class since it will
9525 perform some error-checking and output cross-reference
9527 ++processing_template_decl
;
9529 if (friend_type
!= error_mark_node
)
9530 make_friend_class (type
, friend_type
, /*complain=*/false);
9532 if (adjust_processing_template_decl
)
9533 --processing_template_decl
;
9537 /* Build new DECL_FRIENDLIST. */
9540 /* The file and line for this declaration, to
9541 assist in error message reporting. Since we
9542 called push_tinst_level above, we don't need to
9544 input_location
= DECL_SOURCE_LOCATION (t
);
9546 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9548 ++processing_template_decl
;
9549 push_deferring_access_checks (dk_no_check
);
9552 r
= tsubst_friend_function (t
, args
);
9553 add_friend (type
, r
, /*complain=*/false);
9554 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9556 pop_deferring_access_checks ();
9557 --processing_template_decl
;
9563 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9565 tree decl
= lambda_function (type
);
9568 if (!DECL_TEMPLATE_INFO (decl
)
9569 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9570 instantiate_decl (decl
, false, false);
9572 /* We need to instantiate the capture list from the template
9573 after we've instantiated the closure members, but before we
9574 consider adding the conversion op. Also keep any captures
9575 that may have been added during instantiation of the op(). */
9576 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9578 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9579 args
, tf_warning_or_error
, NULL_TREE
,
9582 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9583 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9585 maybe_add_lambda_conv_op (type
);
9588 gcc_assert (errorcount
);
9591 /* Set the file and line number information to whatever is given for
9592 the class itself. This puts error messages involving generated
9593 implicit functions at a predictable point, and the same point
9594 that would be used for non-template classes. */
9595 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9597 unreverse_member_declarations (type
);
9598 finish_struct_1 (type
);
9599 TYPE_BEING_DEFINED (type
) = 0;
9601 /* We don't instantiate default arguments for member functions. 14.7.1:
9603 The implicit instantiation of a class template specialization causes
9604 the implicit instantiation of the declarations, but not of the
9605 definitions or default arguments, of the class member functions,
9606 member classes, static data members and member templates.... */
9608 /* Some typedefs referenced from within the template code need to be access
9609 checked at template instantiation time, i.e now. These types were
9610 added to the template at parsing time. Let's get those and perform
9611 the access checks then. */
9612 perform_typedefs_access_check (pattern
, args
);
9613 perform_deferred_access_checks (tf_warning_or_error
);
9614 pop_nested_class ();
9615 maximum_field_alignment
= saved_maximum_field_alignment
;
9617 pop_from_top_level ();
9618 pop_deferring_access_checks ();
9621 /* The vtable for a template class can be emitted in any translation
9622 unit in which the class is instantiated. When there is no key
9623 method, however, finish_struct_1 will already have added TYPE to
9624 the keyed_classes list. */
9625 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9626 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9631 /* Wrapper for instantiate_class_template_1. */
9634 instantiate_class_template (tree type
)
9637 timevar_push (TV_TEMPLATE_INST
);
9638 ret
= instantiate_class_template_1 (type
);
9639 timevar_pop (TV_TEMPLATE_INST
);
9644 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9650 else if (TYPE_P (t
))
9651 r
= tsubst (t
, args
, complain
, in_decl
);
9654 if (!(complain
& tf_warning
))
9655 ++c_inhibit_evaluation_warnings
;
9656 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9657 /*integral_constant_expression_p=*/true);
9658 if (!(complain
& tf_warning
))
9659 --c_inhibit_evaluation_warnings
;
9664 /* Given a function parameter pack TMPL_PARM and some function parameters
9665 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9666 and set *SPEC_P to point at the next point in the list. */
9669 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9671 /* Collect all of the extra "packed" parameters into an
9675 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9676 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9677 tree spec_parm
= *spec_p
;
9680 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9682 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9685 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9686 parmvec
= make_tree_vec (len
);
9687 parmtypevec
= make_tree_vec (len
);
9688 spec_parm
= *spec_p
;
9689 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9691 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9692 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9695 /* Build the argument packs. */
9696 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9697 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9698 TREE_TYPE (argpack
) = argtypepack
;
9699 *spec_p
= spec_parm
;
9704 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9705 NONTYPE_ARGUMENT_PACK. */
9708 make_fnparm_pack (tree spec_parm
)
9710 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9713 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9717 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9719 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9720 if (i
>= TREE_VEC_LENGTH (vec
))
9722 return PACK_EXPANSION_P (TREE_VEC_ELT (vec
, i
));
9726 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9729 make_argument_pack_select (tree arg_pack
, unsigned index
)
9731 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9733 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9734 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9739 /* This is a subroutine of tsubst_pack_expansion.
9741 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9742 mechanism to store the (non complete list of) arguments of the
9743 substitution and return a non substituted pack expansion, in order
9744 to wait for when we have enough arguments to really perform the
9748 use_pack_expansion_extra_args_p (tree parm_packs
,
9752 /* If one pack has an expansion and another pack has a normal
9753 argument or if one pack has an empty argument and an another
9754 one hasn't then tsubst_pack_expansion cannot perform the
9755 substitution and need to fall back on the
9756 PACK_EXPANSION_EXTRA mechanism. */
9757 if (parm_packs
== NULL_TREE
)
9759 else if (has_empty_arg
)
9762 bool has_expansion_arg
= false;
9763 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9765 bool has_non_expansion_arg
= false;
9766 for (tree parm_pack
= parm_packs
;
9768 parm_pack
= TREE_CHAIN (parm_pack
))
9770 tree arg
= TREE_VALUE (parm_pack
);
9772 if (argument_pack_element_is_expansion_p (arg
, i
))
9773 has_expansion_arg
= true;
9775 has_non_expansion_arg
= true;
9778 if (has_expansion_arg
&& has_non_expansion_arg
)
9784 /* [temp.variadic]/6 says that:
9786 The instantiation of a pack expansion [...]
9787 produces a list E1,E2, ..., En, where N is the number of elements
9788 in the pack expansion parameters.
9790 This subroutine of tsubst_pack_expansion produces one of these Ei.
9792 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9793 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9794 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9795 INDEX is the index 'i' of the element Ei to produce. ARGS,
9796 COMPLAIN, and IN_DECL are the same parameters as for the
9797 tsubst_pack_expansion function.
9799 The function returns the resulting Ei upon successful completion,
9802 Note that this function possibly modifies the ARGS parameter, so
9803 it's the responsibility of the caller to restore it. */
9806 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9809 tree args
/* This parm gets
9811 tsubst_flags_t complain
,
9815 bool ith_elem_is_expansion
= false;
9817 /* For each parameter pack, change the substitution of the parameter
9818 pack to the ith argument in its argument pack, then expand the
9820 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9822 tree parm
= TREE_PURPOSE (pack
);
9823 tree arg_pack
= TREE_VALUE (pack
);
9824 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9826 ith_elem_is_expansion
|=
9827 argument_pack_element_is_expansion_p (arg_pack
, index
);
9829 /* Select the Ith argument from the pack. */
9830 if (TREE_CODE (parm
) == PARM_DECL
9831 || TREE_CODE (parm
) == FIELD_DECL
)
9835 aps
= make_argument_pack_select (arg_pack
, index
);
9836 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
9837 return error_mark_node
;
9838 register_local_specialization (aps
, parm
);
9841 aps
= retrieve_local_specialization (parm
);
9846 template_parm_level_and_index (parm
, &level
, &idx
);
9850 aps
= make_argument_pack_select (arg_pack
, index
);
9851 /* Update the corresponding argument. */
9852 TMPL_ARG (args
, level
, idx
) = aps
;
9855 /* Re-use the ARGUMENT_PACK_SELECT. */
9856 aps
= TMPL_ARG (args
, level
, idx
);
9858 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9861 /* Substitute into the PATTERN with the (possibly altered)
9863 if (pattern
== in_decl
)
9864 /* Expanding a fixed parameter pack from
9865 coerce_template_parameter_pack. */
9866 t
= tsubst_decl (pattern
, args
, complain
);
9867 else if (!TYPE_P (pattern
))
9868 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9869 /*integral_constant_expression_p=*/false);
9871 t
= tsubst (pattern
, args
, complain
, in_decl
);
9873 /* If the Ith argument pack element is a pack expansion, then
9874 the Ith element resulting from the substituting is going to
9875 be a pack expansion as well. */
9876 if (ith_elem_is_expansion
)
9877 t
= make_pack_expansion (t
);
9882 /* Substitute ARGS into T, which is an pack expansion
9883 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9884 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9885 (if only a partial substitution could be performed) or
9886 ERROR_MARK_NODE if there was an error. */
9888 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9892 tree pack
, packs
= NULL_TREE
;
9893 bool unsubstituted_packs
= false;
9896 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
9897 bool need_local_specializations
= false;
9900 gcc_assert (PACK_EXPANSION_P (t
));
9901 pattern
= PACK_EXPANSION_PATTERN (t
);
9903 /* Add in any args remembered from an earlier partial instantiation. */
9904 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9906 levels
= TMPL_ARGS_DEPTH (args
);
9908 /* Determine the argument packs that will instantiate the parameter
9909 packs used in the expansion expression. While we're at it,
9910 compute the number of arguments to be expanded and make sure it
9912 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
9913 pack
= TREE_CHAIN (pack
))
9915 tree parm_pack
= TREE_VALUE (pack
);
9916 tree arg_pack
= NULL_TREE
;
9917 tree orig_arg
= NULL_TREE
;
9920 if (TREE_CODE (parm_pack
) == BASES
)
9922 if (BASES_DIRECT (parm_pack
))
9923 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9924 args
, complain
, in_decl
, false));
9926 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9927 args
, complain
, in_decl
, false));
9929 if (TREE_CODE (parm_pack
) == PARM_DECL
)
9931 if (PACK_EXPANSION_LOCAL_P (t
))
9932 arg_pack
= retrieve_local_specialization (parm_pack
);
9935 /* We can't rely on local_specializations for a parameter
9936 name used later in a function declaration (such as in a
9937 late-specified return type). Even if it exists, it might
9938 have the wrong value for a recursive call. Just make a
9939 dummy decl, since it's only used for its type. */
9940 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
9941 if (arg_pack
&& DECL_PACK_P (arg_pack
))
9942 /* Partial instantiation of the parm_pack, we can't build
9943 up an argument pack yet. */
9944 arg_pack
= NULL_TREE
;
9946 arg_pack
= make_fnparm_pack (arg_pack
);
9947 need_local_specializations
= true;
9950 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
9951 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
9955 template_parm_level_and_index (parm_pack
, &level
, &idx
);
9957 if (level
<= levels
)
9958 arg_pack
= TMPL_ARG (args
, level
, idx
);
9961 orig_arg
= arg_pack
;
9962 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
9963 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
9965 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
9966 /* This can only happen if we forget to expand an argument
9967 pack somewhere else. Just return an error, silently. */
9969 result
= make_tree_vec (1);
9970 TREE_VEC_ELT (result
, 0) = error_mark_node
;
9977 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
9979 /* Don't bother trying to do a partial substitution with
9980 incomplete packs; we'll try again after deduction. */
9981 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
9986 else if (len
!= my_len
)
9988 if (!(complain
& tf_error
))
9989 /* Fail quietly. */;
9990 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
9991 error ("mismatched argument pack lengths while expanding "
9995 error ("mismatched argument pack lengths while expanding "
9998 return error_mark_node
;
10001 /* Keep track of the parameter packs and their corresponding
10003 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
10004 TREE_TYPE (packs
) = orig_arg
;
10008 /* We can't substitute for this parameter pack. We use a flag as
10009 well as the missing_level counter because function parameter
10010 packs don't have a level. */
10011 unsubstituted_packs
= true;
10015 /* If the expansion is just T..., return the matching argument pack. */
10016 if (!unsubstituted_packs
10017 && TREE_PURPOSE (packs
) == pattern
)
10019 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
10020 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
10021 || pack_expansion_args_count (args
))
10023 /* Otherwise use the normal path so we get convert_from_reference. */
10026 /* We cannot expand this expansion expression, because we don't have
10027 all of the argument packs we need. */
10028 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
10030 /* We got some full packs, but we can't substitute them in until we
10031 have values for all the packs. So remember these until then. */
10033 t
= make_pack_expansion (pattern
);
10034 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
10037 else if (unsubstituted_packs
)
10039 /* There were no real arguments, we're just replacing a parameter
10040 pack with another version of itself. Substitute into the
10041 pattern and return a PACK_EXPANSION_*. The caller will need to
10043 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
10044 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
10045 /*integral_constant_expression_p=*/false);
10047 t
= tsubst (pattern
, args
, complain
, in_decl
);
10048 t
= make_pack_expansion (t
);
10052 gcc_assert (len
>= 0);
10054 if (need_local_specializations
)
10056 /* We're in a late-specified return type, so create our own local
10057 specializations map; the current map is either NULL or (in the
10058 case of recursive unification) might have bindings that we don't
10059 want to use or alter. */
10060 saved_local_specializations
= local_specializations
;
10061 local_specializations
= new hash_map
<tree
, tree
>;
10064 /* For each argument in each argument pack, substitute into the
10066 result
= make_tree_vec (len
);
10067 for (i
= 0; i
< len
; ++i
)
10069 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
10073 TREE_VEC_ELT (result
, i
) = t
;
10074 if (t
== error_mark_node
)
10076 result
= error_mark_node
;
10081 /* Update ARGS to restore the substitution from parameter packs to
10082 their argument packs. */
10083 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
10085 tree parm
= TREE_PURPOSE (pack
);
10087 if (TREE_CODE (parm
) == PARM_DECL
10088 || TREE_CODE (parm
) == FIELD_DECL
)
10089 register_local_specialization (TREE_TYPE (pack
), parm
);
10094 if (TREE_VALUE (pack
) == NULL_TREE
)
10097 template_parm_level_and_index (parm
, &level
, &idx
);
10099 /* Update the corresponding argument. */
10100 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
10101 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
10104 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
10108 if (need_local_specializations
)
10110 delete local_specializations
;
10111 local_specializations
= saved_local_specializations
;
10117 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10118 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10119 parameter packs; all parms generated from a function parameter pack will
10120 have the same DECL_PARM_INDEX. */
10123 get_pattern_parm (tree parm
, tree tmpl
)
10125 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
10128 if (DECL_ARTIFICIAL (parm
))
10130 for (patparm
= DECL_ARGUMENTS (pattern
);
10131 patparm
; patparm
= DECL_CHAIN (patparm
))
10132 if (DECL_ARTIFICIAL (patparm
)
10133 && DECL_NAME (parm
) == DECL_NAME (patparm
))
10138 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
10139 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
10140 gcc_assert (DECL_PARM_INDEX (patparm
)
10141 == DECL_PARM_INDEX (parm
));
10147 /* Substitute ARGS into the vector or list of template arguments T. */
10150 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10153 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
10156 if (t
== error_mark_node
)
10157 return error_mark_node
;
10159 len
= TREE_VEC_LENGTH (t
);
10160 elts
= XALLOCAVEC (tree
, len
);
10162 for (i
= 0; i
< len
; i
++)
10164 tree orig_arg
= TREE_VEC_ELT (t
, i
);
10167 if (TREE_CODE (orig_arg
) == TREE_VEC
)
10168 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
10169 else if (PACK_EXPANSION_P (orig_arg
))
10171 /* Substitute into an expansion expression. */
10172 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
10174 if (TREE_CODE (new_arg
) == TREE_VEC
)
10175 /* Add to the expanded length adjustment the number of
10176 expanded arguments. We subtract one from this
10177 measurement, because the argument pack expression
10178 itself is already counted as 1 in
10179 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10180 the argument pack is empty. */
10181 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
10183 else if (ARGUMENT_PACK_P (orig_arg
))
10185 /* Substitute into each of the arguments. */
10186 new_arg
= TYPE_P (orig_arg
)
10187 ? cxx_make_type (TREE_CODE (orig_arg
))
10188 : make_node (TREE_CODE (orig_arg
));
10190 SET_ARGUMENT_PACK_ARGS (
10192 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
10193 args
, complain
, in_decl
));
10195 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
10196 new_arg
= error_mark_node
;
10198 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
10199 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
10200 complain
, in_decl
);
10201 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
10203 if (TREE_TYPE (new_arg
) == error_mark_node
)
10204 new_arg
= error_mark_node
;
10208 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
10210 if (new_arg
== error_mark_node
)
10211 return error_mark_node
;
10214 if (new_arg
!= orig_arg
)
10221 /* Make space for the expanded arguments coming from template
10223 t
= make_tree_vec (len
+ expanded_len_adjust
);
10224 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10225 arguments for a member template.
10226 In that case each TREE_VEC in ORIG_T represents a level of template
10227 arguments, and ORIG_T won't carry any non defaulted argument count.
10228 It will rather be the nested TREE_VECs that will carry one.
10229 In other words, ORIG_T carries a non defaulted argument count only
10230 if it doesn't contain any nested TREE_VEC. */
10231 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
10233 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
10234 count
+= expanded_len_adjust
;
10235 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
10237 for (i
= 0, out
= 0; i
< len
; i
++)
10239 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
10240 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
10241 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10245 /* Now expand the template argument pack "in place". */
10246 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10247 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10251 TREE_VEC_ELT (t
, out
) = elts
[i
];
10259 /* Return the result of substituting ARGS into the template parameters
10260 given by PARMS. If there are m levels of ARGS and m + n levels of
10261 PARMS, then the result will contain n levels of PARMS. For
10262 example, if PARMS is `template <class T> template <class U>
10263 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10264 result will be `template <int*, double, class V>'. */
10267 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10269 tree r
= NULL_TREE
;
10272 /* When substituting into a template, we must set
10273 PROCESSING_TEMPLATE_DECL as the template parameters may be
10274 dependent if they are based on one-another, and the dependency
10275 predicates are short-circuit outside of templates. */
10276 ++processing_template_decl
;
10278 for (new_parms
= &r
;
10279 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10280 new_parms
= &(TREE_CHAIN (*new_parms
)),
10281 parms
= TREE_CHAIN (parms
))
10284 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10287 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10291 if (parms
== error_mark_node
)
10294 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10296 if (tuple
== error_mark_node
)
10299 TREE_VEC_ELT (new_vec
, i
) =
10300 tsubst_template_parm (tuple
, args
, complain
);
10304 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10305 - TMPL_ARGS_DEPTH (args
)),
10306 new_vec
, NULL_TREE
);
10309 --processing_template_decl
;
10314 /* Return the result of substituting ARGS into one template parameter
10315 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10316 parameter and which TREE_PURPOSE is the default argument of the
10317 template parameter. */
10320 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10322 tree default_value
, parm_decl
;
10324 if (args
== NULL_TREE
10326 || t
== error_mark_node
)
10329 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10331 default_value
= TREE_PURPOSE (t
);
10332 parm_decl
= TREE_VALUE (t
);
10334 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10335 if (TREE_CODE (parm_decl
) == PARM_DECL
10336 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10337 parm_decl
= error_mark_node
;
10338 default_value
= tsubst_template_arg (default_value
, args
,
10339 complain
, NULL_TREE
);
10341 return build_tree_list (default_value
, parm_decl
);
10344 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10345 type T. If T is not an aggregate or enumeration type, it is
10346 handled as if by tsubst. IN_DECL is as for tsubst. If
10347 ENTERING_SCOPE is nonzero, T is the context for a template which
10348 we are presently tsubst'ing. Return the substituted value. */
10351 tsubst_aggr_type (tree t
,
10353 tsubst_flags_t complain
,
10355 int entering_scope
)
10357 if (t
== NULL_TREE
)
10360 switch (TREE_CODE (t
))
10363 if (TYPE_PTRMEMFUNC_P (t
))
10364 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10366 /* Else fall through. */
10367 case ENUMERAL_TYPE
:
10369 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10374 int saved_unevaluated_operand
;
10375 int saved_inhibit_evaluation_warnings
;
10377 /* In "sizeof(X<I>)" we need to evaluate "I". */
10378 saved_unevaluated_operand
= cp_unevaluated_operand
;
10379 cp_unevaluated_operand
= 0;
10380 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10381 c_inhibit_evaluation_warnings
= 0;
10383 /* First, determine the context for the type we are looking
10385 context
= TYPE_CONTEXT (t
);
10386 if (context
&& TYPE_P (context
))
10388 context
= tsubst_aggr_type (context
, args
, complain
,
10389 in_decl
, /*entering_scope=*/1);
10390 /* If context is a nested class inside a class template,
10391 it may still need to be instantiated (c++/33959). */
10392 context
= complete_type (context
);
10395 /* Then, figure out what arguments are appropriate for the
10396 type we are trying to find. For example, given:
10398 template <class T> struct S;
10399 template <class T, class U> void f(T, U) { S<U> su; }
10401 and supposing that we are instantiating f<int, double>,
10402 then our ARGS will be {int, double}, but, when looking up
10403 S we only want {double}. */
10404 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10405 complain
, in_decl
);
10406 if (argvec
== error_mark_node
)
10407 r
= error_mark_node
;
10410 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10411 entering_scope
, complain
);
10412 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10415 cp_unevaluated_operand
= saved_unevaluated_operand
;
10416 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10421 /* This is not a template type, so there's nothing to do. */
10425 return tsubst (t
, args
, complain
, in_decl
);
10429 /* Substitute into the default argument ARG (a default argument for
10430 FN), which has the indicated TYPE. */
10433 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10435 tree saved_class_ptr
= NULL_TREE
;
10436 tree saved_class_ref
= NULL_TREE
;
10437 int errs
= errorcount
+ sorrycount
;
10439 /* This can happen in invalid code. */
10440 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10443 /* This default argument came from a template. Instantiate the
10444 default argument here, not in tsubst. In the case of
10453 we must be careful to do name lookup in the scope of S<T>,
10454 rather than in the current class. */
10455 push_access_scope (fn
);
10456 /* The "this" pointer is not valid in a default argument. */
10459 saved_class_ptr
= current_class_ptr
;
10460 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10461 saved_class_ref
= current_class_ref
;
10462 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10465 push_deferring_access_checks(dk_no_deferred
);
10466 /* The default argument expression may cause implicitly defined
10467 member functions to be synthesized, which will result in garbage
10468 collection. We must treat this situation as if we were within
10469 the body of function so as to avoid collecting live data on the
10472 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10473 complain
, NULL_TREE
,
10474 /*integral_constant_expression_p=*/false);
10476 pop_deferring_access_checks();
10478 /* Restore the "this" pointer. */
10481 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10482 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10485 if (errorcount
+sorrycount
> errs
10486 && (complain
& tf_warning_or_error
))
10487 inform (input_location
,
10488 " when instantiating default argument for call to %D", fn
);
10490 /* Make sure the default argument is reasonable. */
10491 arg
= check_default_argument (type
, arg
, complain
);
10493 pop_access_scope (fn
);
10498 /* Substitute into all the default arguments for FN. */
10501 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10506 tmpl_args
= DECL_TI_ARGS (fn
);
10508 /* If this function is not yet instantiated, we certainly don't need
10509 its default arguments. */
10510 if (uses_template_parms (tmpl_args
))
10512 /* Don't do this again for clones. */
10513 if (DECL_CLONED_FUNCTION_P (fn
))
10516 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10518 arg
= TREE_CHAIN (arg
))
10519 if (TREE_PURPOSE (arg
))
10520 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10522 TREE_PURPOSE (arg
),
10526 /* Substitute the ARGS into the T, which is a _DECL. Return the
10527 result of the substitution. Issue error and warning messages under
10528 control of COMPLAIN. */
10531 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10533 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10534 location_t saved_loc
;
10535 tree r
= NULL_TREE
;
10537 hashval_t hash
= 0;
10539 /* Set the filename and linenumber to improve error-reporting. */
10540 saved_loc
= input_location
;
10541 input_location
= DECL_SOURCE_LOCATION (t
);
10543 switch (TREE_CODE (t
))
10545 case TEMPLATE_DECL
:
10547 /* We can get here when processing a member function template,
10548 member class template, or template template parameter. */
10549 tree decl
= DECL_TEMPLATE_RESULT (t
);
10554 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10556 /* Template template parameter is treated here. */
10557 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10558 if (new_type
== error_mark_node
)
10559 RETURN (error_mark_node
);
10560 /* If we get a real template back, return it. This can happen in
10561 the context of most_specialized_partial_spec. */
10562 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10566 DECL_CHAIN (r
) = NULL_TREE
;
10567 TREE_TYPE (r
) = new_type
;
10568 DECL_TEMPLATE_RESULT (r
)
10569 = build_decl (DECL_SOURCE_LOCATION (decl
),
10570 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10571 DECL_TEMPLATE_PARMS (r
)
10572 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10574 TYPE_NAME (new_type
) = r
;
10578 /* We might already have an instance of this template.
10579 The ARGS are for the surrounding class type, so the
10580 full args contain the tsubst'd args for the context,
10581 plus the innermost args from the template decl. */
10582 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10583 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10584 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10585 /* Because this is a template, the arguments will still be
10586 dependent, even after substitution. If
10587 PROCESSING_TEMPLATE_DECL is not set, the dependency
10588 predicates will short-circuit. */
10589 ++processing_template_decl
;
10590 full_args
= tsubst_template_args (tmpl_args
, args
,
10591 complain
, in_decl
);
10592 --processing_template_decl
;
10593 if (full_args
== error_mark_node
)
10594 RETURN (error_mark_node
);
10596 /* If this is a default template template argument,
10597 tsubst might not have changed anything. */
10598 if (full_args
== tmpl_args
)
10601 hash
= hash_tmpl_and_args (t
, full_args
);
10602 spec
= retrieve_specialization (t
, full_args
, hash
);
10603 if (spec
!= NULL_TREE
)
10609 /* Make a new template decl. It will be similar to the
10610 original, but will record the current template arguments.
10611 We also create a new function declaration, which is just
10612 like the old one, but points to this new template, rather
10613 than the old one. */
10615 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10616 DECL_CHAIN (r
) = NULL_TREE
;
10618 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10620 if (TREE_CODE (decl
) == TYPE_DECL
10621 && !TYPE_DECL_ALIAS_P (decl
))
10624 ++processing_template_decl
;
10625 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10626 --processing_template_decl
;
10627 if (new_type
== error_mark_node
)
10628 RETURN (error_mark_node
);
10630 TREE_TYPE (r
) = new_type
;
10631 /* For a partial specialization, we need to keep pointing to
10632 the primary template. */
10633 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10634 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10635 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10636 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10637 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10642 ++processing_template_decl
;
10643 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10644 --processing_template_decl
;
10645 if (new_decl
== error_mark_node
)
10646 RETURN (error_mark_node
);
10648 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10649 DECL_TI_TEMPLATE (new_decl
) = r
;
10650 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10651 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10652 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10655 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10656 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10657 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10659 /* The template parameters for this new template are all the
10660 template parameters for the old template, except the
10661 outermost level of parameters. */
10662 DECL_TEMPLATE_PARMS (r
)
10663 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10666 if (PRIMARY_TEMPLATE_P (t
))
10667 DECL_PRIMARY_TEMPLATE (r
) = r
;
10669 if (TREE_CODE (decl
) != TYPE_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
10670 /* Record this non-type partial instantiation. */
10671 register_specialization (r
, t
,
10672 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10677 case FUNCTION_DECL
:
10680 tree argvec
= NULL_TREE
;
10688 /* Nobody should be tsubst'ing into non-template functions. */
10689 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10691 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10696 /* If T is not dependent, just return it. We have to
10697 increment PROCESSING_TEMPLATE_DECL because
10698 value_dependent_expression_p assumes that nothing is
10699 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10700 ++processing_template_decl
;
10701 dependent_p
= value_dependent_expression_p (t
);
10702 --processing_template_decl
;
10706 /* Calculate the most general template of which R is a
10707 specialization, and the complete set of arguments used to
10709 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10710 argvec
= tsubst_template_args (DECL_TI_ARGS
10711 (DECL_TEMPLATE_RESULT
10712 (DECL_TI_TEMPLATE (t
))),
10713 args
, complain
, in_decl
);
10714 if (argvec
== error_mark_node
)
10715 RETURN (error_mark_node
);
10717 /* Check to see if we already have this specialization. */
10718 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10719 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10727 /* We can see more levels of arguments than parameters if
10728 there was a specialization of a member template, like
10731 template <class T> struct S { template <class U> void f(); }
10732 template <> template <class U> void S<int>::f(U);
10734 Here, we'll be substituting into the specialization,
10735 because that's where we can find the code we actually
10736 want to generate, but we'll have enough arguments for
10737 the most general template.
10739 We also deal with the peculiar case:
10741 template <class T> struct S {
10742 template <class U> friend void f();
10744 template <class U> void f() {}
10746 template void f<double>();
10748 Here, the ARGS for the instantiation of will be {int,
10749 double}. But, we only need as many ARGS as there are
10750 levels of template parameters in CODE_PATTERN. We are
10751 careful not to get fooled into reducing the ARGS in
10754 template <class T> struct S { template <class U> void f(U); }
10755 template <class T> template <> void S<T>::f(int) {}
10757 which we can spot because the pattern will be a
10758 specialization in this case. */
10759 args_depth
= TMPL_ARGS_DEPTH (args
);
10761 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10762 if (args_depth
> parms_depth
10763 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10764 args
= get_innermost_template_args (args
, parms_depth
);
10768 /* This special case arises when we have something like this:
10770 template <class T> struct S {
10771 friend void f<int>(int, double);
10774 Here, the DECL_TI_TEMPLATE for the friend declaration
10775 will be an IDENTIFIER_NODE. We are being called from
10776 tsubst_friend_function, and we want only to create a
10777 new decl (R) with appropriate types so that we can call
10778 determine_specialization. */
10779 gen_tmpl
= NULL_TREE
;
10782 if (DECL_CLASS_SCOPE_P (t
))
10784 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10788 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10789 complain
, t
, /*entering_scope=*/1);
10794 ctx
= DECL_CONTEXT (t
);
10796 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10797 if (type
== error_mark_node
)
10798 RETURN (error_mark_node
);
10800 /* If we hit excessive deduction depth, the type is bogus even if
10801 it isn't error_mark_node, so don't build a decl. */
10802 if (excessive_deduction_depth
)
10803 RETURN (error_mark_node
);
10805 /* We do NOT check for matching decls pushed separately at this
10806 point, as they may not represent instantiations of this
10807 template, and in any case are considered separate under the
10810 DECL_USE_TEMPLATE (r
) = 0;
10811 TREE_TYPE (r
) = type
;
10812 /* Clear out the mangled name and RTL for the instantiation. */
10813 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10814 SET_DECL_RTL (r
, NULL
);
10815 /* Leave DECL_INITIAL set on deleted instantiations. */
10816 if (!DECL_DELETED_FN (r
))
10817 DECL_INITIAL (r
) = NULL_TREE
;
10818 DECL_CONTEXT (r
) = ctx
;
10820 /* OpenMP UDRs have the only argument a reference to the declared
10821 type. We want to diagnose if the declared type is a reference,
10822 which is invalid, but as references to references are usually
10823 quietly merged, diagnose it here. */
10824 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10827 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10828 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10829 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10830 error_at (DECL_SOURCE_LOCATION (t
),
10831 "reference type %qT in "
10832 "%<#pragma omp declare reduction%>", argtype
);
10833 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10834 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10838 if (member
&& DECL_CONV_FN_P (r
))
10839 /* Type-conversion operator. Reconstruct the name, in
10840 case it's the name of one of the template's parameters. */
10841 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10843 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10845 DECL_RESULT (r
) = NULL_TREE
;
10847 TREE_STATIC (r
) = 0;
10848 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10849 DECL_EXTERNAL (r
) = 1;
10850 /* If this is an instantiation of a function with internal
10851 linkage, we already know what object file linkage will be
10852 assigned to the instantiation. */
10853 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10854 DECL_DEFER_OUTPUT (r
) = 0;
10855 DECL_CHAIN (r
) = NULL_TREE
;
10856 DECL_PENDING_INLINE_INFO (r
) = 0;
10857 DECL_PENDING_INLINE_P (r
) = 0;
10858 DECL_SAVED_TREE (r
) = NULL_TREE
;
10859 DECL_STRUCT_FUNCTION (r
) = NULL
;
10861 /* We'll re-clone as appropriate in instantiate_template. */
10862 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10864 /* If we aren't complaining now, return on error before we register
10865 the specialization so that we'll complain eventually. */
10866 if ((complain
& tf_error
) == 0
10867 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10868 && !grok_op_properties (r
, /*complain=*/false))
10869 RETURN (error_mark_node
);
10871 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10872 this in the special friend case mentioned above where
10873 GEN_TMPL is NULL. */
10876 DECL_TEMPLATE_INFO (r
)
10877 = build_template_info (gen_tmpl
, argvec
);
10878 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10881 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10883 /* We instantiated this while substituting into
10884 the type earlier (template/friend54.C). */
10887 /* We're not supposed to instantiate default arguments
10888 until they are called, for a template. But, for a
10891 template <class T> void f ()
10892 { extern void g(int i = T()); }
10894 we should do the substitution when the template is
10895 instantiated. We handle the member function case in
10896 instantiate_class_template since the default arguments
10897 might refer to other members of the class. */
10899 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10900 && !uses_template_parms (argvec
))
10901 tsubst_default_arguments (r
, complain
);
10904 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10906 /* Copy the list of befriending classes. */
10907 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10909 friends
= &TREE_CHAIN (*friends
))
10911 *friends
= copy_node (*friends
);
10912 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
10917 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
10919 maybe_retrofit_in_chrg (r
);
10920 if (DECL_CONSTRUCTOR_P (r
))
10921 grok_ctor_properties (ctx
, r
);
10922 if (DECL_INHERITED_CTOR_BASE (r
))
10923 deduce_inheriting_ctor (r
);
10924 /* If this is an instantiation of a member template, clone it.
10925 If it isn't, that'll be handled by
10926 clone_constructors_and_destructors. */
10927 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
10928 clone_function_decl (r
, /*update_method_vec_p=*/0);
10930 else if ((complain
& tf_error
) != 0
10931 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10932 && !grok_op_properties (r
, /*complain=*/true))
10933 RETURN (error_mark_node
);
10935 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
10936 SET_DECL_FRIEND_CONTEXT (r
,
10937 tsubst (DECL_FRIEND_CONTEXT (t
),
10938 args
, complain
, in_decl
));
10940 /* Possibly limit visibility based on template args. */
10941 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10942 if (DECL_VISIBILITY_SPECIFIED (t
))
10944 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10945 DECL_ATTRIBUTES (r
)
10946 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10948 determine_visibility (r
);
10949 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
10950 && !processing_template_decl
)
10951 defaulted_late_check (r
);
10953 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10954 args
, complain
, in_decl
);
10960 tree type
= NULL_TREE
;
10962 tree expanded_types
= NULL_TREE
;
10963 tree prev_r
= NULL_TREE
;
10964 tree first_r
= NULL_TREE
;
10966 if (DECL_PACK_P (t
))
10968 /* If there is a local specialization that isn't a
10969 parameter pack, it means that we're doing a "simple"
10970 substitution from inside tsubst_pack_expansion. Just
10971 return the local specialization (which will be a single
10973 tree spec
= retrieve_local_specialization (t
);
10975 && TREE_CODE (spec
) == PARM_DECL
10976 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
10979 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10980 the parameters in this function parameter pack. */
10981 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10982 complain
, in_decl
);
10983 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10985 len
= TREE_VEC_LENGTH (expanded_types
);
10987 /* Zero-length parameter packs are boring. Just substitute
10990 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
10995 /* All we did was update the type. Make a note of that. */
10996 type
= expanded_types
;
10997 expanded_types
= NULL_TREE
;
11001 /* Loop through all of the parameters we'll build. When T is
11002 a function parameter pack, LEN is the number of expanded
11003 types in EXPANDED_TYPES; otherwise, LEN is 1. */
11005 for (i
= 0; i
< len
; ++i
)
11009 if (DECL_TEMPLATE_PARM_P (t
))
11010 SET_DECL_TEMPLATE_PARM_P (r
);
11012 if (expanded_types
)
11013 /* We're on the Ith parameter of the function parameter
11016 /* Get the Ith type. */
11017 type
= TREE_VEC_ELT (expanded_types
, i
);
11019 /* Rename the parameter to include the index. */
11021 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11024 /* We're dealing with a normal parameter. */
11025 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11027 type
= type_decays_to (type
);
11028 TREE_TYPE (r
) = type
;
11029 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11031 if (DECL_INITIAL (r
))
11033 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
11034 DECL_INITIAL (r
) = TREE_TYPE (r
);
11036 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
11037 complain
, in_decl
);
11040 DECL_CONTEXT (r
) = NULL_TREE
;
11042 if (!DECL_TEMPLATE_PARM_P (r
))
11043 DECL_ARG_TYPE (r
) = type_passed_as (type
);
11045 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11046 args
, complain
, in_decl
);
11048 /* Keep track of the first new parameter we
11049 generate. That's what will be returned to the
11054 /* Build a proper chain of parameters when substituting
11055 into a function parameter pack. */
11057 DECL_CHAIN (prev_r
) = r
;
11060 /* If cp_unevaluated_operand is set, we're just looking for a
11061 single dummy parameter, so don't keep going. */
11062 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
11063 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
11064 complain
, DECL_CHAIN (t
));
11066 /* FIRST_R contains the start of the chain we've built. */
11073 tree type
= NULL_TREE
;
11074 tree vec
= NULL_TREE
;
11075 tree expanded_types
= NULL_TREE
;
11078 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
11080 /* This field is a lambda capture pack. Return a TREE_VEC of
11081 the expanded fields to instantiate_class_template_1 and
11082 store them in the specializations hash table as a
11083 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11084 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11085 complain
, in_decl
);
11086 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11088 len
= TREE_VEC_LENGTH (expanded_types
);
11089 vec
= make_tree_vec (len
);
11093 /* All we did was update the type. Make a note of that. */
11094 type
= expanded_types
;
11095 expanded_types
= NULL_TREE
;
11099 for (int i
= 0; i
< len
; ++i
)
11102 if (expanded_types
)
11104 type
= TREE_VEC_ELT (expanded_types
, i
);
11106 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11109 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11111 if (type
== error_mark_node
)
11112 RETURN (error_mark_node
);
11113 TREE_TYPE (r
) = type
;
11114 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11116 if (DECL_C_BIT_FIELD (r
))
11117 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11118 non-bit-fields DECL_INITIAL is a non-static data member
11119 initializer, which gets deferred instantiation. */
11121 = tsubst_expr (DECL_INITIAL (t
), args
,
11123 /*integral_constant_expression_p=*/true);
11124 else if (DECL_INITIAL (t
))
11126 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11127 NSDMI in perform_member_init. Still set DECL_INITIAL
11128 so that we know there is one. */
11129 DECL_INITIAL (r
) = void_node
;
11130 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
11131 retrofit_lang_decl (r
);
11132 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
11134 /* We don't have to set DECL_CONTEXT here; it is set by
11135 finish_member_declaration. */
11136 DECL_CHAIN (r
) = NULL_TREE
;
11138 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11139 args
, complain
, in_decl
);
11142 TREE_VEC_ELT (vec
, i
) = r
;
11148 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
11149 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
11150 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
11151 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
11152 TREE_TYPE (pack
) = tpack
;
11153 register_specialization (pack
, t
, args
, false, 0);
11159 /* We reach here only for member using decls. We also need to check
11160 uses_template_parms because DECL_DEPENDENT_P is not set for a
11161 using-declaration that designates a member of the current
11162 instantiation (c++/53549). */
11163 if (DECL_DEPENDENT_P (t
)
11164 || uses_template_parms (USING_DECL_SCOPE (t
)))
11166 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
11167 complain
, in_decl
);
11168 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
11169 r
= do_class_using_decl (inst_scope
, name
);
11171 r
= error_mark_node
;
11174 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
11175 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
11181 DECL_CHAIN (r
) = NULL_TREE
;
11188 tree argvec
= NULL_TREE
;
11189 tree gen_tmpl
= NULL_TREE
;
11191 tree tmpl
= NULL_TREE
;
11193 tree type
= NULL_TREE
;
11196 if (TREE_TYPE (t
) == error_mark_node
)
11197 RETURN (error_mark_node
);
11199 if (TREE_CODE (t
) == TYPE_DECL
11200 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
11202 /* If this is the canonical decl, we don't have to
11203 mess with instantiations, and often we can't (for
11204 typename, template type parms and such). Note that
11205 TYPE_NAME is not correct for the above test if
11206 we've copied the type for a typedef. */
11207 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11208 if (type
== error_mark_node
)
11209 RETURN (error_mark_node
);
11210 r
= TYPE_NAME (type
);
11214 /* Check to see if we already have the specialization we
11217 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
11219 /* T is a static data member or namespace-scope entity.
11220 We have to substitute into namespace-scope variables
11221 (even though such entities are never templates) because
11224 template <class T> void f() { extern T t; }
11226 where the entity referenced is not known until
11227 instantiation time. */
11229 ctx
= DECL_CONTEXT (t
);
11230 if (DECL_CLASS_SCOPE_P (t
))
11232 ctx
= tsubst_aggr_type (ctx
, args
,
11234 in_decl
, /*entering_scope=*/1);
11235 /* If CTX is unchanged, then T is in fact the
11236 specialization we want. That situation occurs when
11237 referencing a static data member within in its own
11238 class. We can use pointer equality, rather than
11239 same_type_p, because DECL_CONTEXT is always
11241 if (ctx
== DECL_CONTEXT (t
)
11242 /* ... unless T is a member template; in which
11243 case our caller can be willing to create a
11244 specialization of that template represented
11246 && !(DECL_TI_TEMPLATE (t
)
11247 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
11253 tmpl
= DECL_TI_TEMPLATE (t
);
11254 gen_tmpl
= most_general_template (tmpl
);
11255 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11256 if (argvec
== error_mark_node
)
11257 RETURN (error_mark_node
);
11258 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11259 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11264 /* A local variable. */
11266 /* Subsequent calls to pushdecl will fill this in. */
11268 spec
= retrieve_local_specialization (t
);
11270 /* If we already have the specialization we need, there is
11271 nothing more to do. */
11278 /* Create a new node for the specialization we need. */
11280 if (type
== NULL_TREE
)
11282 if (is_typedef_decl (t
))
11283 type
= DECL_ORIGINAL_TYPE (t
);
11285 type
= TREE_TYPE (t
);
11287 && VAR_HAD_UNKNOWN_BOUND (t
)
11288 && type
!= error_mark_node
)
11289 type
= strip_array_domain (type
);
11290 type
= tsubst (type
, args
, complain
, in_decl
);
11294 /* Even if the original location is out of scope, the
11295 newly substituted one is not. */
11296 DECL_DEAD_FOR_LOCAL (r
) = 0;
11297 DECL_INITIALIZED_P (r
) = 0;
11298 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11299 if (type
== error_mark_node
)
11300 RETURN (error_mark_node
);
11301 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11303 /* It may seem that this case cannot occur, since:
11308 declares a function, not a variable. However:
11311 template <typename T> void g() { T t; }
11312 template void g<f>();
11314 is an attempt to declare a variable with function
11316 error ("variable %qD has function type",
11317 /* R is not yet sufficiently initialized, so we
11318 just use its name. */
11320 RETURN (error_mark_node
);
11322 type
= complete_type (type
);
11323 /* Wait until cp_finish_decl to set this again, to handle
11324 circular dependency (template/instantiate6.C). */
11325 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11326 type
= check_var_type (DECL_NAME (r
), type
);
11328 if (DECL_HAS_VALUE_EXPR_P (t
))
11330 tree ve
= DECL_VALUE_EXPR (t
);
11331 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11332 /*constant_expression_p=*/false);
11333 if (REFERENCE_REF_P (ve
))
11335 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11336 ve
= TREE_OPERAND (ve
, 0);
11338 SET_DECL_VALUE_EXPR (r
, ve
);
11340 if (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
11341 set_decl_tls_model (r
, decl_tls_model (t
));
11343 else if (DECL_SELF_REFERENCE_P (t
))
11344 SET_DECL_SELF_REFERENCE_P (r
);
11345 TREE_TYPE (r
) = type
;
11346 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11347 DECL_CONTEXT (r
) = ctx
;
11348 /* Clear out the mangled name and RTL for the instantiation. */
11349 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11350 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11351 SET_DECL_RTL (r
, NULL
);
11352 /* The initializer must not be expanded until it is required;
11353 see [temp.inst]. */
11354 DECL_INITIAL (r
) = NULL_TREE
;
11355 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11356 SET_DECL_RTL (r
, NULL
);
11357 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11360 /* Possibly limit visibility based on template args. */
11361 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11362 if (DECL_VISIBILITY_SPECIFIED (t
))
11364 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11365 DECL_ATTRIBUTES (r
)
11366 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11368 determine_visibility (r
);
11373 /* A static data member declaration is always marked
11374 external when it is declared in-class, even if an
11375 initializer is present. We mimic the non-template
11376 processing here. */
11377 DECL_EXTERNAL (r
) = 1;
11379 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11380 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11381 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11383 else if (!cp_unevaluated_operand
)
11384 register_local_specialization (r
, t
);
11386 DECL_CHAIN (r
) = NULL_TREE
;
11388 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11390 args
, complain
, in_decl
);
11392 /* Preserve a typedef that names a type. */
11393 if (is_typedef_decl (r
))
11395 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11396 set_underlying_type (r
);
11399 layout_decl (r
, 0);
11404 gcc_unreachable ();
11409 /* Restore the file and line information. */
11410 input_location
= saved_loc
;
11415 /* Substitute into the ARG_TYPES of a function type.
11416 If END is a TREE_CHAIN, leave it and any following types
11420 tsubst_arg_types (tree arg_types
,
11423 tsubst_flags_t complain
,
11426 tree remaining_arg_types
;
11427 tree type
= NULL_TREE
;
11429 tree expanded_args
= NULL_TREE
;
11432 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11435 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11436 args
, end
, complain
, in_decl
);
11437 if (remaining_arg_types
== error_mark_node
)
11438 return error_mark_node
;
11440 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11442 /* For a pack expansion, perform substitution on the
11443 entire expression. Later on, we'll handle the arguments
11445 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11446 args
, complain
, in_decl
);
11448 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11449 /* So that we'll spin through the parameters, one by one. */
11450 i
= TREE_VEC_LENGTH (expanded_args
);
11453 /* We only partially substituted into the parameter
11454 pack. Our type is TYPE_PACK_EXPANSION. */
11455 type
= expanded_args
;
11456 expanded_args
= NULL_TREE
;
11464 type
= TREE_VEC_ELT (expanded_args
, i
);
11466 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11468 if (type
== error_mark_node
)
11469 return error_mark_node
;
11470 if (VOID_TYPE_P (type
))
11472 if (complain
& tf_error
)
11474 error ("invalid parameter type %qT", type
);
11476 error ("in declaration %q+D", in_decl
);
11478 return error_mark_node
;
11481 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11482 return error_mark_node
;
11484 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11485 top-level qualifiers as required. */
11486 type
= cv_unqualified (type_decays_to (type
));
11488 /* We do not substitute into default arguments here. The standard
11489 mandates that they be instantiated only when needed, which is
11490 done in build_over_call. */
11491 default_arg
= TREE_PURPOSE (arg_types
);
11493 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11495 /* We've instantiated a template before its default arguments
11496 have been parsed. This can happen for a nested template
11497 class, and is not an error unless we require the default
11498 argument in a call of this function. */
11499 remaining_arg_types
=
11500 tree_cons (default_arg
, type
, remaining_arg_types
);
11501 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11504 remaining_arg_types
=
11505 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11508 return remaining_arg_types
;
11511 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11512 *not* handle the exception-specification for FNTYPE, because the
11513 initial substitution of explicitly provided template parameters
11514 during argument deduction forbids substitution into the
11515 exception-specification:
11519 All references in the function type of the function template to the
11520 corresponding template parameters are replaced by the specified tem-
11521 plate argument values. If a substitution in a template parameter or
11522 in the function type of the function template results in an invalid
11523 type, type deduction fails. [Note: The equivalent substitution in
11524 exception specifications is done only when the function is instanti-
11525 ated, at which point a program is ill-formed if the substitution
11526 results in an invalid type.] */
11529 tsubst_function_type (tree t
,
11531 tsubst_flags_t complain
,
11535 tree arg_types
= NULL_TREE
;
11538 /* The TYPE_CONTEXT is not used for function/method types. */
11539 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11541 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11543 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11545 if (late_return_type_p
)
11547 /* Substitute the argument types. */
11548 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11549 complain
, in_decl
);
11550 if (arg_types
== error_mark_node
)
11551 return error_mark_node
;
11553 tree save_ccp
= current_class_ptr
;
11554 tree save_ccr
= current_class_ref
;
11555 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11556 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11557 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11560 /* DR 1207: 'this' is in scope in the trailing return type. */
11561 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11564 /* Substitute the return type. */
11565 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11569 current_class_ptr
= save_ccp
;
11570 current_class_ref
= save_ccr
;
11574 /* Substitute the return type. */
11575 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11577 if (return_type
== error_mark_node
)
11578 return error_mark_node
;
11579 /* DR 486 clarifies that creation of a function type with an
11580 invalid return type is a deduction failure. */
11581 if (TREE_CODE (return_type
) == ARRAY_TYPE
11582 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11584 if (complain
& tf_error
)
11586 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11587 error ("function returning an array");
11589 error ("function returning a function");
11591 return error_mark_node
;
11594 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11595 return error_mark_node
;
11597 if (!late_return_type_p
)
11599 /* Substitute the argument types. */
11600 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11601 complain
, in_decl
);
11602 if (arg_types
== error_mark_node
)
11603 return error_mark_node
;
11606 /* Construct a new type node and return it. */
11607 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11609 fntype
= build_function_type (return_type
, arg_types
);
11610 fntype
= apply_memfn_quals (fntype
,
11611 type_memfn_quals (t
),
11612 type_memfn_rqual (t
));
11616 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11617 /* Don't pick up extra function qualifiers from the basetype. */
11618 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11619 if (! MAYBE_CLASS_TYPE_P (r
))
11623 Type deduction may fail for any of the following
11626 -- Attempting to create "pointer to member of T" when T
11627 is not a class type. */
11628 if (complain
& tf_error
)
11629 error ("creating pointer to member function of non-class type %qT",
11631 return error_mark_node
;
11634 fntype
= build_method_type_directly (r
, return_type
,
11635 TREE_CHAIN (arg_types
));
11636 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11638 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11640 if (late_return_type_p
)
11641 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11646 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11647 ARGS into that specification, and return the substituted
11648 specification. If there is no specification, return NULL_TREE. */
11651 tsubst_exception_specification (tree fntype
,
11653 tsubst_flags_t complain
,
11660 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11661 new_specs
= NULL_TREE
;
11662 if (specs
&& TREE_PURPOSE (specs
))
11664 /* A noexcept-specifier. */
11665 tree expr
= TREE_PURPOSE (specs
);
11666 if (TREE_CODE (expr
) == INTEGER_CST
)
11670 /* Defer instantiation of noexcept-specifiers to avoid
11671 excessive instantiations (c++/49107). */
11672 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11673 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11675 /* We already partially instantiated this member template,
11676 so combine the new args with the old. */
11677 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11678 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11679 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11680 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11684 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11685 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11689 new_specs
= tsubst_copy_and_build
11690 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11691 /*integral_constant_expression_p=*/true);
11692 new_specs
= build_noexcept_spec (new_specs
, complain
);
11696 if (! TREE_VALUE (specs
))
11703 tree expanded_specs
= NULL_TREE
;
11705 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11707 /* Expand the pack expansion type. */
11708 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11712 if (expanded_specs
== error_mark_node
)
11713 return error_mark_node
;
11714 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11715 len
= TREE_VEC_LENGTH (expanded_specs
);
11718 /* We're substituting into a member template, so
11719 we got a TYPE_PACK_EXPANSION back. Add that
11720 expansion and move on. */
11721 gcc_assert (TREE_CODE (expanded_specs
)
11722 == TYPE_PACK_EXPANSION
);
11723 new_specs
= add_exception_specifier (new_specs
,
11726 specs
= TREE_CHAIN (specs
);
11731 for (i
= 0; i
< len
; ++i
)
11733 if (expanded_specs
)
11734 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11736 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11737 if (spec
== error_mark_node
)
11739 new_specs
= add_exception_specifier (new_specs
, spec
,
11743 specs
= TREE_CHAIN (specs
);
11749 /* Take the tree structure T and replace template parameters used
11750 therein with the argument vector ARGS. IN_DECL is an associated
11751 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11752 Issue error and warning messages under control of COMPLAIN. Note
11753 that we must be relatively non-tolerant of extensions here, in
11754 order to preserve conformance; if we allow substitutions that
11755 should not be allowed, we may allow argument deductions that should
11756 not succeed, and therefore report ambiguous overload situations
11757 where there are none. In theory, we could allow the substitution,
11758 but indicate that it should have failed, and allow our caller to
11759 make sure that the right thing happens, but we don't try to do this
11762 This function is used for dealing with types, decls and the like;
11763 for expressions, use tsubst_expr or tsubst_copy. */
11766 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11768 enum tree_code code
;
11769 tree type
, r
= NULL_TREE
;
11771 if (t
== NULL_TREE
|| t
== error_mark_node
11772 || t
== integer_type_node
11773 || t
== void_type_node
11774 || t
== char_type_node
11775 || t
== unknown_type_node
11776 || TREE_CODE (t
) == NAMESPACE_DECL
11777 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11781 return tsubst_decl (t
, args
, complain
);
11783 if (args
== NULL_TREE
)
11786 code
= TREE_CODE (t
);
11788 if (code
== IDENTIFIER_NODE
)
11789 type
= IDENTIFIER_TYPE_VALUE (t
);
11791 type
= TREE_TYPE (t
);
11793 gcc_assert (type
!= unknown_type_node
);
11795 /* Reuse typedefs. We need to do this to handle dependent attributes,
11796 such as attribute aligned. */
11798 && typedef_variant_p (t
))
11800 tree decl
= TYPE_NAME (t
);
11802 if (alias_template_specialization_p (t
))
11804 /* DECL represents an alias template and we want to
11806 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11807 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11808 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11810 else if (DECL_CLASS_SCOPE_P (decl
)
11811 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11812 && uses_template_parms (DECL_CONTEXT (decl
)))
11814 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11815 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11816 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11818 else if (DECL_FUNCTION_SCOPE_P (decl
)
11819 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11820 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11821 r
= retrieve_local_specialization (decl
);
11823 /* The typedef is from a non-template context. */
11829 r
= cp_build_qualified_type_real
11830 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11831 complain
| tf_ignore_bad_quals
);
11836 /* We don't have an instantiation yet, so drop the typedef. */
11837 int quals
= cp_type_quals (t
);
11838 t
= DECL_ORIGINAL_TYPE (decl
);
11839 t
= cp_build_qualified_type_real (t
, quals
,
11840 complain
| tf_ignore_bad_quals
);
11845 && code
!= TYPENAME_TYPE
11846 && code
!= TEMPLATE_TYPE_PARM
11847 && code
!= IDENTIFIER_NODE
11848 && code
!= FUNCTION_TYPE
11849 && code
!= METHOD_TYPE
)
11850 type
= tsubst (type
, args
, complain
, in_decl
);
11851 if (type
== error_mark_node
)
11852 return error_mark_node
;
11858 case ENUMERAL_TYPE
:
11859 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11860 /*entering_scope=*/0);
11863 case IDENTIFIER_NODE
:
11874 if (t
== integer_type_node
)
11877 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11878 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11882 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11884 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11885 /*integral_constant_expression_p=*/false);
11887 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11889 if (TREE_CODE (max
) == NOP_EXPR
11890 && TREE_SIDE_EFFECTS (omax
)
11891 && !TREE_TYPE (max
))
11892 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11894 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11895 with TREE_SIDE_EFFECTS that indicates this is not an integral
11896 constant expression. */
11897 if (processing_template_decl
11898 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11900 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11901 TREE_SIDE_EFFECTS (max
) = 1;
11904 return compute_array_index_type (NULL_TREE
, max
, complain
);
11907 case TEMPLATE_TYPE_PARM
:
11908 case TEMPLATE_TEMPLATE_PARM
:
11909 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11910 case TEMPLATE_PARM_INDEX
:
11915 tree arg
= NULL_TREE
;
11919 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
11920 template_parm_level_and_index (t
, &level
, &idx
);
11922 levels
= TMPL_ARGS_DEPTH (args
);
11923 if (level
<= levels
)
11925 arg
= TMPL_ARG (args
, level
, idx
);
11927 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
11929 /* See through ARGUMENT_PACK_SELECT arguments. */
11930 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
11931 /* If the selected argument is an expansion E, that most
11932 likely means we were called from
11933 gen_elem_of_pack_expansion_instantiation during the
11934 substituting of pack an argument pack (which Ith
11935 element is a pack expansion, where I is
11936 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11937 In this case, the Ith element resulting from this
11938 substituting is going to be a pack expansion, which
11939 pattern is the pattern of E. Let's return the
11941 gen_elem_of_pack_expansion_instantiation will
11942 build the resulting pack expansion from it. */
11943 if (PACK_EXPANSION_P (arg
))
11945 /* Make sure we aren't throwing away arg info. */
11946 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
11947 arg
= PACK_EXPANSION_PATTERN (arg
);
11952 if (arg
== error_mark_node
)
11953 return error_mark_node
;
11954 else if (arg
!= NULL_TREE
)
11956 if (ARGUMENT_PACK_P (arg
))
11957 /* If ARG is an argument pack, we don't actually want to
11958 perform a substitution here, because substitutions
11959 for argument packs are only done
11960 element-by-element. We can get to this point when
11961 substituting the type of a non-type template
11962 parameter pack, when that type actually contains
11963 template parameter packs from an outer template, e.g.,
11965 template<typename... Types> struct A {
11966 template<Types... Values> struct B { };
11970 if (code
== TEMPLATE_TYPE_PARM
)
11973 gcc_assert (TYPE_P (arg
));
11975 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
11977 return cp_build_qualified_type_real
11978 (arg
, quals
, complain
| tf_ignore_bad_quals
);
11980 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11982 /* We are processing a type constructed from a
11983 template template parameter. */
11984 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
11985 args
, complain
, in_decl
);
11986 if (argvec
== error_mark_node
)
11987 return error_mark_node
;
11989 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
11990 || TREE_CODE (arg
) == TEMPLATE_DECL
11991 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
11993 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
11994 /* Consider this code:
11996 template <template <class> class Template>
11998 template <class Arg> using Bind = Template<Arg>;
12001 template <template <class> class Template, class Arg>
12002 using Instantiate = Template<Arg>; //#0
12004 template <template <class> class Template,
12007 Instantiate<Internal<Template>::template Bind,
12010 When #1 is parsed, the
12011 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12012 parameter `Template' in #0 matches the
12013 UNBOUND_CLASS_TEMPLATE representing the argument
12014 `Internal<Template>::template Bind'; We then want
12015 to assemble the type `Bind<Argument>' that can't
12016 be fully created right now, because
12017 `Internal<Template>' not being complete, the Bind
12018 template cannot be looked up in that context. So
12019 we need to "store" `Bind<Argument>' for later
12020 when the context of Bind becomes complete. Let's
12021 store that in a TYPENAME_TYPE. */
12022 return make_typename_type (TYPE_CONTEXT (arg
),
12023 build_nt (TEMPLATE_ID_EXPR
,
12024 TYPE_IDENTIFIER (arg
),
12029 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12030 are resolving nested-types in the signature of a
12031 member function templates. Otherwise ARG is a
12032 TEMPLATE_DECL and is the real template to be
12034 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
12035 arg
= TYPE_NAME (arg
);
12037 r
= lookup_template_class (arg
,
12039 DECL_CONTEXT (arg
),
12040 /*entering_scope=*/0,
12042 return cp_build_qualified_type_real
12043 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
12046 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12047 return convert_from_reference (unshare_expr (arg
));
12051 /* This can happen during the attempted tsubst'ing in
12052 unify. This means that we don't yet have any information
12053 about the template parameter in question. */
12056 /* Early in template argument deduction substitution, we don't
12057 want to reduce the level of 'auto', or it will be confused
12058 with a normal template parm in subsequent deduction. */
12059 if (is_auto (t
) && (complain
& tf_partial
))
12062 /* If we get here, we must have been looking at a parm for a
12063 more deeply nested template. Make a new version of this
12064 template parameter, but with a lower level. */
12067 case TEMPLATE_TYPE_PARM
:
12068 case TEMPLATE_TEMPLATE_PARM
:
12069 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12070 if (cp_type_quals (t
))
12072 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
12073 r
= cp_build_qualified_type_real
12074 (r
, cp_type_quals (t
),
12075 complain
| (code
== TEMPLATE_TYPE_PARM
12076 ? tf_ignore_bad_quals
: 0));
12081 TEMPLATE_TYPE_PARM_INDEX (r
)
12082 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
12083 r
, levels
, args
, complain
);
12084 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
12085 TYPE_MAIN_VARIANT (r
) = r
;
12086 TYPE_POINTER_TO (r
) = NULL_TREE
;
12087 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
12089 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
12090 /* We have reduced the level of the template
12091 template parameter, but not the levels of its
12092 template parameters, so canonical_type_parameter
12093 will not be able to find the canonical template
12094 template parameter for this level. Thus, we
12095 require structural equality checking to compare
12096 TEMPLATE_TEMPLATE_PARMs. */
12097 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12098 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
12099 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12101 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
12103 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12105 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
12106 complain
, in_decl
);
12107 if (argvec
== error_mark_node
)
12108 return error_mark_node
;
12110 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
12111 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
12116 case TEMPLATE_PARM_INDEX
:
12117 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
12121 gcc_unreachable ();
12129 tree purpose
, value
, chain
;
12131 if (t
== void_list_node
)
12134 purpose
= TREE_PURPOSE (t
);
12137 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
12138 if (purpose
== error_mark_node
)
12139 return error_mark_node
;
12141 value
= TREE_VALUE (t
);
12144 value
= tsubst (value
, args
, complain
, in_decl
);
12145 if (value
== error_mark_node
)
12146 return error_mark_node
;
12148 chain
= TREE_CHAIN (t
);
12149 if (chain
&& chain
!= void_type_node
)
12151 chain
= tsubst (chain
, args
, complain
, in_decl
);
12152 if (chain
== error_mark_node
)
12153 return error_mark_node
;
12155 if (purpose
== TREE_PURPOSE (t
)
12156 && value
== TREE_VALUE (t
)
12157 && chain
== TREE_CHAIN (t
))
12159 return hash_tree_cons (purpose
, value
, chain
);
12163 /* We should never be tsubsting a binfo. */
12164 gcc_unreachable ();
12167 /* A vector of template arguments. */
12168 gcc_assert (!type
);
12169 return tsubst_template_args (t
, args
, complain
, in_decl
);
12172 case REFERENCE_TYPE
:
12174 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
12179 Type deduction may fail for any of the following
12182 -- Attempting to create a pointer to reference type.
12183 -- Attempting to create a reference to a reference type or
12184 a reference to void.
12186 Core issue 106 says that creating a reference to a reference
12187 during instantiation is no longer a cause for failure. We
12188 only enforce this check in strict C++98 mode. */
12189 if ((TREE_CODE (type
) == REFERENCE_TYPE
12190 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
12191 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
12193 static location_t last_loc
;
12195 /* We keep track of the last time we issued this error
12196 message to avoid spewing a ton of messages during a
12197 single bad template instantiation. */
12198 if (complain
& tf_error
12199 && last_loc
!= input_location
)
12201 if (VOID_TYPE_P (type
))
12202 error ("forming reference to void");
12203 else if (code
== POINTER_TYPE
)
12204 error ("forming pointer to reference type %qT", type
);
12206 error ("forming reference to reference type %qT", type
);
12207 last_loc
= input_location
;
12210 return error_mark_node
;
12212 else if (TREE_CODE (type
) == FUNCTION_TYPE
12213 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
12214 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12216 if (complain
& tf_error
)
12218 if (code
== POINTER_TYPE
)
12219 error ("forming pointer to qualified function type %qT",
12222 error ("forming reference to qualified function type %qT",
12225 return error_mark_node
;
12227 else if (code
== POINTER_TYPE
)
12229 r
= build_pointer_type (type
);
12230 if (TREE_CODE (type
) == METHOD_TYPE
)
12231 r
= build_ptrmemfunc_type (r
);
12233 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12234 /* In C++0x, during template argument substitution, when there is an
12235 attempt to create a reference to a reference type, reference
12236 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12238 "If a template-argument for a template-parameter T names a type
12239 that is a reference to a type A, an attempt to create the type
12240 'lvalue reference to cv T' creates the type 'lvalue reference to
12241 A,' while an attempt to create the type type rvalue reference to
12242 cv T' creates the type T"
12244 r
= cp_build_reference_type
12246 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12248 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12249 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12251 if (r
!= error_mark_node
)
12252 /* Will this ever be needed for TYPE_..._TO values? */
12259 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12260 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12264 Type deduction may fail for any of the following
12267 -- Attempting to create "pointer to member of T" when T
12268 is not a class type. */
12269 if (complain
& tf_error
)
12270 error ("creating pointer to member of non-class type %qT", r
);
12271 return error_mark_node
;
12273 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12275 if (complain
& tf_error
)
12276 error ("creating pointer to member reference type %qT", type
);
12277 return error_mark_node
;
12279 if (VOID_TYPE_P (type
))
12281 if (complain
& tf_error
)
12282 error ("creating pointer to member of type void");
12283 return error_mark_node
;
12285 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12286 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12288 /* The type of the implicit object parameter gets its
12289 cv-qualifiers from the FUNCTION_TYPE. */
12292 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12293 type_memfn_rqual (type
));
12294 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12295 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12299 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12303 case FUNCTION_TYPE
:
12308 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12309 if (fntype
== error_mark_node
)
12310 return error_mark_node
;
12312 /* Substitute the exception specification. */
12313 specs
= tsubst_exception_specification (t
, args
, complain
,
12314 in_decl
, /*defer_ok*/true);
12315 if (specs
== error_mark_node
)
12316 return error_mark_node
;
12318 fntype
= build_exception_variant (fntype
, specs
);
12323 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12324 if (domain
== error_mark_node
)
12325 return error_mark_node
;
12327 /* As an optimization, we avoid regenerating the array type if
12328 it will obviously be the same as T. */
12329 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12332 /* These checks should match the ones in create_array_type_for_decl.
12336 The deduction may fail for any of the following reasons:
12338 -- Attempting to create an array with an element type that
12339 is void, a function type, or a reference type, or [DR337]
12340 an abstract class type. */
12341 if (VOID_TYPE_P (type
)
12342 || TREE_CODE (type
) == FUNCTION_TYPE
12343 || (TREE_CODE (type
) == ARRAY_TYPE
12344 && TYPE_DOMAIN (type
) == NULL_TREE
)
12345 || TREE_CODE (type
) == REFERENCE_TYPE
)
12347 if (complain
& tf_error
)
12348 error ("creating array of %qT", type
);
12349 return error_mark_node
;
12352 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12353 return error_mark_node
;
12355 r
= build_cplus_array_type (type
, domain
);
12357 if (TYPE_USER_ALIGN (t
))
12359 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12360 TYPE_USER_ALIGN (r
) = 1;
12366 case TYPENAME_TYPE
:
12368 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12369 in_decl
, /*entering_scope=*/1);
12370 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12371 complain
, in_decl
);
12373 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12374 return error_mark_node
;
12376 if (!MAYBE_CLASS_TYPE_P (ctx
))
12378 if (complain
& tf_error
)
12379 error ("%qT is not a class, struct, or union type", ctx
);
12380 return error_mark_node
;
12382 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12384 /* Normally, make_typename_type does not require that the CTX
12385 have complete type in order to allow things like:
12387 template <class T> struct S { typename S<T>::X Y; };
12389 But, such constructs have already been resolved by this
12390 point, so here CTX really should have complete type, unless
12391 it's a partial instantiation. */
12392 ctx
= complete_type (ctx
);
12393 if (!COMPLETE_TYPE_P (ctx
))
12395 if (complain
& tf_error
)
12396 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12397 return error_mark_node
;
12401 f
= make_typename_type (ctx
, f
, typename_type
,
12402 complain
| tf_keep_type_decl
);
12403 if (f
== error_mark_node
)
12405 if (TREE_CODE (f
) == TYPE_DECL
)
12407 complain
|= tf_ignore_bad_quals
;
12411 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12413 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12415 if (complain
& tf_error
)
12416 error ("%qT resolves to %qT, which is not an enumeration type",
12419 return error_mark_node
;
12421 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12423 if (complain
& tf_error
)
12424 error ("%qT resolves to %qT, which is is not a class type",
12427 return error_mark_node
;
12431 return cp_build_qualified_type_real
12432 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12435 case UNBOUND_CLASS_TEMPLATE
:
12437 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12438 in_decl
, /*entering_scope=*/1);
12439 tree name
= TYPE_IDENTIFIER (t
);
12440 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12442 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12443 return error_mark_node
;
12446 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12447 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12454 ++cp_unevaluated_operand
;
12455 ++c_inhibit_evaluation_warnings
;
12457 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12459 /*integral_constant_expression_p=*/false);
12461 --cp_unevaluated_operand
;
12462 --c_inhibit_evaluation_warnings
;
12464 type
= finish_typeof (type
);
12465 return cp_build_qualified_type_real (type
,
12467 | cp_type_quals (type
),
12471 case DECLTYPE_TYPE
:
12475 ++cp_unevaluated_operand
;
12476 ++c_inhibit_evaluation_warnings
;
12478 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12479 complain
|tf_decltype
, in_decl
,
12480 /*function_p*/false,
12481 /*integral_constant_expression*/false);
12483 --cp_unevaluated_operand
;
12484 --c_inhibit_evaluation_warnings
;
12486 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12487 type
= lambda_capture_field_type (type
,
12488 DECLTYPE_FOR_INIT_CAPTURE (t
));
12489 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12490 type
= lambda_proxy_type (type
);
12493 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12494 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12496 /* In a template ~id could be either a complement expression
12497 or an unqualified-id naming a destructor; if instantiating
12498 it produces an expression, it's not an id-expression or
12501 type
= finish_decltype_type (type
, id
, complain
);
12503 return cp_build_qualified_type_real (type
,
12505 | cp_type_quals (type
),
12506 complain
| tf_ignore_bad_quals
);
12509 case UNDERLYING_TYPE
:
12511 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12512 complain
, in_decl
);
12513 return finish_underlying_type (type
);
12516 case TYPE_ARGUMENT_PACK
:
12517 case NONTYPE_ARGUMENT_PACK
:
12519 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12521 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12525 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12527 /* For template nontype argument packs, also substitute into
12529 if (code
== NONTYPE_ARGUMENT_PACK
)
12530 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12549 /* We should use one of the expression tsubsts for these codes. */
12550 gcc_unreachable ();
12553 sorry ("use of %qs in template", get_tree_code_name (code
));
12554 return error_mark_node
;
12558 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12559 type of the expression on the left-hand side of the "." or "->"
12563 tsubst_baselink (tree baselink
, tree object_type
,
12564 tree args
, tsubst_flags_t complain
, tree in_decl
)
12567 tree qualifying_scope
;
12570 tree template_args
= 0;
12571 bool template_id_p
= false;
12572 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12574 /* A baselink indicates a function from a base class. Both the
12575 BASELINK_ACCESS_BINFO and the base class referenced may
12576 indicate bases of the template class, rather than the
12577 instantiated class. In addition, lookups that were not
12578 ambiguous before may be ambiguous now. Therefore, we perform
12579 the lookup again. */
12580 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12581 qualifying_scope
= tsubst (qualifying_scope
, args
,
12582 complain
, in_decl
);
12583 fns
= BASELINK_FUNCTIONS (baselink
);
12584 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12585 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12587 template_id_p
= true;
12588 template_args
= TREE_OPERAND (fns
, 1);
12589 fns
= TREE_OPERAND (fns
, 0);
12591 template_args
= tsubst_template_args (template_args
, args
,
12592 complain
, in_decl
);
12594 name
= DECL_NAME (get_first_fn (fns
));
12595 if (IDENTIFIER_TYPENAME_P (name
))
12596 name
= mangle_conv_op_name_for_type (optype
);
12597 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12599 return error_mark_node
;
12601 /* If lookup found a single function, mark it as used at this
12602 point. (If it lookup found multiple functions the one selected
12603 later by overload resolution will be marked as used at that
12605 if (BASELINK_P (baselink
))
12606 fns
= BASELINK_FUNCTIONS (baselink
);
12607 if (!template_id_p
&& !really_overloaded_fn (fns
)
12608 && !mark_used (OVL_CURRENT (fns
), complain
) && !(complain
& tf_error
))
12609 return error_mark_node
;
12611 /* Add back the template arguments, if present. */
12612 if (BASELINK_P (baselink
) && template_id_p
)
12613 BASELINK_FUNCTIONS (baselink
)
12614 = build_nt (TEMPLATE_ID_EXPR
,
12615 BASELINK_FUNCTIONS (baselink
),
12617 /* Update the conversion operator type. */
12618 BASELINK_OPTYPE (baselink
) = optype
;
12621 object_type
= current_class_type
;
12624 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12630 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12631 true if the qualified-id will be a postfix-expression in-and-of
12632 itself; false if more of the postfix-expression follows the
12633 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12637 tsubst_qualified_id (tree qualified_id
, tree args
,
12638 tsubst_flags_t complain
, tree in_decl
,
12639 bool done
, bool address_p
)
12645 tree template_args
;
12646 location_t loc
= UNKNOWN_LOCATION
;
12648 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12650 /* Figure out what name to look up. */
12651 name
= TREE_OPERAND (qualified_id
, 1);
12652 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12654 is_template
= true;
12655 loc
= EXPR_LOCATION (name
);
12656 template_args
= TREE_OPERAND (name
, 1);
12658 template_args
= tsubst_template_args (template_args
, args
,
12659 complain
, in_decl
);
12660 name
= TREE_OPERAND (name
, 0);
12664 is_template
= false;
12665 template_args
= NULL_TREE
;
12668 /* Substitute into the qualifying scope. When there are no ARGS, we
12669 are just trying to simplify a non-dependent expression. In that
12670 case the qualifying scope may be dependent, and, in any case,
12671 substituting will not help. */
12672 scope
= TREE_OPERAND (qualified_id
, 0);
12675 scope
= tsubst (scope
, args
, complain
, in_decl
);
12676 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12681 if (dependent_scope_p (scope
))
12684 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12685 return build_qualified_name (NULL_TREE
, scope
, expr
,
12686 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12689 if (!BASELINK_P (name
) && !DECL_P (expr
))
12691 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12693 /* A BIT_NOT_EXPR is used to represent a destructor. */
12694 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12696 error ("qualifying type %qT does not match destructor name ~%qT",
12697 scope
, TREE_OPERAND (expr
, 0));
12698 expr
= error_mark_node
;
12701 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12702 /*is_type_p=*/0, false);
12705 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12706 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12707 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12709 if (complain
& tf_error
)
12711 error ("dependent-name %qE is parsed as a non-type, but "
12712 "instantiation yields a type", qualified_id
);
12713 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12715 return error_mark_node
;
12721 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12723 /* Remember that there was a reference to this entity. */
12724 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
12725 return error_mark_node
;
12728 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12730 if (complain
& tf_error
)
12731 qualified_name_lookup_error (scope
,
12732 TREE_OPERAND (qualified_id
, 1),
12733 expr
, input_location
);
12734 return error_mark_node
;
12738 expr
= lookup_template_function (expr
, template_args
);
12740 if (expr
== error_mark_node
&& complain
& tf_error
)
12741 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12742 expr
, input_location
);
12743 else if (TYPE_P (scope
))
12745 expr
= (adjust_result_of_qualified_name_lookup
12746 (expr
, scope
, current_nonlambda_class_type ()));
12747 expr
= (finish_qualified_id_expr
12748 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12749 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12750 /*template_arg_p=*/false, complain
));
12753 /* Expressions do not generally have reference type. */
12754 if (TREE_CODE (expr
) != SCOPE_REF
12755 /* However, if we're about to form a pointer-to-member, we just
12756 want the referenced member referenced. */
12757 && TREE_CODE (expr
) != OFFSET_REF
)
12758 expr
= convert_from_reference (expr
);
12763 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12764 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12768 tsubst_init (tree init
, tree decl
, tree args
,
12769 tsubst_flags_t complain
, tree in_decl
)
12774 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12778 /* If we had an initializer but it
12779 instantiated to nothing,
12780 value-initialize the object. This will
12781 only occur when the initializer was a
12782 pack expansion where the parameter packs
12783 used in that expansion were of length
12785 init
= build_value_init (TREE_TYPE (decl
),
12787 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12788 init
= get_target_expr_sfinae (init
, complain
);
12794 /* Like tsubst, but deals with expressions. This function just replaces
12795 template parms; to finish processing the resultant expression, use
12796 tsubst_copy_and_build or tsubst_expr. */
12799 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12801 enum tree_code code
;
12804 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12807 code
= TREE_CODE (t
);
12812 r
= retrieve_local_specialization (t
);
12814 if (r
== NULL_TREE
)
12816 /* We get here for a use of 'this' in an NSDMI. */
12817 if (DECL_NAME (t
) == this_identifier
12818 && current_function_decl
12819 && DECL_CONSTRUCTOR_P (current_function_decl
))
12820 return current_class_ptr
;
12822 /* This can happen for a parameter name used later in a function
12823 declaration (such as in a late-specified return type). Just
12824 make a dummy decl, since it's only used for its type. */
12825 gcc_assert (cp_unevaluated_operand
!= 0);
12826 r
= tsubst_decl (t
, args
, complain
);
12827 /* Give it the template pattern as its context; its true context
12828 hasn't been instantiated yet and this is good enough for
12830 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12833 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12834 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12835 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
12836 return error_mark_node
;
12844 if (DECL_TEMPLATE_PARM_P (t
))
12845 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12846 /* There is no need to substitute into namespace-scope
12848 if (DECL_NAMESPACE_SCOPE_P (t
))
12850 /* If ARGS is NULL, then T is known to be non-dependent. */
12851 if (args
== NULL_TREE
)
12852 return scalar_constant_value (t
);
12854 /* Unfortunately, we cannot just call lookup_name here.
12857 template <int I> int f() {
12859 struct S { void g() { E e = a; } };
12862 When we instantiate f<7>::S::g(), say, lookup_name is not
12863 clever enough to find f<7>::a. */
12865 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12866 /*entering_scope=*/0);
12868 for (v
= TYPE_VALUES (enum_type
);
12870 v
= TREE_CHAIN (v
))
12871 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12872 return TREE_VALUE (v
);
12874 /* We didn't find the name. That should never happen; if
12875 name-lookup found it during preliminary parsing, we
12876 should find it again here during instantiation. */
12877 gcc_unreachable ();
12882 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12884 /* Check for a local specialization set up by
12885 tsubst_pack_expansion. */
12886 if (tree r
= retrieve_local_specialization (t
))
12888 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12889 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12893 /* When retrieving a capture pack from a generic lambda, remove the
12894 lambda call op's own template argument list from ARGS. Only the
12895 template arguments active for the closure type should be used to
12896 retrieve the pack specialization. */
12897 if (LAMBDA_FUNCTION_P (current_function_decl
)
12898 && (template_class_depth (DECL_CONTEXT (t
))
12899 != TMPL_ARGS_DEPTH (args
)))
12900 args
= strip_innermost_template_args (args
, 1);
12902 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12903 tsubst_decl put in the hash table. */
12904 return retrieve_specialization (t
, args
, 0);
12907 if (DECL_CONTEXT (t
))
12911 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12912 /*entering_scope=*/1);
12913 if (ctx
!= DECL_CONTEXT (t
))
12915 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
12918 if (complain
& tf_error
)
12919 error ("using invalid field %qD", t
);
12920 return error_mark_node
;
12929 case FUNCTION_DECL
:
12930 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
12931 r
= tsubst (t
, args
, complain
, in_decl
);
12932 else if (local_variable_p (t
))
12934 r
= retrieve_local_specialization (t
);
12935 if (r
== NULL_TREE
)
12937 /* First try name lookup to find the instantiation. */
12938 r
= lookup_name (DECL_NAME (t
));
12941 /* Make sure that the one we found is the one we want. */
12942 tree ctx
= tsubst (DECL_CONTEXT (t
), args
,
12943 complain
, in_decl
);
12944 if (ctx
!= DECL_CONTEXT (r
))
12952 /* This can happen for a variable used in a
12953 late-specified return type of a local lambda, or for a
12954 local static or constant. Building a new VAR_DECL
12955 should be OK in all those cases. */
12956 r
= tsubst_decl (t
, args
, complain
);
12957 if (decl_maybe_constant_var_p (r
))
12959 /* We can't call cp_finish_decl, so handle the
12960 initializer by hand. */
12961 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
12962 complain
, in_decl
);
12963 if (!processing_template_decl
)
12964 init
= maybe_constant_init (init
);
12965 if (processing_template_decl
12966 ? potential_constant_expression (init
)
12967 : reduced_constant_expression_p (init
))
12968 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
12969 = TREE_CONSTANT (r
) = true;
12970 DECL_INITIAL (r
) = init
;
12972 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
12973 || decl_constant_var_p (r
)
12974 || errorcount
|| sorrycount
);
12975 if (!processing_template_decl
)
12977 if (TREE_STATIC (r
))
12978 rest_of_decl_compilation (r
, toplevel_bindings_p (),
12980 else if (decl_constant_var_p (r
))
12981 /* A use of a local constant decays to its value.
12982 FIXME update for core DR 696. */
12983 r
= scalar_constant_value (r
);
12986 /* Remember this for subsequent uses. */
12987 if (local_specializations
)
12988 register_local_specialization (r
, t
);
12993 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
12994 return error_mark_node
;
12997 case NAMESPACE_DECL
:
13001 /* An OVERLOAD will always be a non-dependent overload set; an
13002 overload set from function scope will just be represented with an
13003 IDENTIFIER_NODE, and from class scope with a BASELINK. */
13004 gcc_assert (!uses_template_parms (t
));
13008 return tsubst_baselink (t
, current_nonlambda_class_type (),
13009 args
, complain
, in_decl
);
13011 case TEMPLATE_DECL
:
13012 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13013 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
13014 args
, complain
, in_decl
);
13015 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
13016 return tsubst (t
, args
, complain
, in_decl
);
13017 else if (DECL_CLASS_SCOPE_P (t
)
13018 && uses_template_parms (DECL_CONTEXT (t
)))
13020 /* Template template argument like the following example need
13023 template <template <class> class TT> struct C {};
13024 template <class T> struct D {
13025 template <class U> struct E {};
13030 We are processing the template argument `E' in #1 for
13031 the template instantiation #2. Originally, `E' is a
13032 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13033 have to substitute this with one having context `D<int>'. */
13035 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
13036 return lookup_field (context
, DECL_NAME(t
), 0, false);
13039 /* Ordinary template template argument. */
13043 case REINTERPRET_CAST_EXPR
:
13044 case CONST_CAST_EXPR
:
13045 case STATIC_CAST_EXPR
:
13046 case DYNAMIC_CAST_EXPR
:
13047 case IMPLICIT_CONV_EXPR
:
13051 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13052 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13053 return build1 (code
, type
, op0
);
13057 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
13060 tree expanded
, op
= TREE_OPERAND (t
, 0);
13063 if (SIZEOF_EXPR_TYPE_P (t
))
13064 op
= TREE_TYPE (op
);
13066 ++cp_unevaluated_operand
;
13067 ++c_inhibit_evaluation_warnings
;
13068 /* We only want to compute the number of arguments. */
13069 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
13070 --cp_unevaluated_operand
;
13071 --c_inhibit_evaluation_warnings
;
13073 if (TREE_CODE (expanded
) == TREE_VEC
)
13074 len
= TREE_VEC_LENGTH (expanded
);
13076 if (expanded
== error_mark_node
)
13077 return error_mark_node
;
13078 else if (PACK_EXPANSION_P (expanded
)
13079 || (TREE_CODE (expanded
) == TREE_VEC
13081 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
13083 if (TREE_CODE (expanded
) == TREE_VEC
)
13084 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
13086 if (TYPE_P (expanded
))
13087 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
13088 complain
& tf_error
);
13090 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
13091 complain
& tf_error
);
13094 return build_int_cst (size_type_node
, len
);
13096 if (SIZEOF_EXPR_TYPE_P (t
))
13098 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
13099 args
, complain
, in_decl
);
13100 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
13101 r
= build1 (SIZEOF_EXPR
,
13102 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
13103 SIZEOF_EXPR_TYPE_P (r
) = 1;
13110 case TRUTH_NOT_EXPR
:
13113 case UNARY_PLUS_EXPR
: /* Unary + */
13115 case AT_ENCODE_EXPR
:
13119 case REALPART_EXPR
:
13120 case IMAGPART_EXPR
:
13123 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13124 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13125 return build1 (code
, type
, op0
);
13128 case COMPONENT_REF
:
13133 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13134 name
= TREE_OPERAND (t
, 1);
13135 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
13137 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13138 complain
, in_decl
);
13139 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13141 else if (TREE_CODE (name
) == SCOPE_REF
13142 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
13144 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13145 complain
, in_decl
);
13146 name
= TREE_OPERAND (name
, 1);
13147 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13148 complain
, in_decl
);
13149 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13150 name
= build_qualified_name (/*type=*/NULL_TREE
,
13152 /*template_p=*/false);
13154 else if (BASELINK_P (name
))
13155 name
= tsubst_baselink (name
,
13156 non_reference (TREE_TYPE (object
)),
13160 name
= tsubst_copy (name
, args
, complain
, in_decl
);
13161 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
13167 case TRUNC_DIV_EXPR
:
13168 case CEIL_DIV_EXPR
:
13169 case FLOOR_DIV_EXPR
:
13170 case ROUND_DIV_EXPR
:
13171 case EXACT_DIV_EXPR
:
13175 case TRUNC_MOD_EXPR
:
13176 case FLOOR_MOD_EXPR
:
13177 case TRUTH_ANDIF_EXPR
:
13178 case TRUTH_ORIF_EXPR
:
13179 case TRUTH_AND_EXPR
:
13180 case TRUTH_OR_EXPR
:
13193 case COMPOUND_EXPR
:
13196 case PREDECREMENT_EXPR
:
13197 case PREINCREMENT_EXPR
:
13198 case POSTDECREMENT_EXPR
:
13199 case POSTINCREMENT_EXPR
:
13201 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13202 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13203 return build_nt (code
, op0
, op1
);
13208 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13209 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13210 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
13211 QUALIFIED_NAME_IS_TEMPLATE (t
));
13216 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13217 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13218 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13223 int n
= VL_EXP_OPERAND_LENGTH (t
);
13224 tree result
= build_vl_exp (CALL_EXPR
, n
);
13226 for (i
= 0; i
< n
; i
++)
13227 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13228 complain
, in_decl
);
13234 case PSEUDO_DTOR_EXPR
:
13235 case VEC_PERM_EXPR
:
13237 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13238 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13239 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13240 r
= build_nt (code
, op0
, op1
, op2
);
13241 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13247 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13248 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13249 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13250 r
= build_nt (code
, op0
, op1
, op2
);
13251 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13257 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13258 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13259 r
= build_nt (code
, op0
, op1
);
13260 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13261 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13265 case TEMPLATE_ID_EXPR
:
13267 /* Substituted template arguments */
13268 tree fn
= TREE_OPERAND (t
, 0);
13269 tree targs
= TREE_OPERAND (t
, 1);
13271 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13273 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13275 return lookup_template_function (fn
, targs
);
13280 tree purpose
, value
, chain
;
13282 if (t
== void_list_node
)
13285 purpose
= TREE_PURPOSE (t
);
13287 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13288 value
= TREE_VALUE (t
);
13290 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13291 chain
= TREE_CHAIN (t
);
13292 if (chain
&& chain
!= void_type_node
)
13293 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13294 if (purpose
== TREE_PURPOSE (t
)
13295 && value
== TREE_VALUE (t
)
13296 && chain
== TREE_CHAIN (t
))
13298 return tree_cons (purpose
, value
, chain
);
13303 case ENUMERAL_TYPE
:
13305 case TEMPLATE_TYPE_PARM
:
13306 case TEMPLATE_TEMPLATE_PARM
:
13307 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13308 case TEMPLATE_PARM_INDEX
:
13310 case REFERENCE_TYPE
:
13312 case FUNCTION_TYPE
:
13315 case TYPENAME_TYPE
:
13316 case UNBOUND_CLASS_TEMPLATE
:
13318 case DECLTYPE_TYPE
:
13320 return tsubst (t
, args
, complain
, in_decl
);
13324 /* Fall through. */
13325 case IDENTIFIER_NODE
:
13326 if (IDENTIFIER_TYPENAME_P (t
))
13328 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13329 return mangle_conv_op_name_for_type (new_type
);
13335 /* This is handled by tsubst_copy_and_build. */
13336 gcc_unreachable ();
13340 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13341 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13342 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13345 case CLEANUP_POINT_EXPR
:
13346 /* We shouldn't have built any of these during initial template
13347 generation. Instead, they should be built during instantiation
13348 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13349 gcc_unreachable ();
13353 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13354 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13355 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13356 r
= build2 (code
, type
, op0
, op1
);
13357 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13358 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
13359 && !(complain
& tf_error
))
13360 return error_mark_node
;
13364 case EXPR_PACK_EXPANSION
:
13365 error ("invalid use of pack expansion expression");
13366 return error_mark_node
;
13368 case NONTYPE_ARGUMENT_PACK
:
13369 error ("use %<...%> to expand argument pack");
13370 return error_mark_node
;
13373 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13381 /* Instantiate any typedefs in the type. */
13382 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13383 r
= fold_convert (type
, t
);
13384 gcc_assert (TREE_CODE (r
) == code
);
13389 /* These can sometimes show up in a partial instantiation, but never
13390 involve template parms. */
13391 gcc_assert (!uses_template_parms (t
));
13395 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13396 gcc_checking_assert (false);
13401 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13404 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13405 tree args
, tsubst_flags_t complain
, tree in_decl
)
13407 tree new_clauses
= NULL
, nc
, oc
;
13409 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13411 nc
= copy_node (oc
);
13412 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13415 switch (OMP_CLAUSE_CODE (nc
))
13417 case OMP_CLAUSE_LASTPRIVATE
:
13418 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13420 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13421 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13422 in_decl
, /*integral_constant_expression_p=*/false);
13423 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13424 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13427 case OMP_CLAUSE_PRIVATE
:
13428 case OMP_CLAUSE_SHARED
:
13429 case OMP_CLAUSE_FIRSTPRIVATE
:
13430 case OMP_CLAUSE_COPYIN
:
13431 case OMP_CLAUSE_COPYPRIVATE
:
13432 case OMP_CLAUSE_IF
:
13433 case OMP_CLAUSE_NUM_THREADS
:
13434 case OMP_CLAUSE_SCHEDULE
:
13435 case OMP_CLAUSE_COLLAPSE
:
13436 case OMP_CLAUSE_FINAL
:
13437 case OMP_CLAUSE_DEPEND
:
13438 case OMP_CLAUSE_FROM
:
13439 case OMP_CLAUSE_TO
:
13440 case OMP_CLAUSE_UNIFORM
:
13441 case OMP_CLAUSE_MAP
:
13442 case OMP_CLAUSE_DEVICE
:
13443 case OMP_CLAUSE_DIST_SCHEDULE
:
13444 case OMP_CLAUSE_NUM_TEAMS
:
13445 case OMP_CLAUSE_THREAD_LIMIT
:
13446 case OMP_CLAUSE_SAFELEN
:
13447 case OMP_CLAUSE_SIMDLEN
:
13448 OMP_CLAUSE_OPERAND (nc
, 0)
13449 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13450 in_decl
, /*integral_constant_expression_p=*/false);
13452 case OMP_CLAUSE_REDUCTION
:
13453 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13455 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13456 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13458 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13459 complain
, in_decl
);
13460 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13461 = build_qualified_name (NULL_TREE
, scope
,
13462 TREE_OPERAND (placeholder
, 1),
13466 gcc_assert (identifier_p (placeholder
));
13468 OMP_CLAUSE_OPERAND (nc
, 0)
13469 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13470 in_decl
, /*integral_constant_expression_p=*/false);
13472 case OMP_CLAUSE_LINEAR
:
13473 case OMP_CLAUSE_ALIGNED
:
13474 OMP_CLAUSE_OPERAND (nc
, 0)
13475 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13476 in_decl
, /*integral_constant_expression_p=*/false);
13477 OMP_CLAUSE_OPERAND (nc
, 1)
13478 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13479 in_decl
, /*integral_constant_expression_p=*/false);
13482 case OMP_CLAUSE_NOWAIT
:
13483 case OMP_CLAUSE_ORDERED
:
13484 case OMP_CLAUSE_DEFAULT
:
13485 case OMP_CLAUSE_UNTIED
:
13486 case OMP_CLAUSE_MERGEABLE
:
13487 case OMP_CLAUSE_INBRANCH
:
13488 case OMP_CLAUSE_NOTINBRANCH
:
13489 case OMP_CLAUSE_PROC_BIND
:
13490 case OMP_CLAUSE_FOR
:
13491 case OMP_CLAUSE_PARALLEL
:
13492 case OMP_CLAUSE_SECTIONS
:
13493 case OMP_CLAUSE_TASKGROUP
:
13496 gcc_unreachable ();
13500 new_clauses
= nreverse (new_clauses
);
13502 new_clauses
= finish_omp_clauses (new_clauses
);
13503 return new_clauses
;
13506 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13509 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13512 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13514 tree purpose
, value
, chain
;
13519 if (TREE_CODE (t
) != TREE_LIST
)
13520 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13521 /*function_p=*/false,
13522 /*integral_constant_expression_p=*/false);
13524 if (t
== void_list_node
)
13527 purpose
= TREE_PURPOSE (t
);
13529 purpose
= RECUR (purpose
);
13530 value
= TREE_VALUE (t
);
13533 if (TREE_CODE (value
) != LABEL_DECL
)
13534 value
= RECUR (value
);
13537 value
= lookup_label (DECL_NAME (value
));
13538 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13539 TREE_USED (value
) = 1;
13542 chain
= TREE_CHAIN (t
);
13543 if (chain
&& chain
!= void_type_node
)
13544 chain
= RECUR (chain
);
13545 return tree_cons (purpose
, value
, chain
);
13549 /* Substitute one OMP_FOR iterator. */
13552 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13553 tree condv
, tree incrv
, tree
*clauses
,
13554 tree args
, tsubst_flags_t complain
, tree in_decl
,
13555 bool integral_constant_expression_p
)
13557 #define RECUR(NODE) \
13558 tsubst_expr ((NODE), args, complain, in_decl, \
13559 integral_constant_expression_p)
13560 tree decl
, init
, cond
, incr
;
13562 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13563 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13564 decl
= TREE_OPERAND (init
, 0);
13565 init
= TREE_OPERAND (init
, 1);
13566 tree decl_expr
= NULL_TREE
;
13567 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13569 /* We need to jump through some hoops to handle declarations in the
13570 for-init-statement, since we might need to handle auto deduction,
13571 but we need to keep control of initialization. */
13573 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13574 decl
= tsubst_decl (decl
, args
, complain
);
13577 decl
= RECUR (decl
);
13578 init
= RECUR (init
);
13580 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13581 if (auto_node
&& init
)
13583 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13585 gcc_assert (!type_dependent_expression_p (decl
));
13587 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13591 /* Declare the variable, but don't let that initialize it. */
13592 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13593 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13595 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13598 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13599 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13600 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13602 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13603 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13604 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13605 NOP_EXPR
, rhs
, complain
);
13608 incr
= RECUR (incr
);
13609 TREE_VEC_ELT (declv
, i
) = decl
;
13610 TREE_VEC_ELT (initv
, i
) = init
;
13611 TREE_VEC_ELT (condv
, i
) = cond
;
13612 TREE_VEC_ELT (incrv
, i
) = incr
;
13618 /* Declare and initialize the variable. */
13625 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13627 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13628 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13629 && OMP_CLAUSE_DECL (c
) == decl
)
13631 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13632 && OMP_CLAUSE_DECL (c
) == decl
)
13633 error ("iteration variable %qD should not be firstprivate", decl
);
13634 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13635 && OMP_CLAUSE_DECL (c
) == decl
)
13636 error ("iteration variable %qD should not be reduction", decl
);
13640 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13641 OMP_CLAUSE_DECL (c
) = decl
;
13642 c
= finish_omp_clauses (c
);
13645 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13650 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13651 if (COMPARISON_CLASS_P (cond
))
13653 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13654 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13655 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13658 cond
= RECUR (cond
);
13659 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13660 switch (TREE_CODE (incr
))
13662 case PREINCREMENT_EXPR
:
13663 case PREDECREMENT_EXPR
:
13664 case POSTINCREMENT_EXPR
:
13665 case POSTDECREMENT_EXPR
:
13666 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13667 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13670 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13671 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13673 tree rhs
= TREE_OPERAND (incr
, 1);
13674 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13675 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13676 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13677 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13678 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13682 incr
= RECUR (incr
);
13685 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13686 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13688 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13689 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13690 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13691 TREE_TYPE (decl
), lhs
,
13692 RECUR (TREE_OPERAND (incr
, 2))));
13694 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13695 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13696 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13698 tree rhs
= TREE_OPERAND (incr
, 2);
13699 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13700 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13701 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13702 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13703 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13707 incr
= RECUR (incr
);
13710 incr
= RECUR (incr
);
13714 TREE_VEC_ELT (declv
, i
) = decl
;
13715 TREE_VEC_ELT (initv
, i
) = init
;
13716 TREE_VEC_ELT (condv
, i
) = cond
;
13717 TREE_VEC_ELT (incrv
, i
) = incr
;
13721 /* Like tsubst_copy for expressions, etc. but also does semantic
13725 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13726 bool integral_constant_expression_p
)
13728 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13729 #define RECUR(NODE) \
13730 tsubst_expr ((NODE), args, complain, in_decl, \
13731 integral_constant_expression_p)
13737 if (t
== NULL_TREE
|| t
== error_mark_node
)
13740 loc
= input_location
;
13741 if (EXPR_HAS_LOCATION (t
))
13742 input_location
= EXPR_LOCATION (t
);
13743 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13744 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13746 switch (TREE_CODE (t
))
13748 case STATEMENT_LIST
:
13750 tree_stmt_iterator i
;
13751 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13752 RECUR (tsi_stmt (i
));
13756 case CTOR_INITIALIZER
:
13757 finish_mem_initializers (tsubst_initializer_list
13758 (TREE_OPERAND (t
, 0), args
));
13762 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13766 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13767 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13768 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13770 finish_expr_stmt (tmp
);
13774 do_using_directive (USING_STMT_NAMESPACE (t
));
13779 tree decl
, pattern_decl
;
13782 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13783 if (TREE_CODE (decl
) == LABEL_DECL
)
13784 finish_label_decl (DECL_NAME (decl
));
13785 else if (TREE_CODE (decl
) == USING_DECL
)
13787 tree scope
= USING_DECL_SCOPE (decl
);
13788 tree name
= DECL_NAME (decl
);
13791 scope
= tsubst (scope
, args
, complain
, in_decl
);
13792 decl
= lookup_qualified_name (scope
, name
,
13793 /*is_type_p=*/false,
13794 /*complain=*/false);
13795 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13796 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13798 do_local_using_decl (decl
, scope
, name
);
13800 else if (DECL_PACK_P (decl
))
13802 /* Don't build up decls for a variadic capture proxy, we'll
13803 instantiate the elements directly as needed. */
13808 init
= DECL_INITIAL (decl
);
13809 decl
= tsubst (decl
, args
, complain
, in_decl
);
13810 if (decl
!= error_mark_node
)
13812 /* By marking the declaration as instantiated, we avoid
13813 trying to instantiate it. Since instantiate_decl can't
13814 handle local variables, and since we've already done
13815 all that needs to be done, that's the right thing to
13818 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13820 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13821 /* Anonymous aggregates are a special case. */
13822 finish_anon_union (decl
);
13823 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13825 DECL_CONTEXT (decl
) = current_function_decl
;
13826 if (DECL_NAME (decl
) == this_identifier
)
13828 tree lam
= DECL_CONTEXT (current_function_decl
);
13829 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13830 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13832 insert_capture_proxy (decl
);
13834 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13835 /* We already did a pushtag. */;
13836 else if (TREE_CODE (decl
) == FUNCTION_DECL
13837 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13838 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13840 DECL_CONTEXT (decl
) = NULL_TREE
;
13842 DECL_CONTEXT (decl
) = current_function_decl
;
13843 cp_check_omp_declare_reduction (decl
);
13847 int const_init
= false;
13848 maybe_push_decl (decl
);
13850 && DECL_PRETTY_FUNCTION_P (decl
))
13852 /* For __PRETTY_FUNCTION__ we have to adjust the
13854 const char *const name
13855 = cxx_printable_name (current_function_decl
, 2);
13856 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13859 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
13862 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13864 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13873 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13874 RECUR (FOR_INIT_STMT (t
));
13875 finish_for_init_stmt (stmt
);
13876 tmp
= RECUR (FOR_COND (t
));
13877 finish_for_cond (tmp
, stmt
, false);
13878 tmp
= RECUR (FOR_EXPR (t
));
13879 finish_for_expr (tmp
, stmt
);
13880 RECUR (FOR_BODY (t
));
13881 finish_for_stmt (stmt
);
13884 case RANGE_FOR_STMT
:
13887 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13888 decl
= RANGE_FOR_DECL (t
);
13889 decl
= tsubst (decl
, args
, complain
, in_decl
);
13890 maybe_push_decl (decl
);
13891 expr
= RECUR (RANGE_FOR_EXPR (t
));
13892 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13893 RECUR (RANGE_FOR_BODY (t
));
13894 finish_for_stmt (stmt
);
13899 stmt
= begin_while_stmt ();
13900 tmp
= RECUR (WHILE_COND (t
));
13901 finish_while_stmt_cond (tmp
, stmt
, false);
13902 RECUR (WHILE_BODY (t
));
13903 finish_while_stmt (stmt
);
13907 stmt
= begin_do_stmt ();
13908 RECUR (DO_BODY (t
));
13909 finish_do_body (stmt
);
13910 tmp
= RECUR (DO_COND (t
));
13911 finish_do_stmt (tmp
, stmt
, false);
13915 stmt
= begin_if_stmt ();
13916 tmp
= RECUR (IF_COND (t
));
13917 finish_if_stmt_cond (tmp
, stmt
);
13918 RECUR (THEN_CLAUSE (t
));
13919 finish_then_clause (stmt
);
13921 if (ELSE_CLAUSE (t
))
13923 begin_else_clause (stmt
);
13924 RECUR (ELSE_CLAUSE (t
));
13925 finish_else_clause (stmt
);
13928 finish_if_stmt (stmt
);
13932 if (BIND_EXPR_BODY_BLOCK (t
))
13933 stmt
= begin_function_body ();
13935 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
13936 ? BCS_TRY_BLOCK
: 0);
13938 RECUR (BIND_EXPR_BODY (t
));
13940 if (BIND_EXPR_BODY_BLOCK (t
))
13941 finish_function_body (stmt
);
13943 finish_compound_stmt (stmt
);
13947 finish_break_stmt ();
13950 case CONTINUE_STMT
:
13951 finish_continue_stmt ();
13955 stmt
= begin_switch_stmt ();
13956 tmp
= RECUR (SWITCH_STMT_COND (t
));
13957 finish_switch_cond (tmp
, stmt
);
13958 RECUR (SWITCH_STMT_BODY (t
));
13959 finish_switch_stmt (stmt
);
13962 case CASE_LABEL_EXPR
:
13964 tree low
= RECUR (CASE_LOW (t
));
13965 tree high
= RECUR (CASE_HIGH (t
));
13966 finish_case_label (EXPR_LOCATION (t
), low
, high
);
13972 tree decl
= LABEL_EXPR_LABEL (t
);
13975 label
= finish_label_stmt (DECL_NAME (decl
));
13976 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13977 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13982 tmp
= GOTO_DESTINATION (t
);
13983 if (TREE_CODE (tmp
) != LABEL_DECL
)
13984 /* Computed goto's must be tsubst'd into. On the other hand,
13985 non-computed gotos must not be; the identifier in question
13986 will have no binding. */
13989 tmp
= DECL_NAME (tmp
);
13990 finish_goto_stmt (tmp
);
13995 tree string
= RECUR (ASM_STRING (t
));
13996 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
13997 complain
, in_decl
);
13998 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
13999 complain
, in_decl
);
14000 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
14001 complain
, in_decl
);
14002 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
14003 complain
, in_decl
);
14004 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
14006 tree asm_expr
= tmp
;
14007 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
14008 asm_expr
= TREE_OPERAND (asm_expr
, 0);
14009 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
14016 stmt
= begin_try_block ();
14017 RECUR (TRY_STMTS (t
));
14018 finish_cleanup_try_block (stmt
);
14019 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
14023 tree compound_stmt
= NULL_TREE
;
14025 if (FN_TRY_BLOCK_P (t
))
14026 stmt
= begin_function_try_block (&compound_stmt
);
14028 stmt
= begin_try_block ();
14030 RECUR (TRY_STMTS (t
));
14032 if (FN_TRY_BLOCK_P (t
))
14033 finish_function_try_block (stmt
);
14035 finish_try_block (stmt
);
14037 RECUR (TRY_HANDLERS (t
));
14038 if (FN_TRY_BLOCK_P (t
))
14039 finish_function_handler_sequence (stmt
, compound_stmt
);
14041 finish_handler_sequence (stmt
);
14047 tree decl
= HANDLER_PARMS (t
);
14051 decl
= tsubst (decl
, args
, complain
, in_decl
);
14052 /* Prevent instantiate_decl from trying to instantiate
14053 this variable. We've already done all that needs to be
14055 if (decl
!= error_mark_node
)
14056 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
14058 stmt
= begin_handler ();
14059 finish_handler_parms (decl
, stmt
);
14060 RECUR (HANDLER_BODY (t
));
14061 finish_handler (stmt
);
14066 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
14067 if (CLASS_TYPE_P (tmp
))
14069 /* Local classes are not independent templates; they are
14070 instantiated along with their containing function. And this
14071 way we don't have to deal with pushing out of one local class
14072 to instantiate a member of another local class. */
14074 /* Closures are handled by the LAMBDA_EXPR. */
14075 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
14076 complete_type (tmp
);
14077 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
14078 if (!DECL_ARTIFICIAL (fn
))
14079 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
14083 case STATIC_ASSERT
:
14087 ++c_inhibit_evaluation_warnings
;
14089 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
14092 /*integral_constant_expression_p=*/true);
14093 --c_inhibit_evaluation_warnings
;
14095 finish_static_assert (condition
,
14096 STATIC_ASSERT_MESSAGE (t
),
14097 STATIC_ASSERT_SOURCE_LOCATION (t
),
14098 /*member_p=*/false);
14103 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
14104 args
, complain
, in_decl
);
14105 stmt
= begin_omp_parallel ();
14106 RECUR (OMP_PARALLEL_BODY (t
));
14107 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
14108 = OMP_PARALLEL_COMBINED (t
);
14112 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
14113 args
, complain
, in_decl
);
14114 stmt
= begin_omp_task ();
14115 RECUR (OMP_TASK_BODY (t
));
14116 finish_omp_task (tmp
, stmt
);
14123 case OMP_DISTRIBUTE
:
14125 tree clauses
, body
, pre_body
;
14126 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
14127 tree incrv
= NULL_TREE
;
14130 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
14131 args
, complain
, in_decl
);
14132 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14134 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14135 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14136 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14137 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14140 stmt
= begin_omp_structured_block ();
14142 pre_body
= push_stmt_list ();
14143 RECUR (OMP_FOR_PRE_BODY (t
));
14144 pre_body
= pop_stmt_list (pre_body
);
14146 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14147 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
14148 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
14149 &clauses
, args
, complain
, in_decl
,
14150 integral_constant_expression_p
);
14152 body
= push_stmt_list ();
14153 RECUR (OMP_FOR_BODY (t
));
14154 body
= pop_stmt_list (body
);
14156 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14157 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
14158 condv
, incrv
, body
, pre_body
, clauses
);
14161 t
= make_node (TREE_CODE (t
));
14162 TREE_TYPE (t
) = void_type_node
;
14163 OMP_FOR_BODY (t
) = body
;
14164 OMP_FOR_PRE_BODY (t
) = pre_body
;
14165 OMP_FOR_CLAUSES (t
) = clauses
;
14166 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
14170 add_stmt (finish_omp_structured_block (stmt
));
14177 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14178 args
, complain
, in_decl
);
14179 stmt
= push_stmt_list ();
14180 RECUR (OMP_BODY (t
));
14181 stmt
= pop_stmt_list (stmt
);
14184 OMP_BODY (t
) = stmt
;
14185 OMP_CLAUSES (t
) = tmp
;
14189 case OMP_TARGET_DATA
:
14191 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14192 args
, complain
, in_decl
);
14193 keep_next_level (true);
14194 stmt
= begin_omp_structured_block ();
14196 RECUR (OMP_BODY (t
));
14197 stmt
= finish_omp_structured_block (stmt
);
14200 OMP_BODY (t
) = stmt
;
14201 OMP_CLAUSES (t
) = tmp
;
14205 case OMP_TARGET_UPDATE
:
14206 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
14207 args
, complain
, in_decl
);
14209 OMP_CLAUSES (t
) = tmp
;
14216 case OMP_TASKGROUP
:
14218 stmt
= push_stmt_list ();
14219 RECUR (OMP_BODY (t
));
14220 stmt
= pop_stmt_list (stmt
);
14223 OMP_BODY (t
) = stmt
;
14228 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14229 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14231 tree op1
= TREE_OPERAND (t
, 1);
14232 tree rhs1
= NULL_TREE
;
14234 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14236 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14237 op1
= TREE_OPERAND (op1
, 1);
14239 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14240 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14241 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14242 NULL_TREE
, NULL_TREE
, rhs1
,
14243 OMP_ATOMIC_SEQ_CST (t
));
14247 tree op1
= TREE_OPERAND (t
, 1);
14248 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14249 tree rhs1
= NULL_TREE
;
14250 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14251 enum tree_code opcode
= NOP_EXPR
;
14252 if (code
== OMP_ATOMIC_READ
)
14254 v
= RECUR (TREE_OPERAND (op1
, 0));
14255 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14257 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14258 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14260 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14261 v
= RECUR (TREE_OPERAND (op1
, 0));
14262 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14263 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14265 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14266 op11
= TREE_OPERAND (op11
, 1);
14268 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14269 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14270 opcode
= TREE_CODE (op11
);
14271 if (opcode
== MODIFY_EXPR
)
14277 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14278 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14280 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14281 OMP_ATOMIC_SEQ_CST (t
));
14285 case TRANSACTION_EXPR
:
14288 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14289 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14291 if (TRANSACTION_EXPR_IS_STMT (t
))
14293 tree body
= TRANSACTION_EXPR_BODY (t
);
14294 tree noex
= NULL_TREE
;
14295 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14297 noex
= MUST_NOT_THROW_COND (body
);
14298 if (noex
== NULL_TREE
)
14299 noex
= boolean_true_node
;
14300 body
= TREE_OPERAND (body
, 0);
14302 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14304 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14308 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14309 RECUR (TRANSACTION_EXPR_BODY (t
)),
14316 case MUST_NOT_THROW_EXPR
:
14318 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14319 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14320 RETURN (build_must_not_throw_expr (op0
, cond
));
14323 case EXPR_PACK_EXPANSION
:
14324 error ("invalid use of pack expansion expression");
14325 RETURN (error_mark_node
);
14327 case NONTYPE_ARGUMENT_PACK
:
14328 error ("use %<...%> to expand argument pack");
14329 RETURN (error_mark_node
);
14331 case CILK_SPAWN_STMT
:
14332 cfun
->calls_cilk_spawn
= 1;
14333 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14335 case CILK_SYNC_STMT
:
14336 RETURN (build_cilk_sync ());
14338 case COMPOUND_EXPR
:
14339 tmp
= RECUR (TREE_OPERAND (t
, 0));
14340 if (tmp
== NULL_TREE
)
14341 /* If the first operand was a statement, we're done with it. */
14342 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14343 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14344 RECUR (TREE_OPERAND (t
, 1)),
14347 case ANNOTATE_EXPR
:
14348 tmp
= RECUR (TREE_OPERAND (t
, 0));
14349 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14350 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14353 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14355 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14356 /*function_p=*/false,
14357 integral_constant_expression_p
));
14360 RETURN (NULL_TREE
);
14362 input_location
= loc
;
14368 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14369 function. For description of the body see comment above
14370 cp_parser_omp_declare_reduction_exprs. */
14373 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14375 if (t
== NULL_TREE
|| t
== error_mark_node
)
14378 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14380 tree_stmt_iterator tsi
;
14383 memset (stmts
, 0, sizeof stmts
);
14384 for (i
= 0, tsi
= tsi_start (t
);
14385 i
< 7 && !tsi_end_p (tsi
);
14386 i
++, tsi_next (&tsi
))
14387 stmts
[i
] = tsi_stmt (tsi
);
14388 gcc_assert (tsi_end_p (tsi
));
14392 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14393 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14394 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14395 args
, complain
, in_decl
);
14396 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14397 args
, complain
, in_decl
);
14398 DECL_CONTEXT (omp_out
) = current_function_decl
;
14399 DECL_CONTEXT (omp_in
) = current_function_decl
;
14400 keep_next_level (true);
14401 tree block
= begin_omp_structured_block ();
14402 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14403 block
= finish_omp_structured_block (block
);
14404 block
= maybe_cleanup_point_expr_void (block
);
14405 add_decl_expr (omp_out
);
14406 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14407 TREE_NO_WARNING (omp_out
) = 1;
14408 add_decl_expr (omp_in
);
14409 finish_expr_stmt (block
);
14413 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14414 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14415 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14416 args
, complain
, in_decl
);
14417 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14418 args
, complain
, in_decl
);
14419 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14420 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14421 keep_next_level (true);
14422 tree block
= begin_omp_structured_block ();
14423 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14424 block
= finish_omp_structured_block (block
);
14425 block
= maybe_cleanup_point_expr_void (block
);
14426 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14427 add_decl_expr (omp_priv
);
14428 add_decl_expr (omp_orig
);
14429 finish_expr_stmt (block
);
14431 add_decl_expr (omp_orig
);
14435 /* T is a postfix-expression that is not being used in a function
14436 call. Return the substituted version of T. */
14439 tsubst_non_call_postfix_expression (tree t
, tree args
,
14440 tsubst_flags_t complain
,
14443 if (TREE_CODE (t
) == SCOPE_REF
)
14444 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14445 /*done=*/false, /*address_p=*/false);
14447 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14448 /*function_p=*/false,
14449 /*integral_constant_expression_p=*/false);
14454 /* Like tsubst but deals with expressions and performs semantic
14455 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14458 tsubst_copy_and_build (tree t
,
14460 tsubst_flags_t complain
,
14463 bool integral_constant_expression_p
)
14465 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14466 #define RECUR(NODE) \
14467 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14468 /*function_p=*/false, \
14469 integral_constant_expression_p)
14474 if (t
== NULL_TREE
|| t
== error_mark_node
)
14477 loc
= input_location
;
14478 if (EXPR_HAS_LOCATION (t
))
14479 input_location
= EXPR_LOCATION (t
);
14481 /* N3276 decltype magic only applies to calls at the top level or on the
14482 right side of a comma. */
14483 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14484 complain
&= ~tf_decltype
;
14486 switch (TREE_CODE (t
))
14490 /* Fall through. */
14491 case IDENTIFIER_NODE
:
14495 bool non_integral_constant_expression_p
;
14496 const char *error_msg
;
14498 if (IDENTIFIER_TYPENAME_P (t
))
14500 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14501 t
= mangle_conv_op_name_for_type (new_type
);
14504 /* Look up the name. */
14505 decl
= lookup_name (t
);
14507 /* By convention, expressions use ERROR_MARK_NODE to indicate
14508 failure, not NULL_TREE. */
14509 if (decl
== NULL_TREE
)
14510 decl
= error_mark_node
;
14512 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14514 integral_constant_expression_p
,
14515 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14516 &non_integral_constant_expression_p
,
14517 /*template_p=*/false,
14519 /*address_p=*/false,
14520 /*template_arg_p=*/false,
14525 if (!function_p
&& identifier_p (decl
))
14527 if (complain
& tf_error
)
14528 unqualified_name_lookup_error (decl
);
14529 decl
= error_mark_node
;
14534 case TEMPLATE_ID_EXPR
:
14537 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14538 tree targs
= TREE_OPERAND (t
, 1);
14541 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14543 if (TREE_CODE (templ
) == COMPONENT_REF
)
14545 object
= TREE_OPERAND (templ
, 0);
14546 templ
= TREE_OPERAND (templ
, 1);
14549 object
= NULL_TREE
;
14550 templ
= lookup_template_function (templ
, targs
);
14553 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14554 object
, templ
, NULL_TREE
));
14556 RETURN (baselink_for_fns (templ
));
14561 tree r
= RECUR (TREE_OPERAND (t
, 0));
14563 if (REFERENCE_REF_P (t
))
14565 /* A type conversion to reference type will be enclosed in
14566 such an indirect ref, but the substitution of the cast
14567 will have also added such an indirect ref. */
14568 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14569 r
= convert_from_reference (r
);
14572 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14573 complain
|decltype_flag
);
14579 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14580 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14581 RETURN (build_nop (type
, op0
));
14584 case IMPLICIT_CONV_EXPR
:
14586 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14587 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14588 int flags
= LOOKUP_IMPLICIT
;
14589 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14590 flags
= LOOKUP_NORMAL
;
14591 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14597 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14598 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14599 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14603 case REINTERPRET_CAST_EXPR
:
14604 case CONST_CAST_EXPR
:
14605 case DYNAMIC_CAST_EXPR
:
14606 case STATIC_CAST_EXPR
:
14609 tree op
, r
= NULL_TREE
;
14611 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14612 if (integral_constant_expression_p
14613 && !cast_valid_in_integral_constant_expression_p (type
))
14615 if (complain
& tf_error
)
14616 error ("a cast to a type other than an integral or "
14617 "enumeration type cannot appear in a constant-expression");
14618 RETURN (error_mark_node
);
14621 op
= RECUR (TREE_OPERAND (t
, 0));
14623 warning_sentinel
s(warn_useless_cast
);
14624 switch (TREE_CODE (t
))
14627 r
= build_functional_cast (type
, op
, complain
);
14629 case REINTERPRET_CAST_EXPR
:
14630 r
= build_reinterpret_cast (type
, op
, complain
);
14632 case CONST_CAST_EXPR
:
14633 r
= build_const_cast (type
, op
, complain
);
14635 case DYNAMIC_CAST_EXPR
:
14636 r
= build_dynamic_cast (type
, op
, complain
);
14638 case STATIC_CAST_EXPR
:
14639 r
= build_static_cast (type
, op
, complain
);
14642 gcc_unreachable ();
14648 case POSTDECREMENT_EXPR
:
14649 case POSTINCREMENT_EXPR
:
14650 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14651 args
, complain
, in_decl
);
14652 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14653 complain
|decltype_flag
));
14655 case PREDECREMENT_EXPR
:
14656 case PREINCREMENT_EXPR
:
14660 case TRUTH_NOT_EXPR
:
14661 case UNARY_PLUS_EXPR
: /* Unary + */
14662 case REALPART_EXPR
:
14663 case IMAGPART_EXPR
:
14664 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14665 RECUR (TREE_OPERAND (t
, 0)),
14666 complain
|decltype_flag
));
14668 case FIX_TRUNC_EXPR
:
14669 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14673 op1
= TREE_OPERAND (t
, 0);
14674 if (TREE_CODE (op1
) == LABEL_DECL
)
14675 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14676 EXPR_LOCATION (op1
)));
14677 if (TREE_CODE (op1
) == SCOPE_REF
)
14678 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14679 /*done=*/true, /*address_p=*/true);
14681 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14683 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14684 complain
|decltype_flag
));
14689 case TRUNC_DIV_EXPR
:
14690 case CEIL_DIV_EXPR
:
14691 case FLOOR_DIV_EXPR
:
14692 case ROUND_DIV_EXPR
:
14693 case EXACT_DIV_EXPR
:
14697 case TRUNC_MOD_EXPR
:
14698 case FLOOR_MOD_EXPR
:
14699 case TRUTH_ANDIF_EXPR
:
14700 case TRUTH_ORIF_EXPR
:
14701 case TRUTH_AND_EXPR
:
14702 case TRUTH_OR_EXPR
:
14718 warning_sentinel
s1(warn_type_limits
);
14719 warning_sentinel
s2(warn_div_by_zero
);
14720 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14721 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14722 tree r
= build_x_binary_op
14723 (input_location
, TREE_CODE (t
),
14725 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14727 : TREE_CODE (TREE_OPERAND (t
, 0))),
14729 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14731 : TREE_CODE (TREE_OPERAND (t
, 1))),
14733 complain
|decltype_flag
);
14734 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14735 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14740 case POINTER_PLUS_EXPR
:
14742 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14743 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14744 return fold_build_pointer_plus (op0
, op1
);
14748 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14749 /*address_p=*/false));
14751 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14752 args
, complain
, in_decl
);
14753 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14754 RECUR (TREE_OPERAND (t
, 1)),
14755 complain
|decltype_flag
));
14757 case ARRAY_NOTATION_REF
:
14759 tree start_index
, length
, stride
;
14760 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14761 args
, complain
, in_decl
);
14762 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14763 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14764 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14765 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14766 length
, stride
, TREE_TYPE (op1
)));
14769 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14770 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14777 op1
= TREE_OPERAND (t
, 0);
14778 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14779 op1
= TREE_TYPE (op1
);
14782 /* When there are no ARGS, we are trying to evaluate a
14783 non-dependent expression from the parser. Trying to do
14784 the substitutions may not work. */
14786 op1
= TREE_TYPE (op1
);
14790 ++cp_unevaluated_operand
;
14791 ++c_inhibit_evaluation_warnings
;
14793 op1
= tsubst (op1
, args
, complain
, in_decl
);
14795 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14796 /*function_p=*/false,
14797 /*integral_constant_expression_p=*/
14799 --cp_unevaluated_operand
;
14800 --c_inhibit_evaluation_warnings
;
14803 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14804 complain
& tf_error
);
14806 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14807 complain
& tf_error
);
14808 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14810 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14812 if (!processing_template_decl
&& TYPE_P (op1
))
14814 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14815 build1 (NOP_EXPR
, op1
, error_mark_node
));
14816 SIZEOF_EXPR_TYPE_P (r
) = 1;
14819 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14820 TREE_SIDE_EFFECTS (r
) = 0;
14821 TREE_READONLY (r
) = 1;
14823 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14828 case AT_ENCODE_EXPR
:
14830 op1
= TREE_OPERAND (t
, 0);
14831 ++cp_unevaluated_operand
;
14832 ++c_inhibit_evaluation_warnings
;
14833 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14834 /*function_p=*/false,
14835 /*integral_constant_expression_p=*/false);
14836 --cp_unevaluated_operand
;
14837 --c_inhibit_evaluation_warnings
;
14838 RETURN (objc_build_encode_expr (op1
));
14841 case NOEXCEPT_EXPR
:
14842 op1
= TREE_OPERAND (t
, 0);
14843 ++cp_unevaluated_operand
;
14844 ++c_inhibit_evaluation_warnings
;
14845 ++cp_noexcept_operand
;
14846 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14847 /*function_p=*/false,
14848 /*integral_constant_expression_p=*/false);
14849 --cp_unevaluated_operand
;
14850 --c_inhibit_evaluation_warnings
;
14851 --cp_noexcept_operand
;
14852 RETURN (finish_noexcept_expr (op1
, complain
));
14856 warning_sentinel
s(warn_div_by_zero
);
14857 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
14858 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
14859 tree r
= build_x_modify_expr
14860 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
14861 complain
|decltype_flag
);
14862 /* TREE_NO_WARNING must be set if either the expression was
14863 parenthesized or it uses an operator such as >>= rather
14864 than plain assignment. In the former case, it was already
14865 set and must be copied. In the latter case,
14866 build_x_modify_expr sets it and it must not be reset
14868 if (TREE_NO_WARNING (t
))
14869 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14875 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14876 args
, complain
, in_decl
);
14877 /* Remember that there was a reference to this entity. */
14879 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
14880 RETURN (error_mark_node
);
14881 RETURN (build_x_arrow (input_location
, op1
, complain
));
14885 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14886 tree init
= RECUR (TREE_OPERAND (t
, 3));
14887 vec
<tree
, va_gc
> *placement_vec
;
14888 vec
<tree
, va_gc
> *init_vec
;
14891 if (placement
== NULL_TREE
)
14892 placement_vec
= NULL
;
14895 placement_vec
= make_tree_vector ();
14896 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14897 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14900 /* If there was an initializer in the original tree, but it
14901 instantiated to an empty list, then we should pass a
14902 non-NULL empty vector to tell build_new that it was an
14903 empty initializer() rather than no initializer. This can
14904 only happen when the initializer is a pack expansion whose
14905 parameter packs are of length zero. */
14906 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
14910 init_vec
= make_tree_vector ();
14911 if (init
== void_node
)
14912 gcc_assert (init_vec
!= NULL
);
14915 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
14916 vec_safe_push (init_vec
, TREE_VALUE (init
));
14920 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14921 tree op2
= RECUR (TREE_OPERAND (t
, 2));
14922 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
14923 NEW_EXPR_USE_GLOBAL (t
),
14926 if (placement_vec
!= NULL
)
14927 release_tree_vector (placement_vec
);
14928 if (init_vec
!= NULL
)
14929 release_tree_vector (init_vec
);
14936 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14937 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14938 RETURN (delete_sanity (op0
, op1
,
14939 DELETE_EXPR_USE_VEC (t
),
14940 DELETE_EXPR_USE_GLOBAL (t
),
14944 case COMPOUND_EXPR
:
14946 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
14947 complain
& ~tf_decltype
, in_decl
,
14948 /*function_p=*/false,
14949 integral_constant_expression_p
);
14950 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
14952 RECUR (TREE_OPERAND (t
, 1)),
14953 complain
|decltype_flag
));
14959 vec
<tree
, va_gc
> *call_args
;
14960 unsigned int nargs
, i
;
14965 function
= CALL_EXPR_FN (t
);
14966 /* When we parsed the expression, we determined whether or
14967 not Koenig lookup should be performed. */
14968 koenig_p
= KOENIG_LOOKUP_P (t
);
14969 if (TREE_CODE (function
) == SCOPE_REF
)
14971 qualified_p
= true;
14972 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
14974 /*address_p=*/false);
14976 else if (koenig_p
&& identifier_p (function
))
14978 /* Do nothing; calling tsubst_copy_and_build on an identifier
14979 would incorrectly perform unqualified lookup again.
14981 Note that we can also have an IDENTIFIER_NODE if the earlier
14982 unqualified lookup found a member function; in that case
14983 koenig_p will be false and we do want to do the lookup
14984 again to find the instantiated member function.
14986 FIXME but doing that causes c++/15272, so we need to stop
14987 using IDENTIFIER_NODE in that situation. */
14988 qualified_p
= false;
14992 if (TREE_CODE (function
) == COMPONENT_REF
)
14994 tree op
= TREE_OPERAND (function
, 1);
14996 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
14997 || (BASELINK_P (op
)
14998 && BASELINK_QUALIFIED_P (op
)));
15001 qualified_p
= false;
15003 if (TREE_CODE (function
) == ADDR_EXPR
15004 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
15005 /* Avoid error about taking the address of a constructor. */
15006 function
= TREE_OPERAND (function
, 0);
15008 function
= tsubst_copy_and_build (function
, args
, complain
,
15011 integral_constant_expression_p
);
15013 if (BASELINK_P (function
))
15014 qualified_p
= true;
15017 nargs
= call_expr_nargs (t
);
15018 call_args
= make_tree_vector ();
15019 for (i
= 0; i
< nargs
; ++i
)
15021 tree arg
= CALL_EXPR_ARG (t
, i
);
15023 if (!PACK_EXPANSION_P (arg
))
15024 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
15027 /* Expand the pack expansion and push each entry onto
15029 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
15030 if (TREE_CODE (arg
) == TREE_VEC
)
15032 unsigned int len
, j
;
15034 len
= TREE_VEC_LENGTH (arg
);
15035 for (j
= 0; j
< len
; ++j
)
15037 tree value
= TREE_VEC_ELT (arg
, j
);
15038 if (value
!= NULL_TREE
)
15039 value
= convert_from_reference (value
);
15040 vec_safe_push (call_args
, value
);
15045 /* A partial substitution. Add one entry. */
15046 vec_safe_push (call_args
, arg
);
15051 /* We do not perform argument-dependent lookup if normal
15052 lookup finds a non-function, in accordance with the
15053 expected resolution of DR 218. */
15055 && ((is_overloaded_fn (function
)
15056 /* If lookup found a member function, the Koenig lookup is
15057 not appropriate, even if an unqualified-name was used
15058 to denote the function. */
15059 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
15060 || identifier_p (function
))
15061 /* Only do this when substitution turns a dependent call
15062 into a non-dependent call. */
15063 && type_dependent_expression_p_push (t
)
15064 && !any_type_dependent_arguments_p (call_args
))
15065 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
15067 if (identifier_p (function
)
15068 && !any_type_dependent_arguments_p (call_args
))
15070 if (koenig_p
&& (complain
& tf_warning_or_error
))
15072 /* For backwards compatibility and good diagnostics, try
15073 the unqualified lookup again if we aren't in SFINAE
15075 tree unq
= (tsubst_copy_and_build
15076 (function
, args
, complain
, in_decl
, true,
15077 integral_constant_expression_p
));
15078 if (unq
== error_mark_node
)
15079 RETURN (error_mark_node
);
15081 if (unq
!= function
)
15084 if (INDIRECT_REF_P (fn
))
15085 fn
= TREE_OPERAND (fn
, 0);
15086 if (TREE_CODE (fn
) == COMPONENT_REF
)
15087 fn
= TREE_OPERAND (fn
, 1);
15088 if (is_overloaded_fn (fn
))
15089 fn
= get_first_fn (fn
);
15090 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
15091 "%qD was not declared in this scope, "
15092 "and no declarations were found by "
15093 "argument-dependent lookup at the point "
15094 "of instantiation", function
))
15097 /* Can't say anything more. */;
15098 else if (DECL_CLASS_SCOPE_P (fn
))
15100 location_t loc
= EXPR_LOC_OR_LOC (t
,
15103 "declarations in dependent base %qT are "
15104 "not found by unqualified lookup",
15105 DECL_CLASS_CONTEXT (fn
));
15106 if (current_class_ptr
)
15108 "use %<this->%D%> instead", function
);
15111 "use %<%T::%D%> instead",
15112 current_class_name
, function
);
15115 inform (0, "%q+D declared here, later in the "
15116 "translation unit", fn
);
15121 if (identifier_p (function
))
15123 if (complain
& tf_error
)
15124 unqualified_name_lookup_error (function
);
15125 release_tree_vector (call_args
);
15126 RETURN (error_mark_node
);
15130 /* Remember that there was a reference to this entity. */
15131 if (DECL_P (function
)
15132 && !mark_used (function
, complain
) && !(complain
& tf_error
))
15133 RETURN (error_mark_node
);
15135 /* Put back tf_decltype for the actual call. */
15136 complain
|= decltype_flag
;
15138 if (TREE_CODE (function
) == OFFSET_REF
)
15139 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
15141 else if (TREE_CODE (function
) == COMPONENT_REF
)
15143 tree instance
= TREE_OPERAND (function
, 0);
15144 tree fn
= TREE_OPERAND (function
, 1);
15146 if (processing_template_decl
15147 && (type_dependent_expression_p (instance
)
15148 || (!BASELINK_P (fn
)
15149 && TREE_CODE (fn
) != FIELD_DECL
)
15150 || type_dependent_expression_p (fn
)
15151 || any_type_dependent_arguments_p (call_args
)))
15152 ret
= build_nt_call_vec (function
, call_args
);
15153 else if (!BASELINK_P (fn
))
15154 ret
= finish_call_expr (function
, &call_args
,
15155 /*disallow_virtual=*/false,
15156 /*koenig_p=*/false,
15159 ret
= (build_new_method_call
15161 &call_args
, NULL_TREE
,
15162 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
15167 ret
= finish_call_expr (function
, &call_args
,
15168 /*disallow_virtual=*/qualified_p
,
15172 release_tree_vector (call_args
);
15179 tree cond
= RECUR (TREE_OPERAND (t
, 0));
15180 tree folded_cond
= fold_non_dependent_expr (cond
);
15183 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
15185 if (integer_zerop (folded_cond
))
15187 ++c_inhibit_evaluation_warnings
;
15188 exp1
= RECUR (TREE_OPERAND (t
, 1));
15189 --c_inhibit_evaluation_warnings
;
15190 exp2
= RECUR (TREE_OPERAND (t
, 2));
15194 exp1
= RECUR (TREE_OPERAND (t
, 1));
15195 ++c_inhibit_evaluation_warnings
;
15196 exp2
= RECUR (TREE_OPERAND (t
, 2));
15197 --c_inhibit_evaluation_warnings
;
15199 cond
= folded_cond
;
15203 exp1
= RECUR (TREE_OPERAND (t
, 1));
15204 exp2
= RECUR (TREE_OPERAND (t
, 2));
15207 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
15208 cond
, exp1
, exp2
, complain
));
15211 case PSEUDO_DTOR_EXPR
:
15213 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15214 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15215 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15216 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
15222 tree purpose
, value
, chain
;
15224 if (t
== void_list_node
)
15227 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15228 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15230 /* We have pack expansions, so expand those and
15231 create a new list out of it. */
15232 tree purposevec
= NULL_TREE
;
15233 tree valuevec
= NULL_TREE
;
15237 /* Expand the argument expressions. */
15238 if (TREE_PURPOSE (t
))
15239 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15240 complain
, in_decl
);
15241 if (TREE_VALUE (t
))
15242 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15243 complain
, in_decl
);
15245 /* Build the rest of the list. */
15246 chain
= TREE_CHAIN (t
);
15247 if (chain
&& chain
!= void_type_node
)
15248 chain
= RECUR (chain
);
15250 /* Determine the number of arguments. */
15251 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15253 len
= TREE_VEC_LENGTH (purposevec
);
15254 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15256 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15257 len
= TREE_VEC_LENGTH (valuevec
);
15260 /* Since we only performed a partial substitution into
15261 the argument pack, we only RETURN (a single list
15263 if (purposevec
== TREE_PURPOSE (t
)
15264 && valuevec
== TREE_VALUE (t
)
15265 && chain
== TREE_CHAIN (t
))
15268 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15271 /* Convert the argument vectors into a TREE_LIST */
15275 /* Grab the Ith values. */
15277 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15280 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15283 /* Build the list (backwards). */
15284 chain
= tree_cons (purpose
, value
, chain
);
15290 purpose
= TREE_PURPOSE (t
);
15292 purpose
= RECUR (purpose
);
15293 value
= TREE_VALUE (t
);
15295 value
= RECUR (value
);
15296 chain
= TREE_CHAIN (t
);
15297 if (chain
&& chain
!= void_type_node
)
15298 chain
= RECUR (chain
);
15299 if (purpose
== TREE_PURPOSE (t
)
15300 && value
== TREE_VALUE (t
)
15301 && chain
== TREE_CHAIN (t
))
15303 RETURN (tree_cons (purpose
, value
, chain
));
15306 case COMPONENT_REF
:
15313 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15314 args
, complain
, in_decl
);
15315 /* Remember that there was a reference to this entity. */
15316 if (DECL_P (object
)
15317 && !mark_used (object
, complain
) && !(complain
& tf_error
))
15318 RETURN (error_mark_node
);
15319 object_type
= TREE_TYPE (object
);
15321 member
= TREE_OPERAND (t
, 1);
15322 if (BASELINK_P (member
))
15323 member
= tsubst_baselink (member
,
15324 non_reference (TREE_TYPE (object
)),
15325 args
, complain
, in_decl
);
15327 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15328 if (member
== error_mark_node
)
15329 RETURN (error_mark_node
);
15331 if (type_dependent_expression_p (object
))
15332 /* We can't do much here. */;
15333 else if (!CLASS_TYPE_P (object_type
))
15335 if (scalarish_type_p (object_type
))
15337 tree s
= NULL_TREE
;
15338 tree dtor
= member
;
15340 if (TREE_CODE (dtor
) == SCOPE_REF
)
15342 s
= TREE_OPERAND (dtor
, 0);
15343 dtor
= TREE_OPERAND (dtor
, 1);
15345 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15347 dtor
= TREE_OPERAND (dtor
, 0);
15349 RETURN (finish_pseudo_destructor_expr
15350 (object
, s
, dtor
, input_location
));
15354 else if (TREE_CODE (member
) == SCOPE_REF
15355 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15357 /* Lookup the template functions now that we know what the
15359 tree scope
= TREE_OPERAND (member
, 0);
15360 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15361 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15362 member
= lookup_qualified_name (scope
, tmpl
,
15363 /*is_type_p=*/false,
15364 /*complain=*/false);
15365 if (BASELINK_P (member
))
15367 BASELINK_FUNCTIONS (member
)
15368 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15370 member
= (adjust_result_of_qualified_name_lookup
15371 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15376 qualified_name_lookup_error (scope
, tmpl
, member
,
15378 RETURN (error_mark_node
);
15381 else if (TREE_CODE (member
) == SCOPE_REF
15382 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15383 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15385 if (complain
& tf_error
)
15387 if (TYPE_P (TREE_OPERAND (member
, 0)))
15388 error ("%qT is not a class or namespace",
15389 TREE_OPERAND (member
, 0));
15391 error ("%qD is not a class or namespace",
15392 TREE_OPERAND (member
, 0));
15394 RETURN (error_mark_node
);
15396 else if (TREE_CODE (member
) == FIELD_DECL
)
15398 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15399 if (TREE_CODE (r
) == COMPONENT_REF
)
15400 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15404 r
= finish_class_member_access_expr (object
, member
,
15405 /*template_p=*/false,
15407 if (TREE_CODE (r
) == COMPONENT_REF
)
15408 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15413 RETURN (build_throw
15414 (RECUR (TREE_OPERAND (t
, 0))));
15418 vec
<constructor_elt
, va_gc
> *n
;
15419 constructor_elt
*ce
;
15420 unsigned HOST_WIDE_INT idx
;
15421 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15422 bool process_index_p
;
15424 bool need_copy_p
= false;
15427 if (type
== error_mark_node
)
15428 RETURN (error_mark_node
);
15430 /* digest_init will do the wrong thing if we let it. */
15431 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15434 /* We do not want to process the index of aggregate
15435 initializers as they are identifier nodes which will be
15436 looked up by digest_init. */
15437 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15439 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15440 newlen
= vec_safe_length (n
);
15441 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15443 if (ce
->index
&& process_index_p
15444 /* An identifier index is looked up in the type
15445 being initialized, not the current scope. */
15446 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15447 ce
->index
= RECUR (ce
->index
);
15449 if (PACK_EXPANSION_P (ce
->value
))
15451 /* Substitute into the pack expansion. */
15452 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15455 if (ce
->value
== error_mark_node
15456 || PACK_EXPANSION_P (ce
->value
))
15458 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15459 /* Just move the argument into place. */
15460 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15463 /* Update the length of the final CONSTRUCTOR
15464 arguments vector, and note that we will need to
15466 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15467 need_copy_p
= true;
15471 ce
->value
= RECUR (ce
->value
);
15476 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15478 vec_alloc (n
, newlen
);
15479 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15481 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15483 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15484 for (i
= 0; i
< len
; ++i
)
15485 CONSTRUCTOR_APPEND_ELT (n
, 0,
15486 TREE_VEC_ELT (ce
->value
, i
));
15489 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15493 r
= build_constructor (init_list_type_node
, n
);
15494 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15496 if (TREE_HAS_CONSTRUCTOR (t
))
15497 RETURN (finish_compound_literal (type
, r
, complain
));
15499 TREE_TYPE (r
) = type
;
15505 tree operand_0
= TREE_OPERAND (t
, 0);
15506 if (TYPE_P (operand_0
))
15508 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15509 RETURN (get_typeid (operand_0
, complain
));
15513 operand_0
= RECUR (operand_0
);
15514 RETURN (build_typeid (operand_0
, complain
));
15521 else if (DECL_PACK_P (t
))
15523 /* We don't build decls for an instantiation of a
15524 variadic capture proxy, we instantiate the elements
15526 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15527 return RECUR (DECL_VALUE_EXPR (t
));
15533 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15534 /* ??? We're doing a subset of finish_id_expression here. */
15536 && !processing_template_decl
15537 && !cp_unevaluated_operand
15538 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
15539 && DECL_THREAD_LOCAL_P (r
))
15541 if (tree wrap
= get_tls_wrapper_fn (r
))
15542 /* Replace an evaluated use of the thread_local variable with
15543 a call to its wrapper. */
15544 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
15546 else if (outer_automatic_var_p (r
))
15547 r
= process_outer_var_ref (r
, complain
);
15549 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15550 /* If the original type was a reference, we'll be wrapped in
15551 the appropriate INDIRECT_REF. */
15552 r
= convert_from_reference (r
);
15558 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15559 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15560 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15563 case OFFSETOF_EXPR
:
15564 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0)),
15565 EXPR_LOCATION (t
)));
15569 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15570 complain
, in_decl
);
15572 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15573 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
15574 type2
= RECUR (type2
);
15576 type2
= tsubst (type2
, args
, complain
, in_decl
);
15578 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15583 tree old_stmt_expr
= cur_stmt_expr
;
15584 tree stmt_expr
= begin_stmt_expr ();
15586 cur_stmt_expr
= stmt_expr
;
15587 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15588 integral_constant_expression_p
);
15589 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15590 cur_stmt_expr
= old_stmt_expr
;
15592 /* If the resulting list of expression statement is empty,
15593 fold it further into void_node. */
15594 if (empty_expr_stmt_p (stmt_expr
))
15595 stmt_expr
= void_node
;
15597 RETURN (stmt_expr
);
15602 tree r
= build_lambda_expr ();
15604 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15605 LAMBDA_EXPR_CLOSURE (r
) = type
;
15606 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15608 LAMBDA_EXPR_LOCATION (r
)
15609 = LAMBDA_EXPR_LOCATION (t
);
15610 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15611 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15612 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15613 LAMBDA_EXPR_DISCRIMINATOR (r
)
15614 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15615 /* For a function scope, we want to use tsubst so that we don't
15616 complain about referring to an auto function before its return
15617 type has been deduced. Otherwise, we want to use tsubst_copy so
15618 that we look up the existing field/parameter/variable rather
15619 than build a new one. */
15620 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15621 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15622 scope
= tsubst (scope
, args
, complain
, in_decl
);
15623 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15625 /* Look up the parameter we want directly, as tsubst_copy
15626 doesn't do what we need. */
15627 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15628 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15629 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15630 parm
= DECL_CHAIN (parm
);
15632 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15633 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15634 DECL_CONTEXT (scope
) = fn
;
15637 scope
= RECUR (scope
);
15638 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15639 LAMBDA_EXPR_RETURN_TYPE (r
)
15640 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15642 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15643 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15645 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15646 determine_visibility (TYPE_NAME (type
));
15647 /* Now that we know visibility, instantiate the type so we have a
15648 declaration of the op() for later calls to lambda_function. */
15649 complete_type (type
);
15651 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15653 RETURN (build_lambda_object (r
));
15657 /* We can get here for a constant initializer of non-dependent type.
15658 FIXME stop folding in cp_parser_initializer_clause. */
15660 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15665 case TRANSACTION_EXPR
:
15666 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15667 integral_constant_expression_p
));
15670 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15672 case VEC_PERM_EXPR
:
15674 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15675 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15676 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15677 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15682 /* Handle Objective-C++ constructs, if appropriate. */
15685 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15686 in_decl
, /*function_p=*/false);
15690 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15696 input_location
= loc
;
15700 /* Verify that the instantiated ARGS are valid. For type arguments,
15701 make sure that the type's linkage is ok. For non-type arguments,
15702 make sure they are constants if they are integral or enumerations.
15703 Emit an error under control of COMPLAIN, and return TRUE on error. */
15706 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15708 if (dependent_template_arg_p (t
))
15710 if (ARGUMENT_PACK_P (t
))
15712 tree vec
= ARGUMENT_PACK_ARGS (t
);
15713 int len
= TREE_VEC_LENGTH (vec
);
15714 bool result
= false;
15717 for (i
= 0; i
< len
; ++i
)
15718 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15722 else if (TYPE_P (t
))
15724 /* [basic.link]: A name with no linkage (notably, the name
15725 of a class or enumeration declared in a local scope)
15726 shall not be used to declare an entity with linkage.
15727 This implies that names with no linkage cannot be used as
15730 DR 757 relaxes this restriction for C++0x. */
15731 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15732 : no_linkage_check (t
, /*relaxed_p=*/false));
15736 /* DR 488 makes use of a type with no linkage cause
15737 type deduction to fail. */
15738 if (complain
& tf_error
)
15740 if (TYPE_ANONYMOUS_P (nt
))
15741 error ("%qT is/uses anonymous type", t
);
15743 error ("template argument for %qD uses local type %qT",
15748 /* In order to avoid all sorts of complications, we do not
15749 allow variably-modified types as template arguments. */
15750 else if (variably_modified_type_p (t
, NULL_TREE
))
15752 if (complain
& tf_error
)
15753 error ("%qT is a variably modified type", t
);
15757 /* Class template and alias template arguments should be OK. */
15758 else if (DECL_TYPE_TEMPLATE_P (t
))
15760 /* A non-type argument of integral or enumerated type must be a
15762 else if (TREE_TYPE (t
)
15763 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15764 && !REFERENCE_REF_P (t
)
15765 && !TREE_CONSTANT (t
))
15767 if (complain
& tf_error
)
15768 error ("integral expression %qE is not constant", t
);
15775 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15777 int ix
, len
= DECL_NTPARMS (tmpl
);
15778 bool result
= false;
15780 for (ix
= 0; ix
!= len
; ix
++)
15782 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15785 if (result
&& (complain
& tf_error
))
15786 error (" trying to instantiate %qD", tmpl
);
15790 /* We're out of SFINAE context now, so generate diagnostics for the access
15791 errors we saw earlier when instantiating D from TMPL and ARGS. */
15794 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15796 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15797 tree type
= TREE_TYPE (pattern
);
15798 location_t loc
= input_location
;
15800 push_access_scope (d
);
15801 push_deferring_access_checks (dk_no_deferred
);
15802 input_location
= DECL_SOURCE_LOCATION (pattern
);
15803 tsubst (type
, args
, tf_warning_or_error
, d
);
15804 input_location
= loc
;
15805 pop_deferring_access_checks ();
15806 pop_access_scope (d
);
15809 /* Instantiate the indicated variable, function, or alias template TMPL with
15810 the template arguments in TARG_PTR. */
15813 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15815 tree targ_ptr
= orig_args
;
15819 bool access_ok
= true;
15821 if (tmpl
== error_mark_node
)
15822 return error_mark_node
;
15824 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15826 /* If this function is a clone, handle it specially. */
15827 if (DECL_CLONED_FUNCTION_P (tmpl
))
15832 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15833 DECL_CLONED_FUNCTION. */
15834 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15835 targ_ptr
, complain
);
15836 if (spec
== error_mark_node
)
15837 return error_mark_node
;
15839 /* Look for the clone. */
15840 FOR_EACH_CLONE (clone
, spec
)
15841 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15843 /* We should always have found the clone by now. */
15844 gcc_unreachable ();
15848 if (targ_ptr
== error_mark_node
)
15849 return error_mark_node
;
15851 /* Check to see if we already have this specialization. */
15852 gen_tmpl
= most_general_template (tmpl
);
15853 if (tmpl
!= gen_tmpl
)
15854 /* The TMPL is a partial instantiation. To get a full set of
15855 arguments we must add the arguments used to perform the
15856 partial instantiation. */
15857 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15860 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15861 but it doesn't seem to be on the hot path. */
15862 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15864 gcc_assert (tmpl
== gen_tmpl
15865 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15867 || fndecl
== NULL_TREE
);
15869 if (spec
!= NULL_TREE
)
15871 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15873 if (complain
& tf_error
)
15874 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15875 return error_mark_node
;
15880 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15882 return error_mark_node
;
15884 /* We are building a FUNCTION_DECL, during which the access of its
15885 parameters and return types have to be checked. However this
15886 FUNCTION_DECL which is the desired context for access checking
15887 is not built yet. We solve this chicken-and-egg problem by
15888 deferring all checks until we have the FUNCTION_DECL. */
15889 push_deferring_access_checks (dk_deferred
);
15891 /* Instantiation of the function happens in the context of the function
15892 template, not the context of the overload resolution we're doing. */
15893 push_to_top_level ();
15894 /* If there are dependent arguments, e.g. because we're doing partial
15895 ordering, make sure processing_template_decl stays set. */
15896 if (uses_template_parms (targ_ptr
))
15897 ++processing_template_decl
;
15898 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15900 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15901 complain
, gen_tmpl
, true);
15902 push_nested_class (ctx
);
15905 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
15907 if (VAR_P (pattern
))
15909 /* We need to determine if we're using a partial or explicit
15910 specialization now, because the type of the variable could be
15912 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
15913 tree elt
= most_specialized_partial_spec (tid
, complain
);
15914 if (elt
== error_mark_node
)
15915 pattern
= error_mark_node
;
15918 tmpl
= TREE_VALUE (elt
);
15919 pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15920 targ_ptr
= TREE_PURPOSE (elt
);
15924 /* Substitute template parameters to obtain the specialization. */
15925 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
15926 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15927 pop_nested_class ();
15928 pop_from_top_level ();
15930 if (fndecl
== error_mark_node
)
15932 pop_deferring_access_checks ();
15933 return error_mark_node
;
15936 /* The DECL_TI_TEMPLATE should always be the immediate parent
15937 template, not the most general template. */
15938 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
15940 /* Now we know the specialization, compute access previously
15942 push_access_scope (fndecl
);
15943 if (!perform_deferred_access_checks (complain
))
15945 pop_access_scope (fndecl
);
15946 pop_deferring_access_checks ();
15948 /* If we've just instantiated the main entry point for a function,
15949 instantiate all the alternate entry points as well. We do this
15950 by cloning the instantiation of the main entry point, not by
15951 instantiating the template clones. */
15952 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
15953 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
15957 if (!(complain
& tf_error
))
15959 /* Remember to reinstantiate when we're out of SFINAE so the user
15960 can see the errors. */
15961 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
15963 return error_mark_node
;
15968 /* Wrapper for instantiate_template_1. */
15971 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15974 timevar_push (TV_TEMPLATE_INST
);
15975 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
15976 timevar_pop (TV_TEMPLATE_INST
);
15980 /* Instantiate the alias template TMPL with ARGS. Also push a template
15981 instantiation level, which instantiate_template doesn't do because
15982 functions and variables have sufficient context established by the
15986 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
15988 struct pending_template
*old_last_pend
= last_pending_template
;
15989 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15990 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
15991 return error_mark_node
;
15992 tree tinst
= build_tree_list (tmpl
, args
);
15993 if (!push_tinst_level (tinst
))
15996 return error_mark_node
;
16000 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
16001 args
, tmpl
, complain
,
16002 /*require_all_args=*/true,
16003 /*use_default_args=*/true);
16005 tree r
= instantiate_template (tmpl
, args
, complain
);
16006 pop_tinst_level ();
16007 /* We can't free this if a pending_template entry or last_error_tinst_level
16008 is pointing at it. */
16009 if (last_pending_template
== old_last_pend
16010 && last_error_tinst_level
== old_error_tinst
)
16016 /* PARM is a template parameter pack for FN. Returns true iff
16017 PARM is used in a deducible way in the argument list of FN. */
16020 pack_deducible_p (tree parm
, tree fn
)
16022 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
16023 for (; t
; t
= TREE_CHAIN (t
))
16025 tree type
= TREE_VALUE (t
);
16027 if (!PACK_EXPANSION_P (type
))
16029 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
16030 packs
; packs
= TREE_CHAIN (packs
))
16031 if (template_args_equal (TREE_VALUE (packs
), parm
))
16033 /* The template parameter pack is used in a function parameter
16034 pack. If this is the end of the parameter list, the
16035 template parameter pack is deducible. */
16036 if (TREE_CHAIN (t
) == void_list_node
)
16039 /* Otherwise, not. Well, it could be deduced from
16040 a non-pack parameter, but doing so would end up with
16041 a deduction mismatch, so don't bother. */
16045 /* The template parameter pack isn't used in any function parameter
16046 packs, but it might be used deeper, e.g. tuple<Args...>. */
16050 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
16051 NARGS elements of the arguments that are being used when calling
16052 it. TARGS is a vector into which the deduced template arguments
16055 Returns either a FUNCTION_DECL for the matching specialization of FN or
16056 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
16057 true, diagnostics will be printed to explain why it failed.
16059 If FN is a conversion operator, or we are trying to produce a specific
16060 specialization, RETURN_TYPE is the return type desired.
16062 The EXPLICIT_TARGS are explicit template arguments provided via a
16065 The parameter STRICT is one of:
16068 We are deducing arguments for a function call, as in
16069 [temp.deduct.call].
16072 We are deducing arguments for a conversion function, as in
16073 [temp.deduct.conv].
16076 We are deducing arguments when doing an explicit instantiation
16077 as in [temp.explicit], when determining an explicit specialization
16078 as in [temp.expl.spec], or when taking the address of a function
16079 template, as in [temp.deduct.funcaddr]. */
16082 fn_type_unification (tree fn
,
16083 tree explicit_targs
,
16086 unsigned int nargs
,
16088 unification_kind_t strict
,
16095 tree decl
= NULL_TREE
;
16096 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
16098 static int deduction_depth
;
16099 struct pending_template
*old_last_pend
= last_pending_template
;
16100 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16101 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
16103 tree r
= error_mark_node
;
16106 complain
|= tf_decltype
;
16108 /* In C++0x, it's possible to have a function template whose type depends
16109 on itself recursively. This is most obvious with decltype, but can also
16110 occur with enumeration scope (c++/48969). So we need to catch infinite
16111 recursion and reject the substitution at deduction time; this function
16112 will return error_mark_node for any repeated substitution.
16114 This also catches excessive recursion such as when f<N> depends on
16115 f<N-1> across all integers, and returns error_mark_node for all the
16116 substitutions back up to the initial one.
16118 This is, of course, not reentrant. */
16119 if (excessive_deduction_depth
)
16120 return error_mark_node
;
16121 tinst
= build_tree_list (fn
, NULL_TREE
);
16124 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
16126 fntype
= TREE_TYPE (fn
);
16127 if (explicit_targs
)
16131 The specified template arguments must match the template
16132 parameters in kind (i.e., type, nontype, template), and there
16133 must not be more arguments than there are parameters;
16134 otherwise type deduction fails.
16136 Nontype arguments must match the types of the corresponding
16137 nontype template parameters, or must be convertible to the
16138 types of the corresponding nontype parameters as specified in
16139 _temp.arg.nontype_, otherwise type deduction fails.
16141 All references in the function type of the function template
16142 to the corresponding template parameters are replaced by the
16143 specified template argument values. If a substitution in a
16144 template parameter or in the function type of the function
16145 template results in an invalid type, type deduction fails. */
16146 int i
, len
= TREE_VEC_LENGTH (tparms
);
16147 location_t loc
= input_location
;
16148 bool incomplete
= false;
16150 /* Adjust any explicit template arguments before entering the
16151 substitution context. */
16153 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
16155 /*require_all_args=*/false,
16156 /*use_default_args=*/false));
16157 if (explicit_targs
== error_mark_node
)
16160 /* Substitute the explicit args into the function type. This is
16161 necessary so that, for instance, explicitly declared function
16162 arguments can match null pointed constants. If we were given
16163 an incomplete set of explicit args, we must not do semantic
16164 processing during substitution as we could create partial
16166 for (i
= 0; i
< len
; i
++)
16168 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16169 bool parameter_pack
= false;
16170 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
16172 /* Dig out the actual parm. */
16173 if (TREE_CODE (parm
) == TYPE_DECL
16174 || TREE_CODE (parm
) == TEMPLATE_DECL
)
16176 parm
= TREE_TYPE (parm
);
16177 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
16179 else if (TREE_CODE (parm
) == PARM_DECL
)
16181 parm
= DECL_INITIAL (parm
);
16182 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
16185 if (!parameter_pack
&& targ
== NULL_TREE
)
16186 /* No explicit argument for this template parameter. */
16189 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
16191 /* Mark the argument pack as "incomplete". We could
16192 still deduce more arguments during unification.
16193 We remove this mark in type_unification_real. */
16196 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
16197 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
16198 = ARGUMENT_PACK_ARGS (targ
);
16201 /* We have some incomplete argument packs. */
16206 TREE_VALUE (tinst
) = explicit_targs
;
16207 if (!push_tinst_level (tinst
))
16209 excessive_deduction_depth
= true;
16212 processing_template_decl
+= incomplete
;
16213 input_location
= DECL_SOURCE_LOCATION (fn
);
16214 /* Ignore any access checks; we'll see them again in
16215 instantiate_template and they might have the wrong
16216 access path at this point. */
16217 push_deferring_access_checks (dk_deferred
);
16218 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
16219 complain
| tf_partial
, NULL_TREE
);
16220 pop_deferring_access_checks ();
16221 input_location
= loc
;
16222 processing_template_decl
-= incomplete
;
16223 pop_tinst_level ();
16225 if (fntype
== error_mark_node
)
16228 /* Place the explicitly specified arguments in TARGS. */
16229 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
16230 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
16233 /* Never do unification on the 'this' parameter. */
16234 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
16240 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
16241 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
16242 new_args
[0] = return_type
;
16243 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
16248 /* We allow incomplete unification without an error message here
16249 because the standard doesn't seem to explicitly prohibit it. Our
16250 callers must be ready to deal with unification failures in any
16253 TREE_VALUE (tinst
) = targs
;
16254 /* If we aren't explaining yet, push tinst context so we can see where
16255 any errors (e.g. from class instantiations triggered by instantiation
16256 of default template arguments) come from. If we are explaining, this
16257 context is redundant. */
16258 if (!explain_p
&& !push_tinst_level (tinst
))
16260 excessive_deduction_depth
= true;
16264 /* type_unification_real will pass back any access checks from default
16265 template argument substitution. */
16266 vec
<deferred_access_check
, va_gc
> *checks
;
16269 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16270 targs
, parms
, args
, nargs
, /*subr=*/0,
16271 strict
, flags
, &checks
, explain_p
);
16273 pop_tinst_level ();
16277 /* Now that we have bindings for all of the template arguments,
16278 ensure that the arguments deduced for the template template
16279 parameters have compatible template parameter lists. We cannot
16280 check this property before we have deduced all template
16281 arguments, because the template parameter types of a template
16282 template parameter might depend on prior template parameters
16283 deduced after the template template parameter. The following
16284 ill-formed example illustrates this issue:
16286 template<typename T, template<T> class C> void f(C<5>, T);
16288 template<int N> struct X {};
16291 f(X<5>(), 5l); // error: template argument deduction fails
16294 The template parameter list of 'C' depends on the template type
16295 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16296 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16297 time that we deduce 'C'. */
16298 if (!template_template_parm_bindings_ok_p
16299 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16301 unify_inconsistent_template_template_parameters (explain_p
);
16305 /* All is well so far. Now, check:
16309 When all template arguments have been deduced, all uses of
16310 template parameters in nondeduced contexts are replaced with
16311 the corresponding deduced argument values. If the
16312 substitution results in an invalid type, as described above,
16313 type deduction fails. */
16314 TREE_VALUE (tinst
) = targs
;
16315 if (!push_tinst_level (tinst
))
16317 excessive_deduction_depth
= true;
16321 /* Also collect access checks from the instantiation. */
16322 reopen_deferring_access_checks (checks
);
16324 decl
= instantiate_template (fn
, targs
, complain
);
16326 checks
= get_deferred_access_checks ();
16327 pop_deferring_access_checks ();
16329 pop_tinst_level ();
16331 if (decl
== error_mark_node
)
16334 /* Now perform any access checks encountered during substitution. */
16335 push_access_scope (decl
);
16336 ok
= perform_access_checks (checks
, complain
);
16337 pop_access_scope (decl
);
16341 /* If we're looking for an exact match, check that what we got
16342 is indeed an exact match. It might not be if some template
16343 parameters are used in non-deduced contexts. But don't check
16344 for an exact match if we have dependent template arguments;
16345 in that case we're doing partial ordering, and we already know
16346 that we have two candidates that will provide the actual type. */
16347 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16349 tree substed
= TREE_TYPE (decl
);
16353 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16355 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16356 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16357 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16359 unify_type_mismatch (explain_p
, args
[i
],
16360 TREE_VALUE (sarg
));
16369 if (excessive_deduction_depth
)
16371 if (deduction_depth
== 0)
16372 /* Reset once we're all the way out. */
16373 excessive_deduction_depth
= false;
16376 /* We can't free this if a pending_template entry or last_error_tinst_level
16377 is pointing at it. */
16378 if (last_pending_template
== old_last_pend
16379 && last_error_tinst_level
== old_error_tinst
)
16385 /* Adjust types before performing type deduction, as described in
16386 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16387 sections are symmetric. PARM is the type of a function parameter
16388 or the return type of the conversion function. ARG is the type of
16389 the argument passed to the call, or the type of the value
16390 initialized with the result of the conversion function.
16391 ARG_EXPR is the original argument expression, which may be null. */
16394 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16408 /* Swap PARM and ARG throughout the remainder of this
16409 function; the handling is precisely symmetric since PARM
16410 will initialize ARG rather than vice versa. */
16418 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16419 too, but here handle it by stripping the reference from PARM
16420 rather than by adding it to ARG. */
16421 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16422 && TYPE_REF_IS_RVALUE (*parm
)
16423 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16424 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16425 && TREE_CODE (*arg
) == REFERENCE_TYPE
16426 && !TYPE_REF_IS_RVALUE (*arg
))
16427 *parm
= TREE_TYPE (*parm
);
16428 /* Nothing else to do in this case. */
16432 gcc_unreachable ();
16435 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16437 /* [temp.deduct.call]
16439 If P is not a reference type:
16441 --If A is an array type, the pointer type produced by the
16442 array-to-pointer standard conversion (_conv.array_) is
16443 used in place of A for type deduction; otherwise,
16445 --If A is a function type, the pointer type produced by
16446 the function-to-pointer standard conversion
16447 (_conv.func_) is used in place of A for type deduction;
16450 --If A is a cv-qualified type, the top level
16451 cv-qualifiers of A's type are ignored for type
16453 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16454 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16455 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16456 *arg
= build_pointer_type (*arg
);
16458 *arg
= TYPE_MAIN_VARIANT (*arg
);
16461 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16462 of the form T&&, where T is a template parameter, and the argument
16463 is an lvalue, T is deduced as A& */
16464 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16465 && TYPE_REF_IS_RVALUE (*parm
)
16466 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16467 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16468 && (arg_expr
? real_lvalue_p (arg_expr
)
16469 /* try_one_overload doesn't provide an arg_expr, but
16470 functions are always lvalues. */
16471 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16472 *arg
= build_reference_type (*arg
);
16474 /* [temp.deduct.call]
16476 If P is a cv-qualified type, the top level cv-qualifiers
16477 of P's type are ignored for type deduction. If P is a
16478 reference type, the type referred to by P is used for
16480 *parm
= TYPE_MAIN_VARIANT (*parm
);
16481 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16483 *parm
= TREE_TYPE (*parm
);
16484 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16487 /* DR 322. For conversion deduction, remove a reference type on parm
16488 too (which has been swapped into ARG). */
16489 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16490 *arg
= TREE_TYPE (*arg
);
16495 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16496 template which does contain any deducible template parameters; check if
16497 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16498 unify_one_argument. */
16501 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16502 int flags
, bool explain_p
)
16507 type
= TREE_TYPE (arg
);
16511 if (same_type_p (parm
, type
))
16512 return unify_success (explain_p
);
16514 if (strict
== DEDUCE_CONV
)
16516 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16517 explain_p
? tf_warning_or_error
: tf_none
))
16518 return unify_success (explain_p
);
16520 else if (strict
!= DEDUCE_EXACT
)
16522 if (can_convert_arg (parm
, type
,
16523 TYPE_P (arg
) ? NULL_TREE
: arg
,
16524 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16525 return unify_success (explain_p
);
16528 if (strict
== DEDUCE_EXACT
)
16529 return unify_type_mismatch (explain_p
, parm
, arg
);
16531 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16534 static bool uses_deducible_template_parms (tree type
);
16536 /* Returns true iff the expression EXPR is one from which a template
16537 argument can be deduced. In other words, if it's an undecorated
16538 use of a template non-type parameter. */
16541 deducible_expression (tree expr
)
16543 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16546 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16547 deducible way; that is, if it has a max value of <PARM> - 1. */
16550 deducible_array_bound (tree domain
)
16552 if (domain
== NULL_TREE
)
16555 tree max
= TYPE_MAX_VALUE (domain
);
16556 if (TREE_CODE (max
) != MINUS_EXPR
)
16559 return deducible_expression (TREE_OPERAND (max
, 0));
16562 /* Returns true iff the template arguments ARGS use a template parameter
16563 in a deducible way. */
16566 deducible_template_args (tree args
)
16568 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16571 tree elt
= TREE_VEC_ELT (args
, i
);
16572 if (ARGUMENT_PACK_P (elt
))
16573 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16576 if (PACK_EXPANSION_P (elt
))
16577 elt
= PACK_EXPANSION_PATTERN (elt
);
16578 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16580 else if (TYPE_P (elt
))
16581 deducible
= uses_deducible_template_parms (elt
);
16583 deducible
= deducible_expression (elt
);
16591 /* Returns true iff TYPE contains any deducible references to template
16592 parameters, as per 14.8.2.5. */
16595 uses_deducible_template_parms (tree type
)
16597 if (PACK_EXPANSION_P (type
))
16598 type
= PACK_EXPANSION_PATTERN (type
);
16605 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16606 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16612 if (POINTER_TYPE_P (type
))
16613 return uses_deducible_template_parms (TREE_TYPE (type
));
16615 /* T[integer-constant ]
16617 if (TREE_CODE (type
) == ARRAY_TYPE
)
16618 return (uses_deducible_template_parms (TREE_TYPE (type
))
16619 || deducible_array_bound (TYPE_DOMAIN (type
)));
16631 if (TYPE_PTRMEM_P (type
))
16632 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16633 || (uses_deducible_template_parms
16634 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16636 /* template-name <T> (where template-name refers to a class template)
16637 template-name <i> (where template-name refers to a class template) */
16638 if (CLASS_TYPE_P (type
)
16639 && CLASSTYPE_TEMPLATE_INFO (type
)
16640 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16641 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16642 (CLASSTYPE_TI_ARGS (type
)));
16647 if (TREE_CODE (type
) == FUNCTION_TYPE
16648 || TREE_CODE (type
) == METHOD_TYPE
)
16650 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16652 tree parm
= TYPE_ARG_TYPES (type
);
16653 if (TREE_CODE (type
) == METHOD_TYPE
)
16654 parm
= TREE_CHAIN (parm
);
16655 for (; parm
; parm
= TREE_CHAIN (parm
))
16656 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16663 /* Subroutine of type_unification_real and unify_pack_expansion to
16664 handle unification of a single P/A pair. Parameters are as
16665 for those functions. */
16668 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16669 int subr
, unification_kind_t strict
, int flags
,
16672 tree arg_expr
= NULL_TREE
;
16675 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16676 return unify_invalid (explain_p
);
16677 if (arg
== unknown_type_node
)
16678 /* We can't deduce anything from this, but we might get all the
16679 template args from other function args. */
16680 return unify_success (explain_p
);
16682 /* Implicit conversions (Clause 4) will be performed on a function
16683 argument to convert it to the type of the corresponding function
16684 parameter if the parameter type contains no template-parameters that
16685 participate in template argument deduction. */
16686 if (TYPE_P (parm
) && !uses_template_parms (parm
))
16687 /* For function parameters that contain no template-parameters at all,
16688 we have historically checked for convertibility in order to shortcut
16689 consideration of this candidate. */
16690 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
16692 else if (strict
== DEDUCE_CALL
16693 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16694 /* For function parameters with only non-deducible template parameters,
16696 return unify_success (explain_p
);
16701 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16702 | UNIFY_ALLOW_MORE_CV_QUAL
16703 | UNIFY_ALLOW_DERIVED
);
16707 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16711 arg_strict
= UNIFY_ALLOW_NONE
;
16715 gcc_unreachable ();
16718 /* We only do these transformations if this is the top-level
16719 parameter_type_list in a call or declaration matching; in other
16720 situations (nested function declarators, template argument lists) we
16721 won't be comparing a type to an expression, and we don't do any type
16727 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16728 if (type_unknown_p (arg
))
16730 /* [temp.deduct.type] A template-argument can be
16731 deduced from a pointer to function or pointer
16732 to member function argument if the set of
16733 overloaded functions does not contain function
16734 templates and at most one of a set of
16735 overloaded functions provides a unique
16738 if (resolve_overloaded_unification
16739 (tparms
, targs
, parm
, arg
, strict
,
16740 arg_strict
, explain_p
))
16741 return unify_success (explain_p
);
16742 return unify_overload_resolution_failure (explain_p
, arg
);
16746 arg
= unlowered_expr_type (arg
);
16747 if (arg
== error_mark_node
)
16748 return unify_invalid (explain_p
);
16752 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16755 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16756 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
16757 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16759 /* For deduction from an init-list we need the actual list. */
16760 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16762 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16765 /* Most parms like fn_type_unification.
16767 If SUBR is 1, we're being called recursively (to unify the
16768 arguments of a function or method parameter of a function
16771 CHECKS is a pointer to a vector of access checks encountered while
16772 substituting default template arguments. */
16775 type_unification_real (tree tparms
,
16779 unsigned int xnargs
,
16781 unification_kind_t strict
,
16783 vec
<deferred_access_check
, va_gc
> **checks
,
16788 int ntparms
= TREE_VEC_LENGTH (tparms
);
16789 int saw_undeduced
= 0;
16792 unsigned int nargs
;
16795 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16796 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16797 gcc_assert (ntparms
> 0);
16799 /* Reset the number of non-defaulted template arguments contained
16801 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16809 while (parms
&& parms
!= void_list_node
16812 parm
= TREE_VALUE (parms
);
16814 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16815 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16816 /* For a function parameter pack that occurs at the end of the
16817 parameter-declaration-list, the type A of each remaining
16818 argument of the call is compared with the type P of the
16819 declarator-id of the function parameter pack. */
16822 parms
= TREE_CHAIN (parms
);
16824 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16825 /* For a function parameter pack that does not occur at the
16826 end of the parameter-declaration-list, the type of the
16827 parameter pack is a non-deduced context. */
16833 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16839 && parms
!= void_list_node
16840 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16842 /* Unify the remaining arguments with the pack expansion type. */
16844 tree parmvec
= make_tree_vec (1);
16846 /* Allocate a TREE_VEC and copy in all of the arguments */
16847 argvec
= make_tree_vec (nargs
- ia
);
16848 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16849 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16851 /* Copy the parameter into parmvec. */
16852 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16853 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16854 /*subr=*/subr
, explain_p
))
16857 /* Advance to the end of the list of parameters. */
16858 parms
= TREE_CHAIN (parms
);
16861 /* Fail if we've reached the end of the parm list, and more args
16862 are present, and the parm list isn't variadic. */
16863 if (ia
< nargs
&& parms
== void_list_node
)
16864 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16865 /* Fail if parms are left and they don't have default values and
16866 they aren't all deduced as empty packs (c++/57397). This is
16867 consistent with sufficient_parms_p. */
16868 if (parms
&& parms
!= void_list_node
16869 && TREE_PURPOSE (parms
) == NULL_TREE
)
16871 unsigned int count
= nargs
;
16876 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
16879 p
= TREE_CHAIN (p
);
16881 while (p
&& p
!= void_list_node
);
16882 if (count
!= nargs
)
16883 return unify_too_few_arguments (explain_p
, ia
, count
,
16889 tsubst_flags_t complain
= (explain_p
16890 ? tf_warning_or_error
16893 for (i
= 0; i
< ntparms
; i
++)
16895 tree targ
= TREE_VEC_ELT (targs
, i
);
16896 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16898 /* Clear the "incomplete" flags on all argument packs now so that
16899 substituting them into later default arguments works. */
16900 if (targ
&& ARGUMENT_PACK_P (targ
))
16902 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16903 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16906 if (targ
|| tparm
== error_mark_node
)
16908 tparm
= TREE_VALUE (tparm
);
16910 /* If this is an undeduced nontype parameter that depends on
16911 a type parameter, try another pass; its type may have been
16912 deduced from a later argument than the one from which
16913 this parameter can be deduced. */
16914 if (TREE_CODE (tparm
) == PARM_DECL
16915 && uses_template_parms (TREE_TYPE (tparm
))
16916 && !saw_undeduced
++)
16919 /* Core issue #226 (C++0x) [temp.deduct]:
16921 If a template argument has not been deduced, its
16922 default template argument, if any, is used.
16924 When we are in C++98 mode, TREE_PURPOSE will either
16925 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16926 to explicitly check cxx_dialect here. */
16927 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
16929 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16930 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
16931 reopen_deferring_access_checks (*checks
);
16932 location_t save_loc
= input_location
;
16934 input_location
= DECL_SOURCE_LOCATION (parm
);
16935 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
16936 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
16938 input_location
= save_loc
;
16939 *checks
= get_deferred_access_checks ();
16940 pop_deferring_access_checks ();
16941 if (arg
== error_mark_node
)
16945 TREE_VEC_ELT (targs
, i
) = arg
;
16946 /* The position of the first default template argument,
16947 is also the number of non-defaulted arguments in TARGS.
16949 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16950 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
16955 /* If the type parameter is a parameter pack, then it will
16956 be deduced to an empty parameter pack. */
16957 if (template_parameter_pack_p (tparm
))
16961 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
16963 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
16964 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
16965 TREE_CONSTANT (arg
) = 1;
16968 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16970 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
16972 TREE_VEC_ELT (targs
, i
) = arg
;
16976 return unify_parameter_deduction_failure (explain_p
, tparm
);
16979 #ifdef ENABLE_CHECKING
16980 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16981 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
16984 return unify_success (explain_p
);
16987 /* Subroutine of type_unification_real. Args are like the variables
16988 at the call site. ARG is an overloaded function (or template-id);
16989 we try deducing template args from each of the overloads, and if
16990 only one succeeds, we go with that. Modifies TARGS and returns
16991 true on success. */
16994 resolve_overloaded_unification (tree tparms
,
16998 unification_kind_t strict
,
17002 tree tempargs
= copy_node (targs
);
17004 tree goodfn
= NULL_TREE
;
17007 if (TREE_CODE (arg
) == ADDR_EXPR
)
17009 arg
= TREE_OPERAND (arg
, 0);
17015 if (TREE_CODE (arg
) == COMPONENT_REF
)
17016 /* Handle `&x' where `x' is some static or non-static member
17018 arg
= TREE_OPERAND (arg
, 1);
17020 if (TREE_CODE (arg
) == OFFSET_REF
)
17021 arg
= TREE_OPERAND (arg
, 1);
17023 /* Strip baselink information. */
17024 if (BASELINK_P (arg
))
17025 arg
= BASELINK_FUNCTIONS (arg
);
17027 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
17029 /* If we got some explicit template args, we need to plug them into
17030 the affected templates before we try to unify, in case the
17031 explicit args will completely resolve the templates in question. */
17034 tree expl_subargs
= TREE_OPERAND (arg
, 1);
17035 arg
= TREE_OPERAND (arg
, 0);
17037 for (; arg
; arg
= OVL_NEXT (arg
))
17039 tree fn
= OVL_CURRENT (arg
);
17040 tree subargs
, elem
;
17042 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17045 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17046 expl_subargs
, NULL_TREE
, tf_none
,
17047 /*require_all_args=*/true,
17048 /*use_default_args=*/true);
17049 if (subargs
!= error_mark_node
17050 && !any_dependent_template_arguments_p (subargs
))
17052 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
17053 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17054 elem
, strict
, sub_strict
, addr_p
, explain_p
)
17055 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
17064 /* If no templates (or more than one) are fully resolved by the
17065 explicit arguments, this template-id is a non-deduced context; it
17066 could still be OK if we deduce all template arguments for the
17067 enclosing call through other arguments. */
17071 else if (TREE_CODE (arg
) != OVERLOAD
17072 && TREE_CODE (arg
) != FUNCTION_DECL
)
17073 /* If ARG is, for example, "(0, &f)" then its type will be unknown
17074 -- but the deduction does not succeed because the expression is
17075 not just the function on its own. */
17078 for (; arg
; arg
= OVL_NEXT (arg
))
17079 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17080 TREE_TYPE (OVL_CURRENT (arg
)),
17081 strict
, sub_strict
, addr_p
, explain_p
)
17082 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
17084 goodfn
= OVL_CURRENT (arg
);
17088 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17089 to function or pointer to member function argument if the set of
17090 overloaded functions does not contain function templates and at most
17091 one of a set of overloaded functions provides a unique match.
17093 So if we found multiple possibilities, we return success but don't
17094 deduce anything. */
17098 int i
= TREE_VEC_LENGTH (targs
);
17100 if (TREE_VEC_ELT (tempargs
, i
))
17102 tree old
= TREE_VEC_ELT (targs
, i
);
17103 tree new_
= TREE_VEC_ELT (tempargs
, i
);
17104 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
17105 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
17106 /* Don't forget explicit template arguments in a pack. */
17107 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
17108 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
17109 TREE_VEC_ELT (targs
, i
) = new_
;
17118 /* Core DR 115: In contexts where deduction is done and fails, or in
17119 contexts where deduction is not done, if a template argument list is
17120 specified and it, along with any default template arguments, identifies
17121 a single function template specialization, then the template-id is an
17122 lvalue for the function template specialization. */
17125 resolve_nondeduced_context (tree orig_expr
)
17127 tree expr
, offset
, baselink
;
17130 if (!type_unknown_p (orig_expr
))
17135 offset
= NULL_TREE
;
17136 baselink
= NULL_TREE
;
17138 if (TREE_CODE (expr
) == ADDR_EXPR
)
17140 expr
= TREE_OPERAND (expr
, 0);
17143 if (TREE_CODE (expr
) == OFFSET_REF
)
17146 expr
= TREE_OPERAND (expr
, 1);
17148 if (BASELINK_P (expr
))
17151 expr
= BASELINK_FUNCTIONS (expr
);
17154 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
17157 tree goodfn
= NULL_TREE
;
17159 /* If we got some explicit template args, we need to plug them into
17160 the affected templates before we try to unify, in case the
17161 explicit args will completely resolve the templates in question. */
17163 tree expl_subargs
= TREE_OPERAND (expr
, 1);
17164 tree arg
= TREE_OPERAND (expr
, 0);
17165 tree badfn
= NULL_TREE
;
17166 tree badargs
= NULL_TREE
;
17168 for (; arg
; arg
= OVL_NEXT (arg
))
17170 tree fn
= OVL_CURRENT (arg
);
17171 tree subargs
, elem
;
17173 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17176 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17177 expl_subargs
, NULL_TREE
, tf_none
,
17178 /*require_all_args=*/true,
17179 /*use_default_args=*/true);
17180 if (subargs
!= error_mark_node
17181 && !any_dependent_template_arguments_p (subargs
))
17183 elem
= instantiate_template (fn
, subargs
, tf_none
);
17184 if (elem
== error_mark_node
)
17189 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
17198 mark_used (goodfn
);
17201 expr
= build_baselink (BASELINK_BINFO (baselink
),
17202 BASELINK_ACCESS_BINFO (baselink
),
17203 expr
, BASELINK_OPTYPE (baselink
));
17207 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
17208 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
17211 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
17214 else if (good
== 0 && badargs
)
17215 /* There were no good options and at least one bad one, so let the
17216 user know what the problem is. */
17217 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
17222 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17223 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17224 different overloads deduce different arguments for a given parm.
17225 ADDR_P is true if the expression for which deduction is being
17226 performed was of the form "& fn" rather than simply "fn".
17228 Returns 1 on success. */
17231 try_one_overload (tree tparms
,
17236 unification_kind_t strict
,
17245 if (arg
== error_mark_node
)
17248 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17249 to function or pointer to member function argument if the set of
17250 overloaded functions does not contain function templates and at most
17251 one of a set of overloaded functions provides a unique match.
17253 So if this is a template, just return success. */
17255 if (uses_template_parms (arg
))
17258 if (TREE_CODE (arg
) == METHOD_TYPE
)
17259 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
17261 arg
= build_pointer_type (arg
);
17263 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
17265 /* We don't copy orig_targs for this because if we have already deduced
17266 some template args from previous args, unify would complain when we
17267 try to deduce a template parameter for the same argument, even though
17268 there isn't really a conflict. */
17269 nargs
= TREE_VEC_LENGTH (targs
);
17270 tempargs
= make_tree_vec (nargs
);
17272 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
17275 /* First make sure we didn't deduce anything that conflicts with
17276 explicitly specified args. */
17277 for (i
= nargs
; i
--; )
17279 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17280 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17284 else if (uses_template_parms (elt
))
17285 /* Since we're unifying against ourselves, we will fill in
17286 template args used in the function parm list with our own
17287 template parms. Discard them. */
17288 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17289 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17293 for (i
= nargs
; i
--; )
17295 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17298 TREE_VEC_ELT (targs
, i
) = elt
;
17304 /* PARM is a template class (perhaps with unbound template
17305 parameters). ARG is a fully instantiated type. If ARG can be
17306 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17307 TARGS are as for unify. */
17310 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17313 tree copy_of_targs
;
17315 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17316 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17317 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17320 /* We need to make a new template argument vector for the call to
17321 unify. If we used TARGS, we'd clutter it up with the result of
17322 the attempted unification, even if this class didn't work out.
17323 We also don't want to commit ourselves to all the unifications
17324 we've already done, since unification is supposed to be done on
17325 an argument-by-argument basis. In other words, consider the
17326 following pathological case:
17328 template <int I, int J, int K>
17331 template <int I, int J>
17332 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17334 template <int I, int J, int K>
17335 void f(S<I, J, K>, S<I, I, I>);
17344 Now, by the time we consider the unification involving `s2', we
17345 already know that we must have `f<0, 0, 0>'. But, even though
17346 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17347 because there are two ways to unify base classes of S<0, 1, 2>
17348 with S<I, I, I>. If we kept the already deduced knowledge, we
17349 would reject the possibility I=1. */
17350 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17352 /* If unification failed, we're done. */
17353 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17354 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17360 /* Given a template type PARM and a class type ARG, find the unique
17361 base type in ARG that is an instance of PARM. We do not examine
17362 ARG itself; only its base-classes. If there is not exactly one
17363 appropriate base class, return NULL_TREE. PARM may be the type of
17364 a partial specialization, as well as a plain template type. Used
17367 static enum template_base_result
17368 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17369 bool explain_p
, tree
*result
)
17371 tree rval
= NULL_TREE
;
17374 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17376 binfo
= TYPE_BINFO (complete_type (arg
));
17379 /* The type could not be completed. */
17380 *result
= NULL_TREE
;
17381 return tbr_incomplete_type
;
17384 /* Walk in inheritance graph order. The search order is not
17385 important, and this avoids multiple walks of virtual bases. */
17386 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17388 tree r
= try_class_unification (tparms
, targs
, parm
,
17389 BINFO_TYPE (binfo
), explain_p
);
17393 /* If there is more than one satisfactory baseclass, then:
17397 If they yield more than one possible deduced A, the type
17401 if (rval
&& !same_type_p (r
, rval
))
17403 *result
= NULL_TREE
;
17404 return tbr_ambiguous_baseclass
;
17412 return tbr_success
;
17415 /* Returns the level of DECL, which declares a template parameter. */
17418 template_decl_level (tree decl
)
17420 switch (TREE_CODE (decl
))
17423 case TEMPLATE_DECL
:
17424 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17427 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17430 gcc_unreachable ();
17435 /* Decide whether ARG can be unified with PARM, considering only the
17436 cv-qualifiers of each type, given STRICT as documented for unify.
17437 Returns nonzero iff the unification is OK on that basis. */
17440 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17442 int arg_quals
= cp_type_quals (arg
);
17443 int parm_quals
= cp_type_quals (parm
);
17445 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17446 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17448 /* Although a CVR qualifier is ignored when being applied to a
17449 substituted template parameter ([8.3.2]/1 for example), that
17450 does not allow us to unify "const T" with "int&" because both
17451 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17452 It is ok when we're allowing additional CV qualifiers
17453 at the outer level [14.8.2.1]/3,1st bullet. */
17454 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17455 || TREE_CODE (arg
) == FUNCTION_TYPE
17456 || TREE_CODE (arg
) == METHOD_TYPE
)
17457 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17460 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17461 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17465 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17466 && (arg_quals
& parm_quals
) != parm_quals
)
17469 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17470 && (parm_quals
& arg_quals
) != arg_quals
)
17476 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17478 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17480 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17481 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17482 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17484 *index
= TEMPLATE_TYPE_IDX (parm
);
17485 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17489 *index
= TEMPLATE_PARM_IDX (parm
);
17490 *level
= TEMPLATE_PARM_LEVEL (parm
);
17494 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17496 if (unify (TP, TA, P, A, S, EP)) \
17500 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17501 expansion at the end of PACKED_PARMS. Returns 0 if the type
17502 deduction succeeds, 1 otherwise. STRICT is the same as in
17503 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17504 call argument list. We'll need to adjust the arguments to make them
17505 types. SUBR tells us if this is from a recursive call to
17506 type_unification_real, or for comparing two template argument
17510 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17511 tree packed_args
, unification_kind_t strict
,
17512 bool subr
, bool explain_p
)
17515 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17516 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17517 tree pack
, packs
= NULL_TREE
;
17518 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17520 packed_args
= expand_template_argument_pack (packed_args
);
17522 int len
= TREE_VEC_LENGTH (packed_args
);
17524 /* Determine the parameter packs we will be deducing from the
17525 pattern, and record their current deductions. */
17526 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17527 pack
; pack
= TREE_CHAIN (pack
))
17529 tree parm_pack
= TREE_VALUE (pack
);
17532 /* Determine the index and level of this parameter pack. */
17533 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17535 /* Keep track of the parameter packs and their corresponding
17537 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17538 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17541 /* Loop through all of the arguments that have not yet been
17542 unified and unify each with the pattern. */
17543 for (i
= start
; i
< len
; i
++)
17546 bool any_explicit
= false;
17547 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17549 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17550 or the element of its argument pack at the current index if
17551 this argument was explicitly specified. */
17552 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17556 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17559 if (TREE_VALUE (pack
)
17560 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17561 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17563 any_explicit
= true;
17564 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17566 TMPL_ARG (targs
, level
, idx
) = arg
;
17569 /* If we had explicit template arguments, substitute them into the
17570 pattern before deduction. */
17573 /* Some arguments might still be unspecified or dependent. */
17575 ++processing_template_decl
;
17576 dependent
= any_dependent_template_arguments_p (targs
);
17578 --processing_template_decl
;
17579 parm
= tsubst (pattern
, targs
,
17580 explain_p
? tf_warning_or_error
: tf_none
,
17583 --processing_template_decl
;
17584 if (parm
== error_mark_node
)
17590 /* Unify the pattern with the current argument. */
17591 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17592 LOOKUP_IMPLICIT
, explain_p
))
17595 /* For each parameter pack, collect the deduced value. */
17596 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17599 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17601 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17602 TMPL_ARG (targs
, level
, idx
);
17606 /* Verify that the results of unification with the parameter packs
17607 produce results consistent with what we've seen before, and make
17608 the deduced argument packs available. */
17609 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17611 tree old_pack
= TREE_VALUE (pack
);
17612 tree new_args
= TREE_TYPE (pack
);
17613 int i
, len
= TREE_VEC_LENGTH (new_args
);
17615 bool nondeduced_p
= false;
17617 /* By default keep the original deduced argument pack.
17618 If necessary, more specific code is going to update the
17619 resulting deduced argument later down in this function. */
17620 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17621 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17623 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17624 actually deduce anything. */
17625 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17626 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17627 nondeduced_p
= true;
17631 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17633 /* If we had fewer function args than explicit template args,
17634 just use the explicits. */
17635 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17636 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17637 if (len
< explicit_len
)
17638 new_args
= explicit_args
;
17644 /* Build the deduced *_ARGUMENT_PACK. */
17645 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17647 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17648 TREE_TYPE (result
) =
17649 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17650 TREE_CONSTANT (result
) = 1;
17653 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17655 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17657 /* Note the deduced argument packs for this parameter
17659 TMPL_ARG (targs
, level
, idx
) = result
;
17661 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17662 && (ARGUMENT_PACK_ARGS (old_pack
)
17663 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17665 /* We only had the explicitly-provided arguments before, but
17666 now we have a complete set of arguments. */
17667 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17669 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17670 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17671 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17675 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17676 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17678 if (!comp_template_args_with_info (old_args
, new_args
,
17679 &bad_old_arg
, &bad_new_arg
))
17680 /* Inconsistent unification of this parameter pack. */
17681 return unify_parameter_pack_inconsistent (explain_p
,
17687 return unify_success (explain_p
);
17690 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17691 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17692 parameters and return value are as for unify. */
17695 unify_array_domain (tree tparms
, tree targs
,
17696 tree parm_dom
, tree arg_dom
,
17704 /* Our representation of array types uses "N - 1" as the
17705 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17706 not an integer constant. We cannot unify arbitrarily
17707 complex expressions, so we eliminate the MINUS_EXPRs
17709 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17710 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17713 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17714 parm_max
= TREE_OPERAND (parm_max
, 0);
17716 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17717 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17720 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17721 trying to unify the type of a variable with the type
17722 of a template parameter. For example:
17724 template <unsigned int N>
17725 void f (char (&) [N]);
17732 Here, the type of the ARG will be "int [g(i)]", and
17733 may be a SAVE_EXPR, etc. */
17734 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17735 return unify_vla_arg (explain_p
, arg_dom
);
17736 arg_max
= TREE_OPERAND (arg_max
, 0);
17739 /* If only one of the bounds used a MINUS_EXPR, compensate
17740 by adding one to the other bound. */
17741 if (parm_cst
&& !arg_cst
)
17742 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17746 else if (arg_cst
&& !parm_cst
)
17747 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17752 return unify (tparms
, targs
, parm_max
, arg_max
,
17753 UNIFY_ALLOW_INTEGER
, explain_p
);
17756 /* Deduce the value of template parameters. TPARMS is the (innermost)
17757 set of template parameters to a template. TARGS is the bindings
17758 for those template parameters, as determined thus far; TARGS may
17759 include template arguments for outer levels of template parameters
17760 as well. PARM is a parameter to a template function, or a
17761 subcomponent of that parameter; ARG is the corresponding argument.
17762 This function attempts to match PARM with ARG in a manner
17763 consistent with the existing assignments in TARGS. If more values
17764 are deduced, then TARGS is updated.
17766 Returns 0 if the type deduction succeeds, 1 otherwise. The
17767 parameter STRICT is a bitwise or of the following flags:
17770 Require an exact match between PARM and ARG.
17771 UNIFY_ALLOW_MORE_CV_QUAL:
17772 Allow the deduced ARG to be more cv-qualified (by qualification
17773 conversion) than ARG.
17774 UNIFY_ALLOW_LESS_CV_QUAL:
17775 Allow the deduced ARG to be less cv-qualified than ARG.
17776 UNIFY_ALLOW_DERIVED:
17777 Allow the deduced ARG to be a template base class of ARG,
17778 or a pointer to a template base class of the type pointed to by
17780 UNIFY_ALLOW_INTEGER:
17781 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17782 case for more information.
17783 UNIFY_ALLOW_OUTER_LEVEL:
17784 This is the outermost level of a deduction. Used to determine validity
17785 of qualification conversions. A valid qualification conversion must
17786 have const qualified pointers leading up to the inner type which
17787 requires additional CV quals, except at the outer level, where const
17788 is not required [conv.qual]. It would be normal to set this flag in
17789 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17790 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17791 This is the outermost level of a deduction, and PARM can be more CV
17792 qualified at this point.
17793 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17794 This is the outermost level of a deduction, and PARM can be less CV
17795 qualified at this point. */
17798 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17804 int strict_in
= strict
;
17806 /* I don't think this will do the right thing with respect to types.
17807 But the only case I've seen it in so far has been array bounds, where
17808 signedness is the only information lost, and I think that will be
17810 while (TREE_CODE (parm
) == NOP_EXPR
)
17811 parm
= TREE_OPERAND (parm
, 0);
17813 if (arg
== error_mark_node
)
17814 return unify_invalid (explain_p
);
17815 if (arg
== unknown_type_node
17816 || arg
== init_list_type_node
)
17817 /* We can't deduce anything from this, but we might get all the
17818 template args from other function args. */
17819 return unify_success (explain_p
);
17821 /* If PARM uses template parameters, then we can't bail out here,
17822 even if ARG == PARM, since we won't record unifications for the
17823 template parameters. We might need them if we're trying to
17824 figure out which of two things is more specialized. */
17825 if (arg
== parm
&& !uses_template_parms (parm
))
17826 return unify_success (explain_p
);
17828 /* Handle init lists early, so the rest of the function can assume
17829 we're dealing with a type. */
17830 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17834 tree orig_parm
= parm
;
17836 /* Replace T with std::initializer_list<T> for deduction. */
17837 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17838 && flag_deduce_init_list
)
17839 parm
= listify (parm
);
17841 if (!is_std_init_list (parm
)
17842 && TREE_CODE (parm
) != ARRAY_TYPE
)
17843 /* We can only deduce from an initializer list argument if the
17844 parameter is std::initializer_list or an array; otherwise this
17845 is a non-deduced context. */
17846 return unify_success (explain_p
);
17848 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17849 elttype
= TREE_TYPE (parm
);
17852 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17853 /* Deduction is defined in terms of a single type, so just punt
17854 on the (bizarre) std::initializer_list<T...>. */
17855 if (PACK_EXPANSION_P (elttype
))
17856 return unify_success (explain_p
);
17859 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
17861 int elt_strict
= strict
;
17863 if (elt
== error_mark_node
)
17864 return unify_invalid (explain_p
);
17866 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
17868 tree type
= TREE_TYPE (elt
);
17869 if (type
== error_mark_node
)
17870 return unify_invalid (explain_p
);
17871 /* It should only be possible to get here for a call. */
17872 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
17873 elt_strict
|= maybe_adjust_types_for_deduction
17874 (DEDUCE_CALL
, &elttype
, &type
, elt
);
17878 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
17882 if (TREE_CODE (parm
) == ARRAY_TYPE
17883 && deducible_array_bound (TYPE_DOMAIN (parm
)))
17885 /* Also deduce from the length of the initializer list. */
17886 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
17887 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
17888 if (idx
== error_mark_node
)
17889 return unify_invalid (explain_p
);
17890 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17894 /* If the std::initializer_list<T> deduction worked, replace the
17895 deduced A with std::initializer_list<A>. */
17896 if (orig_parm
!= parm
)
17898 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
17899 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17900 targ
= listify (targ
);
17901 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
17903 return unify_success (explain_p
);
17906 /* Immediately reject some pairs that won't unify because of
17907 cv-qualification mismatches. */
17908 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17910 /* It is the elements of the array which hold the cv quals of an array
17911 type, and the elements might be template type parms. We'll check
17912 when we recurse. */
17913 && TREE_CODE (arg
) != ARRAY_TYPE
17914 /* We check the cv-qualifiers when unifying with template type
17915 parameters below. We want to allow ARG `const T' to unify with
17916 PARM `T' for example, when computing which of two templates
17917 is more specialized, for example. */
17918 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
17919 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
17920 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17922 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
17923 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
17924 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
17925 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
17926 strict
&= ~UNIFY_ALLOW_DERIVED
;
17927 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17928 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
17930 switch (TREE_CODE (parm
))
17932 case TYPENAME_TYPE
:
17934 case UNBOUND_CLASS_TEMPLATE
:
17935 /* In a type which contains a nested-name-specifier, template
17936 argument values cannot be deduced for template parameters used
17937 within the nested-name-specifier. */
17938 return unify_success (explain_p
);
17940 case TEMPLATE_TYPE_PARM
:
17941 case TEMPLATE_TEMPLATE_PARM
:
17942 case BOUND_TEMPLATE_TEMPLATE_PARM
:
17943 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17944 if (error_operand_p (tparm
))
17945 return unify_invalid (explain_p
);
17947 if (TEMPLATE_TYPE_LEVEL (parm
)
17948 != template_decl_level (tparm
))
17949 /* The PARM is not one we're trying to unify. Just check
17950 to see if it matches ARG. */
17952 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17953 && (is_auto (parm
) ? is_auto (arg
)
17954 : same_type_p (parm
, arg
)))
17955 return unify_success (explain_p
);
17957 return unify_type_mismatch (explain_p
, parm
, arg
);
17959 idx
= TEMPLATE_TYPE_IDX (parm
);
17960 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17961 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
17962 if (error_operand_p (tparm
))
17963 return unify_invalid (explain_p
);
17965 /* Check for mixed types and values. */
17966 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17967 && TREE_CODE (tparm
) != TYPE_DECL
)
17968 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17969 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
17970 gcc_unreachable ();
17972 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17974 /* ARG must be constructed from a template class or a template
17975 template parameter. */
17976 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
17977 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
17978 return unify_template_deduction_failure (explain_p
, parm
, arg
);
17980 tree parmvec
= TYPE_TI_ARGS (parm
);
17981 /* An alias template name is never deduced. */
17982 if (TYPE_ALIAS_P (arg
))
17983 arg
= strip_typedefs (arg
);
17984 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
17985 tree full_argvec
= add_to_template_args (targs
, argvec
);
17987 = DECL_INNERMOST_TEMPLATE_PARMS
17988 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
17990 int parm_variadic_p
= 0;
17992 /* The resolution to DR150 makes clear that default
17993 arguments for an N-argument may not be used to bind T
17994 to a template template parameter with fewer than N
17995 parameters. It is not safe to permit the binding of
17996 default arguments as an extension, as that may change
17997 the meaning of a conforming program. Consider:
17999 struct Dense { static const unsigned int dim = 1; };
18001 template <template <typename> class View,
18003 void operator+(float, View<Block> const&);
18005 template <typename Block,
18006 unsigned int Dim = Block::dim>
18007 struct Lvalue_proxy { operator float() const; };
18011 Lvalue_proxy<Dense> p;
18016 Here, if Lvalue_proxy is permitted to bind to View, then
18017 the global operator+ will be used; if they are not, the
18018 Lvalue_proxy will be converted to float. */
18019 if (coerce_template_parms (parm_parms
,
18021 TYPE_TI_TEMPLATE (parm
),
18023 ? tf_warning_or_error
18025 /*require_all_args=*/true,
18026 /*use_default_args=*/false)
18027 == error_mark_node
)
18030 /* Deduce arguments T, i from TT<T> or TT<i>.
18031 We check each element of PARMVEC and ARGVEC individually
18032 rather than the whole TREE_VEC since they can have
18033 different number of elements. */
18035 parmvec
= expand_template_argument_pack (parmvec
);
18036 argvec
= expand_template_argument_pack (argvec
);
18038 len
= TREE_VEC_LENGTH (parmvec
);
18040 /* Check if the parameters end in a pack, making them
18043 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
18044 parm_variadic_p
= 1;
18046 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18047 /* If the template argument list of P contains a pack
18048 expansion that is not the last template argument, the
18049 entire template argument list is a non-deduced
18051 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
18052 return unify_success (explain_p
);
18054 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
18055 return unify_too_few_arguments (explain_p
,
18056 TREE_VEC_LENGTH (argvec
), len
);
18058 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18060 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18061 TREE_VEC_ELT (parmvec
, i
),
18062 TREE_VEC_ELT (argvec
, i
),
18063 UNIFY_ALLOW_NONE
, explain_p
);
18066 if (parm_variadic_p
18067 && unify_pack_expansion (tparms
, targs
,
18070 /*subr=*/true, explain_p
))
18073 arg
= TYPE_TI_TEMPLATE (arg
);
18075 /* Fall through to deduce template name. */
18078 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18079 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18081 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
18083 /* Simple cases: Value already set, does match or doesn't. */
18084 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
18085 return unify_success (explain_p
);
18087 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18091 /* If PARM is `const T' and ARG is only `int', we don't have
18092 a match unless we are allowing additional qualification.
18093 If ARG is `const int' and PARM is just `T' that's OK;
18094 that binds `const int' to `T'. */
18095 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
18097 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18099 /* Consider the case where ARG is `const volatile int' and
18100 PARM is `const T'. Then, T should be `volatile int'. */
18101 arg
= cp_build_qualified_type_real
18102 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
18103 if (arg
== error_mark_node
)
18104 return unify_invalid (explain_p
);
18106 /* Simple cases: Value already set, does match or doesn't. */
18107 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
18108 return unify_success (explain_p
);
18110 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18112 /* Make sure that ARG is not a variable-sized array. (Note
18113 that were talking about variable-sized arrays (like
18114 `int[n]'), rather than arrays of unknown size (like
18115 `int[]').) We'll get very confused by such a type since
18116 the bound of the array is not constant, and therefore
18117 not mangleable. Besides, such types are not allowed in
18118 ISO C++, so we can do as we please here. We do allow
18119 them for 'auto' deduction, since that isn't ABI-exposed. */
18120 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
18121 return unify_vla_arg (explain_p
, arg
);
18123 /* Strip typedefs as in convert_template_argument. */
18124 arg
= canonicalize_type_argument (arg
, tf_none
);
18127 /* If ARG is a parameter pack or an expansion, we cannot unify
18128 against it unless PARM is also a parameter pack. */
18129 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18130 && !template_parameter_pack_p (parm
))
18131 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18133 /* If the argument deduction results is a METHOD_TYPE,
18134 then there is a problem.
18135 METHOD_TYPE doesn't map to any real C++ type the result of
18136 the deduction can not be of that type. */
18137 if (TREE_CODE (arg
) == METHOD_TYPE
)
18138 return unify_method_type_error (explain_p
, arg
);
18140 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18141 return unify_success (explain_p
);
18143 case TEMPLATE_PARM_INDEX
:
18144 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18145 if (error_operand_p (tparm
))
18146 return unify_invalid (explain_p
);
18148 if (TEMPLATE_PARM_LEVEL (parm
)
18149 != template_decl_level (tparm
))
18151 /* The PARM is not one we're trying to unify. Just check
18152 to see if it matches ARG. */
18153 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
18154 && cp_tree_equal (parm
, arg
));
18156 unify_expression_unequal (explain_p
, parm
, arg
);
18160 idx
= TEMPLATE_PARM_IDX (parm
);
18161 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18165 int x
= !cp_tree_equal (targ
, arg
);
18167 unify_inconsistency (explain_p
, parm
, targ
, arg
);
18171 /* [temp.deduct.type] If, in the declaration of a function template
18172 with a non-type template-parameter, the non-type
18173 template-parameter is used in an expression in the function
18174 parameter-list and, if the corresponding template-argument is
18175 deduced, the template-argument type shall match the type of the
18176 template-parameter exactly, except that a template-argument
18177 deduced from an array bound may be of any integral type.
18178 The non-type parameter might use already deduced type parameters. */
18179 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
18180 if (!TREE_TYPE (arg
))
18181 /* Template-parameter dependent expression. Just accept it for now.
18182 It will later be processed in convert_template_argument. */
18184 else if (same_type_p (TREE_TYPE (arg
), tparm
))
18186 else if ((strict
& UNIFY_ALLOW_INTEGER
)
18187 && CP_INTEGRAL_TYPE_P (tparm
))
18188 /* Convert the ARG to the type of PARM; the deduced non-type
18189 template argument must exactly match the types of the
18190 corresponding parameter. */
18191 arg
= fold (build_nop (tparm
, arg
));
18192 else if (uses_template_parms (tparm
))
18193 /* We haven't deduced the type of this parameter yet. Try again
18195 return unify_success (explain_p
);
18197 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
18199 /* If ARG is a parameter pack or an expansion, we cannot unify
18200 against it unless PARM is also a parameter pack. */
18201 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18202 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
18203 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18205 arg
= strip_typedefs_expr (arg
);
18206 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18207 return unify_success (explain_p
);
18211 /* A pointer-to-member constant can be unified only with
18212 another constant. */
18213 if (TREE_CODE (arg
) != PTRMEM_CST
)
18214 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
18216 /* Just unify the class member. It would be useless (and possibly
18217 wrong, depending on the strict flags) to unify also
18218 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18219 arg refer to the same variable, even if through different
18220 classes. For instance:
18222 struct A { int x; };
18225 Unification of &A::x and &B::x must succeed. */
18226 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
18227 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
18232 if (!TYPE_PTR_P (arg
))
18233 return unify_type_mismatch (explain_p
, parm
, arg
);
18235 /* [temp.deduct.call]
18237 A can be another pointer or pointer to member type that can
18238 be converted to the deduced A via a qualification
18239 conversion (_conv.qual_).
18241 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18242 This will allow for additional cv-qualification of the
18243 pointed-to types if appropriate. */
18245 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
18246 /* The derived-to-base conversion only persists through one
18247 level of pointers. */
18248 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
18250 return unify (tparms
, targs
, TREE_TYPE (parm
),
18251 TREE_TYPE (arg
), strict
, explain_p
);
18254 case REFERENCE_TYPE
:
18255 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
18256 return unify_type_mismatch (explain_p
, parm
, arg
);
18257 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18258 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18261 if (TREE_CODE (arg
) != ARRAY_TYPE
)
18262 return unify_type_mismatch (explain_p
, parm
, arg
);
18263 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
18264 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
18265 return unify_type_mismatch (explain_p
, parm
, arg
);
18266 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18267 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18268 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
18269 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18270 TYPE_DOMAIN (arg
), explain_p
);
18271 return unify_success (explain_p
);
18278 case ENUMERAL_TYPE
:
18281 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18282 return unify_type_mismatch (explain_p
, parm
, arg
);
18284 /* We have already checked cv-qualification at the top of the
18286 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
18287 return unify_type_mismatch (explain_p
, parm
, arg
);
18289 /* As far as unification is concerned, this wins. Later checks
18290 will invalidate it if necessary. */
18291 return unify_success (explain_p
);
18293 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18294 /* Type INTEGER_CST can come from ordinary constant template args. */
18296 while (TREE_CODE (arg
) == NOP_EXPR
)
18297 arg
= TREE_OPERAND (arg
, 0);
18299 if (TREE_CODE (arg
) != INTEGER_CST
)
18300 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18301 return (tree_int_cst_equal (parm
, arg
)
18302 ? unify_success (explain_p
)
18303 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18307 int i
, len
, argslen
;
18308 int parm_variadic_p
= 0;
18310 if (TREE_CODE (arg
) != TREE_VEC
)
18311 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18313 len
= TREE_VEC_LENGTH (parm
);
18314 argslen
= TREE_VEC_LENGTH (arg
);
18316 /* Check for pack expansions in the parameters. */
18317 for (i
= 0; i
< len
; ++i
)
18319 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18322 /* We can unify against something with a trailing
18324 parm_variadic_p
= 1;
18326 /* [temp.deduct.type]/9: If the template argument list of
18327 P contains a pack expansion that is not the last
18328 template argument, the entire template argument list
18329 is a non-deduced context. */
18330 return unify_success (explain_p
);
18334 /* If we don't have enough arguments to satisfy the parameters
18335 (not counting the pack expression at the end), or we have
18336 too many arguments for a parameter list that doesn't end in
18337 a pack expression, we can't unify. */
18338 if (parm_variadic_p
18339 ? argslen
< len
- parm_variadic_p
18341 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18343 /* Unify all of the parameters that precede the (optional)
18344 pack expression. */
18345 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18347 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18348 TREE_VEC_ELT (parm
, i
),
18349 TREE_VEC_ELT (arg
, i
),
18350 UNIFY_ALLOW_NONE
, explain_p
);
18352 if (parm_variadic_p
)
18353 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18355 /*subr=*/true, explain_p
);
18356 return unify_success (explain_p
);
18361 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18362 return unify_type_mismatch (explain_p
, parm
, arg
);
18364 if (TYPE_PTRMEMFUNC_P (parm
))
18366 if (!TYPE_PTRMEMFUNC_P (arg
))
18367 return unify_type_mismatch (explain_p
, parm
, arg
);
18369 return unify (tparms
, targs
,
18370 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18371 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18372 strict
, explain_p
);
18374 else if (TYPE_PTRMEMFUNC_P (arg
))
18375 return unify_type_mismatch (explain_p
, parm
, arg
);
18377 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18379 tree t
= NULL_TREE
;
18381 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18383 /* First, we try to unify the PARM and ARG directly. */
18384 t
= try_class_unification (tparms
, targs
,
18385 parm
, arg
, explain_p
);
18389 /* Fallback to the special case allowed in
18390 [temp.deduct.call]:
18392 If P is a class, and P has the form
18393 template-id, then A can be a derived class of
18394 the deduced A. Likewise, if P is a pointer to
18395 a class of the form template-id, A can be a
18396 pointer to a derived class pointed to by the
18398 enum template_base_result r
;
18399 r
= get_template_base (tparms
, targs
, parm
, arg
,
18403 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18406 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18407 && (CLASSTYPE_TI_TEMPLATE (parm
)
18408 == CLASSTYPE_TI_TEMPLATE (arg
)))
18409 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18410 Then, we should unify `int' and `U'. */
18413 /* There's no chance of unification succeeding. */
18414 return unify_type_mismatch (explain_p
, parm
, arg
);
18416 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18417 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18419 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18420 return unify_type_mismatch (explain_p
, parm
, arg
);
18421 return unify_success (explain_p
);
18424 case FUNCTION_TYPE
:
18426 unsigned int nargs
;
18431 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18432 return unify_type_mismatch (explain_p
, parm
, arg
);
18434 /* CV qualifications for methods can never be deduced, they must
18435 match exactly. We need to check them explicitly here,
18436 because type_unification_real treats them as any other
18437 cv-qualified parameter. */
18438 if (TREE_CODE (parm
) == METHOD_TYPE
18439 && (!check_cv_quals_for_unify
18441 class_of_this_parm (arg
),
18442 class_of_this_parm (parm
))))
18443 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18445 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18446 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18448 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18449 args
= XALLOCAVEC (tree
, nargs
);
18450 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18451 a
!= NULL_TREE
&& a
!= void_list_node
;
18452 a
= TREE_CHAIN (a
), ++i
)
18453 args
[i
] = TREE_VALUE (a
);
18456 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18457 args
, nargs
, 1, DEDUCE_EXACT
,
18458 LOOKUP_NORMAL
, NULL
, explain_p
);
18462 /* Unify a pointer to member with a pointer to member function, which
18463 deduces the type of the member as a function type. */
18464 if (TYPE_PTRMEMFUNC_P (arg
))
18466 /* Check top-level cv qualifiers */
18467 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18468 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18470 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18471 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18472 UNIFY_ALLOW_NONE
, explain_p
);
18474 /* Determine the type of the function we are unifying against. */
18475 tree fntype
= static_fn_type (arg
);
18477 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18480 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18481 return unify_type_mismatch (explain_p
, parm
, arg
);
18482 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18483 TYPE_OFFSET_BASETYPE (arg
),
18484 UNIFY_ALLOW_NONE
, explain_p
);
18485 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18486 strict
, explain_p
);
18489 if (DECL_TEMPLATE_PARM_P (parm
))
18490 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18491 if (arg
!= scalar_constant_value (parm
))
18492 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18493 return unify_success (explain_p
);
18496 case TEMPLATE_DECL
:
18497 /* Matched cases are handled by the ARG == PARM test above. */
18498 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18501 /* A non-type template parameter that is a variable should be a
18502 an integral constant, in which case, it whould have been
18503 folded into its (constant) value. So we should not be getting
18504 a variable here. */
18505 gcc_unreachable ();
18507 case TYPE_ARGUMENT_PACK
:
18508 case NONTYPE_ARGUMENT_PACK
:
18509 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18510 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18513 case DECLTYPE_TYPE
:
18514 case UNDERLYING_TYPE
:
18515 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18516 or UNDERLYING_TYPE nodes. */
18517 return unify_success (explain_p
);
18520 /* Unification fails if we hit an error node. */
18521 return unify_invalid (explain_p
);
18524 if (REFERENCE_REF_P (parm
))
18526 if (REFERENCE_REF_P (arg
))
18527 arg
= TREE_OPERAND (arg
, 0);
18528 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18529 strict
, explain_p
);
18534 /* An unresolved overload is a nondeduced context. */
18535 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18536 return unify_success (explain_p
);
18537 gcc_assert (EXPR_P (parm
));
18539 /* We must be looking at an expression. This can happen with
18543 void foo(S<I>, S<I + 2>);
18545 This is a "nondeduced context":
18549 The nondeduced contexts are:
18551 --A type that is a template-id in which one or more of
18552 the template-arguments is an expression that references
18553 a template-parameter.
18555 In these cases, we assume deduction succeeded, but don't
18556 actually infer any unifications. */
18558 if (!uses_template_parms (parm
)
18559 && !template_args_equal (parm
, arg
))
18560 return unify_expression_unequal (explain_p
, parm
, arg
);
18562 return unify_success (explain_p
);
18565 #undef RECUR_AND_CHECK_FAILURE
18567 /* Note that DECL can be defined in this translation unit, if
18571 mark_definable (tree decl
)
18574 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18575 FOR_EACH_CLONE (clone
, decl
)
18576 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18579 /* Called if RESULT is explicitly instantiated, or is a member of an
18580 explicitly instantiated class. */
18583 mark_decl_instantiated (tree result
, int extern_p
)
18585 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18587 /* If this entity has already been written out, it's too late to
18588 make any modifications. */
18589 if (TREE_ASM_WRITTEN (result
))
18592 /* For anonymous namespace we don't need to do anything. */
18593 if (decl_anon_ns_mem_p (result
))
18595 gcc_assert (!TREE_PUBLIC (result
));
18599 if (TREE_CODE (result
) != FUNCTION_DECL
)
18600 /* The TREE_PUBLIC flag for function declarations will have been
18601 set correctly by tsubst. */
18602 TREE_PUBLIC (result
) = 1;
18604 /* This might have been set by an earlier implicit instantiation. */
18605 DECL_COMDAT (result
) = 0;
18608 DECL_NOT_REALLY_EXTERN (result
) = 0;
18611 mark_definable (result
);
18612 mark_needed (result
);
18613 /* Always make artificials weak. */
18614 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18615 comdat_linkage (result
);
18616 /* For WIN32 we also want to put explicit instantiations in
18617 linkonce sections. */
18618 else if (TREE_PUBLIC (result
))
18619 maybe_make_one_only (result
);
18622 /* If EXTERN_P, then this function will not be emitted -- unless
18623 followed by an explicit instantiation, at which point its linkage
18624 will be adjusted. If !EXTERN_P, then this function will be
18625 emitted here. In neither circumstance do we want
18626 import_export_decl to adjust the linkage. */
18627 DECL_INTERFACE_KNOWN (result
) = 1;
18630 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18631 important template arguments. If any are missing, we check whether
18632 they're important by using error_mark_node for substituting into any
18633 args that were used for partial ordering (the ones between ARGS and END)
18634 and seeing if it bubbles up. */
18637 check_undeduced_parms (tree targs
, tree args
, tree end
)
18639 bool found
= false;
18641 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18642 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18645 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18649 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18650 if (substed
== error_mark_node
)
18656 /* Given two function templates PAT1 and PAT2, return:
18658 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18659 -1 if PAT2 is more specialized than PAT1.
18660 0 if neither is more specialized.
18662 LEN indicates the number of parameters we should consider
18663 (defaulted parameters should not be considered).
18665 The 1998 std underspecified function template partial ordering, and
18666 DR214 addresses the issue. We take pairs of arguments, one from
18667 each of the templates, and deduce them against each other. One of
18668 the templates will be more specialized if all the *other*
18669 template's arguments deduce against its arguments and at least one
18670 of its arguments *does* *not* deduce against the other template's
18671 corresponding argument. Deduction is done as for class templates.
18672 The arguments used in deduction have reference and top level cv
18673 qualifiers removed. Iff both arguments were originally reference
18674 types *and* deduction succeeds in both directions, an lvalue reference
18675 wins against an rvalue reference and otherwise the template
18676 with the more cv-qualified argument wins for that pairing (if
18677 neither is more cv-qualified, they both are equal). Unlike regular
18678 deduction, after all the arguments have been deduced in this way,
18679 we do *not* verify the deduced template argument values can be
18680 substituted into non-deduced contexts.
18682 The logic can be a bit confusing here, because we look at deduce1 and
18683 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18684 can find template arguments for pat1 to make arg1 look like arg2, that
18685 means that arg2 is at least as specialized as arg1. */
18688 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18690 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18691 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18692 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18693 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18694 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18695 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18696 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18697 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18698 tree origs1
, origs2
;
18699 bool lose1
= false;
18700 bool lose2
= false;
18702 /* Remove the this parameter from non-static member functions. If
18703 one is a non-static member function and the other is not a static
18704 member function, remove the first parameter from that function
18705 also. This situation occurs for operator functions where we
18706 locate both a member function (with this pointer) and non-member
18707 operator (with explicit first operand). */
18708 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18710 len
--; /* LEN is the number of significant arguments for DECL1 */
18711 args1
= TREE_CHAIN (args1
);
18712 if (!DECL_STATIC_FUNCTION_P (decl2
))
18713 args2
= TREE_CHAIN (args2
);
18715 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18717 args2
= TREE_CHAIN (args2
);
18718 if (!DECL_STATIC_FUNCTION_P (decl1
))
18721 args1
= TREE_CHAIN (args1
);
18725 /* If only one is a conversion operator, they are unordered. */
18726 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18729 /* Consider the return type for a conversion function */
18730 if (DECL_CONV_FN_P (decl1
))
18732 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18733 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18737 processing_template_decl
++;
18743 /* Stop when an ellipsis is seen. */
18744 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18746 tree arg1
= TREE_VALUE (args1
);
18747 tree arg2
= TREE_VALUE (args2
);
18748 int deduce1
, deduce2
;
18754 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18755 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18757 /* When both arguments are pack expansions, we need only
18758 unify the patterns themselves. */
18759 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18760 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18762 /* This is the last comparison we need to do. */
18766 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18768 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18769 arg1
= TREE_TYPE (arg1
);
18770 quals1
= cp_type_quals (arg1
);
18773 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18775 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18776 arg2
= TREE_TYPE (arg2
);
18777 quals2
= cp_type_quals (arg2
);
18780 arg1
= TYPE_MAIN_VARIANT (arg1
);
18781 arg2
= TYPE_MAIN_VARIANT (arg2
);
18783 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18785 int i
, len2
= list_length (args2
);
18786 tree parmvec
= make_tree_vec (1);
18787 tree argvec
= make_tree_vec (len2
);
18790 /* Setup the parameter vector, which contains only ARG1. */
18791 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18793 /* Setup the argument vector, which contains the remaining
18795 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18796 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18798 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18799 argvec
, DEDUCE_EXACT
,
18800 /*subr=*/true, /*explain_p=*/false)
18803 /* We cannot deduce in the other direction, because ARG1 is
18804 a pack expansion but ARG2 is not. */
18807 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18809 int i
, len1
= list_length (args1
);
18810 tree parmvec
= make_tree_vec (1);
18811 tree argvec
= make_tree_vec (len1
);
18814 /* Setup the parameter vector, which contains only ARG1. */
18815 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18817 /* Setup the argument vector, which contains the remaining
18819 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18820 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18822 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18823 argvec
, DEDUCE_EXACT
,
18824 /*subr=*/true, /*explain_p=*/false)
18827 /* We cannot deduce in the other direction, because ARG2 is
18828 a pack expansion but ARG1 is not.*/
18834 /* The normal case, where neither argument is a pack
18836 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18837 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18839 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18840 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18844 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18845 arg2, then arg2 is not as specialized as arg1. */
18851 /* "If, for a given type, deduction succeeds in both directions
18852 (i.e., the types are identical after the transformations above)
18853 and both P and A were reference types (before being replaced with
18854 the type referred to above):
18855 - if the type from the argument template was an lvalue reference and
18856 the type from the parameter template was not, the argument type is
18857 considered to be more specialized than the other; otherwise,
18858 - if the type from the argument template is more cv-qualified
18859 than the type from the parameter template (as described above),
18860 the argument type is considered to be more specialized than the other;
18862 - neither type is more specialized than the other." */
18864 if (deduce1
&& deduce2
)
18866 if (ref1
&& ref2
&& ref1
!= ref2
)
18873 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
18875 if ((quals1
& quals2
) == quals2
)
18877 if ((quals1
& quals2
) == quals1
)
18882 if (lose1
&& lose2
)
18883 /* We've failed to deduce something in either direction.
18884 These must be unordered. */
18887 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18888 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18889 /* We have already processed all of the arguments in our
18890 handing of the pack expansion type. */
18893 args1
= TREE_CHAIN (args1
);
18894 args2
= TREE_CHAIN (args2
);
18897 /* "In most cases, all template parameters must have values in order for
18898 deduction to succeed, but for partial ordering purposes a template
18899 parameter may remain without a value provided it is not used in the
18900 types being used for partial ordering."
18902 Thus, if we are missing any of the targs1 we need to substitute into
18903 origs1, then pat2 is not as specialized as pat1. This can happen when
18904 there is a nondeduced context. */
18905 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
18907 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
18910 processing_template_decl
--;
18912 /* All things being equal, if the next argument is a pack expansion
18913 for one function but not for the other, prefer the
18914 non-variadic function. FIXME this is bogus; see c++/41958. */
18916 && args1
&& TREE_VALUE (args1
)
18917 && args2
&& TREE_VALUE (args2
))
18919 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
18920 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
18923 if (lose1
== lose2
)
18931 /* Determine which of two partial specializations of TMPL is more
18934 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
18935 to the first partial specialization. The TREE_PURPOSE is the
18936 innermost set of template parameters for the partial
18937 specialization. PAT2 is similar, but for the second template.
18939 Return 1 if the first partial specialization is more specialized;
18940 -1 if the second is more specialized; 0 if neither is more
18943 See [temp.class.order] for information about determining which of
18944 two templates is more specialized. */
18947 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
18951 bool any_deductions
= false;
18953 tree tmpl1
= TREE_VALUE (pat1
);
18954 tree tmpl2
= TREE_VALUE (pat2
);
18955 tree parms1
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl1
);
18956 tree parms2
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl2
);
18957 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
18958 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
18960 /* Just like what happens for functions, if we are ordering between
18961 different template specializations, we may encounter dependent
18962 types in the arguments, and we need our dependency check functions
18963 to behave correctly. */
18964 ++processing_template_decl
;
18965 targs
= get_partial_spec_bindings (tmpl
, parms1
, specargs1
, specargs2
);
18969 any_deductions
= true;
18972 targs
= get_partial_spec_bindings (tmpl
, parms2
, specargs2
, specargs1
);
18976 any_deductions
= true;
18978 --processing_template_decl
;
18980 /* In the case of a tie where at least one of the templates
18981 has a parameter pack at the end, the template with the most
18982 non-packed parameters wins. */
18985 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
18986 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
18988 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
18989 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
18990 int len1
= TREE_VEC_LENGTH (args1
);
18991 int len2
= TREE_VEC_LENGTH (args2
);
18993 /* We don't count the pack expansion at the end. */
18994 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
18996 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
19001 else if (len1
< len2
)
19008 /* Return the template arguments that will produce the function signature
19009 DECL from the function template FN, with the explicit template
19010 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
19011 also match. Return NULL_TREE if no satisfactory arguments could be
19015 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
19017 int ntparms
= DECL_NTPARMS (fn
);
19018 tree targs
= make_tree_vec (ntparms
);
19019 tree decl_type
= TREE_TYPE (decl
);
19020 tree decl_arg_types
;
19022 unsigned int nargs
, ix
;
19025 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
19027 /* Never do unification on the 'this' parameter. */
19028 decl_arg_types
= skip_artificial_parms_for (decl
,
19029 TYPE_ARG_TYPES (decl_type
));
19031 nargs
= list_length (decl_arg_types
);
19032 args
= XALLOCAVEC (tree
, nargs
);
19033 for (arg
= decl_arg_types
, ix
= 0;
19034 arg
!= NULL_TREE
&& arg
!= void_list_node
;
19035 arg
= TREE_CHAIN (arg
), ++ix
)
19036 args
[ix
] = TREE_VALUE (arg
);
19038 if (fn_type_unification (fn
, explicit_args
, targs
,
19040 (check_rettype
|| DECL_CONV_FN_P (fn
)
19041 ? TREE_TYPE (decl_type
) : NULL_TREE
),
19042 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
19044 == error_mark_node
)
19050 /* Return the innermost template arguments that, when applied to a partial
19051 specialization of TMPL whose innermost template parameters are
19052 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
19055 For example, suppose we have:
19057 template <class T, class U> struct S {};
19058 template <class T> struct S<T*, int> {};
19060 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
19061 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
19062 int}. The resulting vector will be {double}, indicating that `T'
19063 is bound to `double'. */
19066 get_partial_spec_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
19068 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
19070 tree innermost_deduced_args
;
19072 innermost_deduced_args
= make_tree_vec (ntparms
);
19073 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19075 deduced_args
= copy_node (args
);
19076 SET_TMPL_ARGS_LEVEL (deduced_args
,
19077 TMPL_ARGS_DEPTH (deduced_args
),
19078 innermost_deduced_args
);
19081 deduced_args
= innermost_deduced_args
;
19083 if (unify (tparms
, deduced_args
,
19084 INNERMOST_TEMPLATE_ARGS (spec_args
),
19085 INNERMOST_TEMPLATE_ARGS (args
),
19086 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
19089 for (i
= 0; i
< ntparms
; ++i
)
19090 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
19093 /* Verify that nondeduced template arguments agree with the type
19094 obtained from argument deduction.
19098 struct A { typedef int X; };
19099 template <class T, class U> struct C {};
19100 template <class T> struct C<T, typename T::X> {};
19102 Then with the instantiation `C<A, int>', we can deduce that
19103 `T' is `A' but unify () does not check whether `typename T::X'
19105 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
19106 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19108 tf_none
, false, false);
19109 if (spec_args
== error_mark_node
19110 /* We only need to check the innermost arguments; the other
19111 arguments will always agree. */
19112 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
19113 INNERMOST_TEMPLATE_ARGS (args
)))
19116 /* Now that we have bindings for all of the template arguments,
19117 ensure that the arguments deduced for the template template
19118 parameters have compatible template parameter lists. See the use
19119 of template_template_parm_bindings_ok_p in fn_type_unification
19120 for more information. */
19121 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
19124 return deduced_args
;
19127 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19128 Return the TREE_LIST node with the most specialized template, if
19129 any. If there is no most specialized template, the error_mark_node
19132 Note that this function does not look at, or modify, the
19133 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19134 returned is one of the elements of INSTANTIATIONS, callers may
19135 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19136 and retrieve it from the value returned. */
19139 most_specialized_instantiation (tree templates
)
19143 ++processing_template_decl
;
19146 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
19150 if (get_bindings (TREE_VALUE (champ
),
19151 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19152 NULL_TREE
, /*check_ret=*/true))
19155 if (get_bindings (TREE_VALUE (fn
),
19156 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19157 NULL_TREE
, /*check_ret=*/true))
19164 /* Equally specialized, move to next function. If there
19165 is no next function, nothing's most specialized. */
19166 fn
= TREE_CHAIN (fn
);
19174 /* Now verify that champ is better than everything earlier in the
19175 instantiation list. */
19176 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
19177 if (get_bindings (TREE_VALUE (champ
),
19178 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19179 NULL_TREE
, /*check_ret=*/true)
19180 || !get_bindings (TREE_VALUE (fn
),
19181 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19182 NULL_TREE
, /*check_ret=*/true))
19188 processing_template_decl
--;
19191 return error_mark_node
;
19196 /* If DECL is a specialization of some template, return the most
19197 general such template. Otherwise, returns NULL_TREE.
19199 For example, given:
19201 template <class T> struct S { template <class U> void f(U); };
19203 if TMPL is `template <class U> void S<int>::f(U)' this will return
19204 the full template. This function will not trace past partial
19205 specializations, however. For example, given in addition:
19207 template <class T> struct S<T*> { template <class U> void f(U); };
19209 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19210 `template <class T> template <class U> S<T*>::f(U)'. */
19213 most_general_template (tree decl
)
19215 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19217 if (tree tinfo
= get_template_info (decl
))
19218 decl
= TI_TEMPLATE (tinfo
);
19219 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19220 template friend, or a FIELD_DECL for a capture pack. */
19221 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19225 /* Look for more and more general templates. */
19226 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
19228 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19229 (See cp-tree.h for details.) */
19230 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
19233 if (CLASS_TYPE_P (TREE_TYPE (decl
))
19234 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
19235 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
19238 /* Stop if we run into an explicitly specialized class template. */
19239 if (!DECL_NAMESPACE_SCOPE_P (decl
)
19240 && DECL_CONTEXT (decl
)
19241 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
19244 decl
= DECL_TI_TEMPLATE (decl
);
19250 /* Return the most specialized of the template partial specializations
19251 which can produce TARGET, a specialization of some class or variable
19252 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
19253 a TEMPLATE_DECL node corresponding to the partial specialization, while
19254 the TREE_PURPOSE is the set of template arguments that must be
19255 substituted into the template pattern in order to generate TARGET.
19257 If the choice of partial specialization is ambiguous, a diagnostic
19258 is issued, and the error_mark_node is returned. If there are no
19259 partial specializations matching TARGET, then NULL_TREE is
19260 returned, indicating that the primary template should be used. */
19263 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
19265 tree list
= NULL_TREE
;
19270 tree outer_args
= NULL_TREE
;
19273 if (TYPE_P (target
))
19275 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
19276 tmpl
= TI_TEMPLATE (tinfo
);
19277 args
= TI_ARGS (tinfo
);
19279 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
19281 tmpl
= TREE_OPERAND (target
, 0);
19282 args
= TREE_OPERAND (target
, 1);
19284 else if (VAR_P (target
))
19286 tree tinfo
= DECL_TEMPLATE_INFO (target
);
19287 tmpl
= TI_TEMPLATE (tinfo
);
19288 args
= TI_ARGS (tinfo
);
19291 gcc_unreachable ();
19293 tree main_tmpl
= most_general_template (tmpl
);
19295 /* For determining which partial specialization to use, only the
19296 innermost args are interesting. */
19297 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19299 outer_args
= strip_innermost_template_args (args
, 1);
19300 args
= INNERMOST_TEMPLATE_ARGS (args
);
19303 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
19305 tree partial_spec_args
;
19307 tree spec_tmpl
= TREE_VALUE (t
);
19309 partial_spec_args
= TREE_PURPOSE (t
);
19311 ++processing_template_decl
;
19315 /* Discard the outer levels of args, and then substitute in the
19316 template args from the enclosing class. */
19317 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19318 partial_spec_args
= tsubst_template_args
19319 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19321 /* And the same for the partial specialization TEMPLATE_DECL. */
19322 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19325 partial_spec_args
=
19326 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19329 /*require_all_args=*/true,
19330 /*use_default_args=*/true);
19332 --processing_template_decl
;
19334 if (partial_spec_args
== error_mark_node
)
19335 return error_mark_node
;
19336 if (spec_tmpl
== error_mark_node
)
19337 return error_mark_node
;
19339 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19340 spec_args
= get_partial_spec_bindings (tmpl
, parms
,
19346 spec_args
= add_to_template_args (outer_args
, spec_args
);
19347 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
19348 TREE_TYPE (list
) = TREE_TYPE (t
);
19355 ambiguous_p
= false;
19358 t
= TREE_CHAIN (t
);
19359 for (; t
; t
= TREE_CHAIN (t
))
19361 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19368 t
= TREE_CHAIN (t
);
19371 ambiguous_p
= true;
19380 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19382 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19385 ambiguous_p
= true;
19393 char *spaces
= NULL
;
19394 if (!(complain
& tf_error
))
19395 return error_mark_node
;
19396 if (TYPE_P (target
))
19397 error ("ambiguous template instantiation for %q#T", target
);
19399 error ("ambiguous template instantiation for %q#D", target
);
19400 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19401 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19403 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
19404 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
19405 "%s %#S", spaces
? spaces
: str
, subst
);
19406 spaces
= spaces
? spaces
: get_spaces (str
);
19409 return error_mark_node
;
19415 /* Explicitly instantiate DECL. */
19418 do_decl_instantiation (tree decl
, tree storage
)
19420 tree result
= NULL_TREE
;
19423 if (!decl
|| decl
== error_mark_node
)
19424 /* An error occurred, for which grokdeclarator has already issued
19425 an appropriate message. */
19427 else if (! DECL_LANG_SPECIFIC (decl
))
19429 error ("explicit instantiation of non-template %q#D", decl
);
19433 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
19434 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
19436 if (VAR_P (decl
) && !var_templ
)
19438 /* There is an asymmetry here in the way VAR_DECLs and
19439 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19440 the latter, the DECL we get back will be marked as a
19441 template instantiation, and the appropriate
19442 DECL_TEMPLATE_INFO will be set up. This does not happen for
19443 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19444 should handle VAR_DECLs as it currently handles
19446 if (!DECL_CLASS_SCOPE_P (decl
))
19448 error ("%qD is not a static data member of a class template", decl
);
19451 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19452 if (!result
|| !VAR_P (result
))
19454 error ("no matching template for %qD found", decl
);
19457 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19459 error ("type %qT for explicit instantiation %qD does not match "
19460 "declared type %qT", TREE_TYPE (result
), decl
,
19465 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
19467 error ("explicit instantiation of %q#D", decl
);
19473 /* Check for various error cases. Note that if the explicit
19474 instantiation is valid the RESULT will currently be marked as an
19475 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19476 until we get here. */
19478 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19480 /* DR 259 [temp.spec].
19482 Both an explicit instantiation and a declaration of an explicit
19483 specialization shall not appear in a program unless the explicit
19484 instantiation follows a declaration of the explicit specialization.
19486 For a given set of template parameters, if an explicit
19487 instantiation of a template appears after a declaration of an
19488 explicit specialization for that template, the explicit
19489 instantiation has no effect. */
19492 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19496 No program shall explicitly instantiate any template more
19499 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19500 the first instantiation was `extern' and the second is not,
19501 and EXTERN_P for the opposite case. */
19502 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19503 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19504 /* If an "extern" explicit instantiation follows an ordinary
19505 explicit instantiation, the template is instantiated. */
19509 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19511 error ("no matching template for %qD found", result
);
19514 else if (!DECL_TEMPLATE_INFO (result
))
19516 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19520 if (storage
== NULL_TREE
)
19522 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19524 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19525 pedwarn (input_location
, OPT_Wpedantic
,
19526 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19531 error ("storage class %qD applied to template instantiation", storage
);
19533 check_explicit_instantiation_namespace (result
);
19534 mark_decl_instantiated (result
, extern_p
);
19536 instantiate_decl (result
, /*defer_ok=*/1,
19537 /*expl_inst_class_mem_p=*/false);
19541 mark_class_instantiated (tree t
, int extern_p
)
19543 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19544 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19545 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19546 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19549 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19550 rest_of_type_compilation (t
, 1);
19554 /* Called from do_type_instantiation through binding_table_foreach to
19555 do recursive instantiation for the type bound in ENTRY. */
19557 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19559 tree storage
= *(tree
*) data
;
19561 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19562 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19563 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19566 /* Called from do_type_instantiation to instantiate a member
19567 (a member function or a static member variable) of an
19568 explicitly instantiated class template. */
19570 instantiate_class_member (tree decl
, int extern_p
)
19572 mark_decl_instantiated (decl
, extern_p
);
19574 instantiate_decl (decl
, /*defer_ok=*/1,
19575 /*expl_inst_class_mem_p=*/true);
19578 /* Perform an explicit instantiation of template class T. STORAGE, if
19579 non-null, is the RID for extern, inline or static. COMPLAIN is
19580 nonzero if this is called from the parser, zero if called recursively,
19581 since the standard is unclear (as detailed below). */
19584 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19589 int previous_instantiation_extern_p
= 0;
19591 if (TREE_CODE (t
) == TYPE_DECL
)
19594 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19597 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19599 error ("explicit instantiation of non-class template %qD", tmpl
);
19601 error ("explicit instantiation of non-template type %qT", t
);
19607 if (!COMPLETE_TYPE_P (t
))
19609 if (complain
& tf_error
)
19610 error ("explicit instantiation of %q#T before definition of template",
19615 if (storage
!= NULL_TREE
)
19617 if (!in_system_header_at (input_location
))
19619 if (storage
== ridpointers
[(int) RID_EXTERN
])
19621 if (cxx_dialect
== cxx98
)
19622 pedwarn (input_location
, OPT_Wpedantic
,
19623 "ISO C++ 1998 forbids the use of %<extern%> on "
19624 "explicit instantiations");
19627 pedwarn (input_location
, OPT_Wpedantic
,
19628 "ISO C++ forbids the use of %qE"
19629 " on explicit instantiations", storage
);
19632 if (storage
== ridpointers
[(int) RID_INLINE
])
19634 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19636 else if (storage
== ridpointers
[(int) RID_STATIC
])
19640 error ("storage class %qD applied to template instantiation",
19646 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19648 /* DR 259 [temp.spec].
19650 Both an explicit instantiation and a declaration of an explicit
19651 specialization shall not appear in a program unless the explicit
19652 instantiation follows a declaration of the explicit specialization.
19654 For a given set of template parameters, if an explicit
19655 instantiation of a template appears after a declaration of an
19656 explicit specialization for that template, the explicit
19657 instantiation has no effect. */
19660 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19664 No program shall explicitly instantiate any template more
19667 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19668 instantiation was `extern'. If EXTERN_P then the second is.
19669 These cases are OK. */
19670 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19672 if (!previous_instantiation_extern_p
&& !extern_p
19673 && (complain
& tf_error
))
19674 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19676 /* If we've already instantiated the template, just return now. */
19677 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19681 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19682 mark_class_instantiated (t
, extern_p
);
19690 /* In contrast to implicit instantiation, where only the
19691 declarations, and not the definitions, of members are
19692 instantiated, we have here:
19696 The explicit instantiation of a class template specialization
19697 implies the instantiation of all of its members not
19698 previously explicitly specialized in the translation unit
19699 containing the explicit instantiation.
19701 Of course, we can't instantiate member template classes, since
19702 we don't have any arguments for them. Note that the standard
19703 is unclear on whether the instantiation of the members are
19704 *explicit* instantiations or not. However, the most natural
19705 interpretation is that it should be an explicit instantiation. */
19708 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19709 if (TREE_CODE (tmp
) == FUNCTION_DECL
19710 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19711 instantiate_class_member (tmp
, extern_p
);
19713 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19714 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19715 instantiate_class_member (tmp
, extern_p
);
19717 if (CLASSTYPE_NESTED_UTDS (t
))
19718 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19719 bt_instantiate_type_proc
, &storage
);
19723 /* Given a function DECL, which is a specialization of TMPL, modify
19724 DECL to be a re-instantiation of TMPL with the same template
19725 arguments. TMPL should be the template into which tsubst'ing
19726 should occur for DECL, not the most general template.
19728 One reason for doing this is a scenario like this:
19731 void f(const T&, int i);
19733 void g() { f(3, 7); }
19736 void f(const T& t, const int i) { }
19738 Note that when the template is first instantiated, with
19739 instantiate_template, the resulting DECL will have no name for the
19740 first parameter, and the wrong type for the second. So, when we go
19741 to instantiate the DECL, we regenerate it. */
19744 regenerate_decl_from_template (tree decl
, tree tmpl
)
19746 /* The arguments used to instantiate DECL, from the most general
19751 args
= DECL_TI_ARGS (decl
);
19752 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19754 /* Make sure that we can see identifiers, and compute access
19756 push_access_scope (decl
);
19758 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19766 args_depth
= TMPL_ARGS_DEPTH (args
);
19767 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19768 if (args_depth
> parms_depth
)
19769 args
= get_innermost_template_args (args
, parms_depth
);
19771 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19772 args
, tf_error
, NULL_TREE
,
19773 /*defer_ok*/false);
19774 if (specs
&& specs
!= error_mark_node
)
19775 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19778 /* Merge parameter declarations. */
19779 decl_parm
= skip_artificial_parms_for (decl
,
19780 DECL_ARGUMENTS (decl
));
19782 = skip_artificial_parms_for (code_pattern
,
19783 DECL_ARGUMENTS (code_pattern
));
19784 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19789 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19790 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19791 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19793 parm_type
= type_decays_to (parm_type
);
19794 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19795 TREE_TYPE (decl_parm
) = parm_type
;
19796 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19797 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19799 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19800 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19802 decl_parm
= DECL_CHAIN (decl_parm
);
19803 pattern_parm
= DECL_CHAIN (pattern_parm
);
19805 /* Merge any parameters that match with the function parameter
19807 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19810 tree expanded_types
;
19811 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19812 the parameters in this function parameter pack. */
19813 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19814 args
, tf_error
, NULL_TREE
);
19815 len
= TREE_VEC_LENGTH (expanded_types
);
19816 for (i
= 0; i
< len
; i
++)
19821 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19822 /* Rename the parameter to include the index. */
19823 DECL_NAME (decl_parm
) =
19824 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19825 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19826 parm_type
= type_decays_to (parm_type
);
19827 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19828 TREE_TYPE (decl_parm
) = parm_type
;
19829 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19830 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19832 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19833 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19835 decl_parm
= DECL_CHAIN (decl_parm
);
19838 /* Merge additional specifiers from the CODE_PATTERN. */
19839 if (DECL_DECLARED_INLINE_P (code_pattern
)
19840 && !DECL_DECLARED_INLINE_P (decl
))
19841 DECL_DECLARED_INLINE_P (decl
) = 1;
19843 else if (VAR_P (decl
))
19845 DECL_INITIAL (decl
) =
19846 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19847 tf_error
, DECL_TI_TEMPLATE (decl
),
19848 /*integral_constant_expression_p=*/false);
19849 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19850 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19851 tf_error
, DECL_TI_TEMPLATE (decl
));
19854 gcc_unreachable ();
19856 pop_access_scope (decl
);
19859 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19860 substituted to get DECL. */
19863 template_for_substitution (tree decl
)
19865 tree tmpl
= DECL_TI_TEMPLATE (decl
);
19867 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19868 for the instantiation. This is not always the most general
19869 template. Consider, for example:
19872 struct S { template <class U> void f();
19873 template <> void f<int>(); };
19875 and an instantiation of S<double>::f<int>. We want TD to be the
19876 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19877 while (/* An instantiation cannot have a definition, so we need a
19878 more general template. */
19879 DECL_TEMPLATE_INSTANTIATION (tmpl
)
19880 /* We must also deal with friend templates. Given:
19882 template <class T> struct S {
19883 template <class U> friend void f() {};
19886 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19887 so far as the language is concerned, but that's still
19888 where we get the pattern for the instantiation from. On
19889 other hand, if the definition comes outside the class, say:
19891 template <class T> struct S {
19892 template <class U> friend void f();
19894 template <class U> friend void f() {}
19896 we don't need to look any further. That's what the check for
19897 DECL_INITIAL is for. */
19898 || (TREE_CODE (decl
) == FUNCTION_DECL
19899 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
19900 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
19902 /* The present template, TD, should not be a definition. If it
19903 were a definition, we should be using it! Note that we
19904 cannot restructure the loop to just keep going until we find
19905 a template with a definition, since that might go too far if
19906 a specialization was declared, but not defined. */
19908 /* Fetch the more general template. */
19909 tmpl
= DECL_TI_TEMPLATE (tmpl
);
19915 /* Returns true if we need to instantiate this template instance even if we
19916 know we aren't going to emit it.. */
19919 always_instantiate_p (tree decl
)
19921 /* We always instantiate inline functions so that we can inline them. An
19922 explicit instantiation declaration prohibits implicit instantiation of
19923 non-inline functions. With high levels of optimization, we would
19924 normally inline non-inline functions -- but we're not allowed to do
19925 that for "extern template" functions. Therefore, we check
19926 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19927 return ((TREE_CODE (decl
) == FUNCTION_DECL
19928 && (DECL_DECLARED_INLINE_P (decl
)
19929 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
19930 /* And we need to instantiate static data members so that
19931 their initializers are available in integral constant
19934 && decl_maybe_constant_var_p (decl
)));
19937 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19938 instantiate it now, modifying TREE_TYPE (fn). */
19941 maybe_instantiate_noexcept (tree fn
)
19943 tree fntype
, spec
, noex
, clone
;
19945 /* Don't instantiate a noexcept-specification from template context. */
19946 if (processing_template_decl
)
19949 if (DECL_CLONED_FUNCTION_P (fn
))
19950 fn
= DECL_CLONED_FUNCTION (fn
);
19951 fntype
= TREE_TYPE (fn
);
19952 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
19954 if (!spec
|| !TREE_PURPOSE (spec
))
19957 noex
= TREE_PURPOSE (spec
);
19959 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
19961 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
19962 spec
= get_defaulted_eh_spec (fn
);
19963 else if (push_tinst_level (fn
))
19965 push_access_scope (fn
);
19966 push_deferring_access_checks (dk_no_deferred
);
19967 input_location
= DECL_SOURCE_LOCATION (fn
);
19968 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
19969 DEFERRED_NOEXCEPT_ARGS (noex
),
19970 tf_warning_or_error
, fn
,
19971 /*function_p=*/false,
19972 /*integral_constant_expression_p=*/true);
19973 pop_deferring_access_checks ();
19974 pop_access_scope (fn
);
19975 pop_tinst_level ();
19976 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
19977 if (spec
== error_mark_node
)
19978 spec
= noexcept_false_spec
;
19981 spec
= noexcept_false_spec
;
19983 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
19986 FOR_EACH_CLONE (clone
, fn
)
19988 if (TREE_TYPE (clone
) == fntype
)
19989 TREE_TYPE (clone
) = TREE_TYPE (fn
);
19991 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
19995 /* Produce the definition of D, a _DECL generated from a template. If
19996 DEFER_OK is nonzero, then we don't have to actually do the
19997 instantiation now; we just have to do it sometime. Normally it is
19998 an error if this is an explicit instantiation but D is undefined.
19999 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
20000 explicitly instantiated class template. */
20003 instantiate_decl (tree d
, int defer_ok
,
20004 bool expl_inst_class_mem_p
)
20006 tree tmpl
= DECL_TI_TEMPLATE (d
);
20013 bool pattern_defined
;
20014 location_t saved_loc
= input_location
;
20015 int saved_unevaluated_operand
= cp_unevaluated_operand
;
20016 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
20022 /* This function should only be used to instantiate templates for
20023 functions and static member variables. */
20024 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
20026 /* Variables are never deferred; if instantiation is required, they
20027 are instantiated right away. That allows for better code in the
20028 case that an expression refers to the value of the variable --
20029 if the variable has a constant value the referring expression can
20030 take advantage of that fact. */
20032 || DECL_DECLARED_CONSTEXPR_P (d
))
20035 /* Don't instantiate cloned functions. Instead, instantiate the
20036 functions they cloned. */
20037 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
20038 d
= DECL_CLONED_FUNCTION (d
);
20040 if (DECL_TEMPLATE_INSTANTIATED (d
)
20041 || (TREE_CODE (d
) == FUNCTION_DECL
20042 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
20043 || DECL_TEMPLATE_SPECIALIZATION (d
))
20044 /* D has already been instantiated or explicitly specialized, so
20045 there's nothing for us to do here.
20047 It might seem reasonable to check whether or not D is an explicit
20048 instantiation, and, if so, stop here. But when an explicit
20049 instantiation is deferred until the end of the compilation,
20050 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
20051 the instantiation. */
20054 /* Check to see whether we know that this template will be
20055 instantiated in some other file, as with "extern template"
20057 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
20059 /* In general, we do not instantiate such templates. */
20060 if (external_p
&& !always_instantiate_p (d
))
20063 gen_tmpl
= most_general_template (tmpl
);
20064 gen_args
= DECL_TI_ARGS (d
);
20066 if (tmpl
!= gen_tmpl
)
20067 /* We should already have the extra args. */
20068 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
20069 == TMPL_ARGS_DEPTH (gen_args
));
20070 /* And what's in the hash table should match D. */
20071 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
20072 || spec
== NULL_TREE
);
20074 /* This needs to happen before any tsubsting. */
20075 if (! push_tinst_level (d
))
20078 timevar_push (TV_TEMPLATE_INST
);
20080 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
20081 for the instantiation. */
20082 td
= template_for_substitution (d
);
20083 code_pattern
= DECL_TEMPLATE_RESULT (td
);
20085 /* We should never be trying to instantiate a member of a class
20086 template or partial specialization. */
20087 gcc_assert (d
!= code_pattern
);
20089 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
20090 || DECL_TEMPLATE_SPECIALIZATION (td
))
20091 /* In the case of a friend template whose definition is provided
20092 outside the class, we may have too many arguments. Drop the
20093 ones we don't need. The same is true for specializations. */
20094 args
= get_innermost_template_args
20095 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
20099 if (TREE_CODE (d
) == FUNCTION_DECL
)
20101 deleted_p
= DECL_DELETED_FN (code_pattern
);
20102 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
20103 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
20109 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
20112 /* We may be in the middle of deferred access check. Disable it now. */
20113 push_deferring_access_checks (dk_no_deferred
);
20115 /* Unless an explicit instantiation directive has already determined
20116 the linkage of D, remember that a definition is available for
20118 if (pattern_defined
20119 && !DECL_INTERFACE_KNOWN (d
)
20120 && !DECL_NOT_REALLY_EXTERN (d
))
20121 mark_definable (d
);
20123 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
20124 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
20125 input_location
= DECL_SOURCE_LOCATION (d
);
20127 /* If D is a member of an explicitly instantiated class template,
20128 and no definition is available, treat it like an implicit
20130 if (!pattern_defined
&& expl_inst_class_mem_p
20131 && DECL_EXPLICIT_INSTANTIATION (d
))
20133 /* Leave linkage flags alone on instantiations with anonymous
20135 if (TREE_PUBLIC (d
))
20137 DECL_NOT_REALLY_EXTERN (d
) = 0;
20138 DECL_INTERFACE_KNOWN (d
) = 0;
20140 SET_DECL_IMPLICIT_INSTANTIATION (d
);
20143 /* Defer all other templates, unless we have been explicitly
20144 forbidden from doing so. */
20145 if (/* If there is no definition, we cannot instantiate the
20148 /* If it's OK to postpone instantiation, do so. */
20150 /* If this is a static data member that will be defined
20151 elsewhere, we don't want to instantiate the entire data
20152 member, but we do want to instantiate the initializer so that
20153 we can substitute that elsewhere. */
20154 || (external_p
&& VAR_P (d
))
20155 /* Handle here a deleted function too, avoid generating
20156 its body (c++/61080). */
20159 /* The definition of the static data member is now required so
20160 we must substitute the initializer. */
20162 && !DECL_INITIAL (d
)
20163 && DECL_INITIAL (code_pattern
))
20167 bool const_init
= false;
20168 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20170 ns
= decl_namespace_context (d
);
20171 push_nested_namespace (ns
);
20173 push_nested_class (DECL_CONTEXT (d
));
20174 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
20176 tf_warning_or_error
, NULL_TREE
,
20177 /*integral_constant_expression_p=*/false);
20178 /* If instantiating the initializer involved instantiating this
20179 again, don't call cp_finish_decl twice. */
20180 if (!DECL_INITIAL (d
))
20182 /* Make sure the initializer is still constant, in case of
20183 circular dependency (template/instantiate6.C). */
20185 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20186 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
20187 /*asmspec_tree=*/NULL_TREE
,
20188 LOOKUP_ONLYCONVERTING
);
20191 pop_nested_class ();
20192 pop_nested_namespace (ns
);
20195 /* We restore the source position here because it's used by
20196 add_pending_template. */
20197 input_location
= saved_loc
;
20199 if (at_eof
&& !pattern_defined
20200 && DECL_EXPLICIT_INSTANTIATION (d
)
20201 && DECL_NOT_REALLY_EXTERN (d
))
20204 The definition of a non-exported function template, a
20205 non-exported member function template, or a non-exported
20206 member function or static data member of a class template
20207 shall be present in every translation unit in which it is
20208 explicitly instantiated. */
20209 permerror (input_location
, "explicit instantiation of %qD "
20210 "but no definition available", d
);
20212 /* If we're in unevaluated context, we just wanted to get the
20213 constant value; this isn't an odr use, so don't queue
20214 a full instantiation. */
20215 if (cp_unevaluated_operand
!= 0)
20217 /* ??? Historically, we have instantiated inline functions, even
20218 when marked as "extern template". */
20219 if (!(external_p
&& VAR_P (d
)))
20220 add_pending_template (d
);
20223 /* Tell the repository that D is available in this translation unit
20224 -- and see if it is supposed to be instantiated here. */
20225 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
20227 /* In a PCH file, despite the fact that the repository hasn't
20228 requested instantiation in the PCH it is still possible that
20229 an instantiation will be required in a file that includes the
20232 add_pending_template (d
);
20233 /* Instantiate inline functions so that the inliner can do its
20234 job, even though we'll not be emitting a copy of this
20236 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
20240 fn_context
= decl_function_context (d
);
20241 nested
= (current_function_decl
!= NULL_TREE
);
20243 push_to_top_level ();
20247 push_function_context ();
20248 cp_unevaluated_operand
= 0;
20249 c_inhibit_evaluation_warnings
= 0;
20252 /* Mark D as instantiated so that recursive calls to
20253 instantiate_decl do not try to instantiate it again. */
20254 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
20256 /* Regenerate the declaration in case the template has been modified
20257 by a subsequent redeclaration. */
20258 regenerate_decl_from_template (d
, td
);
20260 /* We already set the file and line above. Reset them now in case
20261 they changed as a result of calling regenerate_decl_from_template. */
20262 input_location
= DECL_SOURCE_LOCATION (d
);
20267 bool const_init
= false;
20269 /* Clear out DECL_RTL; whatever was there before may not be right
20270 since we've reset the type of the declaration. */
20271 SET_DECL_RTL (d
, NULL
);
20272 DECL_IN_AGGR_P (d
) = 0;
20274 /* The initializer is placed in DECL_INITIAL by
20275 regenerate_decl_from_template so we don't need to
20276 push/pop_access_scope again here. Pull it out so that
20277 cp_finish_decl can process it. */
20278 init
= DECL_INITIAL (d
);
20279 DECL_INITIAL (d
) = NULL_TREE
;
20280 DECL_INITIALIZED_P (d
) = 0;
20282 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20283 initializer. That function will defer actual emission until
20284 we have a chance to determine linkage. */
20285 DECL_EXTERNAL (d
) = 0;
20287 /* Enter the scope of D so that access-checking works correctly. */
20288 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20290 push_nested_class (DECL_CONTEXT (d
));
20292 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20293 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
20296 pop_nested_class ();
20298 if (variable_template_p (td
))
20299 note_variable_template_instantiation (d
);
20301 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
20302 synthesize_method (d
);
20303 else if (TREE_CODE (d
) == FUNCTION_DECL
)
20305 hash_map
<tree
, tree
> *saved_local_specializations
;
20309 tree block
= NULL_TREE
;
20311 /* Save away the current list, in case we are instantiating one
20312 template from within the body of another. */
20313 saved_local_specializations
= local_specializations
;
20315 /* Set up the list of local specializations. */
20316 local_specializations
= new hash_map
<tree
, tree
>;
20318 /* Set up context. */
20319 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20320 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20321 block
= push_stmt_list ();
20323 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
20325 /* Some typedefs referenced from within the template code need to be
20326 access checked at template instantiation time, i.e now. These
20327 types were added to the template at parsing time. Let's get those
20328 and perform the access checks then. */
20329 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20332 /* Create substitution entries for the parameters. */
20333 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20334 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20335 spec_parm
= DECL_ARGUMENTS (d
);
20336 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20338 register_local_specialization (spec_parm
, tmpl_parm
);
20339 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20340 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20342 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20344 if (!DECL_PACK_P (tmpl_parm
))
20346 register_local_specialization (spec_parm
, tmpl_parm
);
20347 spec_parm
= DECL_CHAIN (spec_parm
);
20351 /* Register the (value) argument pack as a specialization of
20352 TMPL_PARM, then move on. */
20353 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20354 register_local_specialization (argpack
, tmpl_parm
);
20357 gcc_assert (!spec_parm
);
20359 /* Substitute into the body of the function. */
20360 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20361 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20362 tf_warning_or_error
, tmpl
);
20365 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20366 tf_warning_or_error
, tmpl
,
20367 /*integral_constant_expression_p=*/false);
20369 /* Set the current input_location to the end of the function
20370 so that finish_function knows where we are. */
20372 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20374 /* Remember if we saw an infinite loop in the template. */
20375 current_function_infinite_loop
20376 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20379 /* We don't need the local specializations any more. */
20380 delete local_specializations
;
20381 local_specializations
= saved_local_specializations
;
20383 /* Finish the function. */
20384 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20385 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20386 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20389 d
= finish_function (0);
20390 expand_or_defer_fn (d
);
20393 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20394 cp_check_omp_declare_reduction (d
);
20397 /* We're not deferring instantiation any more. */
20398 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20401 pop_from_top_level ();
20403 pop_function_context ();
20406 input_location
= saved_loc
;
20407 cp_unevaluated_operand
= saved_unevaluated_operand
;
20408 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20409 pop_deferring_access_checks ();
20410 pop_tinst_level ();
20412 timevar_pop (TV_TEMPLATE_INST
);
20417 /* Run through the list of templates that we wish we could
20418 instantiate, and instantiate any we can. RETRIES is the
20419 number of times we retry pending template instantiation. */
20422 instantiate_pending_templates (int retries
)
20425 location_t saved_loc
= input_location
;
20427 /* Instantiating templates may trigger vtable generation. This in turn
20428 may require further template instantiations. We place a limit here
20429 to avoid infinite loop. */
20430 if (pending_templates
&& retries
>= max_tinst_depth
)
20432 tree decl
= pending_templates
->tinst
->decl
;
20434 fatal_error (input_location
,
20435 "template instantiation depth exceeds maximum of %d"
20436 " instantiating %q+D, possibly from virtual table generation"
20437 " (use -ftemplate-depth= to increase the maximum)",
20438 max_tinst_depth
, decl
);
20439 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20440 /* Pretend that we defined it. */
20441 DECL_INITIAL (decl
) = error_mark_node
;
20447 struct pending_template
**t
= &pending_templates
;
20448 struct pending_template
*last
= NULL
;
20452 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20453 bool complete
= false;
20455 if (TYPE_P (instantiation
))
20459 if (!COMPLETE_TYPE_P (instantiation
))
20461 instantiate_class_template (instantiation
);
20462 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20463 for (fn
= TYPE_METHODS (instantiation
);
20465 fn
= TREE_CHAIN (fn
))
20466 if (! DECL_ARTIFICIAL (fn
))
20467 instantiate_decl (fn
,
20469 /*expl_inst_class_mem_p=*/false);
20470 if (COMPLETE_TYPE_P (instantiation
))
20474 complete
= COMPLETE_TYPE_P (instantiation
);
20478 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20479 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20482 = instantiate_decl (instantiation
,
20484 /*expl_inst_class_mem_p=*/false);
20485 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20489 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20490 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20494 /* If INSTANTIATION has been instantiated, then we don't
20495 need to consider it again in the future. */
20503 current_tinst_level
= NULL
;
20505 last_pending_template
= last
;
20507 while (reconsider
);
20509 input_location
= saved_loc
;
20512 /* Substitute ARGVEC into T, which is a list of initializers for
20513 either base class or a non-static data member. The TREE_PURPOSEs
20514 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20515 instantiate_decl. */
20518 tsubst_initializer_list (tree t
, tree argvec
)
20520 tree inits
= NULL_TREE
;
20522 for (; t
; t
= TREE_CHAIN (t
))
20526 tree expanded_bases
= NULL_TREE
;
20527 tree expanded_arguments
= NULL_TREE
;
20530 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20535 /* Expand the base class expansion type into separate base
20537 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20538 tf_warning_or_error
,
20540 if (expanded_bases
== error_mark_node
)
20543 /* We'll be building separate TREE_LISTs of arguments for
20545 len
= TREE_VEC_LENGTH (expanded_bases
);
20546 expanded_arguments
= make_tree_vec (len
);
20547 for (i
= 0; i
< len
; i
++)
20548 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20550 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20551 expand each argument in the TREE_VALUE of t. */
20552 expr
= make_node (EXPR_PACK_EXPANSION
);
20553 PACK_EXPANSION_LOCAL_P (expr
) = true;
20554 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20555 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20557 if (TREE_VALUE (t
) == void_type_node
)
20558 /* VOID_TYPE_NODE is used to indicate
20559 value-initialization. */
20561 for (i
= 0; i
< len
; i
++)
20562 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20566 /* Substitute parameter packs into each argument in the
20568 in_base_initializer
= 1;
20569 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20571 tree expanded_exprs
;
20573 /* Expand the argument. */
20574 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20576 = tsubst_pack_expansion (expr
, argvec
,
20577 tf_warning_or_error
,
20579 if (expanded_exprs
== error_mark_node
)
20582 /* Prepend each of the expanded expressions to the
20583 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20584 for (i
= 0; i
< len
; i
++)
20586 TREE_VEC_ELT (expanded_arguments
, i
) =
20587 tree_cons (NULL_TREE
,
20588 TREE_VEC_ELT (expanded_exprs
, i
),
20589 TREE_VEC_ELT (expanded_arguments
, i
));
20592 in_base_initializer
= 0;
20594 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20595 since we built them backwards. */
20596 for (i
= 0; i
< len
; i
++)
20598 TREE_VEC_ELT (expanded_arguments
, i
) =
20599 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20604 for (i
= 0; i
< len
; ++i
)
20606 if (expanded_bases
)
20608 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20609 decl
= expand_member_init (decl
);
20610 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20615 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20616 tf_warning_or_error
, NULL_TREE
);
20618 decl
= expand_member_init (decl
);
20619 if (decl
&& !DECL_P (decl
))
20620 in_base_initializer
= 1;
20622 init
= TREE_VALUE (t
);
20624 if (init
!= void_type_node
)
20625 init
= tsubst_expr (init
, argvec
,
20626 tf_warning_or_error
, NULL_TREE
,
20627 /*integral_constant_expression_p=*/false);
20628 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20629 /* If we had an initializer but it instantiated to nothing,
20630 value-initialize the object. This will only occur when
20631 the initializer was a pack expansion where the parameter
20632 packs used in that expansion were of length zero. */
20633 init
= void_type_node
;
20634 in_base_initializer
= 0;
20639 init
= build_tree_list (decl
, init
);
20640 TREE_CHAIN (init
) = inits
;
20648 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20651 set_current_access_from_decl (tree decl
)
20653 if (TREE_PRIVATE (decl
))
20654 current_access_specifier
= access_private_node
;
20655 else if (TREE_PROTECTED (decl
))
20656 current_access_specifier
= access_protected_node
;
20658 current_access_specifier
= access_public_node
;
20661 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20662 is the instantiation (which should have been created with
20663 start_enum) and ARGS are the template arguments to use. */
20666 tsubst_enum (tree tag
, tree newtag
, tree args
)
20670 if (SCOPED_ENUM_P (newtag
))
20671 begin_scope (sk_scoped_enum
, newtag
);
20673 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20678 decl
= TREE_VALUE (e
);
20679 /* Note that in a template enum, the TREE_VALUE is the
20680 CONST_DECL, not the corresponding INTEGER_CST. */
20681 value
= tsubst_expr (DECL_INITIAL (decl
),
20682 args
, tf_warning_or_error
, NULL_TREE
,
20683 /*integral_constant_expression_p=*/true);
20685 /* Give this enumeration constant the correct access. */
20686 set_current_access_from_decl (decl
);
20688 /* Actually build the enumerator itself. */
20690 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
20693 if (SCOPED_ENUM_P (newtag
))
20696 finish_enum_value_list (newtag
);
20697 finish_enum (newtag
);
20699 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20700 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20703 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20704 its type -- but without substituting the innermost set of template
20705 arguments. So, innermost set of template parameters will appear in
20709 get_mostly_instantiated_function_type (tree decl
)
20711 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
20712 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
20715 /* Return truthvalue if we're processing a template different from
20716 the last one involved in diagnostics. */
20718 problematic_instantiation_changed (void)
20720 return current_tinst_level
!= last_error_tinst_level
;
20723 /* Remember current template involved in diagnostics. */
20725 record_last_problematic_instantiation (void)
20727 last_error_tinst_level
= current_tinst_level
;
20730 struct tinst_level
*
20731 current_instantiation (void)
20733 return current_tinst_level
;
20736 /* Return TRUE if current_function_decl is being instantiated, false
20740 instantiating_current_function_p (void)
20742 return (current_instantiation ()
20743 && current_instantiation ()->decl
== current_function_decl
);
20746 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20747 type. Return zero for ok, nonzero for disallowed. Issue error and
20748 warning messages under control of COMPLAIN. */
20751 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20753 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20755 else if (POINTER_TYPE_P (type
))
20757 else if (TYPE_PTRMEM_P (type
))
20759 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20761 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20763 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20765 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20768 if (complain
& tf_error
)
20770 if (type
== error_mark_node
)
20771 inform (input_location
, "invalid template non-type parameter");
20773 error ("%q#T is not a valid type for a template non-type parameter",
20779 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20780 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20783 dependent_type_p_r (tree type
)
20789 A type is dependent if it is:
20791 -- a template parameter. Template template parameters are types
20792 for us (since TYPE_P holds true for them) so we handle
20794 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20795 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20797 /* -- a qualified-id with a nested-name-specifier which contains a
20798 class-name that names a dependent type or whose unqualified-id
20799 names a dependent type. */
20800 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20802 /* -- a cv-qualified type where the cv-unqualified type is
20804 No code is necessary for this bullet; the code below handles
20805 cv-qualified types, and we don't want to strip aliases with
20806 TYPE_MAIN_VARIANT because of DR 1558. */
20807 /* -- a compound type constructed from any dependent type. */
20808 if (TYPE_PTRMEM_P (type
))
20809 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20810 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20812 else if (TYPE_PTR_P (type
)
20813 || TREE_CODE (type
) == REFERENCE_TYPE
)
20814 return dependent_type_p (TREE_TYPE (type
));
20815 else if (TREE_CODE (type
) == FUNCTION_TYPE
20816 || TREE_CODE (type
) == METHOD_TYPE
)
20820 if (dependent_type_p (TREE_TYPE (type
)))
20822 for (arg_type
= TYPE_ARG_TYPES (type
);
20824 arg_type
= TREE_CHAIN (arg_type
))
20825 if (dependent_type_p (TREE_VALUE (arg_type
)))
20829 /* -- an array type constructed from any dependent type or whose
20830 size is specified by a constant expression that is
20833 We checked for type- and value-dependence of the bounds in
20834 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20835 if (TREE_CODE (type
) == ARRAY_TYPE
)
20837 if (TYPE_DOMAIN (type
)
20838 && dependent_type_p (TYPE_DOMAIN (type
)))
20840 return dependent_type_p (TREE_TYPE (type
));
20843 /* -- a template-id in which either the template name is a template
20845 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20847 /* ... or any of the template arguments is a dependent type or
20848 an expression that is type-dependent or value-dependent. */
20849 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
20850 && (any_dependent_template_arguments_p
20851 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
20853 /* For an alias template specialization, check the arguments both to the
20854 class template and the alias template. */
20855 else if (alias_template_specialization_p (type
)
20856 && (any_dependent_template_arguments_p
20857 (INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (type
)))))
20860 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20861 dependent; if the argument of the `typeof' expression is not
20862 type-dependent, then it should already been have resolved. */
20863 if (TREE_CODE (type
) == TYPEOF_TYPE
20864 || TREE_CODE (type
) == DECLTYPE_TYPE
20865 || TREE_CODE (type
) == UNDERLYING_TYPE
)
20868 /* A template argument pack is dependent if any of its packed
20870 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
20872 tree args
= ARGUMENT_PACK_ARGS (type
);
20873 int i
, len
= TREE_VEC_LENGTH (args
);
20874 for (i
= 0; i
< len
; ++i
)
20875 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20879 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20880 be template parameters. */
20881 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
20884 /* The standard does not specifically mention types that are local
20885 to template functions or local classes, but they should be
20886 considered dependent too. For example:
20888 template <int I> void f() {
20893 The size of `E' cannot be known until the value of `I' has been
20894 determined. Therefore, `E' must be considered dependent. */
20895 scope
= TYPE_CONTEXT (type
);
20896 if (scope
&& TYPE_P (scope
))
20897 return dependent_type_p (scope
);
20898 /* Don't use type_dependent_expression_p here, as it can lead
20899 to infinite recursion trying to determine whether a lambda
20900 nested in a lambda is dependent (c++/47687). */
20901 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
20902 && DECL_LANG_SPECIFIC (scope
)
20903 && DECL_TEMPLATE_INFO (scope
)
20904 && (any_dependent_template_arguments_p
20905 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
20908 /* Other types are non-dependent. */
20912 /* Returns TRUE if TYPE is dependent, in the sense of
20913 [temp.dep.type]. Note that a NULL type is considered dependent. */
20916 dependent_type_p (tree type
)
20918 /* If there are no template parameters in scope, then there can't be
20919 any dependent types. */
20920 if (!processing_template_decl
)
20922 /* If we are not processing a template, then nobody should be
20923 providing us with a dependent type. */
20925 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
20929 /* If the type is NULL, we have not computed a type for the entity
20930 in question; in that case, the type is dependent. */
20934 /* Erroneous types can be considered non-dependent. */
20935 if (type
== error_mark_node
)
20938 /* If we have not already computed the appropriate value for TYPE,
20940 if (!TYPE_DEPENDENT_P_VALID (type
))
20942 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
20943 TYPE_DEPENDENT_P_VALID (type
) = 1;
20946 return TYPE_DEPENDENT_P (type
);
20949 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20950 lookup. In other words, a dependent type that is not the current
20954 dependent_scope_p (tree scope
)
20956 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
20957 && !currently_open_class (scope
));
20960 /* T is a SCOPE_REF; return whether we need to consider it
20961 instantiation-dependent so that we can check access at instantiation
20962 time even though we know which member it resolves to. */
20965 instantiation_dependent_scope_ref_p (tree t
)
20967 if (DECL_P (TREE_OPERAND (t
, 1))
20968 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
20969 && accessible_in_template_p (TREE_OPERAND (t
, 0),
20970 TREE_OPERAND (t
, 1)))
20976 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20977 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20980 /* Note that this predicate is not appropriate for general expressions;
20981 only constant expressions (that satisfy potential_constant_expression)
20982 can be tested for value dependence. */
20985 value_dependent_expression_p (tree expression
)
20987 if (!processing_template_decl
)
20990 /* A name declared with a dependent type. */
20991 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
20994 switch (TREE_CODE (expression
))
20996 case IDENTIFIER_NODE
:
20997 /* A name that has not been looked up -- must be dependent. */
21000 case TEMPLATE_PARM_INDEX
:
21001 /* A non-type template parm. */
21005 /* A non-type template parm. */
21006 if (DECL_TEMPLATE_PARM_P (expression
))
21008 return value_dependent_expression_p (DECL_INITIAL (expression
));
21011 /* A constant with literal type and is initialized
21012 with an expression that is value-dependent.
21014 Note that a non-dependent parenthesized initializer will have
21015 already been replaced with its constant value, so if we see
21016 a TREE_LIST it must be dependent. */
21017 if (DECL_INITIAL (expression
)
21018 && decl_constant_var_p (expression
)
21019 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
21020 /* cp_finish_decl doesn't fold reference initializers. */
21021 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
21022 || value_dependent_expression_p (DECL_INITIAL (expression
))))
21026 case DYNAMIC_CAST_EXPR
:
21027 case STATIC_CAST_EXPR
:
21028 case CONST_CAST_EXPR
:
21029 case REINTERPRET_CAST_EXPR
:
21031 /* These expressions are value-dependent if the type to which
21032 the cast occurs is dependent or the expression being casted
21033 is value-dependent. */
21035 tree type
= TREE_TYPE (expression
);
21037 if (dependent_type_p (type
))
21040 /* A functional cast has a list of operands. */
21041 expression
= TREE_OPERAND (expression
, 0);
21044 /* If there are no operands, it must be an expression such
21045 as "int()". This should not happen for aggregate types
21046 because it would form non-constant expressions. */
21047 gcc_assert (cxx_dialect
>= cxx11
21048 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
21053 if (TREE_CODE (expression
) == TREE_LIST
)
21054 return any_value_dependent_elements_p (expression
);
21056 return value_dependent_expression_p (expression
);
21060 if (SIZEOF_EXPR_TYPE_P (expression
))
21061 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
21065 /* A `sizeof' expression is value-dependent if the operand is
21066 type-dependent or is a pack expansion. */
21067 expression
= TREE_OPERAND (expression
, 0);
21068 if (PACK_EXPANSION_P (expression
))
21070 else if (TYPE_P (expression
))
21071 return dependent_type_p (expression
);
21072 return instantiation_dependent_expression_p (expression
);
21074 case AT_ENCODE_EXPR
:
21075 /* An 'encode' expression is value-dependent if the operand is
21077 expression
= TREE_OPERAND (expression
, 0);
21078 return dependent_type_p (expression
);
21080 case NOEXCEPT_EXPR
:
21081 expression
= TREE_OPERAND (expression
, 0);
21082 return instantiation_dependent_expression_p (expression
);
21085 /* All instantiation-dependent expressions should also be considered
21086 value-dependent. */
21087 return instantiation_dependent_scope_ref_p (expression
);
21089 case COMPONENT_REF
:
21090 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
21091 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
21093 case NONTYPE_ARGUMENT_PACK
:
21094 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
21095 is value-dependent. */
21097 tree values
= ARGUMENT_PACK_ARGS (expression
);
21098 int i
, len
= TREE_VEC_LENGTH (values
);
21100 for (i
= 0; i
< len
; ++i
)
21101 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
21109 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
21110 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
21111 || (type2
? dependent_type_p (type2
) : false));
21115 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21116 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
21119 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21120 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
21124 tree op
= TREE_OPERAND (expression
, 0);
21125 return (value_dependent_expression_p (op
)
21126 || has_value_dependent_address (op
));
21131 tree fn
= get_callee_fndecl (expression
);
21133 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
21135 nargs
= call_expr_nargs (expression
);
21136 for (i
= 0; i
< nargs
; ++i
)
21138 tree op
= CALL_EXPR_ARG (expression
, i
);
21139 /* In a call to a constexpr member function, look through the
21140 implicit ADDR_EXPR on the object argument so that it doesn't
21141 cause the call to be considered value-dependent. We also
21142 look through it in potential_constant_expression. */
21143 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
21144 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
21145 && TREE_CODE (op
) == ADDR_EXPR
)
21146 op
= TREE_OPERAND (op
, 0);
21147 if (value_dependent_expression_p (op
))
21153 case TEMPLATE_ID_EXPR
:
21154 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21156 return type_dependent_expression_p (expression
);
21162 if (dependent_type_p (TREE_TYPE (expression
)))
21164 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
21165 if (value_dependent_expression_p (val
))
21171 /* Treat a GNU statement expression as dependent to avoid crashing
21172 under instantiate_non_dependent_expr; it can't be constant. */
21176 /* A constant expression is value-dependent if any subexpression is
21177 value-dependent. */
21178 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
21180 case tcc_reference
:
21182 case tcc_comparison
:
21184 case tcc_expression
:
21187 int i
, len
= cp_tree_operand_length (expression
);
21189 for (i
= 0; i
< len
; i
++)
21191 tree t
= TREE_OPERAND (expression
, i
);
21193 /* In some cases, some of the operands may be missing.l
21194 (For example, in the case of PREDECREMENT_EXPR, the
21195 amount to increment by may be missing.) That doesn't
21196 make the expression dependent. */
21197 if (t
&& value_dependent_expression_p (t
))
21208 /* The expression is not value-dependent. */
21212 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21213 [temp.dep.expr]. Note that an expression with no type is
21214 considered dependent. Other parts of the compiler arrange for an
21215 expression with type-dependent subexpressions to have no type, so
21216 this function doesn't have to be fully recursive. */
21219 type_dependent_expression_p (tree expression
)
21221 if (!processing_template_decl
)
21224 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
21227 /* An unresolved name is always dependent. */
21228 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
21231 /* Some expression forms are never type-dependent. */
21232 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
21233 || TREE_CODE (expression
) == SIZEOF_EXPR
21234 || TREE_CODE (expression
) == ALIGNOF_EXPR
21235 || TREE_CODE (expression
) == AT_ENCODE_EXPR
21236 || TREE_CODE (expression
) == NOEXCEPT_EXPR
21237 || TREE_CODE (expression
) == TRAIT_EXPR
21238 || TREE_CODE (expression
) == TYPEID_EXPR
21239 || TREE_CODE (expression
) == DELETE_EXPR
21240 || TREE_CODE (expression
) == VEC_DELETE_EXPR
21241 || TREE_CODE (expression
) == THROW_EXPR
)
21244 /* The types of these expressions depends only on the type to which
21245 the cast occurs. */
21246 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
21247 || TREE_CODE (expression
) == STATIC_CAST_EXPR
21248 || TREE_CODE (expression
) == CONST_CAST_EXPR
21249 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
21250 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
21251 || TREE_CODE (expression
) == CAST_EXPR
)
21252 return dependent_type_p (TREE_TYPE (expression
));
21254 /* The types of these expressions depends only on the type created
21255 by the expression. */
21256 if (TREE_CODE (expression
) == NEW_EXPR
21257 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
21259 /* For NEW_EXPR tree nodes created inside a template, either
21260 the object type itself or a TREE_LIST may appear as the
21262 tree type
= TREE_OPERAND (expression
, 1);
21263 if (TREE_CODE (type
) == TREE_LIST
)
21264 /* This is an array type. We need to check array dimensions
21266 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
21267 || value_dependent_expression_p
21268 (TREE_OPERAND (TREE_VALUE (type
), 1));
21270 return dependent_type_p (type
);
21273 if (TREE_CODE (expression
) == SCOPE_REF
)
21275 tree scope
= TREE_OPERAND (expression
, 0);
21276 tree name
= TREE_OPERAND (expression
, 1);
21278 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21279 contains an identifier associated by name lookup with one or more
21280 declarations declared with a dependent type, or...a
21281 nested-name-specifier or qualified-id that names a member of an
21282 unknown specialization. */
21283 return (type_dependent_expression_p (name
)
21284 || dependent_scope_p (scope
));
21287 if (TREE_CODE (expression
) == FUNCTION_DECL
21288 && DECL_LANG_SPECIFIC (expression
)
21289 && DECL_TEMPLATE_INFO (expression
)
21290 && (any_dependent_template_arguments_p
21291 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
21294 if (TREE_CODE (expression
) == TEMPLATE_DECL
21295 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
21298 if (TREE_CODE (expression
) == STMT_EXPR
)
21299 expression
= stmt_expr_value_expr (expression
);
21301 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21306 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21308 if (type_dependent_expression_p (elt
))
21314 /* A static data member of the current instantiation with incomplete
21315 array type is type-dependent, as the definition and specializations
21316 can have different bounds. */
21317 if (VAR_P (expression
)
21318 && DECL_CLASS_SCOPE_P (expression
)
21319 && dependent_type_p (DECL_CONTEXT (expression
))
21320 && VAR_HAD_UNKNOWN_BOUND (expression
))
21323 /* An array of unknown bound depending on a variadic parameter, eg:
21325 template<typename... Args>
21326 void foo (Args... args)
21328 int arr[] = { args... };
21331 template<int... vals>
21334 int arr[] = { vals... };
21337 If the array has no length and has an initializer, it must be that
21338 we couldn't determine its length in cp_complete_array_type because
21339 it is dependent. */
21340 if (VAR_P (expression
)
21341 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21342 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21343 && DECL_INITIAL (expression
))
21346 /* A variable template specialization is type-dependent if it has any
21347 dependent template arguments. */
21348 if (VAR_P (expression
)
21349 && DECL_LANG_SPECIFIC (expression
)
21350 && DECL_TEMPLATE_INFO (expression
)
21351 && variable_template_p (DECL_TI_TEMPLATE (expression
)))
21352 return any_dependent_template_arguments_p (DECL_TI_ARGS (expression
));
21354 if (TREE_TYPE (expression
) == unknown_type_node
)
21356 if (TREE_CODE (expression
) == ADDR_EXPR
)
21357 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21358 if (TREE_CODE (expression
) == COMPONENT_REF
21359 || TREE_CODE (expression
) == OFFSET_REF
)
21361 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21363 expression
= TREE_OPERAND (expression
, 1);
21364 if (identifier_p (expression
))
21367 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21368 if (TREE_CODE (expression
) == SCOPE_REF
)
21371 /* Always dependent, on the number of arguments if nothing else. */
21372 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21375 if (BASELINK_P (expression
))
21377 if (BASELINK_OPTYPE (expression
)
21378 && dependent_type_p (BASELINK_OPTYPE (expression
)))
21380 expression
= BASELINK_FUNCTIONS (expression
);
21383 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21385 if (any_dependent_template_arguments_p
21386 (TREE_OPERAND (expression
, 1)))
21388 expression
= TREE_OPERAND (expression
, 0);
21390 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21391 || TREE_CODE (expression
) == FUNCTION_DECL
);
21395 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21397 expression
= OVL_NEXT (expression
);
21402 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21404 return (dependent_type_p (TREE_TYPE (expression
)));
21407 /* walk_tree callback function for instantiation_dependent_expression_p,
21408 below. Returns non-zero if a dependent subexpression is found. */
21411 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21416 /* We don't have to worry about decltype currently because decltype
21417 of an instantiation-dependent expr is a dependent type. This
21418 might change depending on the resolution of DR 1172. */
21419 *walk_subtrees
= false;
21422 enum tree_code code
= TREE_CODE (*tp
);
21425 /* Don't treat an argument list as dependent just because it has no
21433 /* A constant with a dependent initializer is dependent. */
21434 if (value_dependent_expression_p (*tp
))
21438 case TEMPLATE_PARM_INDEX
:
21441 /* Handle expressions with type operands. */
21445 case AT_ENCODE_EXPR
:
21447 tree op
= TREE_OPERAND (*tp
, 0);
21448 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21449 op
= TREE_TYPE (op
);
21452 if (dependent_type_p (op
))
21456 *walk_subtrees
= false;
21464 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21465 || (TRAIT_EXPR_TYPE2 (*tp
)
21466 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21468 *walk_subtrees
= false;
21471 case COMPONENT_REF
:
21472 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21473 /* In a template, finish_class_member_access_expr creates a
21474 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21475 type-dependent, so that we can check access control at
21476 instantiation time (PR 42277). See also Core issue 1273. */
21481 if (instantiation_dependent_scope_ref_p (*tp
))
21486 /* Treat statement-expressions as dependent. */
21494 if (type_dependent_expression_p (*tp
))
21500 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21501 sense defined by the ABI:
21503 "An expression is instantiation-dependent if it is type-dependent
21504 or value-dependent, or it has a subexpression that is type-dependent
21505 or value-dependent." */
21508 instantiation_dependent_expression_p (tree expression
)
21512 if (!processing_template_decl
)
21515 if (expression
== error_mark_node
)
21518 result
= cp_walk_tree_without_duplicates (&expression
,
21519 instantiation_dependent_r
, NULL
);
21520 return result
!= NULL_TREE
;
21523 /* Like type_dependent_expression_p, but it also works while not processing
21524 a template definition, i.e. during substitution or mangling. */
21527 type_dependent_expression_p_push (tree expr
)
21530 ++processing_template_decl
;
21531 b
= type_dependent_expression_p (expr
);
21532 --processing_template_decl
;
21536 /* Returns TRUE if ARGS contains a type-dependent expression. */
21539 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21544 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21546 if (type_dependent_expression_p (arg
))
21552 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21553 expressions) contains any type-dependent expressions. */
21556 any_type_dependent_elements_p (const_tree list
)
21558 for (; list
; list
= TREE_CHAIN (list
))
21559 if (type_dependent_expression_p (TREE_VALUE (list
)))
21565 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21566 expressions) contains any value-dependent expressions. */
21569 any_value_dependent_elements_p (const_tree list
)
21571 for (; list
; list
= TREE_CHAIN (list
))
21572 if (value_dependent_expression_p (TREE_VALUE (list
)))
21578 /* Returns TRUE if the ARG (a template argument) is dependent. */
21581 dependent_template_arg_p (tree arg
)
21583 if (!processing_template_decl
)
21586 /* Assume a template argument that was wrongly written by the user
21587 is dependent. This is consistent with what
21588 any_dependent_template_arguments_p [that calls this function]
21590 if (!arg
|| arg
== error_mark_node
)
21593 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21594 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21596 if (TREE_CODE (arg
) == TEMPLATE_DECL
21597 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21598 return dependent_template_p (arg
);
21599 else if (ARGUMENT_PACK_P (arg
))
21601 tree args
= ARGUMENT_PACK_ARGS (arg
);
21602 int i
, len
= TREE_VEC_LENGTH (args
);
21603 for (i
= 0; i
< len
; ++i
)
21605 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21611 else if (TYPE_P (arg
))
21612 return dependent_type_p (arg
);
21614 return (type_dependent_expression_p (arg
)
21615 || value_dependent_expression_p (arg
));
21618 /* Returns true if ARGS (a collection of template arguments) contains
21619 any types that require structural equality testing. */
21622 any_template_arguments_need_structural_equality_p (tree args
)
21629 if (args
== error_mark_node
)
21632 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21634 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21635 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21637 tree arg
= TREE_VEC_ELT (level
, j
);
21638 tree packed_args
= NULL_TREE
;
21641 if (ARGUMENT_PACK_P (arg
))
21643 /* Look inside the argument pack. */
21644 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21645 len
= TREE_VEC_LENGTH (packed_args
);
21648 for (k
= 0; k
< len
; ++k
)
21651 arg
= TREE_VEC_ELT (packed_args
, k
);
21653 if (error_operand_p (arg
))
21655 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21657 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21659 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21660 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21669 /* Returns true if ARGS (a collection of template arguments) contains
21670 any dependent arguments. */
21673 any_dependent_template_arguments_p (const_tree args
)
21680 if (args
== error_mark_node
)
21683 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21685 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21686 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21687 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21694 /* Returns TRUE if the template TMPL is dependent. */
21697 dependent_template_p (tree tmpl
)
21699 if (TREE_CODE (tmpl
) == OVERLOAD
)
21703 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21705 tmpl
= OVL_NEXT (tmpl
);
21710 /* Template template parameters are dependent. */
21711 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21712 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21714 /* So are names that have not been looked up. */
21715 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21717 /* So are member templates of dependent classes. */
21718 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21719 return dependent_type_p (DECL_CONTEXT (tmpl
));
21723 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21726 dependent_template_id_p (tree tmpl
, tree args
)
21728 return (dependent_template_p (tmpl
)
21729 || any_dependent_template_arguments_p (args
));
21732 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21736 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21740 if (!processing_template_decl
)
21743 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21745 tree decl
= TREE_VEC_ELT (declv
, i
);
21746 tree init
= TREE_VEC_ELT (initv
, i
);
21747 tree cond
= TREE_VEC_ELT (condv
, i
);
21748 tree incr
= TREE_VEC_ELT (incrv
, i
);
21750 if (type_dependent_expression_p (decl
))
21753 if (init
&& type_dependent_expression_p (init
))
21756 if (type_dependent_expression_p (cond
))
21759 if (COMPARISON_CLASS_P (cond
)
21760 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21761 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21764 if (TREE_CODE (incr
) == MODOP_EXPR
)
21766 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21767 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21770 else if (type_dependent_expression_p (incr
))
21772 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21774 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21776 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21778 tree t
= TREE_OPERAND (incr
, 1);
21779 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21780 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21789 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21790 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21791 no such TYPE can be found. Note that this function peers inside
21792 uninstantiated templates and therefore should be used only in
21793 extremely limited situations. ONLY_CURRENT_P restricts this
21794 peering to the currently open classes hierarchy (which is required
21795 when comparing types). */
21798 resolve_typename_type (tree type
, bool only_current_p
)
21807 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21809 scope
= TYPE_CONTEXT (type
);
21810 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21811 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21812 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21813 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21814 identifier of the TYPENAME_TYPE anymore.
21815 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21816 TYPENAME_TYPE instead, we avoid messing up with a possible
21817 typedef variant case. */
21818 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21820 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21821 it first before we can figure out what NAME refers to. */
21822 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21824 if (TYPENAME_IS_RESOLVING_P (scope
))
21825 /* Given a class template A with a dependent base with nested type C,
21826 typedef typename A::C::C C will land us here, as trying to resolve
21827 the initial A::C leads to the local C typedef, which leads back to
21828 A::C::C. So we break the recursion now. */
21831 scope
= resolve_typename_type (scope
, only_current_p
);
21833 /* If we don't know what SCOPE refers to, then we cannot resolve the
21835 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21837 /* If the SCOPE is a template type parameter, we have no way of
21838 resolving the name. */
21839 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21841 /* If the SCOPE is not the current instantiation, there's no reason
21842 to look inside it. */
21843 if (only_current_p
&& !currently_open_class (scope
))
21845 /* If this is a typedef, we don't want to look inside (c++/11987). */
21846 if (typedef_variant_p (type
))
21848 /* If SCOPE isn't the template itself, it will not have a valid
21849 TYPE_FIELDS list. */
21850 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21851 /* scope is either the template itself or a compatible instantiation
21852 like X<T>, so look up the name in the original template. */
21853 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
21855 /* scope is a partial instantiation, so we can't do the lookup or we
21856 will lose the template arguments. */
21858 /* Enter the SCOPE so that name lookup will be resolved as if we
21859 were in the class definition. In particular, SCOPE will no
21860 longer be considered a dependent type. */
21861 pushed_scope
= push_scope (scope
);
21862 /* Look up the declaration. */
21863 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
21864 tf_warning_or_error
);
21866 result
= NULL_TREE
;
21868 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21869 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21872 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
21873 && TREE_CODE (decl
) == TYPE_DECL
)
21875 result
= TREE_TYPE (decl
);
21876 if (result
== error_mark_node
)
21877 result
= NULL_TREE
;
21879 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
21880 && DECL_CLASS_TEMPLATE_P (decl
))
21884 /* Obtain the template and the arguments. */
21885 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
21886 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
21887 /* Instantiate the template. */
21888 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
21889 /*entering_scope=*/0,
21890 tf_error
| tf_user
);
21891 if (result
== error_mark_node
)
21892 result
= NULL_TREE
;
21895 /* Leave the SCOPE. */
21897 pop_scope (pushed_scope
);
21899 /* If we failed to resolve it, return the original typename. */
21903 /* If lookup found a typename type, resolve that too. */
21904 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
21906 /* Ill-formed programs can cause infinite recursion here, so we
21907 must catch that. */
21908 TYPENAME_IS_RESOLVING_P (type
) = 1;
21909 result
= resolve_typename_type (result
, only_current_p
);
21910 TYPENAME_IS_RESOLVING_P (type
) = 0;
21913 /* Qualify the resulting type. */
21914 quals
= cp_type_quals (type
);
21916 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
21921 /* EXPR is an expression which is not type-dependent. Return a proxy
21922 for EXPR that can be used to compute the types of larger
21923 expressions containing EXPR. */
21926 build_non_dependent_expr (tree expr
)
21930 #ifdef ENABLE_CHECKING
21931 /* Try to get a constant value for all non-dependent expressions in
21932 order to expose bugs in *_dependent_expression_p and constexpr. */
21933 if (cxx_dialect
>= cxx11
)
21934 fold_non_dependent_expr (expr
);
21937 /* Preserve OVERLOADs; the functions must be available to resolve
21940 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
21941 inner_expr
= stmt_expr_value_expr (inner_expr
);
21942 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
21943 inner_expr
= TREE_OPERAND (inner_expr
, 0);
21944 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
21945 inner_expr
= TREE_OPERAND (inner_expr
, 1);
21946 if (is_overloaded_fn (inner_expr
)
21947 || TREE_CODE (inner_expr
) == OFFSET_REF
)
21949 /* There is no need to return a proxy for a variable. */
21952 /* Preserve string constants; conversions from string constants to
21953 "char *" are allowed, even though normally a "const char *"
21954 cannot be used to initialize a "char *". */
21955 if (TREE_CODE (expr
) == STRING_CST
)
21957 /* Preserve void and arithmetic constants, as an optimization -- there is no
21958 reason to create a new node. */
21959 if (TREE_CODE (expr
) == VOID_CST
21960 || TREE_CODE (expr
) == INTEGER_CST
21961 || TREE_CODE (expr
) == REAL_CST
)
21963 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21964 There is at least one place where we want to know that a
21965 particular expression is a throw-expression: when checking a ?:
21966 expression, there are special rules if the second or third
21967 argument is a throw-expression. */
21968 if (TREE_CODE (expr
) == THROW_EXPR
)
21971 /* Don't wrap an initializer list, we need to be able to look inside. */
21972 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
21975 /* Don't wrap a dummy object, we need to be able to test for it. */
21976 if (is_dummy_object (expr
))
21979 if (TREE_CODE (expr
) == COND_EXPR
)
21980 return build3 (COND_EXPR
,
21982 TREE_OPERAND (expr
, 0),
21983 (TREE_OPERAND (expr
, 1)
21984 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
21985 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
21986 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
21987 if (TREE_CODE (expr
) == COMPOUND_EXPR
21988 && !COMPOUND_EXPR_OVERLOADED (expr
))
21989 return build2 (COMPOUND_EXPR
,
21991 TREE_OPERAND (expr
, 0),
21992 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
21994 /* If the type is unknown, it can't really be non-dependent */
21995 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
21997 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21998 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
22001 /* ARGS is a vector of expressions as arguments to a function call.
22002 Replace the arguments with equivalent non-dependent expressions.
22003 This modifies ARGS in place. */
22006 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
22011 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
22013 tree newarg
= build_non_dependent_expr (arg
);
22015 (*args
)[ix
] = newarg
;
22019 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
22020 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
22024 make_auto_1 (tree name
)
22026 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
22027 TYPE_NAME (au
) = build_decl (input_location
,
22028 TYPE_DECL
, name
, au
);
22029 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
22030 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
22031 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
22032 TYPE_NAME (au
), NULL_TREE
);
22033 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
22034 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
22035 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
22041 make_decltype_auto (void)
22043 return make_auto_1 (get_identifier ("decltype(auto)"));
22049 return make_auto_1 (get_identifier ("auto"));
22052 /* Given type ARG, return std::initializer_list<ARG>. */
22057 tree std_init_list
= namespace_binding
22058 (get_identifier ("initializer_list"), std_node
);
22060 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
22062 error ("deducing from brace-enclosed initializer list requires "
22063 "#include <initializer_list>");
22064 return error_mark_node
;
22066 argvec
= make_tree_vec (1);
22067 TREE_VEC_ELT (argvec
, 0) = arg
;
22068 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
22069 NULL_TREE
, 0, tf_warning_or_error
);
22072 /* Replace auto in TYPE with std::initializer_list<auto>. */
22075 listify_autos (tree type
, tree auto_node
)
22077 tree init_auto
= listify (auto_node
);
22078 tree argvec
= make_tree_vec (1);
22079 TREE_VEC_ELT (argvec
, 0) = init_auto
;
22080 if (processing_template_decl
)
22081 argvec
= add_to_template_args (current_template_args (), argvec
);
22082 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22085 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
22086 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
22089 do_auto_deduction (tree type
, tree init
, tree auto_node
)
22093 if (init
== error_mark_node
)
22094 return error_mark_node
;
22096 if (type_dependent_expression_p (init
))
22097 /* Defining a subset of type-dependent expressions that we can deduce
22098 from ahead of time isn't worth the trouble. */
22101 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
22102 with either a new invented type template parameter U or, if the
22103 initializer is a braced-init-list (8.5.4), with
22104 std::initializer_list<U>. */
22105 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
22107 if (!DIRECT_LIST_INIT_P (init
))
22108 type
= listify_autos (type
, auto_node
);
22109 else if (CONSTRUCTOR_NELTS (init
) == 1)
22110 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
22113 if (permerror (input_location
, "direct-list-initialization of "
22114 "%<auto%> requires exactly one element"))
22115 inform (input_location
,
22116 "for deduction to %<std::initializer_list%>, use copy-"
22117 "list-initialization (i.e. add %<=%> before the %<{%>)");
22118 type
= listify_autos (type
, auto_node
);
22122 init
= resolve_nondeduced_context (init
);
22124 targs
= make_tree_vec (1);
22125 if (AUTO_IS_DECLTYPE (auto_node
))
22127 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
22128 && !REF_PARENTHESIZED_P (init
)));
22129 TREE_VEC_ELT (targs
, 0)
22130 = finish_decltype_type (init
, id
, tf_warning_or_error
);
22131 if (type
!= auto_node
)
22133 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
22134 return error_mark_node
;
22139 tree parms
= build_tree_list (NULL_TREE
, type
);
22140 tree tparms
= make_tree_vec (1);
22143 TREE_VEC_ELT (tparms
, 0)
22144 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
22145 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
22146 DEDUCE_CALL
, LOOKUP_NORMAL
,
22147 NULL
, /*explain_p=*/false);
22150 if (processing_template_decl
)
22151 /* Try again at instantiation time. */
22153 if (type
&& type
!= error_mark_node
)
22154 /* If type is error_mark_node a diagnostic must have been
22155 emitted by now. Also, having a mention to '<type error>'
22156 in the diagnostic is not really useful to the user. */
22158 if (cfun
&& auto_node
== current_function_auto_return_pattern
22159 && LAMBDA_FUNCTION_P (current_function_decl
))
22160 error ("unable to deduce lambda return type from %qE", init
);
22162 error ("unable to deduce %qT from %qE", type
, init
);
22164 return error_mark_node
;
22168 /* If the list of declarators contains more than one declarator, the type
22169 of each declared variable is determined as described above. If the
22170 type deduced for the template parameter U is not the same in each
22171 deduction, the program is ill-formed. */
22172 if (TREE_TYPE (auto_node
)
22173 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
22175 if (cfun
&& auto_node
== current_function_auto_return_pattern
22176 && LAMBDA_FUNCTION_P (current_function_decl
))
22177 error ("inconsistent types %qT and %qT deduced for "
22178 "lambda return type", TREE_TYPE (auto_node
),
22179 TREE_VEC_ELT (targs
, 0));
22181 error ("inconsistent deduction for %qT: %qT and then %qT",
22182 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
22183 return error_mark_node
;
22185 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
22187 if (processing_template_decl
)
22188 targs
= add_to_template_args (current_template_args (), targs
);
22189 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
22192 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22196 splice_late_return_type (tree type
, tree late_return_type
)
22200 if (late_return_type
== NULL_TREE
)
22202 argvec
= make_tree_vec (1);
22203 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
22204 if (processing_template_parmlist
)
22205 /* For a late-specified return type in a template type-parameter, we
22206 need to add a dummy argument level for its parmlist. */
22207 argvec
= add_to_template_args
22208 (make_tree_vec (processing_template_parmlist
), argvec
);
22209 if (current_template_parms
)
22210 argvec
= add_to_template_args (current_template_args (), argvec
);
22211 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22214 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22215 'decltype(auto)'. */
22218 is_auto (const_tree type
)
22220 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
22221 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
22222 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
22228 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22229 a use of `auto'. Returns NULL_TREE otherwise. */
22232 type_uses_auto (tree type
)
22234 return find_type_usage (type
, is_auto
);
22237 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22238 'decltype(auto)' or a concept. */
22241 is_auto_or_concept (const_tree type
)
22243 return is_auto (type
); // or concept
22246 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22247 a concept identifier) iff TYPE contains a use of a generic type. Returns
22248 NULL_TREE otherwise. */
22251 type_uses_auto_or_concept (tree type
)
22253 return find_type_usage (type
, is_auto_or_concept
);
22257 /* For a given template T, return the vector of typedefs referenced
22258 in T for which access check is needed at T instantiation time.
22259 T is either a FUNCTION_DECL or a RECORD_TYPE.
22260 Those typedefs were added to T by the function
22261 append_type_to_template_for_access_check. */
22263 vec
<qualified_typedef_usage_t
, va_gc
> *
22264 get_types_needing_access_check (tree t
)
22267 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
22269 if (!t
|| t
== error_mark_node
)
22272 if (!(ti
= get_template_info (t
)))
22275 if (CLASS_TYPE_P (t
)
22276 || TREE_CODE (t
) == FUNCTION_DECL
)
22278 if (!TI_TEMPLATE (ti
))
22281 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
22287 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22288 tied to T. That list of typedefs will be access checked at
22289 T instantiation time.
22290 T is either a FUNCTION_DECL or a RECORD_TYPE.
22291 TYPE_DECL is a TYPE_DECL node representing a typedef.
22292 SCOPE is the scope through which TYPE_DECL is accessed.
22293 LOCATION is the location of the usage point of TYPE_DECL.
22295 This function is a subroutine of
22296 append_type_to_template_for_access_check. */
22299 append_type_to_template_for_access_check_1 (tree t
,
22302 location_t location
)
22304 qualified_typedef_usage_t typedef_usage
;
22307 if (!t
|| t
== error_mark_node
)
22310 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
22311 || CLASS_TYPE_P (t
))
22313 && TREE_CODE (type_decl
) == TYPE_DECL
22316 if (!(ti
= get_template_info (t
)))
22319 gcc_assert (TI_TEMPLATE (ti
));
22321 typedef_usage
.typedef_decl
= type_decl
;
22322 typedef_usage
.context
= scope
;
22323 typedef_usage
.locus
= location
;
22325 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22328 /* Append TYPE_DECL to the template TEMPL.
22329 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22330 At TEMPL instanciation time, TYPE_DECL will be checked to see
22331 if it can be accessed through SCOPE.
22332 LOCATION is the location of the usage point of TYPE_DECL.
22334 e.g. consider the following code snippet:
22341 template<class U> struct S
22343 C::myint mi; // <-- usage point of the typedef C::myint
22348 At S<char> instantiation time, we need to check the access of C::myint
22349 In other words, we need to check the access of the myint typedef through
22350 the C scope. For that purpose, this function will add the myint typedef
22351 and the scope C through which its being accessed to a list of typedefs
22352 tied to the template S. That list will be walked at template instantiation
22353 time and access check performed on each typedefs it contains.
22354 Note that this particular code snippet should yield an error because
22355 myint is private to C. */
22358 append_type_to_template_for_access_check (tree templ
,
22361 location_t location
)
22363 qualified_typedef_usage_t
*iter
;
22366 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22368 /* Make sure we don't append the type to the template twice. */
22369 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22370 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22373 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22377 /* Convert the generic type parameters in PARM that match the types given in the
22378 range [START_IDX, END_IDX) from the current_template_parms into generic type
22382 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22384 tree current
= current_template_parms
;
22385 int depth
= TMPL_PARMS_DEPTH (current
);
22386 current
= INNERMOST_TEMPLATE_PARMS (current
);
22387 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22389 for (int i
= 0; i
< start_idx
; ++i
)
22390 TREE_VEC_ELT (replacement
, i
)
22391 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22393 for (int i
= start_idx
; i
< end_idx
; ++i
)
22395 /* Create a distinct parameter pack type from the current parm and add it
22396 to the replacement args to tsubst below into the generic function
22399 tree o
= TREE_TYPE (TREE_VALUE
22400 (TREE_VEC_ELT (current
, i
)));
22401 tree t
= copy_type (o
);
22402 TEMPLATE_TYPE_PARM_INDEX (t
)
22403 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22405 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22406 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22407 TYPE_MAIN_VARIANT (t
) = t
;
22408 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22409 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22410 TREE_VEC_ELT (replacement
, i
) = t
;
22411 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22414 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22415 TREE_VEC_ELT (replacement
, i
)
22416 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22418 /* If there are more levels then build up the replacement with the outer
22421 replacement
= add_to_template_args (template_parms_to_args
22422 (TREE_CHAIN (current_template_parms
)),
22425 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22429 /* Set up the hash tables for template instantiations. */
22432 init_template_processing (void)
22434 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22435 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22438 /* Print stats about the template hash tables for -fstats. */
22441 print_template_statistics (void)
22443 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22444 "%f collisions\n", (long) decl_specializations
->size (),
22445 (long) decl_specializations
->elements (),
22446 decl_specializations
->collisions ());
22447 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22448 "%f collisions\n", (long) type_specializations
->size (),
22449 (long) type_specializations
->elements (),
22450 type_specializations
->collisions ());
22453 #include "gt-cp-pt.h"