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
)
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
))
7327 return cp_tree_equal (ot
, nt
);
7330 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7331 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7332 NEWARG_PTR with the offending arguments if they are non-NULL. */
7335 comp_template_args_with_info (tree oldargs
, tree newargs
,
7336 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7340 if (oldargs
== newargs
)
7343 if (!oldargs
|| !newargs
)
7346 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7349 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7351 tree nt
= TREE_VEC_ELT (newargs
, i
);
7352 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7354 if (! template_args_equal (ot
, nt
))
7356 if (oldarg_ptr
!= NULL
)
7358 if (newarg_ptr
!= NULL
)
7366 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7367 of template arguments. Returns 0 otherwise. */
7370 comp_template_args (tree oldargs
, tree newargs
)
7372 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7376 add_pending_template (tree d
)
7378 tree ti
= (TYPE_P (d
)
7379 ? CLASSTYPE_TEMPLATE_INFO (d
)
7380 : DECL_TEMPLATE_INFO (d
));
7381 struct pending_template
*pt
;
7384 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7387 /* We are called both from instantiate_decl, where we've already had a
7388 tinst_level pushed, and instantiate_template, where we haven't.
7390 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7393 push_tinst_level (d
);
7395 pt
= ggc_alloc
<pending_template
> ();
7397 pt
->tinst
= current_tinst_level
;
7398 if (last_pending_template
)
7399 last_pending_template
->next
= pt
;
7401 pending_templates
= pt
;
7403 last_pending_template
= pt
;
7405 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7412 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7413 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7414 documentation for TEMPLATE_ID_EXPR. */
7417 lookup_template_function (tree fns
, tree arglist
)
7421 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7422 return error_mark_node
;
7424 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7426 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7428 error ("%q#D is not a function template", fns
);
7429 return error_mark_node
;
7432 if (BASELINK_P (fns
))
7434 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7436 BASELINK_FUNCTIONS (fns
),
7441 type
= TREE_TYPE (fns
);
7442 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7443 type
= unknown_type_node
;
7445 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7448 /* Within the scope of a template class S<T>, the name S gets bound
7449 (in build_self_reference) to a TYPE_DECL for the class, not a
7450 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7451 or one of its enclosing classes, and that type is a template,
7452 return the associated TEMPLATE_DECL. Otherwise, the original
7455 Also handle the case when DECL is a TREE_LIST of ambiguous
7456 injected-class-names from different bases. */
7459 maybe_get_template_decl_from_type_decl (tree decl
)
7461 if (decl
== NULL_TREE
)
7464 /* DR 176: A lookup that finds an injected-class-name (10.2
7465 [class.member.lookup]) can result in an ambiguity in certain cases
7466 (for example, if it is found in more than one base class). If all of
7467 the injected-class-names that are found refer to specializations of
7468 the same class template, and if the name is followed by a
7469 template-argument-list, the reference refers to the class template
7470 itself and not a specialization thereof, and is not ambiguous. */
7471 if (TREE_CODE (decl
) == TREE_LIST
)
7473 tree t
, tmpl
= NULL_TREE
;
7474 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7476 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7479 else if (tmpl
!= elt
)
7482 if (tmpl
&& t
== NULL_TREE
)
7488 return (decl
!= NULL_TREE
7489 && DECL_SELF_REFERENCE_P (decl
)
7490 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7491 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7494 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7495 parameters, find the desired type.
7497 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7499 IN_DECL, if non-NULL, is the template declaration we are trying to
7502 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7503 the class we are looking up.
7505 Issue error and warning messages under control of COMPLAIN.
7507 If the template class is really a local class in a template
7508 function, then the FUNCTION_CONTEXT is the function in which it is
7511 ??? Note that this function is currently called *twice* for each
7512 template-id: the first time from the parser, while creating the
7513 incomplete type (finish_template_type), and the second type during the
7514 real instantiation (instantiate_template_class). This is surely something
7515 that we want to avoid. It also causes some problems with argument
7516 coercion (see convert_nontype_argument for more information on this). */
7519 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7520 int entering_scope
, tsubst_flags_t complain
)
7522 tree templ
= NULL_TREE
, parmlist
;
7529 if (identifier_p (d1
))
7531 tree value
= innermost_non_namespace_value (d1
);
7532 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7537 push_decl_namespace (context
);
7538 templ
= lookup_name (d1
);
7539 templ
= maybe_get_template_decl_from_type_decl (templ
);
7541 pop_decl_namespace ();
7544 context
= DECL_CONTEXT (templ
);
7546 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7548 tree type
= TREE_TYPE (d1
);
7550 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7551 an implicit typename for the second A. Deal with it. */
7552 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7553 type
= TREE_TYPE (type
);
7555 if (CLASSTYPE_TEMPLATE_INFO (type
))
7557 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7558 d1
= DECL_NAME (templ
);
7561 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7562 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7564 templ
= TYPE_TI_TEMPLATE (d1
);
7565 d1
= DECL_NAME (templ
);
7567 else if (DECL_TYPE_TEMPLATE_P (d1
))
7570 d1
= DECL_NAME (templ
);
7571 context
= DECL_CONTEXT (templ
);
7573 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7576 d1
= DECL_NAME (templ
);
7579 /* Issue an error message if we didn't find a template. */
7582 if (complain
& tf_error
)
7583 error ("%qT is not a template", d1
);
7584 return error_mark_node
;
7587 if (TREE_CODE (templ
) != TEMPLATE_DECL
7588 /* Make sure it's a user visible template, if it was named by
7590 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7591 && !PRIMARY_TEMPLATE_P (templ
)))
7593 if (complain
& tf_error
)
7595 error ("non-template type %qT used as a template", d1
);
7597 error ("for template declaration %q+D", in_decl
);
7599 return error_mark_node
;
7602 complain
&= ~tf_user
;
7604 /* An alias that just changes the name of a template is equivalent to the
7605 other template, so if any of the arguments are pack expansions, strip
7606 the alias to avoid problems with a pack expansion passed to a non-pack
7607 alias template parameter (DR 1430). */
7608 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7609 templ
= get_underlying_template (templ
);
7611 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7613 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7614 template arguments */
7620 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7622 /* Consider an example where a template template parameter declared as
7624 template <class T, class U = std::allocator<T> > class TT
7626 The template parameter level of T and U are one level larger than
7627 of TT. To proper process the default argument of U, say when an
7628 instantiation `TT<int>' is seen, we need to build the full
7629 arguments containing {int} as the innermost level. Outer levels,
7630 available when not appearing as default template argument, can be
7631 obtained from the arguments of the enclosing template.
7633 Suppose that TT is later substituted with std::vector. The above
7634 instantiation is `TT<int, std::allocator<T> >' with TT at
7635 level 1, and T at level 2, while the template arguments at level 1
7636 becomes {std::vector} and the inner level 2 is {int}. */
7638 outer
= DECL_CONTEXT (templ
);
7640 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7641 else if (current_template_parms
)
7642 /* This is an argument of the current template, so we haven't set
7643 DECL_CONTEXT yet. */
7644 outer
= current_template_args ();
7647 arglist
= add_to_template_args (outer
, arglist
);
7649 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7651 /*require_all_args=*/true,
7652 /*use_default_args=*/true);
7653 if (arglist2
== error_mark_node
7654 || (!uses_template_parms (arglist2
)
7655 && check_instantiated_args (templ
, arglist2
, complain
)))
7656 return error_mark_node
;
7658 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7663 tree template_type
= TREE_TYPE (templ
);
7666 tree found
= NULL_TREE
;
7669 int is_dependent_type
;
7670 int use_partial_inst_tmpl
= false;
7672 if (template_type
== error_mark_node
)
7673 /* An error occurred while building the template TEMPL, and a
7674 diagnostic has most certainly been emitted for that
7675 already. Let's propagate that error. */
7676 return error_mark_node
;
7678 gen_tmpl
= most_general_template (templ
);
7679 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7680 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7681 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7683 if (arg_depth
== 1 && parm_depth
> 1)
7685 /* We've been given an incomplete set of template arguments.
7688 template <class T> struct S1 {
7689 template <class U> struct S2 {};
7690 template <class U> struct S2<U*> {};
7693 we will be called with an ARGLIST of `U*', but the
7694 TEMPLATE will be `template <class T> template
7695 <class U> struct S1<T>::S2'. We must fill in the missing
7698 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7700 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7703 /* Now we should have enough arguments. */
7704 gcc_assert (parm_depth
== arg_depth
);
7706 /* From here on, we're only interested in the most general
7709 /* Calculate the BOUND_ARGS. These will be the args that are
7710 actually tsubst'd into the definition to create the
7714 /* We have multiple levels of arguments to coerce, at once. */
7716 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
7718 tree bound_args
= make_tree_vec (parm_depth
);
7720 for (i
= saved_depth
,
7721 t
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7722 i
> 0 && t
!= NULL_TREE
;
7723 --i
, t
= TREE_CHAIN (t
))
7726 if (i
== saved_depth
)
7727 a
= coerce_template_parms (TREE_VALUE (t
),
7730 /*require_all_args=*/true,
7731 /*use_default_args=*/true);
7733 /* Outer levels should have already been coerced. */
7734 a
= TMPL_ARGS_LEVEL (arglist
, i
);
7736 /* Don't process further if one of the levels fails. */
7737 if (a
== error_mark_node
)
7739 /* Restore the ARGLIST to its full size. */
7740 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7741 return error_mark_node
;
7744 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
7746 /* We temporarily reduce the length of the ARGLIST so
7747 that coerce_template_parms will see only the arguments
7748 corresponding to the template parameters it is
7750 TREE_VEC_LENGTH (arglist
)--;
7753 /* Restore the ARGLIST to its full size. */
7754 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7756 arglist
= bound_args
;
7760 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
7761 INNERMOST_TEMPLATE_ARGS (arglist
),
7764 /*require_all_args=*/true,
7765 /*use_default_args=*/true);
7767 if (arglist
== error_mark_node
)
7768 /* We were unable to bind the arguments. */
7769 return error_mark_node
;
7771 /* In the scope of a template class, explicit references to the
7772 template class refer to the type of the template, not any
7773 instantiation of it. For example, in:
7775 template <class T> class C { void f(C<T>); }
7777 the `C<T>' is just the same as `C'. Outside of the
7778 class, however, such a reference is an instantiation. */
7780 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7781 || currently_open_class (template_type
))
7782 /* comp_template_args is expensive, check it last. */
7783 && comp_template_args (TYPE_TI_ARGS (template_type
),
7785 return template_type
;
7787 /* If we already have this specialization, return it. */
7788 elt
.tmpl
= gen_tmpl
;
7790 hash
= spec_hasher::hash (&elt
);
7791 entry
= type_specializations
->find_with_hash (&elt
, hash
);
7796 is_dependent_type
= uses_template_parms (arglist
);
7798 /* If the deduced arguments are invalid, then the binding
7800 if (!is_dependent_type
7801 && check_instantiated_args (gen_tmpl
,
7802 INNERMOST_TEMPLATE_ARGS (arglist
),
7804 return error_mark_node
;
7806 if (!is_dependent_type
7807 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7808 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7809 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7811 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7812 DECL_NAME (gen_tmpl
),
7813 /*tag_scope=*/ts_global
);
7817 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7819 if (context
== error_mark_node
)
7820 return error_mark_node
;
7823 context
= global_namespace
;
7825 /* Create the type. */
7826 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7828 /* The user referred to a specialization of an alias
7829 template represented by GEN_TMPL.
7831 [temp.alias]/2 says:
7833 When a template-id refers to the specialization of an
7834 alias template, it is equivalent to the associated
7835 type obtained by substitution of its
7836 template-arguments for the template-parameters in the
7837 type-id of the alias template. */
7839 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7840 /* Note that the call above (by indirectly calling
7841 register_specialization in tsubst_decl) registers the
7842 TYPE_DECL representing the specialization of the alias
7843 template. So next time someone substitutes ARGLIST for
7844 the template parms into the alias template (GEN_TMPL),
7845 she'll get that TYPE_DECL back. */
7847 if (t
== error_mark_node
)
7850 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7852 if (!is_dependent_type
)
7854 set_current_access_from_decl (TYPE_NAME (template_type
));
7855 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7856 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7857 arglist
, complain
, in_decl
),
7858 SCOPED_ENUM_P (template_type
), NULL
);
7860 if (t
== error_mark_node
)
7865 /* We don't want to call start_enum for this type, since
7866 the values for the enumeration constants may involve
7867 template parameters. And, no one should be interested
7868 in the enumeration constants for such a type. */
7869 t
= cxx_make_type (ENUMERAL_TYPE
);
7870 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7872 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7873 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7874 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7876 else if (CLASS_TYPE_P (template_type
))
7878 t
= make_class_type (TREE_CODE (template_type
));
7879 CLASSTYPE_DECLARED_CLASS (t
)
7880 = CLASSTYPE_DECLARED_CLASS (template_type
);
7881 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7882 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7884 /* A local class. Make sure the decl gets registered properly. */
7885 if (context
== current_function_decl
)
7886 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7888 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7889 /* This instantiation is another name for the primary
7890 template type. Set the TYPE_CANONICAL field
7892 TYPE_CANONICAL (t
) = template_type
;
7893 else if (any_template_arguments_need_structural_equality_p (arglist
))
7894 /* Some of the template arguments require structural
7895 equality testing, so this template class requires
7896 structural equality testing. */
7897 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7902 /* If we called start_enum or pushtag above, this information
7903 will already be set up. */
7906 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7908 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7909 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7910 DECL_SOURCE_LOCATION (type_decl
)
7911 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7914 type_decl
= TYPE_NAME (t
);
7916 if (CLASS_TYPE_P (template_type
))
7918 TREE_PRIVATE (type_decl
)
7919 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7920 TREE_PROTECTED (type_decl
)
7921 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7922 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7924 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7925 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7929 if (OVERLOAD_TYPE_P (t
)
7930 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7933 = lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (template_type
)))
7935 if (!TREE_CHAIN (attributes
))
7936 TYPE_ATTRIBUTES (t
) = attributes
;
7939 = build_tree_list (TREE_PURPOSE (attributes
),
7940 TREE_VALUE (attributes
));
7944 /* Let's consider the explicit specialization of a member
7945 of a class template specialization that is implicitly instantiated,
7950 template<class U> struct M {}; //#0
7955 struct S<int>::M<char> //#1
7959 [temp.expl.spec]/4 says this is valid.
7961 In this case, when we write:
7964 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7967 When we encounter #1, we want to store the partial instantiation
7968 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7970 For all cases other than this "explicit specialization of member of a
7971 class template", we just want to store the most general template into
7972 the CLASSTYPE_TI_TEMPLATE of M.
7974 This case of "explicit specialization of member of a class template"
7976 1/ the enclosing class is an instantiation of, and therefore not
7977 the same as, the context of the most general template, and
7978 2/ we aren't looking at the partial instantiation itself, i.e.
7979 the innermost arguments are not the same as the innermost parms of
7980 the most general template.
7982 So it's only when 1/ and 2/ happens that we want to use the partial
7983 instantiation of the member template in lieu of its most general
7986 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
7987 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
7988 /* the enclosing class must be an instantiation... */
7989 && CLASS_TYPE_P (context
)
7990 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
7992 tree partial_inst_args
;
7993 TREE_VEC_LENGTH (arglist
)--;
7994 ++processing_template_decl
;
7996 tsubst (INNERMOST_TEMPLATE_ARGS
7997 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
7998 arglist
, complain
, NULL_TREE
);
7999 --processing_template_decl
;
8000 TREE_VEC_LENGTH (arglist
)++;
8001 use_partial_inst_tmpl
=
8002 /*...and we must not be looking at the partial instantiation
8004 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
8008 if (!use_partial_inst_tmpl
)
8009 /* This case is easy; there are no member templates involved. */
8013 /* This is a full instantiation of a member template. Find
8014 the partial instantiation of which this is an instance. */
8016 /* Temporarily reduce by one the number of levels in the ARGLIST
8017 so as to avoid comparing the last set of arguments. */
8018 TREE_VEC_LENGTH (arglist
)--;
8019 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
8020 TREE_VEC_LENGTH (arglist
)++;
8021 /* FOUND is either a proper class type, or an alias
8022 template specialization. In the later case, it's a
8023 TYPE_DECL, resulting from the substituting of arguments
8024 for parameters in the TYPE_DECL of the alias template
8025 done earlier. So be careful while getting the template
8027 found
= TREE_CODE (found
) == TYPE_DECL
8028 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
8029 : CLASSTYPE_TI_TEMPLATE (found
);
8032 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
8035 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
8036 entry
= ggc_alloc
<spec_entry
> ();
8040 /* Note this use of the partial instantiation so we can check it
8041 later in maybe_process_partial_specialization. */
8042 DECL_TEMPLATE_INSTANTIATIONS (found
)
8043 = tree_cons (arglist
, t
,
8044 DECL_TEMPLATE_INSTANTIATIONS (found
));
8046 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
8047 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8048 /* Now that the type has been registered on the instantiations
8049 list, we set up the enumerators. Because the enumeration
8050 constants may involve the enumeration type itself, we make
8051 sure to register the type first, and then create the
8052 constants. That way, doing tsubst_expr for the enumeration
8053 constants won't result in recursive calls here; we'll find
8054 the instantiation and exit above. */
8055 tsubst_enum (template_type
, t
, arglist
);
8057 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
8058 /* If the type makes use of template parameters, the
8059 code that generates debugging information will crash. */
8060 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
8062 /* Possibly limit visibility based on template args. */
8063 TREE_PUBLIC (type_decl
) = 1;
8064 determine_visibility (type_decl
);
8066 inherit_targ_abi_tags (t
);
8072 /* Wrapper for lookup_template_class_1. */
8075 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
8076 int entering_scope
, tsubst_flags_t complain
)
8079 timevar_push (TV_TEMPLATE_INST
);
8080 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
8081 entering_scope
, complain
);
8082 timevar_pop (TV_TEMPLATE_INST
);
8086 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST.
8087 The type of the expression is the unknown_type_node since the
8088 template-id could refer to an explicit or partial specialization. */
8091 lookup_template_variable (tree templ
, tree arglist
)
8093 tree type
= unknown_type_node
;
8094 tsubst_flags_t complain
= tf_warning_or_error
;
8095 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (templ
));
8096 arglist
= coerce_template_parms (parms
, arglist
, templ
, complain
,
8097 /*req_all*/true, /*use_default*/true);
8098 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
8106 /* True when we should also visit template parameters that occur in
8107 non-deduced contexts. */
8108 bool include_nondeduced_p
;
8109 hash_set
<tree
> *visited
;
8112 /* Called from for_each_template_parm via walk_tree. */
8115 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
8118 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
8119 tree_fn_t fn
= pfd
->fn
;
8120 void *data
= pfd
->data
;
8123 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
8124 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
8125 pfd
->include_nondeduced_p
))
8126 return error_mark_node
;
8128 switch (TREE_CODE (t
))
8131 if (TYPE_PTRMEMFUNC_P (t
))
8137 if (!TYPE_TEMPLATE_INFO (t
))
8139 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
8140 fn
, data
, pfd
->visited
,
8141 pfd
->include_nondeduced_p
))
8142 return error_mark_node
;
8146 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
8147 fn
, data
, pfd
->visited
,
8148 pfd
->include_nondeduced_p
)
8149 || for_each_template_parm (TYPE_MAX_VALUE (t
),
8150 fn
, data
, pfd
->visited
,
8151 pfd
->include_nondeduced_p
))
8152 return error_mark_node
;
8156 /* Since we're not going to walk subtrees, we have to do this
8158 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
8159 pfd
->visited
, pfd
->include_nondeduced_p
))
8160 return error_mark_node
;
8164 /* Check the return type. */
8165 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8166 pfd
->include_nondeduced_p
))
8167 return error_mark_node
;
8169 /* Check the parameter types. Since default arguments are not
8170 instantiated until they are needed, the TYPE_ARG_TYPES may
8171 contain expressions that involve template parameters. But,
8172 no-one should be looking at them yet. And, once they're
8173 instantiated, they don't contain template parameters, so
8174 there's no point in looking at them then, either. */
8178 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
8179 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
8180 pfd
->visited
, pfd
->include_nondeduced_p
))
8181 return error_mark_node
;
8183 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8184 want walk_tree walking into them itself. */
8190 case UNDERLYING_TYPE
:
8191 if (pfd
->include_nondeduced_p
8192 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
8194 pfd
->include_nondeduced_p
))
8195 return error_mark_node
;
8200 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
8201 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
8202 pfd
->visited
, pfd
->include_nondeduced_p
))
8203 return error_mark_node
;
8208 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
8209 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
8210 pfd
->visited
, pfd
->include_nondeduced_p
))
8211 return error_mark_node
;
8212 if (DECL_CONTEXT (t
)
8213 && pfd
->include_nondeduced_p
8214 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
8215 pfd
->visited
, pfd
->include_nondeduced_p
))
8216 return error_mark_node
;
8219 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8220 /* Record template parameters such as `T' inside `TT<T>'. */
8221 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
8222 pfd
->include_nondeduced_p
))
8223 return error_mark_node
;
8226 case TEMPLATE_TEMPLATE_PARM
:
8227 case TEMPLATE_TYPE_PARM
:
8228 case TEMPLATE_PARM_INDEX
:
8229 if (fn
&& (*fn
)(t
, data
))
8230 return error_mark_node
;
8232 return error_mark_node
;
8236 /* A template template parameter is encountered. */
8237 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
8238 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8239 pfd
->include_nondeduced_p
))
8240 return error_mark_node
;
8242 /* Already substituted template template parameter */
8248 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8250 pfd
->include_nondeduced_p
))
8251 return error_mark_node
;
8255 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8256 && pfd
->include_nondeduced_p
8257 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8258 (TREE_TYPE (t
)), fn
, data
,
8259 pfd
->visited
, pfd
->include_nondeduced_p
))
8260 return error_mark_node
;
8265 /* If there's no type, then this thing must be some expression
8266 involving template parameters. */
8267 if (!fn
&& !TREE_TYPE (t
))
8268 return error_mark_node
;
8273 case IMPLICIT_CONV_EXPR
:
8274 case REINTERPRET_CAST_EXPR
:
8275 case CONST_CAST_EXPR
:
8276 case STATIC_CAST_EXPR
:
8277 case DYNAMIC_CAST_EXPR
:
8281 case PSEUDO_DTOR_EXPR
:
8283 return error_mark_node
;
8290 /* We didn't find any template parameters we liked. */
8294 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8295 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8296 call FN with the parameter and the DATA.
8297 If FN returns nonzero, the iteration is terminated, and
8298 for_each_template_parm returns 1. Otherwise, the iteration
8299 continues. If FN never returns a nonzero value, the value
8300 returned by for_each_template_parm is 0. If FN is NULL, it is
8301 considered to be the function which always returns 1.
8303 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8304 parameters that occur in non-deduced contexts. When false, only
8305 visits those template parameters that can be deduced. */
8308 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8309 hash_set
<tree
> *visited
,
8310 bool include_nondeduced_p
)
8312 struct pair_fn_data pfd
;
8318 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8320 /* Walk the tree. (Conceptually, we would like to walk without
8321 duplicates, but for_each_template_parm_r recursively calls
8322 for_each_template_parm, so we would need to reorganize a fair
8323 bit to use walk_tree_without_duplicates, so we keep our own
8326 pfd
.visited
= visited
;
8328 pfd
.visited
= new hash_set
<tree
>;
8329 result
= cp_walk_tree (&t
,
8330 for_each_template_parm_r
,
8332 pfd
.visited
) != NULL_TREE
;
8344 /* Returns true if T depends on any template parameter. */
8347 uses_template_parms (tree t
)
8353 int saved_processing_template_decl
;
8355 saved_processing_template_decl
= processing_template_decl
;
8356 if (!saved_processing_template_decl
)
8357 processing_template_decl
= 1;
8359 dependent_p
= dependent_type_p (t
);
8360 else if (TREE_CODE (t
) == TREE_VEC
)
8361 dependent_p
= any_dependent_template_arguments_p (t
);
8362 else if (TREE_CODE (t
) == TREE_LIST
)
8363 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8364 || uses_template_parms (TREE_CHAIN (t
)));
8365 else if (TREE_CODE (t
) == TYPE_DECL
)
8366 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8369 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8370 || TREE_CODE (t
) == OVERLOAD
8373 || TREE_CODE (t
) == TRAIT_EXPR
8374 || TREE_CODE (t
) == CONSTRUCTOR
8375 || CONSTANT_CLASS_P (t
))
8376 dependent_p
= (type_dependent_expression_p (t
)
8377 || value_dependent_expression_p (t
));
8380 gcc_assert (t
== error_mark_node
);
8381 dependent_p
= false;
8384 processing_template_decl
= saved_processing_template_decl
;
8389 /* Returns true iff current_function_decl is an incompletely instantiated
8390 template. Useful instead of processing_template_decl because the latter
8391 is set to 0 during instantiate_non_dependent_expr. */
8394 in_template_function (void)
8396 tree fn
= current_function_decl
;
8398 ++processing_template_decl
;
8399 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8400 && DECL_TEMPLATE_INFO (fn
)
8401 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8402 --processing_template_decl
;
8406 /* Returns true if T depends on any template parameter with level LEVEL. */
8409 uses_template_parms_level (tree t
, int level
)
8411 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8412 /*include_nondeduced_p=*/true);
8415 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8416 ill-formed translation unit, i.e. a variable or function that isn't
8417 usable in a constant expression. */
8420 neglectable_inst_p (tree d
)
8423 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8424 : decl_maybe_constant_var_p (d
)));
8427 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8428 neglectable and instantiated from within an erroneous instantiation. */
8431 limit_bad_template_recursion (tree decl
)
8433 struct tinst_level
*lev
= current_tinst_level
;
8434 int errs
= errorcount
+ sorrycount
;
8435 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8438 for (; lev
; lev
= lev
->next
)
8439 if (neglectable_inst_p (lev
->decl
))
8442 return (lev
&& errs
> lev
->errors
);
8445 static int tinst_depth
;
8446 extern int max_tinst_depth
;
8449 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8451 /* We're starting to instantiate D; record the template instantiation context
8452 for diagnostics and to restore it later. */
8455 push_tinst_level (tree d
)
8457 return push_tinst_level_loc (d
, input_location
);
8460 /* We're starting to instantiate D; record the template instantiation context
8461 at LOC for diagnostics and to restore it later. */
8464 push_tinst_level_loc (tree d
, location_t loc
)
8466 struct tinst_level
*new_level
;
8468 if (tinst_depth
>= max_tinst_depth
)
8470 fatal_error ("template instantiation depth exceeds maximum of %d"
8471 " (use -ftemplate-depth= to increase the maximum)",
8476 /* If the current instantiation caused problems, don't let it instantiate
8477 anything else. Do allow deduction substitution and decls usable in
8478 constant expressions. */
8479 if (limit_bad_template_recursion (d
))
8482 new_level
= ggc_alloc
<tinst_level
> ();
8483 new_level
->decl
= d
;
8484 new_level
->locus
= loc
;
8485 new_level
->errors
= errorcount
+sorrycount
;
8486 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8487 new_level
->next
= current_tinst_level
;
8488 current_tinst_level
= new_level
;
8491 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8492 depth_reached
= tinst_depth
;
8497 /* We're done instantiating this template; return to the instantiation
8501 pop_tinst_level (void)
8503 /* Restore the filename and line number stashed away when we started
8504 this instantiation. */
8505 input_location
= current_tinst_level
->locus
;
8506 current_tinst_level
= current_tinst_level
->next
;
8510 /* We're instantiating a deferred template; restore the template
8511 instantiation context in which the instantiation was requested, which
8512 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8515 reopen_tinst_level (struct tinst_level
*level
)
8517 struct tinst_level
*t
;
8520 for (t
= level
; t
; t
= t
->next
)
8523 current_tinst_level
= level
;
8525 if (current_tinst_level
)
8526 current_tinst_level
->errors
= errorcount
+sorrycount
;
8530 /* Returns the TINST_LEVEL which gives the original instantiation
8533 struct tinst_level
*
8534 outermost_tinst_level (void)
8536 struct tinst_level
*level
= current_tinst_level
;
8539 level
= level
->next
;
8543 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8544 vector of template arguments, as for tsubst.
8546 Returns an appropriate tsubst'd friend declaration. */
8549 tsubst_friend_function (tree decl
, tree args
)
8553 if (TREE_CODE (decl
) == FUNCTION_DECL
8554 && DECL_TEMPLATE_INSTANTIATION (decl
)
8555 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8556 /* This was a friend declared with an explicit template
8557 argument list, e.g.:
8561 to indicate that f was a template instantiation, not a new
8562 function declaration. Now, we have to figure out what
8563 instantiation of what template. */
8565 tree template_id
, arglist
, fns
;
8568 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8570 /* Friend functions are looked up in the containing namespace scope.
8571 We must enter that scope, to avoid finding member functions of the
8572 current class with same name. */
8573 push_nested_namespace (ns
);
8574 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8575 tf_warning_or_error
, NULL_TREE
,
8576 /*integral_constant_expression_p=*/false);
8577 pop_nested_namespace (ns
);
8578 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8579 tf_warning_or_error
, NULL_TREE
);
8580 template_id
= lookup_template_function (fns
, arglist
);
8582 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8583 tmpl
= determine_specialization (template_id
, new_friend
,
8585 /*need_member_template=*/0,
8586 TREE_VEC_LENGTH (args
),
8588 return instantiate_template (tmpl
, new_args
, tf_error
);
8591 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8593 /* The NEW_FRIEND will look like an instantiation, to the
8594 compiler, but is not an instantiation from the point of view of
8595 the language. For example, we might have had:
8597 template <class T> struct S {
8598 template <class U> friend void f(T, U);
8601 Then, in S<int>, template <class U> void f(int, U) is not an
8602 instantiation of anything. */
8603 if (new_friend
== error_mark_node
)
8604 return error_mark_node
;
8606 DECL_USE_TEMPLATE (new_friend
) = 0;
8607 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8609 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8610 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8611 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8614 /* The mangled name for the NEW_FRIEND is incorrect. The function
8615 is not a template instantiation and should not be mangled like
8616 one. Therefore, we forget the mangling here; we'll recompute it
8617 later if we need it. */
8618 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8620 SET_DECL_RTL (new_friend
, NULL
);
8621 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8624 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8627 tree new_friend_template_info
;
8628 tree new_friend_result_template_info
;
8630 int new_friend_is_defn
;
8632 /* We must save some information from NEW_FRIEND before calling
8633 duplicate decls since that function will free NEW_FRIEND if
8635 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8636 new_friend_is_defn
=
8637 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8638 (template_for_substitution (new_friend
)))
8640 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8642 /* This declaration is a `primary' template. */
8643 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8645 new_friend_result_template_info
8646 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8649 new_friend_result_template_info
= NULL_TREE
;
8651 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8652 if (new_friend_is_defn
)
8653 DECL_INITIAL (new_friend
) = error_mark_node
;
8655 /* Inside pushdecl_namespace_level, we will push into the
8656 current namespace. However, the friend function should go
8657 into the namespace of the template. */
8658 ns
= decl_namespace_context (new_friend
);
8659 push_nested_namespace (ns
);
8660 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8661 pop_nested_namespace (ns
);
8663 if (old_decl
== error_mark_node
)
8664 return error_mark_node
;
8666 if (old_decl
!= new_friend
)
8668 /* This new friend declaration matched an existing
8669 declaration. For example, given:
8671 template <class T> void f(T);
8672 template <class U> class C {
8673 template <class T> friend void f(T) {}
8676 the friend declaration actually provides the definition
8677 of `f', once C has been instantiated for some type. So,
8678 old_decl will be the out-of-class template declaration,
8679 while new_friend is the in-class definition.
8681 But, if `f' was called before this point, the
8682 instantiation of `f' will have DECL_TI_ARGS corresponding
8683 to `T' but not to `U', references to which might appear
8684 in the definition of `f'. Previously, the most general
8685 template for an instantiation of `f' was the out-of-class
8686 version; now it is the in-class version. Therefore, we
8687 run through all specialization of `f', adding to their
8688 DECL_TI_ARGS appropriately. In particular, they need a
8689 new set of outer arguments, corresponding to the
8690 arguments for this class instantiation.
8692 The same situation can arise with something like this:
8695 template <class T> class C {
8699 when `C<int>' is instantiated. Now, `f(int)' is defined
8702 if (!new_friend_is_defn
)
8703 /* On the other hand, if the in-class declaration does
8704 *not* provide a definition, then we don't want to alter
8705 existing definitions. We can just leave everything
8710 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8711 tree new_args
= TI_ARGS (new_friend_template_info
);
8713 /* Overwrite whatever template info was there before, if
8714 any, with the new template information pertaining to
8716 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8718 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8720 /* We should have called reregister_specialization in
8722 gcc_assert (retrieve_specialization (new_template
,
8726 /* Instantiate it if the global has already been used. */
8727 if (DECL_ODR_USED (old_decl
))
8728 instantiate_decl (old_decl
, /*defer_ok=*/true,
8729 /*expl_inst_class_mem_p=*/false);
8735 /* Indicate that the old function template is a partial
8737 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8738 = new_friend_result_template_info
;
8740 gcc_assert (new_template
8741 == most_general_template (new_template
));
8742 gcc_assert (new_template
!= old_decl
);
8744 /* Reassign any specializations already in the hash table
8745 to the new more general template, and add the
8746 additional template args. */
8747 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8751 tree spec
= TREE_VALUE (t
);
8754 elt
.tmpl
= old_decl
;
8755 elt
.args
= DECL_TI_ARGS (spec
);
8756 elt
.spec
= NULL_TREE
;
8758 decl_specializations
->remove_elt (&elt
);
8761 = add_outermost_template_args (new_args
,
8762 DECL_TI_ARGS (spec
));
8764 register_specialization
8765 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8768 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8772 /* The information from NEW_FRIEND has been merged into OLD_DECL
8773 by duplicate_decls. */
8774 new_friend
= old_decl
;
8779 tree context
= DECL_CONTEXT (new_friend
);
8783 template <class T> class C {
8784 template <class U> friend void C1<U>::f (); // case 1
8785 friend void C2<T>::f (); // case 2
8787 we only need to make sure CONTEXT is a complete type for
8788 case 2. To distinguish between the two cases, we note that
8789 CONTEXT of case 1 remains dependent type after tsubst while
8790 this isn't true for case 2. */
8791 ++processing_template_decl
;
8792 dependent_p
= dependent_type_p (context
);
8793 --processing_template_decl
;
8796 && !complete_type_or_else (context
, NULL_TREE
))
8797 return error_mark_node
;
8799 if (COMPLETE_TYPE_P (context
))
8801 tree fn
= new_friend
;
8802 /* do_friend adds the TEMPLATE_DECL for any member friend
8803 template even if it isn't a member template, i.e.
8804 template <class T> friend A<T>::f();
8805 Look through it in that case. */
8806 if (TREE_CODE (fn
) == TEMPLATE_DECL
8807 && !PRIMARY_TEMPLATE_P (fn
))
8808 fn
= DECL_TEMPLATE_RESULT (fn
);
8809 /* Check to see that the declaration is really present, and,
8810 possibly obtain an improved declaration. */
8811 fn
= check_classfn (context
, fn
, NULL_TREE
);
8821 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8822 template arguments, as for tsubst.
8824 Returns an appropriate tsubst'd friend type or error_mark_node on
8828 tsubst_friend_class (tree friend_tmpl
, tree args
)
8834 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8836 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8837 return TREE_TYPE (t
);
8840 context
= CP_DECL_CONTEXT (friend_tmpl
);
8842 if (context
!= global_namespace
)
8844 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8845 push_nested_namespace (context
);
8847 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8850 /* Look for a class template declaration. We look for hidden names
8851 because two friend declarations of the same template are the
8852 same. For example, in:
8855 template <typename> friend class F;
8857 template <typename> struct B {
8858 template <typename> friend class F;
8861 both F templates are the same. */
8862 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8863 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8865 /* But, if we don't find one, it might be because we're in a
8866 situation like this:
8874 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8875 for `S<int>', not the TEMPLATE_DECL. */
8876 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8878 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8879 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8882 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8884 /* The friend template has already been declared. Just
8885 check to see that the declarations match, and install any new
8886 default parameters. We must tsubst the default parameters,
8887 of course. We only need the innermost template parameters
8888 because that is all that redeclare_class_template will look
8890 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8891 > TMPL_ARGS_DEPTH (args
))
8894 location_t saved_input_location
;
8895 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8896 args
, tf_warning_or_error
);
8898 saved_input_location
= input_location
;
8899 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8900 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8901 input_location
= saved_input_location
;
8905 friend_type
= TREE_TYPE (tmpl
);
8909 /* The friend template has not already been declared. In this
8910 case, the instantiation of the template class will cause the
8911 injection of this template into the global scope. */
8912 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8913 if (tmpl
== error_mark_node
)
8914 return error_mark_node
;
8916 /* The new TMPL is not an instantiation of anything, so we
8917 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8918 the new type because that is supposed to be the corresponding
8919 template decl, i.e., TMPL. */
8920 DECL_USE_TEMPLATE (tmpl
) = 0;
8921 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8922 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8923 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8924 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8926 /* Inject this template into the global scope. */
8927 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8930 if (context
!= global_namespace
)
8932 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8933 pop_nested_namespace (context
);
8935 pop_nested_class ();
8941 /* Returns zero if TYPE cannot be completed later due to circularity.
8942 Otherwise returns one. */
8945 can_complete_type_without_circularity (tree type
)
8947 if (type
== NULL_TREE
|| type
== error_mark_node
)
8949 else if (COMPLETE_TYPE_P (type
))
8951 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8952 return can_complete_type_without_circularity (TREE_TYPE (type
));
8953 else if (CLASS_TYPE_P (type
)
8954 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
8960 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
8962 /* Apply any attributes which had to be deferred until instantiation
8963 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8964 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8967 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
8968 tree args
, tsubst_flags_t complain
, tree in_decl
)
8970 tree last_dep
= NULL_TREE
;
8974 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
8975 if (ATTR_IS_DEPENDENT (t
))
8978 attributes
= copy_list (attributes
);
8982 if (DECL_P (*decl_p
))
8984 if (TREE_TYPE (*decl_p
) == error_mark_node
)
8986 p
= &DECL_ATTRIBUTES (*decl_p
);
8989 p
= &TYPE_ATTRIBUTES (*decl_p
);
8993 tree late_attrs
= NULL_TREE
;
8994 tree
*q
= &late_attrs
;
8996 for (*p
= attributes
; *p
; )
8999 if (ATTR_IS_DEPENDENT (t
))
9001 *p
= TREE_CHAIN (t
);
9002 TREE_CHAIN (t
) = NULL_TREE
;
9003 if ((flag_openmp
|| flag_cilkplus
)
9004 && is_attribute_p ("omp declare simd",
9005 get_attribute_name (t
))
9008 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
9009 clauses
= tsubst_omp_clauses (clauses
, true, args
,
9011 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
9012 clauses
= finish_omp_clauses (clauses
);
9013 tree parms
= DECL_ARGUMENTS (*decl_p
);
9015 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
9017 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
9019 TREE_VALUE (t
) = NULL_TREE
;
9021 /* If the first attribute argument is an identifier, don't
9022 pass it through tsubst. Attributes like mode, format,
9023 cleanup and several target specific attributes expect it
9025 else if (attribute_takes_identifier_p (get_attribute_name (t
))
9029 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
9031 /*integral_constant_expression_p=*/false);
9032 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
9034 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
9039 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
9040 /*integral_constant_expression_p=*/false);
9042 q
= &TREE_CHAIN (t
);
9045 p
= &TREE_CHAIN (t
);
9048 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
9052 /* Perform (or defer) access check for typedefs that were referenced
9053 from within the template TMPL code.
9054 This is a subroutine of instantiate_decl and instantiate_class_template.
9055 TMPL is the template to consider and TARGS is the list of arguments of
9059 perform_typedefs_access_check (tree tmpl
, tree targs
)
9061 location_t saved_location
;
9063 qualified_typedef_usage_t
*iter
;
9066 || (!CLASS_TYPE_P (tmpl
)
9067 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
9070 saved_location
= input_location
;
9071 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
9073 tree type_decl
= iter
->typedef_decl
;
9074 tree type_scope
= iter
->context
;
9076 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
9079 if (uses_template_parms (type_decl
))
9080 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
9081 if (uses_template_parms (type_scope
))
9082 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
9084 /* Make access check error messages point to the location
9085 of the use of the typedef. */
9086 input_location
= iter
->locus
;
9087 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
9088 type_decl
, type_decl
,
9089 tf_warning_or_error
);
9091 input_location
= saved_location
;
9095 instantiate_class_template_1 (tree type
)
9097 tree templ
, args
, pattern
, t
, member
;
9101 unsigned int saved_maximum_field_alignment
;
9104 if (type
== error_mark_node
)
9105 return error_mark_node
;
9107 if (COMPLETE_OR_OPEN_TYPE_P (type
)
9108 || uses_template_parms (type
))
9111 /* Figure out which template is being instantiated. */
9112 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
9113 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
9115 /* Determine what specialization of the original template to
9117 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
9118 if (t
== error_mark_node
)
9120 TYPE_BEING_DEFINED (type
) = 1;
9121 return error_mark_node
;
9125 /* This TYPE is actually an instantiation of a partial
9126 specialization. We replace the innermost set of ARGS with
9127 the arguments appropriate for substitution. For example,
9130 template <class T> struct S {};
9131 template <class T> struct S<T*> {};
9133 and supposing that we are instantiating S<int*>, ARGS will
9134 presently be {int*} -- but we need {int}. */
9135 pattern
= TREE_TYPE (t
);
9136 args
= TREE_PURPOSE (t
);
9140 pattern
= TREE_TYPE (templ
);
9141 args
= CLASSTYPE_TI_ARGS (type
);
9144 /* If the template we're instantiating is incomplete, then clearly
9145 there's nothing we can do. */
9146 if (!COMPLETE_TYPE_P (pattern
))
9149 /* If we've recursively instantiated too many templates, stop. */
9150 if (! push_tinst_level (type
))
9153 /* Now we're really doing the instantiation. Mark the type as in
9154 the process of being defined. */
9155 TYPE_BEING_DEFINED (type
) = 1;
9157 /* We may be in the middle of deferred access check. Disable
9159 push_deferring_access_checks (dk_no_deferred
);
9161 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
9162 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9163 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
9164 fn_context
= error_mark_node
;
9166 push_to_top_level ();
9167 /* Use #pragma pack from the template context. */
9168 saved_maximum_field_alignment
= maximum_field_alignment
;
9169 maximum_field_alignment
= TYPE_PRECISION (pattern
);
9171 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
9173 /* Set the input location to the most specialized template definition.
9174 This is needed if tsubsting causes an error. */
9175 typedecl
= TYPE_MAIN_DECL (pattern
);
9176 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
9177 DECL_SOURCE_LOCATION (typedecl
);
9179 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
9180 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
9181 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
9182 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
9183 if (ANON_AGGR_TYPE_P (pattern
))
9184 SET_ANON_AGGR_TYPE_P (type
);
9185 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
9187 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
9188 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
9189 /* Adjust visibility for template arguments. */
9190 determine_visibility (TYPE_MAIN_DECL (type
));
9192 if (CLASS_TYPE_P (type
))
9193 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
9195 pbinfo
= TYPE_BINFO (pattern
);
9197 /* We should never instantiate a nested class before its enclosing
9198 class; we need to look up the nested class by name before we can
9199 instantiate it, and that lookup should instantiate the enclosing
9201 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
9202 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
9204 base_list
= NULL_TREE
;
9205 if (BINFO_N_BASE_BINFOS (pbinfo
))
9211 /* We must enter the scope containing the type, as that is where
9212 the accessibility of types named in dependent bases are
9214 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9216 /* Substitute into each of the bases to determine the actual
9218 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9221 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9222 tree expanded_bases
= NULL_TREE
;
9225 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9228 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9229 args
, tf_error
, NULL_TREE
);
9230 if (expanded_bases
== error_mark_node
)
9233 len
= TREE_VEC_LENGTH (expanded_bases
);
9236 for (idx
= 0; idx
< len
; idx
++)
9239 /* Extract the already-expanded base class. */
9240 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9242 /* Substitute to figure out the base class. */
9243 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9246 if (base
== error_mark_node
)
9249 base_list
= tree_cons (access
, base
, base_list
);
9250 if (BINFO_VIRTUAL_P (pbase_binfo
))
9251 TREE_TYPE (base_list
) = integer_type_node
;
9255 /* The list is now in reverse order; correct that. */
9256 base_list
= nreverse (base_list
);
9259 pop_scope (pushed_scope
);
9261 /* Now call xref_basetypes to set up all the base-class
9263 xref_basetypes (type
, base_list
);
9265 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9266 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9267 args
, tf_error
, NULL_TREE
);
9268 fixup_attribute_variants (type
);
9270 /* Now that our base classes are set up, enter the scope of the
9271 class, so that name lookups into base classes, etc. will work
9272 correctly. This is precisely analogous to what we do in
9273 begin_class_definition when defining an ordinary non-template
9274 class, except we also need to push the enclosing classes. */
9275 push_nested_class (type
);
9277 /* Now members are processed in the order of declaration. */
9278 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9279 member
; member
= TREE_CHAIN (member
))
9281 tree t
= TREE_VALUE (member
);
9283 if (TREE_PURPOSE (member
))
9287 /* Build new CLASSTYPE_NESTED_UTDS. */
9290 bool class_template_p
;
9292 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9293 && TYPE_LANG_SPECIFIC (t
)
9294 && CLASSTYPE_IS_TEMPLATE (t
));
9295 /* If the member is a class template, then -- even after
9296 substitution -- there may be dependent types in the
9297 template argument list for the class. We increment
9298 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9299 that function will assume that no types are dependent
9300 when outside of a template. */
9301 if (class_template_p
)
9302 ++processing_template_decl
;
9303 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9304 if (class_template_p
)
9305 --processing_template_decl
;
9306 if (newtag
== error_mark_node
)
9309 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9311 tree name
= TYPE_IDENTIFIER (t
);
9313 if (class_template_p
)
9314 /* Unfortunately, lookup_template_class sets
9315 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9316 instantiation (i.e., for the type of a member
9317 template class nested within a template class.)
9318 This behavior is required for
9319 maybe_process_partial_specialization to work
9320 correctly, but is not accurate in this case;
9321 the TAG is not an instantiation of anything.
9322 (The corresponding TEMPLATE_DECL is an
9323 instantiation, but the TYPE is not.) */
9324 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9326 /* Now, we call pushtag to put this NEWTAG into the scope of
9327 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9328 pushtag calling push_template_decl. We don't have to do
9329 this for enums because it will already have been done in
9332 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9333 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9336 else if (DECL_DECLARES_FUNCTION_P (t
))
9338 /* Build new TYPE_METHODS. */
9341 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9342 ++processing_template_decl
;
9343 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9344 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9345 --processing_template_decl
;
9346 set_current_access_from_decl (r
);
9347 finish_member_declaration (r
);
9348 /* Instantiate members marked with attribute used. */
9349 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9351 if (TREE_CODE (r
) == FUNCTION_DECL
9352 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9353 cp_check_omp_declare_reduction (r
);
9355 else if (DECL_CLASS_TEMPLATE_P (t
)
9356 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
9357 /* A closure type for a lambda in a default argument for a
9358 member template. Ignore it; it will be instantiated with
9359 the default argument. */;
9362 /* Build new TYPE_FIELDS. */
9363 if (TREE_CODE (t
) == STATIC_ASSERT
)
9367 ++c_inhibit_evaluation_warnings
;
9369 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9370 tf_warning_or_error
, NULL_TREE
,
9371 /*integral_constant_expression_p=*/true);
9372 --c_inhibit_evaluation_warnings
;
9374 finish_static_assert (condition
,
9375 STATIC_ASSERT_MESSAGE (t
),
9376 STATIC_ASSERT_SOURCE_LOCATION (t
),
9379 else if (TREE_CODE (t
) != CONST_DECL
)
9382 tree vec
= NULL_TREE
;
9385 /* The file and line for this declaration, to
9386 assist in error message reporting. Since we
9387 called push_tinst_level above, we don't need to
9389 input_location
= DECL_SOURCE_LOCATION (t
);
9391 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9392 ++processing_template_decl
;
9393 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9394 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9395 --processing_template_decl
;
9397 if (TREE_CODE (r
) == TREE_VEC
)
9399 /* A capture pack became multiple fields. */
9401 len
= TREE_VEC_LENGTH (vec
);
9404 for (int i
= 0; i
< len
; ++i
)
9407 r
= TREE_VEC_ELT (vec
, i
);
9412 [t]he initialization (and any associated
9413 side-effects) of a static data member does
9414 not occur unless the static data member is
9415 itself used in a way that requires the
9416 definition of the static data member to
9419 Therefore, we do not substitute into the
9420 initialized for the static data member here. */
9421 finish_static_data_member_decl
9424 /*init_const_expr_p=*/false,
9425 /*asmspec_tree=*/NULL_TREE
,
9427 /* Instantiate members marked with attribute used. */
9428 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9431 else if (TREE_CODE (r
) == FIELD_DECL
)
9433 /* Determine whether R has a valid type and can be
9434 completed later. If R is invalid, then its type
9435 is replaced by error_mark_node. */
9436 tree rtype
= TREE_TYPE (r
);
9437 if (can_complete_type_without_circularity (rtype
))
9438 complete_type (rtype
);
9440 if (!COMPLETE_TYPE_P (rtype
))
9442 cxx_incomplete_type_error (r
, rtype
);
9443 TREE_TYPE (r
) = error_mark_node
;
9447 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9448 such a thing will already have been added to the field
9449 list by tsubst_enum in finish_member_declaration in the
9450 CLASSTYPE_NESTED_UTDS case above. */
9451 if (!(TREE_CODE (r
) == TYPE_DECL
9452 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9453 && DECL_ARTIFICIAL (r
)))
9455 set_current_access_from_decl (r
);
9456 finish_member_declaration (r
);
9464 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9465 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9467 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9469 tree friend_type
= t
;
9470 bool adjust_processing_template_decl
= false;
9472 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9474 /* template <class T> friend class C; */
9475 friend_type
= tsubst_friend_class (friend_type
, args
);
9476 adjust_processing_template_decl
= true;
9478 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9480 /* template <class T> friend class C::D; */
9481 friend_type
= tsubst (friend_type
, args
,
9482 tf_warning_or_error
, NULL_TREE
);
9483 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9484 friend_type
= TREE_TYPE (friend_type
);
9485 adjust_processing_template_decl
= true;
9487 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9488 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9490 /* This could be either
9494 when dependent_type_p is false or
9496 template <class U> friend class T::C;
9499 friend_type
= tsubst (friend_type
, args
,
9500 tf_warning_or_error
, NULL_TREE
);
9501 /* Bump processing_template_decl for correct
9502 dependent_type_p calculation. */
9503 ++processing_template_decl
;
9504 if (dependent_type_p (friend_type
))
9505 adjust_processing_template_decl
= true;
9506 --processing_template_decl
;
9508 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9509 && hidden_name_p (TYPE_NAME (friend_type
)))
9513 where C hasn't been declared yet. Let's lookup name
9514 from namespace scope directly, bypassing any name that
9515 come from dependent base class. */
9516 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9518 /* The call to xref_tag_from_type does injection for friend
9520 push_nested_namespace (ns
);
9522 xref_tag_from_type (friend_type
, NULL_TREE
,
9523 /*tag_scope=*/ts_current
);
9524 pop_nested_namespace (ns
);
9526 else if (uses_template_parms (friend_type
))
9527 /* friend class C<T>; */
9528 friend_type
= tsubst (friend_type
, args
,
9529 tf_warning_or_error
, NULL_TREE
);
9534 where C is already declared or
9536 friend class C<int>;
9538 We don't have to do anything in these cases. */
9540 if (adjust_processing_template_decl
)
9541 /* Trick make_friend_class into realizing that the friend
9542 we're adding is a template, not an ordinary class. It's
9543 important that we use make_friend_class since it will
9544 perform some error-checking and output cross-reference
9546 ++processing_template_decl
;
9548 if (friend_type
!= error_mark_node
)
9549 make_friend_class (type
, friend_type
, /*complain=*/false);
9551 if (adjust_processing_template_decl
)
9552 --processing_template_decl
;
9556 /* Build new DECL_FRIENDLIST. */
9559 /* The file and line for this declaration, to
9560 assist in error message reporting. Since we
9561 called push_tinst_level above, we don't need to
9563 input_location
= DECL_SOURCE_LOCATION (t
);
9565 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9567 ++processing_template_decl
;
9568 push_deferring_access_checks (dk_no_check
);
9571 r
= tsubst_friend_function (t
, args
);
9572 add_friend (type
, r
, /*complain=*/false);
9573 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9575 pop_deferring_access_checks ();
9576 --processing_template_decl
;
9582 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9584 tree decl
= lambda_function (type
);
9587 if (!DECL_TEMPLATE_INFO (decl
)
9588 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9589 instantiate_decl (decl
, false, false);
9591 /* We need to instantiate the capture list from the template
9592 after we've instantiated the closure members, but before we
9593 consider adding the conversion op. Also keep any captures
9594 that may have been added during instantiation of the op(). */
9595 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9597 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9598 args
, tf_warning_or_error
, NULL_TREE
,
9601 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9602 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9604 maybe_add_lambda_conv_op (type
);
9607 gcc_assert (errorcount
);
9610 /* Set the file and line number information to whatever is given for
9611 the class itself. This puts error messages involving generated
9612 implicit functions at a predictable point, and the same point
9613 that would be used for non-template classes. */
9614 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9616 unreverse_member_declarations (type
);
9617 finish_struct_1 (type
);
9618 TYPE_BEING_DEFINED (type
) = 0;
9620 /* We don't instantiate default arguments for member functions. 14.7.1:
9622 The implicit instantiation of a class template specialization causes
9623 the implicit instantiation of the declarations, but not of the
9624 definitions or default arguments, of the class member functions,
9625 member classes, static data members and member templates.... */
9627 /* Some typedefs referenced from within the template code need to be access
9628 checked at template instantiation time, i.e now. These types were
9629 added to the template at parsing time. Let's get those and perform
9630 the access checks then. */
9631 perform_typedefs_access_check (pattern
, args
);
9632 perform_deferred_access_checks (tf_warning_or_error
);
9633 pop_nested_class ();
9634 maximum_field_alignment
= saved_maximum_field_alignment
;
9636 pop_from_top_level ();
9637 pop_deferring_access_checks ();
9640 /* The vtable for a template class can be emitted in any translation
9641 unit in which the class is instantiated. When there is no key
9642 method, however, finish_struct_1 will already have added TYPE to
9643 the keyed_classes list. */
9644 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9645 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9650 /* Wrapper for instantiate_class_template_1. */
9653 instantiate_class_template (tree type
)
9656 timevar_push (TV_TEMPLATE_INST
);
9657 ret
= instantiate_class_template_1 (type
);
9658 timevar_pop (TV_TEMPLATE_INST
);
9663 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9669 else if (TYPE_P (t
))
9670 r
= tsubst (t
, args
, complain
, in_decl
);
9673 if (!(complain
& tf_warning
))
9674 ++c_inhibit_evaluation_warnings
;
9675 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9676 /*integral_constant_expression_p=*/true);
9677 if (!(complain
& tf_warning
))
9678 --c_inhibit_evaluation_warnings
;
9683 /* Given a function parameter pack TMPL_PARM and some function parameters
9684 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9685 and set *SPEC_P to point at the next point in the list. */
9688 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9690 /* Collect all of the extra "packed" parameters into an
9694 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9695 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9696 tree spec_parm
= *spec_p
;
9699 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9701 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9704 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9705 parmvec
= make_tree_vec (len
);
9706 parmtypevec
= make_tree_vec (len
);
9707 spec_parm
= *spec_p
;
9708 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9710 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9711 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9714 /* Build the argument packs. */
9715 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9716 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9717 TREE_TYPE (argpack
) = argtypepack
;
9718 *spec_p
= spec_parm
;
9723 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9724 NONTYPE_ARGUMENT_PACK. */
9727 make_fnparm_pack (tree spec_parm
)
9729 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9732 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9736 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9738 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9739 if (i
>= TREE_VEC_LENGTH (vec
))
9741 return PACK_EXPANSION_P (TREE_VEC_ELT (vec
, i
));
9745 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9748 make_argument_pack_select (tree arg_pack
, unsigned index
)
9750 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9752 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9753 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9758 /* This is a subroutine of tsubst_pack_expansion.
9760 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9761 mechanism to store the (non complete list of) arguments of the
9762 substitution and return a non substituted pack expansion, in order
9763 to wait for when we have enough arguments to really perform the
9767 use_pack_expansion_extra_args_p (tree parm_packs
,
9771 /* If one pack has an expansion and another pack has a normal
9772 argument or if one pack has an empty argument and an another
9773 one hasn't then tsubst_pack_expansion cannot perform the
9774 substitution and need to fall back on the
9775 PACK_EXPANSION_EXTRA mechanism. */
9776 if (parm_packs
== NULL_TREE
)
9778 else if (has_empty_arg
)
9781 bool has_expansion_arg
= false;
9782 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9784 bool has_non_expansion_arg
= false;
9785 for (tree parm_pack
= parm_packs
;
9787 parm_pack
= TREE_CHAIN (parm_pack
))
9789 tree arg
= TREE_VALUE (parm_pack
);
9791 if (argument_pack_element_is_expansion_p (arg
, i
))
9792 has_expansion_arg
= true;
9794 has_non_expansion_arg
= true;
9797 if (has_expansion_arg
&& has_non_expansion_arg
)
9803 /* [temp.variadic]/6 says that:
9805 The instantiation of a pack expansion [...]
9806 produces a list E1,E2, ..., En, where N is the number of elements
9807 in the pack expansion parameters.
9809 This subroutine of tsubst_pack_expansion produces one of these Ei.
9811 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9812 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9813 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9814 INDEX is the index 'i' of the element Ei to produce. ARGS,
9815 COMPLAIN, and IN_DECL are the same parameters as for the
9816 tsubst_pack_expansion function.
9818 The function returns the resulting Ei upon successful completion,
9821 Note that this function possibly modifies the ARGS parameter, so
9822 it's the responsibility of the caller to restore it. */
9825 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9828 tree args
/* This parm gets
9830 tsubst_flags_t complain
,
9834 bool ith_elem_is_expansion
= false;
9836 /* For each parameter pack, change the substitution of the parameter
9837 pack to the ith argument in its argument pack, then expand the
9839 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9841 tree parm
= TREE_PURPOSE (pack
);
9842 tree arg_pack
= TREE_VALUE (pack
);
9843 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9845 ith_elem_is_expansion
|=
9846 argument_pack_element_is_expansion_p (arg_pack
, index
);
9848 /* Select the Ith argument from the pack. */
9849 if (TREE_CODE (parm
) == PARM_DECL
9850 || TREE_CODE (parm
) == FIELD_DECL
)
9854 aps
= make_argument_pack_select (arg_pack
, index
);
9856 register_local_specialization (aps
, parm
);
9859 aps
= retrieve_local_specialization (parm
);
9864 template_parm_level_and_index (parm
, &level
, &idx
);
9868 aps
= make_argument_pack_select (arg_pack
, index
);
9869 /* Update the corresponding argument. */
9870 TMPL_ARG (args
, level
, idx
) = aps
;
9873 /* Re-use the ARGUMENT_PACK_SELECT. */
9874 aps
= TMPL_ARG (args
, level
, idx
);
9876 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9879 /* Substitute into the PATTERN with the (possibly altered)
9881 if (pattern
== in_decl
)
9882 /* Expanding a fixed parameter pack from
9883 coerce_template_parameter_pack. */
9884 t
= tsubst_decl (pattern
, args
, complain
);
9885 else if (!TYPE_P (pattern
))
9886 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9887 /*integral_constant_expression_p=*/false);
9889 t
= tsubst (pattern
, args
, complain
, in_decl
);
9891 /* If the Ith argument pack element is a pack expansion, then
9892 the Ith element resulting from the substituting is going to
9893 be a pack expansion as well. */
9894 if (ith_elem_is_expansion
)
9895 t
= make_pack_expansion (t
);
9900 /* Substitute ARGS into T, which is an pack expansion
9901 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9902 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9903 (if only a partial substitution could be performed) or
9904 ERROR_MARK_NODE if there was an error. */
9906 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9910 tree pack
, packs
= NULL_TREE
;
9911 bool unsubstituted_packs
= false;
9914 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
9915 bool need_local_specializations
= false;
9918 gcc_assert (PACK_EXPANSION_P (t
));
9919 pattern
= PACK_EXPANSION_PATTERN (t
);
9921 /* Add in any args remembered from an earlier partial instantiation. */
9922 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9924 levels
= TMPL_ARGS_DEPTH (args
);
9926 /* Determine the argument packs that will instantiate the parameter
9927 packs used in the expansion expression. While we're at it,
9928 compute the number of arguments to be expanded and make sure it
9930 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
9931 pack
= TREE_CHAIN (pack
))
9933 tree parm_pack
= TREE_VALUE (pack
);
9934 tree arg_pack
= NULL_TREE
;
9935 tree orig_arg
= NULL_TREE
;
9938 if (TREE_CODE (parm_pack
) == BASES
)
9940 if (BASES_DIRECT (parm_pack
))
9941 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9942 args
, complain
, in_decl
, false));
9944 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9945 args
, complain
, in_decl
, false));
9947 if (TREE_CODE (parm_pack
) == PARM_DECL
)
9949 if (PACK_EXPANSION_LOCAL_P (t
))
9950 arg_pack
= retrieve_local_specialization (parm_pack
);
9953 /* We can't rely on local_specializations for a parameter
9954 name used later in a function declaration (such as in a
9955 late-specified return type). Even if it exists, it might
9956 have the wrong value for a recursive call. Just make a
9957 dummy decl, since it's only used for its type. */
9958 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
9959 if (arg_pack
&& DECL_PACK_P (arg_pack
))
9960 /* Partial instantiation of the parm_pack, we can't build
9961 up an argument pack yet. */
9962 arg_pack
= NULL_TREE
;
9964 arg_pack
= make_fnparm_pack (arg_pack
);
9965 need_local_specializations
= true;
9968 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
9969 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
9973 template_parm_level_and_index (parm_pack
, &level
, &idx
);
9975 if (level
<= levels
)
9976 arg_pack
= TMPL_ARG (args
, level
, idx
);
9979 orig_arg
= arg_pack
;
9980 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
9981 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
9983 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
9984 /* This can only happen if we forget to expand an argument
9985 pack somewhere else. Just return an error, silently. */
9987 result
= make_tree_vec (1);
9988 TREE_VEC_ELT (result
, 0) = error_mark_node
;
9995 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
9997 /* Don't bother trying to do a partial substitution with
9998 incomplete packs; we'll try again after deduction. */
9999 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
10004 else if (len
!= my_len
)
10006 if (!(complain
& tf_error
))
10007 /* Fail quietly. */;
10008 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
10009 error ("mismatched argument pack lengths while expanding "
10013 error ("mismatched argument pack lengths while expanding "
10016 return error_mark_node
;
10019 /* Keep track of the parameter packs and their corresponding
10021 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
10022 TREE_TYPE (packs
) = orig_arg
;
10026 /* We can't substitute for this parameter pack. We use a flag as
10027 well as the missing_level counter because function parameter
10028 packs don't have a level. */
10029 unsubstituted_packs
= true;
10033 /* If the expansion is just T..., return the matching argument pack. */
10034 if (!unsubstituted_packs
10035 && TREE_PURPOSE (packs
) == pattern
)
10037 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
10038 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
10039 || pack_expansion_args_count (args
))
10041 /* Otherwise use the normal path so we get convert_from_reference. */
10044 /* We cannot expand this expansion expression, because we don't have
10045 all of the argument packs we need. */
10046 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
10048 /* We got some full packs, but we can't substitute them in until we
10049 have values for all the packs. So remember these until then. */
10051 t
= make_pack_expansion (pattern
);
10052 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
10055 else if (unsubstituted_packs
)
10057 /* There were no real arguments, we're just replacing a parameter
10058 pack with another version of itself. Substitute into the
10059 pattern and return a PACK_EXPANSION_*. The caller will need to
10061 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
10062 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
10063 /*integral_constant_expression_p=*/false);
10065 t
= tsubst (pattern
, args
, complain
, in_decl
);
10066 t
= make_pack_expansion (t
);
10070 gcc_assert (len
>= 0);
10072 if (need_local_specializations
)
10074 /* We're in a late-specified return type, so create our own local
10075 specializations map; the current map is either NULL or (in the
10076 case of recursive unification) might have bindings that we don't
10077 want to use or alter. */
10078 saved_local_specializations
= local_specializations
;
10079 local_specializations
= new hash_map
<tree
, tree
>;
10082 /* For each argument in each argument pack, substitute into the
10084 result
= make_tree_vec (len
);
10085 for (i
= 0; i
< len
; ++i
)
10087 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
10091 TREE_VEC_ELT (result
, i
) = t
;
10092 if (t
== error_mark_node
)
10094 result
= error_mark_node
;
10099 /* Update ARGS to restore the substitution from parameter packs to
10100 their argument packs. */
10101 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
10103 tree parm
= TREE_PURPOSE (pack
);
10105 if (TREE_CODE (parm
) == PARM_DECL
10106 || TREE_CODE (parm
) == FIELD_DECL
)
10107 register_local_specialization (TREE_TYPE (pack
), parm
);
10112 if (TREE_VALUE (pack
) == NULL_TREE
)
10115 template_parm_level_and_index (parm
, &level
, &idx
);
10117 /* Update the corresponding argument. */
10118 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
10119 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
10122 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
10126 if (need_local_specializations
)
10128 delete local_specializations
;
10129 local_specializations
= saved_local_specializations
;
10135 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10136 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10137 parameter packs; all parms generated from a function parameter pack will
10138 have the same DECL_PARM_INDEX. */
10141 get_pattern_parm (tree parm
, tree tmpl
)
10143 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
10146 if (DECL_ARTIFICIAL (parm
))
10148 for (patparm
= DECL_ARGUMENTS (pattern
);
10149 patparm
; patparm
= DECL_CHAIN (patparm
))
10150 if (DECL_ARTIFICIAL (patparm
)
10151 && DECL_NAME (parm
) == DECL_NAME (patparm
))
10156 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
10157 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
10158 gcc_assert (DECL_PARM_INDEX (patparm
)
10159 == DECL_PARM_INDEX (parm
));
10165 /* Substitute ARGS into the vector or list of template arguments T. */
10168 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10171 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
10174 if (t
== error_mark_node
)
10175 return error_mark_node
;
10177 len
= TREE_VEC_LENGTH (t
);
10178 elts
= XALLOCAVEC (tree
, len
);
10180 for (i
= 0; i
< len
; i
++)
10182 tree orig_arg
= TREE_VEC_ELT (t
, i
);
10185 if (TREE_CODE (orig_arg
) == TREE_VEC
)
10186 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
10187 else if (PACK_EXPANSION_P (orig_arg
))
10189 /* Substitute into an expansion expression. */
10190 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
10192 if (TREE_CODE (new_arg
) == TREE_VEC
)
10193 /* Add to the expanded length adjustment the number of
10194 expanded arguments. We subtract one from this
10195 measurement, because the argument pack expression
10196 itself is already counted as 1 in
10197 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10198 the argument pack is empty. */
10199 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
10201 else if (ARGUMENT_PACK_P (orig_arg
))
10203 /* Substitute into each of the arguments. */
10204 new_arg
= TYPE_P (orig_arg
)
10205 ? cxx_make_type (TREE_CODE (orig_arg
))
10206 : make_node (TREE_CODE (orig_arg
));
10208 SET_ARGUMENT_PACK_ARGS (
10210 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
10211 args
, complain
, in_decl
));
10213 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
10214 new_arg
= error_mark_node
;
10216 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
10217 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
10218 complain
, in_decl
);
10219 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
10221 if (TREE_TYPE (new_arg
) == error_mark_node
)
10222 new_arg
= error_mark_node
;
10226 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
10228 if (new_arg
== error_mark_node
)
10229 return error_mark_node
;
10232 if (new_arg
!= orig_arg
)
10239 /* Make space for the expanded arguments coming from template
10241 t
= make_tree_vec (len
+ expanded_len_adjust
);
10242 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10243 arguments for a member template.
10244 In that case each TREE_VEC in ORIG_T represents a level of template
10245 arguments, and ORIG_T won't carry any non defaulted argument count.
10246 It will rather be the nested TREE_VECs that will carry one.
10247 In other words, ORIG_T carries a non defaulted argument count only
10248 if it doesn't contain any nested TREE_VEC. */
10249 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
10251 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
10252 count
+= expanded_len_adjust
;
10253 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
10255 for (i
= 0, out
= 0; i
< len
; i
++)
10257 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
10258 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
10259 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10263 /* Now expand the template argument pack "in place". */
10264 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10265 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10269 TREE_VEC_ELT (t
, out
) = elts
[i
];
10277 /* Return the result of substituting ARGS into the template parameters
10278 given by PARMS. If there are m levels of ARGS and m + n levels of
10279 PARMS, then the result will contain n levels of PARMS. For
10280 example, if PARMS is `template <class T> template <class U>
10281 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10282 result will be `template <int*, double, class V>'. */
10285 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10287 tree r
= NULL_TREE
;
10290 /* When substituting into a template, we must set
10291 PROCESSING_TEMPLATE_DECL as the template parameters may be
10292 dependent if they are based on one-another, and the dependency
10293 predicates are short-circuit outside of templates. */
10294 ++processing_template_decl
;
10296 for (new_parms
= &r
;
10297 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10298 new_parms
= &(TREE_CHAIN (*new_parms
)),
10299 parms
= TREE_CHAIN (parms
))
10302 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10305 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10309 if (parms
== error_mark_node
)
10312 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10314 if (tuple
== error_mark_node
)
10317 TREE_VEC_ELT (new_vec
, i
) =
10318 tsubst_template_parm (tuple
, args
, complain
);
10322 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10323 - TMPL_ARGS_DEPTH (args
)),
10324 new_vec
, NULL_TREE
);
10327 --processing_template_decl
;
10332 /* Return the result of substituting ARGS into one template parameter
10333 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10334 parameter and which TREE_PURPOSE is the default argument of the
10335 template parameter. */
10338 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10340 tree default_value
, parm_decl
;
10342 if (args
== NULL_TREE
10344 || t
== error_mark_node
)
10347 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10349 default_value
= TREE_PURPOSE (t
);
10350 parm_decl
= TREE_VALUE (t
);
10352 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10353 if (TREE_CODE (parm_decl
) == PARM_DECL
10354 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10355 parm_decl
= error_mark_node
;
10356 default_value
= tsubst_template_arg (default_value
, args
,
10357 complain
, NULL_TREE
);
10359 return build_tree_list (default_value
, parm_decl
);
10362 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10363 type T. If T is not an aggregate or enumeration type, it is
10364 handled as if by tsubst. IN_DECL is as for tsubst. If
10365 ENTERING_SCOPE is nonzero, T is the context for a template which
10366 we are presently tsubst'ing. Return the substituted value. */
10369 tsubst_aggr_type (tree t
,
10371 tsubst_flags_t complain
,
10373 int entering_scope
)
10375 if (t
== NULL_TREE
)
10378 switch (TREE_CODE (t
))
10381 if (TYPE_PTRMEMFUNC_P (t
))
10382 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10384 /* Else fall through. */
10385 case ENUMERAL_TYPE
:
10387 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10392 int saved_unevaluated_operand
;
10393 int saved_inhibit_evaluation_warnings
;
10395 /* In "sizeof(X<I>)" we need to evaluate "I". */
10396 saved_unevaluated_operand
= cp_unevaluated_operand
;
10397 cp_unevaluated_operand
= 0;
10398 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10399 c_inhibit_evaluation_warnings
= 0;
10401 /* First, determine the context for the type we are looking
10403 context
= TYPE_CONTEXT (t
);
10404 if (context
&& TYPE_P (context
))
10406 context
= tsubst_aggr_type (context
, args
, complain
,
10407 in_decl
, /*entering_scope=*/1);
10408 /* If context is a nested class inside a class template,
10409 it may still need to be instantiated (c++/33959). */
10410 context
= complete_type (context
);
10413 /* Then, figure out what arguments are appropriate for the
10414 type we are trying to find. For example, given:
10416 template <class T> struct S;
10417 template <class T, class U> void f(T, U) { S<U> su; }
10419 and supposing that we are instantiating f<int, double>,
10420 then our ARGS will be {int, double}, but, when looking up
10421 S we only want {double}. */
10422 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10423 complain
, in_decl
);
10424 if (argvec
== error_mark_node
)
10425 r
= error_mark_node
;
10428 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10429 entering_scope
, complain
);
10430 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10433 cp_unevaluated_operand
= saved_unevaluated_operand
;
10434 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10439 /* This is not a template type, so there's nothing to do. */
10443 return tsubst (t
, args
, complain
, in_decl
);
10447 /* Substitute into the default argument ARG (a default argument for
10448 FN), which has the indicated TYPE. */
10451 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10453 tree saved_class_ptr
= NULL_TREE
;
10454 tree saved_class_ref
= NULL_TREE
;
10455 int errs
= errorcount
+ sorrycount
;
10457 /* This can happen in invalid code. */
10458 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10461 /* This default argument came from a template. Instantiate the
10462 default argument here, not in tsubst. In the case of
10471 we must be careful to do name lookup in the scope of S<T>,
10472 rather than in the current class. */
10473 push_access_scope (fn
);
10474 /* The "this" pointer is not valid in a default argument. */
10477 saved_class_ptr
= current_class_ptr
;
10478 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10479 saved_class_ref
= current_class_ref
;
10480 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10483 push_deferring_access_checks(dk_no_deferred
);
10484 /* The default argument expression may cause implicitly defined
10485 member functions to be synthesized, which will result in garbage
10486 collection. We must treat this situation as if we were within
10487 the body of function so as to avoid collecting live data on the
10490 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10491 complain
, NULL_TREE
,
10492 /*integral_constant_expression_p=*/false);
10494 pop_deferring_access_checks();
10496 /* Restore the "this" pointer. */
10499 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10500 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10503 if (errorcount
+sorrycount
> errs
10504 && (complain
& tf_warning_or_error
))
10505 inform (input_location
,
10506 " when instantiating default argument for call to %D", fn
);
10508 /* Make sure the default argument is reasonable. */
10509 arg
= check_default_argument (type
, arg
, complain
);
10511 pop_access_scope (fn
);
10516 /* Substitute into all the default arguments for FN. */
10519 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10524 tmpl_args
= DECL_TI_ARGS (fn
);
10526 /* If this function is not yet instantiated, we certainly don't need
10527 its default arguments. */
10528 if (uses_template_parms (tmpl_args
))
10530 /* Don't do this again for clones. */
10531 if (DECL_CLONED_FUNCTION_P (fn
))
10534 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10536 arg
= TREE_CHAIN (arg
))
10537 if (TREE_PURPOSE (arg
))
10538 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10540 TREE_PURPOSE (arg
),
10544 /* Substitute the ARGS into the T, which is a _DECL. Return the
10545 result of the substitution. Issue error and warning messages under
10546 control of COMPLAIN. */
10549 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10551 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10552 location_t saved_loc
;
10553 tree r
= NULL_TREE
;
10555 hashval_t hash
= 0;
10557 /* Set the filename and linenumber to improve error-reporting. */
10558 saved_loc
= input_location
;
10559 input_location
= DECL_SOURCE_LOCATION (t
);
10561 switch (TREE_CODE (t
))
10563 case TEMPLATE_DECL
:
10565 /* We can get here when processing a member function template,
10566 member class template, or template template parameter. */
10567 tree decl
= DECL_TEMPLATE_RESULT (t
);
10572 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10574 /* Template template parameter is treated here. */
10575 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10576 if (new_type
== error_mark_node
)
10577 RETURN (error_mark_node
);
10578 /* If we get a real template back, return it. This can happen in
10579 the context of most_specialized_partial_spec. */
10580 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10584 DECL_CHAIN (r
) = NULL_TREE
;
10585 TREE_TYPE (r
) = new_type
;
10586 DECL_TEMPLATE_RESULT (r
)
10587 = build_decl (DECL_SOURCE_LOCATION (decl
),
10588 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10589 DECL_TEMPLATE_PARMS (r
)
10590 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10592 TYPE_NAME (new_type
) = r
;
10596 /* We might already have an instance of this template.
10597 The ARGS are for the surrounding class type, so the
10598 full args contain the tsubst'd args for the context,
10599 plus the innermost args from the template decl. */
10600 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10601 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10602 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10603 /* Because this is a template, the arguments will still be
10604 dependent, even after substitution. If
10605 PROCESSING_TEMPLATE_DECL is not set, the dependency
10606 predicates will short-circuit. */
10607 ++processing_template_decl
;
10608 full_args
= tsubst_template_args (tmpl_args
, args
,
10609 complain
, in_decl
);
10610 --processing_template_decl
;
10611 if (full_args
== error_mark_node
)
10612 RETURN (error_mark_node
);
10614 /* If this is a default template template argument,
10615 tsubst might not have changed anything. */
10616 if (full_args
== tmpl_args
)
10619 hash
= hash_tmpl_and_args (t
, full_args
);
10620 spec
= retrieve_specialization (t
, full_args
, hash
);
10621 if (spec
!= NULL_TREE
)
10627 /* Make a new template decl. It will be similar to the
10628 original, but will record the current template arguments.
10629 We also create a new function declaration, which is just
10630 like the old one, but points to this new template, rather
10631 than the old one. */
10633 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10634 DECL_CHAIN (r
) = NULL_TREE
;
10636 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10638 if (TREE_CODE (decl
) == TYPE_DECL
10639 && !TYPE_DECL_ALIAS_P (decl
))
10642 ++processing_template_decl
;
10643 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10644 --processing_template_decl
;
10645 if (new_type
== error_mark_node
)
10646 RETURN (error_mark_node
);
10648 TREE_TYPE (r
) = new_type
;
10649 /* For a partial specialization, we need to keep pointing to
10650 the primary template. */
10651 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10652 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10653 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10654 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10655 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10660 ++processing_template_decl
;
10661 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10662 --processing_template_decl
;
10663 if (new_decl
== error_mark_node
)
10664 RETURN (error_mark_node
);
10666 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10667 DECL_TI_TEMPLATE (new_decl
) = r
;
10668 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10669 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10670 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10673 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10674 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10675 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10677 /* The template parameters for this new template are all the
10678 template parameters for the old template, except the
10679 outermost level of parameters. */
10680 DECL_TEMPLATE_PARMS (r
)
10681 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10684 if (PRIMARY_TEMPLATE_P (t
))
10685 DECL_PRIMARY_TEMPLATE (r
) = r
;
10687 if (TREE_CODE (decl
) != TYPE_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
10688 /* Record this non-type partial instantiation. */
10689 register_specialization (r
, t
,
10690 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10695 case FUNCTION_DECL
:
10698 tree argvec
= NULL_TREE
;
10706 /* Nobody should be tsubst'ing into non-template functions. */
10707 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10709 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10714 /* If T is not dependent, just return it. We have to
10715 increment PROCESSING_TEMPLATE_DECL because
10716 value_dependent_expression_p assumes that nothing is
10717 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10718 ++processing_template_decl
;
10719 dependent_p
= value_dependent_expression_p (t
);
10720 --processing_template_decl
;
10724 /* Calculate the most general template of which R is a
10725 specialization, and the complete set of arguments used to
10727 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10728 argvec
= tsubst_template_args (DECL_TI_ARGS
10729 (DECL_TEMPLATE_RESULT
10730 (DECL_TI_TEMPLATE (t
))),
10731 args
, complain
, in_decl
);
10732 if (argvec
== error_mark_node
)
10733 RETURN (error_mark_node
);
10735 /* Check to see if we already have this specialization. */
10736 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10737 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10745 /* We can see more levels of arguments than parameters if
10746 there was a specialization of a member template, like
10749 template <class T> struct S { template <class U> void f(); }
10750 template <> template <class U> void S<int>::f(U);
10752 Here, we'll be substituting into the specialization,
10753 because that's where we can find the code we actually
10754 want to generate, but we'll have enough arguments for
10755 the most general template.
10757 We also deal with the peculiar case:
10759 template <class T> struct S {
10760 template <class U> friend void f();
10762 template <class U> void f() {}
10764 template void f<double>();
10766 Here, the ARGS for the instantiation of will be {int,
10767 double}. But, we only need as many ARGS as there are
10768 levels of template parameters in CODE_PATTERN. We are
10769 careful not to get fooled into reducing the ARGS in
10772 template <class T> struct S { template <class U> void f(U); }
10773 template <class T> template <> void S<T>::f(int) {}
10775 which we can spot because the pattern will be a
10776 specialization in this case. */
10777 args_depth
= TMPL_ARGS_DEPTH (args
);
10779 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10780 if (args_depth
> parms_depth
10781 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10782 args
= get_innermost_template_args (args
, parms_depth
);
10786 /* This special case arises when we have something like this:
10788 template <class T> struct S {
10789 friend void f<int>(int, double);
10792 Here, the DECL_TI_TEMPLATE for the friend declaration
10793 will be an IDENTIFIER_NODE. We are being called from
10794 tsubst_friend_function, and we want only to create a
10795 new decl (R) with appropriate types so that we can call
10796 determine_specialization. */
10797 gen_tmpl
= NULL_TREE
;
10800 if (DECL_CLASS_SCOPE_P (t
))
10802 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10806 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10807 complain
, t
, /*entering_scope=*/1);
10812 ctx
= DECL_CONTEXT (t
);
10814 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10815 if (type
== error_mark_node
)
10816 RETURN (error_mark_node
);
10818 /* If we hit excessive deduction depth, the type is bogus even if
10819 it isn't error_mark_node, so don't build a decl. */
10820 if (excessive_deduction_depth
)
10821 RETURN (error_mark_node
);
10823 /* We do NOT check for matching decls pushed separately at this
10824 point, as they may not represent instantiations of this
10825 template, and in any case are considered separate under the
10828 DECL_USE_TEMPLATE (r
) = 0;
10829 TREE_TYPE (r
) = type
;
10830 /* Clear out the mangled name and RTL for the instantiation. */
10831 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10832 SET_DECL_RTL (r
, NULL
);
10833 /* Leave DECL_INITIAL set on deleted instantiations. */
10834 if (!DECL_DELETED_FN (r
))
10835 DECL_INITIAL (r
) = NULL_TREE
;
10836 DECL_CONTEXT (r
) = ctx
;
10838 /* OpenMP UDRs have the only argument a reference to the declared
10839 type. We want to diagnose if the declared type is a reference,
10840 which is invalid, but as references to references are usually
10841 quietly merged, diagnose it here. */
10842 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10845 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10846 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10847 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10848 error_at (DECL_SOURCE_LOCATION (t
),
10849 "reference type %qT in "
10850 "%<#pragma omp declare reduction%>", argtype
);
10851 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10852 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10856 if (member
&& DECL_CONV_FN_P (r
))
10857 /* Type-conversion operator. Reconstruct the name, in
10858 case it's the name of one of the template's parameters. */
10859 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10861 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10863 DECL_RESULT (r
) = NULL_TREE
;
10865 TREE_STATIC (r
) = 0;
10866 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10867 DECL_EXTERNAL (r
) = 1;
10868 /* If this is an instantiation of a function with internal
10869 linkage, we already know what object file linkage will be
10870 assigned to the instantiation. */
10871 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10872 DECL_DEFER_OUTPUT (r
) = 0;
10873 DECL_CHAIN (r
) = NULL_TREE
;
10874 DECL_PENDING_INLINE_INFO (r
) = 0;
10875 DECL_PENDING_INLINE_P (r
) = 0;
10876 DECL_SAVED_TREE (r
) = NULL_TREE
;
10877 DECL_STRUCT_FUNCTION (r
) = NULL
;
10879 /* We'll re-clone as appropriate in instantiate_template. */
10880 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10882 /* If we aren't complaining now, return on error before we register
10883 the specialization so that we'll complain eventually. */
10884 if ((complain
& tf_error
) == 0
10885 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10886 && !grok_op_properties (r
, /*complain=*/false))
10887 RETURN (error_mark_node
);
10889 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10890 this in the special friend case mentioned above where
10891 GEN_TMPL is NULL. */
10894 DECL_TEMPLATE_INFO (r
)
10895 = build_template_info (gen_tmpl
, argvec
);
10896 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10899 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10901 /* We instantiated this while substituting into
10902 the type earlier (template/friend54.C). */
10905 /* We're not supposed to instantiate default arguments
10906 until they are called, for a template. But, for a
10909 template <class T> void f ()
10910 { extern void g(int i = T()); }
10912 we should do the substitution when the template is
10913 instantiated. We handle the member function case in
10914 instantiate_class_template since the default arguments
10915 might refer to other members of the class. */
10917 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10918 && !uses_template_parms (argvec
))
10919 tsubst_default_arguments (r
, complain
);
10922 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10924 /* Copy the list of befriending classes. */
10925 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10927 friends
= &TREE_CHAIN (*friends
))
10929 *friends
= copy_node (*friends
);
10930 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
10935 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
10937 maybe_retrofit_in_chrg (r
);
10938 if (DECL_CONSTRUCTOR_P (r
))
10939 grok_ctor_properties (ctx
, r
);
10940 if (DECL_INHERITED_CTOR_BASE (r
))
10941 deduce_inheriting_ctor (r
);
10942 /* If this is an instantiation of a member template, clone it.
10943 If it isn't, that'll be handled by
10944 clone_constructors_and_destructors. */
10945 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
10946 clone_function_decl (r
, /*update_method_vec_p=*/0);
10948 else if ((complain
& tf_error
) != 0
10949 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10950 && !grok_op_properties (r
, /*complain=*/true))
10951 RETURN (error_mark_node
);
10953 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
10954 SET_DECL_FRIEND_CONTEXT (r
,
10955 tsubst (DECL_FRIEND_CONTEXT (t
),
10956 args
, complain
, in_decl
));
10958 /* Possibly limit visibility based on template args. */
10959 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10960 if (DECL_VISIBILITY_SPECIFIED (t
))
10962 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10963 DECL_ATTRIBUTES (r
)
10964 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10966 determine_visibility (r
);
10967 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
10968 && !processing_template_decl
)
10969 defaulted_late_check (r
);
10971 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10972 args
, complain
, in_decl
);
10978 tree type
= NULL_TREE
;
10980 tree expanded_types
= NULL_TREE
;
10981 tree prev_r
= NULL_TREE
;
10982 tree first_r
= NULL_TREE
;
10984 if (DECL_PACK_P (t
))
10986 /* If there is a local specialization that isn't a
10987 parameter pack, it means that we're doing a "simple"
10988 substitution from inside tsubst_pack_expansion. Just
10989 return the local specialization (which will be a single
10991 tree spec
= retrieve_local_specialization (t
);
10993 && TREE_CODE (spec
) == PARM_DECL
10994 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
10997 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10998 the parameters in this function parameter pack. */
10999 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11000 complain
, in_decl
);
11001 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11003 len
= TREE_VEC_LENGTH (expanded_types
);
11005 /* Zero-length parameter packs are boring. Just substitute
11008 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
11013 /* All we did was update the type. Make a note of that. */
11014 type
= expanded_types
;
11015 expanded_types
= NULL_TREE
;
11019 /* Loop through all of the parameters we'll build. When T is
11020 a function parameter pack, LEN is the number of expanded
11021 types in EXPANDED_TYPES; otherwise, LEN is 1. */
11023 for (i
= 0; i
< len
; ++i
)
11027 if (DECL_TEMPLATE_PARM_P (t
))
11028 SET_DECL_TEMPLATE_PARM_P (r
);
11030 if (expanded_types
)
11031 /* We're on the Ith parameter of the function parameter
11034 /* Get the Ith type. */
11035 type
= TREE_VEC_ELT (expanded_types
, i
);
11037 /* Rename the parameter to include the index. */
11039 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11042 /* We're dealing with a normal parameter. */
11043 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11045 type
= type_decays_to (type
);
11046 TREE_TYPE (r
) = type
;
11047 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11049 if (DECL_INITIAL (r
))
11051 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
11052 DECL_INITIAL (r
) = TREE_TYPE (r
);
11054 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
11055 complain
, in_decl
);
11058 DECL_CONTEXT (r
) = NULL_TREE
;
11060 if (!DECL_TEMPLATE_PARM_P (r
))
11061 DECL_ARG_TYPE (r
) = type_passed_as (type
);
11063 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11064 args
, complain
, in_decl
);
11066 /* Keep track of the first new parameter we
11067 generate. That's what will be returned to the
11072 /* Build a proper chain of parameters when substituting
11073 into a function parameter pack. */
11075 DECL_CHAIN (prev_r
) = r
;
11078 /* If cp_unevaluated_operand is set, we're just looking for a
11079 single dummy parameter, so don't keep going. */
11080 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
11081 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
11082 complain
, DECL_CHAIN (t
));
11084 /* FIRST_R contains the start of the chain we've built. */
11091 tree type
= NULL_TREE
;
11092 tree vec
= NULL_TREE
;
11093 tree expanded_types
= NULL_TREE
;
11096 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
11098 /* This field is a lambda capture pack. Return a TREE_VEC of
11099 the expanded fields to instantiate_class_template_1 and
11100 store them in the specializations hash table as a
11101 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11102 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11103 complain
, in_decl
);
11104 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11106 len
= TREE_VEC_LENGTH (expanded_types
);
11107 vec
= make_tree_vec (len
);
11111 /* All we did was update the type. Make a note of that. */
11112 type
= expanded_types
;
11113 expanded_types
= NULL_TREE
;
11117 for (int i
= 0; i
< len
; ++i
)
11120 if (expanded_types
)
11122 type
= TREE_VEC_ELT (expanded_types
, i
);
11124 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11127 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11129 if (type
== error_mark_node
)
11130 RETURN (error_mark_node
);
11131 TREE_TYPE (r
) = type
;
11132 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11134 if (DECL_C_BIT_FIELD (r
))
11135 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11136 non-bit-fields DECL_INITIAL is a non-static data member
11137 initializer, which gets deferred instantiation. */
11139 = tsubst_expr (DECL_INITIAL (t
), args
,
11141 /*integral_constant_expression_p=*/true);
11142 else if (DECL_INITIAL (t
))
11144 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11145 NSDMI in perform_member_init. Still set DECL_INITIAL
11146 so that we know there is one. */
11147 DECL_INITIAL (r
) = void_node
;
11148 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
11149 retrofit_lang_decl (r
);
11150 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
11152 /* We don't have to set DECL_CONTEXT here; it is set by
11153 finish_member_declaration. */
11154 DECL_CHAIN (r
) = NULL_TREE
;
11156 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11157 args
, complain
, in_decl
);
11160 TREE_VEC_ELT (vec
, i
) = r
;
11166 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
11167 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
11168 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
11169 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
11170 TREE_TYPE (pack
) = tpack
;
11171 register_specialization (pack
, t
, args
, false, 0);
11177 /* We reach here only for member using decls. We also need to check
11178 uses_template_parms because DECL_DEPENDENT_P is not set for a
11179 using-declaration that designates a member of the current
11180 instantiation (c++/53549). */
11181 if (DECL_DEPENDENT_P (t
)
11182 || uses_template_parms (USING_DECL_SCOPE (t
)))
11184 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
11185 complain
, in_decl
);
11186 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
11187 r
= do_class_using_decl (inst_scope
, name
);
11189 r
= error_mark_node
;
11192 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
11193 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
11199 DECL_CHAIN (r
) = NULL_TREE
;
11206 tree argvec
= NULL_TREE
;
11207 tree gen_tmpl
= NULL_TREE
;
11209 tree tmpl
= NULL_TREE
;
11211 tree type
= NULL_TREE
;
11214 if (TREE_TYPE (t
) == error_mark_node
)
11215 RETURN (error_mark_node
);
11217 if (TREE_CODE (t
) == TYPE_DECL
11218 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
11220 /* If this is the canonical decl, we don't have to
11221 mess with instantiations, and often we can't (for
11222 typename, template type parms and such). Note that
11223 TYPE_NAME is not correct for the above test if
11224 we've copied the type for a typedef. */
11225 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11226 if (type
== error_mark_node
)
11227 RETURN (error_mark_node
);
11228 r
= TYPE_NAME (type
);
11232 /* Check to see if we already have the specialization we
11235 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
11237 /* T is a static data member or namespace-scope entity.
11238 We have to substitute into namespace-scope variables
11239 (even though such entities are never templates) because
11242 template <class T> void f() { extern T t; }
11244 where the entity referenced is not known until
11245 instantiation time. */
11247 ctx
= DECL_CONTEXT (t
);
11248 if (DECL_CLASS_SCOPE_P (t
))
11250 ctx
= tsubst_aggr_type (ctx
, args
,
11252 in_decl
, /*entering_scope=*/1);
11253 /* If CTX is unchanged, then T is in fact the
11254 specialization we want. That situation occurs when
11255 referencing a static data member within in its own
11256 class. We can use pointer equality, rather than
11257 same_type_p, because DECL_CONTEXT is always
11259 if (ctx
== DECL_CONTEXT (t
)
11260 /* ... unless T is a member template; in which
11261 case our caller can be willing to create a
11262 specialization of that template represented
11264 && !(DECL_TI_TEMPLATE (t
)
11265 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
11271 tmpl
= DECL_TI_TEMPLATE (t
);
11272 gen_tmpl
= most_general_template (tmpl
);
11273 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11274 if (argvec
== error_mark_node
)
11275 RETURN (error_mark_node
);
11276 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11277 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11282 /* A local variable. */
11284 /* Subsequent calls to pushdecl will fill this in. */
11286 spec
= retrieve_local_specialization (t
);
11288 /* If we already have the specialization we need, there is
11289 nothing more to do. */
11296 /* Create a new node for the specialization we need. */
11298 if (type
== NULL_TREE
)
11300 if (is_typedef_decl (t
))
11301 type
= DECL_ORIGINAL_TYPE (t
);
11303 type
= TREE_TYPE (t
);
11305 && VAR_HAD_UNKNOWN_BOUND (t
)
11306 && type
!= error_mark_node
)
11307 type
= strip_array_domain (type
);
11308 type
= tsubst (type
, args
, complain
, in_decl
);
11312 /* Even if the original location is out of scope, the
11313 newly substituted one is not. */
11314 DECL_DEAD_FOR_LOCAL (r
) = 0;
11315 DECL_INITIALIZED_P (r
) = 0;
11316 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11317 if (type
== error_mark_node
)
11318 RETURN (error_mark_node
);
11319 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11321 /* It may seem that this case cannot occur, since:
11326 declares a function, not a variable. However:
11329 template <typename T> void g() { T t; }
11330 template void g<f>();
11332 is an attempt to declare a variable with function
11334 error ("variable %qD has function type",
11335 /* R is not yet sufficiently initialized, so we
11336 just use its name. */
11338 RETURN (error_mark_node
);
11340 type
= complete_type (type
);
11341 /* Wait until cp_finish_decl to set this again, to handle
11342 circular dependency (template/instantiate6.C). */
11343 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11344 type
= check_var_type (DECL_NAME (r
), type
);
11346 if (DECL_HAS_VALUE_EXPR_P (t
))
11348 tree ve
= DECL_VALUE_EXPR (t
);
11349 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11350 /*constant_expression_p=*/false);
11351 if (REFERENCE_REF_P (ve
))
11353 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11354 ve
= TREE_OPERAND (ve
, 0);
11356 SET_DECL_VALUE_EXPR (r
, ve
);
11358 if (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
11359 set_decl_tls_model (r
, decl_tls_model (t
));
11361 else if (DECL_SELF_REFERENCE_P (t
))
11362 SET_DECL_SELF_REFERENCE_P (r
);
11363 TREE_TYPE (r
) = type
;
11364 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11365 DECL_CONTEXT (r
) = ctx
;
11366 /* Clear out the mangled name and RTL for the instantiation. */
11367 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11368 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11369 SET_DECL_RTL (r
, NULL
);
11370 /* The initializer must not be expanded until it is required;
11371 see [temp.inst]. */
11372 DECL_INITIAL (r
) = NULL_TREE
;
11373 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11374 SET_DECL_RTL (r
, NULL
);
11375 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11378 /* Possibly limit visibility based on template args. */
11379 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11380 if (DECL_VISIBILITY_SPECIFIED (t
))
11382 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11383 DECL_ATTRIBUTES (r
)
11384 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11386 determine_visibility (r
);
11391 /* A static data member declaration is always marked
11392 external when it is declared in-class, even if an
11393 initializer is present. We mimic the non-template
11394 processing here. */
11395 DECL_EXTERNAL (r
) = 1;
11397 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11398 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11399 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11401 else if (!cp_unevaluated_operand
)
11402 register_local_specialization (r
, t
);
11404 DECL_CHAIN (r
) = NULL_TREE
;
11406 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11408 args
, complain
, in_decl
);
11410 /* Preserve a typedef that names a type. */
11411 if (is_typedef_decl (r
))
11413 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11414 set_underlying_type (r
);
11417 layout_decl (r
, 0);
11422 gcc_unreachable ();
11427 /* Restore the file and line information. */
11428 input_location
= saved_loc
;
11433 /* Substitute into the ARG_TYPES of a function type.
11434 If END is a TREE_CHAIN, leave it and any following types
11438 tsubst_arg_types (tree arg_types
,
11441 tsubst_flags_t complain
,
11444 tree remaining_arg_types
;
11445 tree type
= NULL_TREE
;
11447 tree expanded_args
= NULL_TREE
;
11450 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11453 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11454 args
, end
, complain
, in_decl
);
11455 if (remaining_arg_types
== error_mark_node
)
11456 return error_mark_node
;
11458 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11460 /* For a pack expansion, perform substitution on the
11461 entire expression. Later on, we'll handle the arguments
11463 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11464 args
, complain
, in_decl
);
11466 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11467 /* So that we'll spin through the parameters, one by one. */
11468 i
= TREE_VEC_LENGTH (expanded_args
);
11471 /* We only partially substituted into the parameter
11472 pack. Our type is TYPE_PACK_EXPANSION. */
11473 type
= expanded_args
;
11474 expanded_args
= NULL_TREE
;
11482 type
= TREE_VEC_ELT (expanded_args
, i
);
11484 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11486 if (type
== error_mark_node
)
11487 return error_mark_node
;
11488 if (VOID_TYPE_P (type
))
11490 if (complain
& tf_error
)
11492 error ("invalid parameter type %qT", type
);
11494 error ("in declaration %q+D", in_decl
);
11496 return error_mark_node
;
11499 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11500 return error_mark_node
;
11502 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11503 top-level qualifiers as required. */
11504 type
= cv_unqualified (type_decays_to (type
));
11506 /* We do not substitute into default arguments here. The standard
11507 mandates that they be instantiated only when needed, which is
11508 done in build_over_call. */
11509 default_arg
= TREE_PURPOSE (arg_types
);
11511 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11513 /* We've instantiated a template before its default arguments
11514 have been parsed. This can happen for a nested template
11515 class, and is not an error unless we require the default
11516 argument in a call of this function. */
11517 remaining_arg_types
=
11518 tree_cons (default_arg
, type
, remaining_arg_types
);
11519 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11522 remaining_arg_types
=
11523 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11526 return remaining_arg_types
;
11529 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11530 *not* handle the exception-specification for FNTYPE, because the
11531 initial substitution of explicitly provided template parameters
11532 during argument deduction forbids substitution into the
11533 exception-specification:
11537 All references in the function type of the function template to the
11538 corresponding template parameters are replaced by the specified tem-
11539 plate argument values. If a substitution in a template parameter or
11540 in the function type of the function template results in an invalid
11541 type, type deduction fails. [Note: The equivalent substitution in
11542 exception specifications is done only when the function is instanti-
11543 ated, at which point a program is ill-formed if the substitution
11544 results in an invalid type.] */
11547 tsubst_function_type (tree t
,
11549 tsubst_flags_t complain
,
11553 tree arg_types
= NULL_TREE
;
11556 /* The TYPE_CONTEXT is not used for function/method types. */
11557 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11559 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11561 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11563 if (late_return_type_p
)
11565 /* Substitute the argument types. */
11566 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11567 complain
, in_decl
);
11568 if (arg_types
== error_mark_node
)
11569 return error_mark_node
;
11571 tree save_ccp
= current_class_ptr
;
11572 tree save_ccr
= current_class_ref
;
11573 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11574 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11575 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11578 /* DR 1207: 'this' is in scope in the trailing return type. */
11579 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11582 /* Substitute the return type. */
11583 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11587 current_class_ptr
= save_ccp
;
11588 current_class_ref
= save_ccr
;
11592 /* Substitute the return type. */
11593 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11595 if (return_type
== error_mark_node
)
11596 return error_mark_node
;
11597 /* DR 486 clarifies that creation of a function type with an
11598 invalid return type is a deduction failure. */
11599 if (TREE_CODE (return_type
) == ARRAY_TYPE
11600 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11602 if (complain
& tf_error
)
11604 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11605 error ("function returning an array");
11607 error ("function returning a function");
11609 return error_mark_node
;
11612 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11613 return error_mark_node
;
11615 if (!late_return_type_p
)
11617 /* Substitute the argument types. */
11618 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11619 complain
, in_decl
);
11620 if (arg_types
== error_mark_node
)
11621 return error_mark_node
;
11624 /* Construct a new type node and return it. */
11625 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11627 fntype
= build_function_type (return_type
, arg_types
);
11628 fntype
= apply_memfn_quals (fntype
,
11629 type_memfn_quals (t
),
11630 type_memfn_rqual (t
));
11634 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11635 /* Don't pick up extra function qualifiers from the basetype. */
11636 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11637 if (! MAYBE_CLASS_TYPE_P (r
))
11641 Type deduction may fail for any of the following
11644 -- Attempting to create "pointer to member of T" when T
11645 is not a class type. */
11646 if (complain
& tf_error
)
11647 error ("creating pointer to member function of non-class type %qT",
11649 return error_mark_node
;
11652 fntype
= build_method_type_directly (r
, return_type
,
11653 TREE_CHAIN (arg_types
));
11654 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11656 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11658 if (late_return_type_p
)
11659 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11664 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11665 ARGS into that specification, and return the substituted
11666 specification. If there is no specification, return NULL_TREE. */
11669 tsubst_exception_specification (tree fntype
,
11671 tsubst_flags_t complain
,
11678 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11679 new_specs
= NULL_TREE
;
11680 if (specs
&& TREE_PURPOSE (specs
))
11682 /* A noexcept-specifier. */
11683 tree expr
= TREE_PURPOSE (specs
);
11684 if (TREE_CODE (expr
) == INTEGER_CST
)
11688 /* Defer instantiation of noexcept-specifiers to avoid
11689 excessive instantiations (c++/49107). */
11690 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11691 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11693 /* We already partially instantiated this member template,
11694 so combine the new args with the old. */
11695 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11696 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11697 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11698 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11702 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11703 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11707 new_specs
= tsubst_copy_and_build
11708 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11709 /*integral_constant_expression_p=*/true);
11710 new_specs
= build_noexcept_spec (new_specs
, complain
);
11714 if (! TREE_VALUE (specs
))
11721 tree expanded_specs
= NULL_TREE
;
11723 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11725 /* Expand the pack expansion type. */
11726 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11730 if (expanded_specs
== error_mark_node
)
11731 return error_mark_node
;
11732 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11733 len
= TREE_VEC_LENGTH (expanded_specs
);
11736 /* We're substituting into a member template, so
11737 we got a TYPE_PACK_EXPANSION back. Add that
11738 expansion and move on. */
11739 gcc_assert (TREE_CODE (expanded_specs
)
11740 == TYPE_PACK_EXPANSION
);
11741 new_specs
= add_exception_specifier (new_specs
,
11744 specs
= TREE_CHAIN (specs
);
11749 for (i
= 0; i
< len
; ++i
)
11751 if (expanded_specs
)
11752 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11754 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11755 if (spec
== error_mark_node
)
11757 new_specs
= add_exception_specifier (new_specs
, spec
,
11761 specs
= TREE_CHAIN (specs
);
11767 /* Take the tree structure T and replace template parameters used
11768 therein with the argument vector ARGS. IN_DECL is an associated
11769 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11770 Issue error and warning messages under control of COMPLAIN. Note
11771 that we must be relatively non-tolerant of extensions here, in
11772 order to preserve conformance; if we allow substitutions that
11773 should not be allowed, we may allow argument deductions that should
11774 not succeed, and therefore report ambiguous overload situations
11775 where there are none. In theory, we could allow the substitution,
11776 but indicate that it should have failed, and allow our caller to
11777 make sure that the right thing happens, but we don't try to do this
11780 This function is used for dealing with types, decls and the like;
11781 for expressions, use tsubst_expr or tsubst_copy. */
11784 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11786 enum tree_code code
;
11787 tree type
, r
= NULL_TREE
;
11789 if (t
== NULL_TREE
|| t
== error_mark_node
11790 || t
== integer_type_node
11791 || t
== void_type_node
11792 || t
== char_type_node
11793 || t
== unknown_type_node
11794 || TREE_CODE (t
) == NAMESPACE_DECL
11795 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11799 return tsubst_decl (t
, args
, complain
);
11801 if (args
== NULL_TREE
)
11804 code
= TREE_CODE (t
);
11806 if (code
== IDENTIFIER_NODE
)
11807 type
= IDENTIFIER_TYPE_VALUE (t
);
11809 type
= TREE_TYPE (t
);
11811 gcc_assert (type
!= unknown_type_node
);
11813 /* Reuse typedefs. We need to do this to handle dependent attributes,
11814 such as attribute aligned. */
11816 && typedef_variant_p (t
))
11818 tree decl
= TYPE_NAME (t
);
11820 if (alias_template_specialization_p (t
))
11822 /* DECL represents an alias template and we want to
11824 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11825 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11826 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11828 else if (DECL_CLASS_SCOPE_P (decl
)
11829 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11830 && uses_template_parms (DECL_CONTEXT (decl
)))
11832 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11833 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11834 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11836 else if (DECL_FUNCTION_SCOPE_P (decl
)
11837 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11838 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11839 r
= retrieve_local_specialization (decl
);
11841 /* The typedef is from a non-template context. */
11847 r
= cp_build_qualified_type_real
11848 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11849 complain
| tf_ignore_bad_quals
);
11854 /* We don't have an instantiation yet, so drop the typedef. */
11855 int quals
= cp_type_quals (t
);
11856 t
= DECL_ORIGINAL_TYPE (decl
);
11857 t
= cp_build_qualified_type_real (t
, quals
,
11858 complain
| tf_ignore_bad_quals
);
11863 && code
!= TYPENAME_TYPE
11864 && code
!= TEMPLATE_TYPE_PARM
11865 && code
!= IDENTIFIER_NODE
11866 && code
!= FUNCTION_TYPE
11867 && code
!= METHOD_TYPE
)
11868 type
= tsubst (type
, args
, complain
, in_decl
);
11869 if (type
== error_mark_node
)
11870 return error_mark_node
;
11876 case ENUMERAL_TYPE
:
11877 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11878 /*entering_scope=*/0);
11881 case IDENTIFIER_NODE
:
11892 if (t
== integer_type_node
)
11895 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11896 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11900 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11902 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11903 /*integral_constant_expression_p=*/false);
11905 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11907 if (TREE_CODE (max
) == NOP_EXPR
11908 && TREE_SIDE_EFFECTS (omax
)
11909 && !TREE_TYPE (max
))
11910 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11912 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11913 with TREE_SIDE_EFFECTS that indicates this is not an integral
11914 constant expression. */
11915 if (processing_template_decl
11916 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11918 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11919 TREE_SIDE_EFFECTS (max
) = 1;
11922 return compute_array_index_type (NULL_TREE
, max
, complain
);
11925 case TEMPLATE_TYPE_PARM
:
11926 case TEMPLATE_TEMPLATE_PARM
:
11927 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11928 case TEMPLATE_PARM_INDEX
:
11933 tree arg
= NULL_TREE
;
11937 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
11938 template_parm_level_and_index (t
, &level
, &idx
);
11940 levels
= TMPL_ARGS_DEPTH (args
);
11941 if (level
<= levels
)
11943 arg
= TMPL_ARG (args
, level
, idx
);
11945 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
11947 /* See through ARGUMENT_PACK_SELECT arguments. */
11948 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
11949 /* If the selected argument is an expansion E, that most
11950 likely means we were called from
11951 gen_elem_of_pack_expansion_instantiation during the
11952 substituting of pack an argument pack (which Ith
11953 element is a pack expansion, where I is
11954 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11955 In this case, the Ith element resulting from this
11956 substituting is going to be a pack expansion, which
11957 pattern is the pattern of E. Let's return the
11959 gen_elem_of_pack_expansion_instantiation will
11960 build the resulting pack expansion from it. */
11961 if (PACK_EXPANSION_P (arg
))
11963 /* Make sure we aren't throwing away arg info. */
11964 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
11965 arg
= PACK_EXPANSION_PATTERN (arg
);
11970 if (arg
== error_mark_node
)
11971 return error_mark_node
;
11972 else if (arg
!= NULL_TREE
)
11974 if (ARGUMENT_PACK_P (arg
))
11975 /* If ARG is an argument pack, we don't actually want to
11976 perform a substitution here, because substitutions
11977 for argument packs are only done
11978 element-by-element. We can get to this point when
11979 substituting the type of a non-type template
11980 parameter pack, when that type actually contains
11981 template parameter packs from an outer template, e.g.,
11983 template<typename... Types> struct A {
11984 template<Types... Values> struct B { };
11988 if (code
== TEMPLATE_TYPE_PARM
)
11991 gcc_assert (TYPE_P (arg
));
11993 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
11995 return cp_build_qualified_type_real
11996 (arg
, quals
, complain
| tf_ignore_bad_quals
);
11998 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12000 /* We are processing a type constructed from a
12001 template template parameter. */
12002 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
12003 args
, complain
, in_decl
);
12004 if (argvec
== error_mark_node
)
12005 return error_mark_node
;
12007 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
12008 || TREE_CODE (arg
) == TEMPLATE_DECL
12009 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
12011 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
12012 /* Consider this code:
12014 template <template <class> class Template>
12016 template <class Arg> using Bind = Template<Arg>;
12019 template <template <class> class Template, class Arg>
12020 using Instantiate = Template<Arg>; //#0
12022 template <template <class> class Template,
12025 Instantiate<Internal<Template>::template Bind,
12028 When #1 is parsed, the
12029 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12030 parameter `Template' in #0 matches the
12031 UNBOUND_CLASS_TEMPLATE representing the argument
12032 `Internal<Template>::template Bind'; We then want
12033 to assemble the type `Bind<Argument>' that can't
12034 be fully created right now, because
12035 `Internal<Template>' not being complete, the Bind
12036 template cannot be looked up in that context. So
12037 we need to "store" `Bind<Argument>' for later
12038 when the context of Bind becomes complete. Let's
12039 store that in a TYPENAME_TYPE. */
12040 return make_typename_type (TYPE_CONTEXT (arg
),
12041 build_nt (TEMPLATE_ID_EXPR
,
12042 TYPE_IDENTIFIER (arg
),
12047 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12048 are resolving nested-types in the signature of a
12049 member function templates. Otherwise ARG is a
12050 TEMPLATE_DECL and is the real template to be
12052 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
12053 arg
= TYPE_NAME (arg
);
12055 r
= lookup_template_class (arg
,
12057 DECL_CONTEXT (arg
),
12058 /*entering_scope=*/0,
12060 return cp_build_qualified_type_real
12061 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
12064 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12065 return convert_from_reference (unshare_expr (arg
));
12069 /* This can happen during the attempted tsubst'ing in
12070 unify. This means that we don't yet have any information
12071 about the template parameter in question. */
12074 /* Early in template argument deduction substitution, we don't
12075 want to reduce the level of 'auto', or it will be confused
12076 with a normal template parm in subsequent deduction. */
12077 if (is_auto (t
) && (complain
& tf_partial
))
12080 /* If we get here, we must have been looking at a parm for a
12081 more deeply nested template. Make a new version of this
12082 template parameter, but with a lower level. */
12085 case TEMPLATE_TYPE_PARM
:
12086 case TEMPLATE_TEMPLATE_PARM
:
12087 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12088 if (cp_type_quals (t
))
12090 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
12091 r
= cp_build_qualified_type_real
12092 (r
, cp_type_quals (t
),
12093 complain
| (code
== TEMPLATE_TYPE_PARM
12094 ? tf_ignore_bad_quals
: 0));
12099 TEMPLATE_TYPE_PARM_INDEX (r
)
12100 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
12101 r
, levels
, args
, complain
);
12102 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
12103 TYPE_MAIN_VARIANT (r
) = r
;
12104 TYPE_POINTER_TO (r
) = NULL_TREE
;
12105 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
12107 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
12108 /* We have reduced the level of the template
12109 template parameter, but not the levels of its
12110 template parameters, so canonical_type_parameter
12111 will not be able to find the canonical template
12112 template parameter for this level. Thus, we
12113 require structural equality checking to compare
12114 TEMPLATE_TEMPLATE_PARMs. */
12115 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12116 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
12117 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12119 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
12121 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12123 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
12124 complain
, in_decl
);
12125 if (argvec
== error_mark_node
)
12126 return error_mark_node
;
12128 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
12129 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
12134 case TEMPLATE_PARM_INDEX
:
12135 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
12139 gcc_unreachable ();
12147 tree purpose
, value
, chain
;
12149 if (t
== void_list_node
)
12152 purpose
= TREE_PURPOSE (t
);
12155 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
12156 if (purpose
== error_mark_node
)
12157 return error_mark_node
;
12159 value
= TREE_VALUE (t
);
12162 value
= tsubst (value
, args
, complain
, in_decl
);
12163 if (value
== error_mark_node
)
12164 return error_mark_node
;
12166 chain
= TREE_CHAIN (t
);
12167 if (chain
&& chain
!= void_type_node
)
12169 chain
= tsubst (chain
, args
, complain
, in_decl
);
12170 if (chain
== error_mark_node
)
12171 return error_mark_node
;
12173 if (purpose
== TREE_PURPOSE (t
)
12174 && value
== TREE_VALUE (t
)
12175 && chain
== TREE_CHAIN (t
))
12177 return hash_tree_cons (purpose
, value
, chain
);
12181 /* We should never be tsubsting a binfo. */
12182 gcc_unreachable ();
12185 /* A vector of template arguments. */
12186 gcc_assert (!type
);
12187 return tsubst_template_args (t
, args
, complain
, in_decl
);
12190 case REFERENCE_TYPE
:
12192 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
12197 Type deduction may fail for any of the following
12200 -- Attempting to create a pointer to reference type.
12201 -- Attempting to create a reference to a reference type or
12202 a reference to void.
12204 Core issue 106 says that creating a reference to a reference
12205 during instantiation is no longer a cause for failure. We
12206 only enforce this check in strict C++98 mode. */
12207 if ((TREE_CODE (type
) == REFERENCE_TYPE
12208 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
12209 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
12211 static location_t last_loc
;
12213 /* We keep track of the last time we issued this error
12214 message to avoid spewing a ton of messages during a
12215 single bad template instantiation. */
12216 if (complain
& tf_error
12217 && last_loc
!= input_location
)
12219 if (VOID_TYPE_P (type
))
12220 error ("forming reference to void");
12221 else if (code
== POINTER_TYPE
)
12222 error ("forming pointer to reference type %qT", type
);
12224 error ("forming reference to reference type %qT", type
);
12225 last_loc
= input_location
;
12228 return error_mark_node
;
12230 else if (TREE_CODE (type
) == FUNCTION_TYPE
12231 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
12232 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12234 if (complain
& tf_error
)
12236 if (code
== POINTER_TYPE
)
12237 error ("forming pointer to qualified function type %qT",
12240 error ("forming reference to qualified function type %qT",
12243 return error_mark_node
;
12245 else if (code
== POINTER_TYPE
)
12247 r
= build_pointer_type (type
);
12248 if (TREE_CODE (type
) == METHOD_TYPE
)
12249 r
= build_ptrmemfunc_type (r
);
12251 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12252 /* In C++0x, during template argument substitution, when there is an
12253 attempt to create a reference to a reference type, reference
12254 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12256 "If a template-argument for a template-parameter T names a type
12257 that is a reference to a type A, an attempt to create the type
12258 'lvalue reference to cv T' creates the type 'lvalue reference to
12259 A,' while an attempt to create the type type rvalue reference to
12260 cv T' creates the type T"
12262 r
= cp_build_reference_type
12264 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12266 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12267 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12269 if (r
!= error_mark_node
)
12270 /* Will this ever be needed for TYPE_..._TO values? */
12277 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12278 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12282 Type deduction may fail for any of the following
12285 -- Attempting to create "pointer to member of T" when T
12286 is not a class type. */
12287 if (complain
& tf_error
)
12288 error ("creating pointer to member of non-class type %qT", r
);
12289 return error_mark_node
;
12291 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12293 if (complain
& tf_error
)
12294 error ("creating pointer to member reference type %qT", type
);
12295 return error_mark_node
;
12297 if (VOID_TYPE_P (type
))
12299 if (complain
& tf_error
)
12300 error ("creating pointer to member of type void");
12301 return error_mark_node
;
12303 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12304 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12306 /* The type of the implicit object parameter gets its
12307 cv-qualifiers from the FUNCTION_TYPE. */
12310 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12311 type_memfn_rqual (type
));
12312 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12313 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12317 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12321 case FUNCTION_TYPE
:
12326 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12327 if (fntype
== error_mark_node
)
12328 return error_mark_node
;
12330 /* Substitute the exception specification. */
12331 specs
= tsubst_exception_specification (t
, args
, complain
,
12332 in_decl
, /*defer_ok*/true);
12333 if (specs
== error_mark_node
)
12334 return error_mark_node
;
12336 fntype
= build_exception_variant (fntype
, specs
);
12341 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12342 if (domain
== error_mark_node
)
12343 return error_mark_node
;
12345 /* As an optimization, we avoid regenerating the array type if
12346 it will obviously be the same as T. */
12347 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12350 /* These checks should match the ones in create_array_type_for_decl.
12354 The deduction may fail for any of the following reasons:
12356 -- Attempting to create an array with an element type that
12357 is void, a function type, or a reference type, or [DR337]
12358 an abstract class type. */
12359 if (VOID_TYPE_P (type
)
12360 || TREE_CODE (type
) == FUNCTION_TYPE
12361 || (TREE_CODE (type
) == ARRAY_TYPE
12362 && TYPE_DOMAIN (type
) == NULL_TREE
)
12363 || TREE_CODE (type
) == REFERENCE_TYPE
)
12365 if (complain
& tf_error
)
12366 error ("creating array of %qT", type
);
12367 return error_mark_node
;
12370 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12371 return error_mark_node
;
12373 r
= build_cplus_array_type (type
, domain
);
12375 if (TYPE_USER_ALIGN (t
))
12377 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12378 TYPE_USER_ALIGN (r
) = 1;
12384 case TYPENAME_TYPE
:
12386 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12387 in_decl
, /*entering_scope=*/1);
12388 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12389 complain
, in_decl
);
12391 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12392 return error_mark_node
;
12394 if (!MAYBE_CLASS_TYPE_P (ctx
))
12396 if (complain
& tf_error
)
12397 error ("%qT is not a class, struct, or union type", ctx
);
12398 return error_mark_node
;
12400 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12402 /* Normally, make_typename_type does not require that the CTX
12403 have complete type in order to allow things like:
12405 template <class T> struct S { typename S<T>::X Y; };
12407 But, such constructs have already been resolved by this
12408 point, so here CTX really should have complete type, unless
12409 it's a partial instantiation. */
12410 ctx
= complete_type (ctx
);
12411 if (!COMPLETE_TYPE_P (ctx
))
12413 if (complain
& tf_error
)
12414 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12415 return error_mark_node
;
12419 f
= make_typename_type (ctx
, f
, typename_type
,
12420 complain
| tf_keep_type_decl
);
12421 if (f
== error_mark_node
)
12423 if (TREE_CODE (f
) == TYPE_DECL
)
12425 complain
|= tf_ignore_bad_quals
;
12429 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12431 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12433 if (complain
& tf_error
)
12434 error ("%qT resolves to %qT, which is not an enumeration type",
12437 return error_mark_node
;
12439 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12441 if (complain
& tf_error
)
12442 error ("%qT resolves to %qT, which is is not a class type",
12445 return error_mark_node
;
12449 return cp_build_qualified_type_real
12450 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12453 case UNBOUND_CLASS_TEMPLATE
:
12455 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12456 in_decl
, /*entering_scope=*/1);
12457 tree name
= TYPE_IDENTIFIER (t
);
12458 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12460 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12461 return error_mark_node
;
12464 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12465 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12472 ++cp_unevaluated_operand
;
12473 ++c_inhibit_evaluation_warnings
;
12475 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12477 /*integral_constant_expression_p=*/false);
12479 --cp_unevaluated_operand
;
12480 --c_inhibit_evaluation_warnings
;
12482 type
= finish_typeof (type
);
12483 return cp_build_qualified_type_real (type
,
12485 | cp_type_quals (type
),
12489 case DECLTYPE_TYPE
:
12493 ++cp_unevaluated_operand
;
12494 ++c_inhibit_evaluation_warnings
;
12496 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12497 complain
|tf_decltype
, in_decl
,
12498 /*function_p*/false,
12499 /*integral_constant_expression*/false);
12501 --cp_unevaluated_operand
;
12502 --c_inhibit_evaluation_warnings
;
12504 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12505 type
= lambda_capture_field_type (type
,
12506 DECLTYPE_FOR_INIT_CAPTURE (t
));
12507 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12508 type
= lambda_proxy_type (type
);
12511 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12512 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12514 /* In a template ~id could be either a complement expression
12515 or an unqualified-id naming a destructor; if instantiating
12516 it produces an expression, it's not an id-expression or
12519 type
= finish_decltype_type (type
, id
, complain
);
12521 return cp_build_qualified_type_real (type
,
12523 | cp_type_quals (type
),
12524 complain
| tf_ignore_bad_quals
);
12527 case UNDERLYING_TYPE
:
12529 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12530 complain
, in_decl
);
12531 return finish_underlying_type (type
);
12534 case TYPE_ARGUMENT_PACK
:
12535 case NONTYPE_ARGUMENT_PACK
:
12537 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12539 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12543 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12545 /* For template nontype argument packs, also substitute into
12547 if (code
== NONTYPE_ARGUMENT_PACK
)
12548 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12567 /* We should use one of the expression tsubsts for these codes. */
12568 gcc_unreachable ();
12571 sorry ("use of %qs in template", get_tree_code_name (code
));
12572 return error_mark_node
;
12576 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12577 type of the expression on the left-hand side of the "." or "->"
12581 tsubst_baselink (tree baselink
, tree object_type
,
12582 tree args
, tsubst_flags_t complain
, tree in_decl
)
12585 tree qualifying_scope
;
12588 tree template_args
= 0;
12589 bool template_id_p
= false;
12590 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12592 /* A baselink indicates a function from a base class. Both the
12593 BASELINK_ACCESS_BINFO and the base class referenced may
12594 indicate bases of the template class, rather than the
12595 instantiated class. In addition, lookups that were not
12596 ambiguous before may be ambiguous now. Therefore, we perform
12597 the lookup again. */
12598 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12599 qualifying_scope
= tsubst (qualifying_scope
, args
,
12600 complain
, in_decl
);
12601 fns
= BASELINK_FUNCTIONS (baselink
);
12602 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12603 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12605 template_id_p
= true;
12606 template_args
= TREE_OPERAND (fns
, 1);
12607 fns
= TREE_OPERAND (fns
, 0);
12609 template_args
= tsubst_template_args (template_args
, args
,
12610 complain
, in_decl
);
12612 name
= DECL_NAME (get_first_fn (fns
));
12613 if (IDENTIFIER_TYPENAME_P (name
))
12614 name
= mangle_conv_op_name_for_type (optype
);
12615 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12617 return error_mark_node
;
12619 /* If lookup found a single function, mark it as used at this
12620 point. (If it lookup found multiple functions the one selected
12621 later by overload resolution will be marked as used at that
12623 if (BASELINK_P (baselink
))
12624 fns
= BASELINK_FUNCTIONS (baselink
);
12625 if (!template_id_p
&& !really_overloaded_fn (fns
))
12626 mark_used (OVL_CURRENT (fns
));
12628 /* Add back the template arguments, if present. */
12629 if (BASELINK_P (baselink
) && template_id_p
)
12630 BASELINK_FUNCTIONS (baselink
)
12631 = build_nt (TEMPLATE_ID_EXPR
,
12632 BASELINK_FUNCTIONS (baselink
),
12634 /* Update the conversion operator type. */
12635 BASELINK_OPTYPE (baselink
) = optype
;
12638 object_type
= current_class_type
;
12641 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12647 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12648 true if the qualified-id will be a postfix-expression in-and-of
12649 itself; false if more of the postfix-expression follows the
12650 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12654 tsubst_qualified_id (tree qualified_id
, tree args
,
12655 tsubst_flags_t complain
, tree in_decl
,
12656 bool done
, bool address_p
)
12662 tree template_args
;
12663 location_t loc
= UNKNOWN_LOCATION
;
12665 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12667 /* Figure out what name to look up. */
12668 name
= TREE_OPERAND (qualified_id
, 1);
12669 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12671 is_template
= true;
12672 loc
= EXPR_LOCATION (name
);
12673 template_args
= TREE_OPERAND (name
, 1);
12675 template_args
= tsubst_template_args (template_args
, args
,
12676 complain
, in_decl
);
12677 name
= TREE_OPERAND (name
, 0);
12681 is_template
= false;
12682 template_args
= NULL_TREE
;
12685 /* Substitute into the qualifying scope. When there are no ARGS, we
12686 are just trying to simplify a non-dependent expression. In that
12687 case the qualifying scope may be dependent, and, in any case,
12688 substituting will not help. */
12689 scope
= TREE_OPERAND (qualified_id
, 0);
12692 scope
= tsubst (scope
, args
, complain
, in_decl
);
12693 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12698 if (dependent_scope_p (scope
))
12701 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12702 return build_qualified_name (NULL_TREE
, scope
, expr
,
12703 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12706 if (!BASELINK_P (name
) && !DECL_P (expr
))
12708 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12710 /* A BIT_NOT_EXPR is used to represent a destructor. */
12711 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12713 error ("qualifying type %qT does not match destructor name ~%qT",
12714 scope
, TREE_OPERAND (expr
, 0));
12715 expr
= error_mark_node
;
12718 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12719 /*is_type_p=*/0, false);
12722 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12723 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12724 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12726 if (complain
& tf_error
)
12728 error ("dependent-name %qE is parsed as a non-type, but "
12729 "instantiation yields a type", qualified_id
);
12730 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12732 return error_mark_node
;
12738 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12740 /* Remember that there was a reference to this entity. */
12744 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12746 if (complain
& tf_error
)
12747 qualified_name_lookup_error (scope
,
12748 TREE_OPERAND (qualified_id
, 1),
12749 expr
, input_location
);
12750 return error_mark_node
;
12754 expr
= lookup_template_function (expr
, template_args
);
12756 if (expr
== error_mark_node
&& complain
& tf_error
)
12757 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12758 expr
, input_location
);
12759 else if (TYPE_P (scope
))
12761 expr
= (adjust_result_of_qualified_name_lookup
12762 (expr
, scope
, current_nonlambda_class_type ()));
12763 expr
= (finish_qualified_id_expr
12764 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12765 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12766 /*template_arg_p=*/false, complain
));
12769 /* Expressions do not generally have reference type. */
12770 if (TREE_CODE (expr
) != SCOPE_REF
12771 /* However, if we're about to form a pointer-to-member, we just
12772 want the referenced member referenced. */
12773 && TREE_CODE (expr
) != OFFSET_REF
)
12774 expr
= convert_from_reference (expr
);
12779 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12780 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12784 tsubst_init (tree init
, tree decl
, tree args
,
12785 tsubst_flags_t complain
, tree in_decl
)
12790 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12794 /* If we had an initializer but it
12795 instantiated to nothing,
12796 value-initialize the object. This will
12797 only occur when the initializer was a
12798 pack expansion where the parameter packs
12799 used in that expansion were of length
12801 init
= build_value_init (TREE_TYPE (decl
),
12803 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12804 init
= get_target_expr_sfinae (init
, complain
);
12810 /* Like tsubst, but deals with expressions. This function just replaces
12811 template parms; to finish processing the resultant expression, use
12812 tsubst_copy_and_build or tsubst_expr. */
12815 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12817 enum tree_code code
;
12820 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12823 code
= TREE_CODE (t
);
12828 r
= retrieve_local_specialization (t
);
12830 if (r
== NULL_TREE
)
12832 /* We get here for a use of 'this' in an NSDMI. */
12833 if (DECL_NAME (t
) == this_identifier
12834 && current_function_decl
12835 && DECL_CONSTRUCTOR_P (current_function_decl
))
12836 return current_class_ptr
;
12838 /* This can happen for a parameter name used later in a function
12839 declaration (such as in a late-specified return type). Just
12840 make a dummy decl, since it's only used for its type. */
12841 gcc_assert (cp_unevaluated_operand
!= 0);
12842 r
= tsubst_decl (t
, args
, complain
);
12843 /* Give it the template pattern as its context; its true context
12844 hasn't been instantiated yet and this is good enough for
12846 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12849 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12850 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12859 if (DECL_TEMPLATE_PARM_P (t
))
12860 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12861 /* There is no need to substitute into namespace-scope
12863 if (DECL_NAMESPACE_SCOPE_P (t
))
12865 /* If ARGS is NULL, then T is known to be non-dependent. */
12866 if (args
== NULL_TREE
)
12867 return scalar_constant_value (t
);
12869 /* Unfortunately, we cannot just call lookup_name here.
12872 template <int I> int f() {
12874 struct S { void g() { E e = a; } };
12877 When we instantiate f<7>::S::g(), say, lookup_name is not
12878 clever enough to find f<7>::a. */
12880 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12881 /*entering_scope=*/0);
12883 for (v
= TYPE_VALUES (enum_type
);
12885 v
= TREE_CHAIN (v
))
12886 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12887 return TREE_VALUE (v
);
12889 /* We didn't find the name. That should never happen; if
12890 name-lookup found it during preliminary parsing, we
12891 should find it again here during instantiation. */
12892 gcc_unreachable ();
12897 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12899 /* Check for a local specialization set up by
12900 tsubst_pack_expansion. */
12901 if (tree r
= retrieve_local_specialization (t
))
12903 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12904 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12908 /* When retrieving a capture pack from a generic lambda, remove the
12909 lambda call op's own template argument list from ARGS. Only the
12910 template arguments active for the closure type should be used to
12911 retrieve the pack specialization. */
12912 if (LAMBDA_FUNCTION_P (current_function_decl
)
12913 && (template_class_depth (DECL_CONTEXT (t
))
12914 != TMPL_ARGS_DEPTH (args
)))
12915 args
= strip_innermost_template_args (args
, 1);
12917 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12918 tsubst_decl put in the hash table. */
12919 return retrieve_specialization (t
, args
, 0);
12922 if (DECL_CONTEXT (t
))
12926 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12927 /*entering_scope=*/1);
12928 if (ctx
!= DECL_CONTEXT (t
))
12930 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
12933 if (complain
& tf_error
)
12934 error ("using invalid field %qD", t
);
12935 return error_mark_node
;
12944 case FUNCTION_DECL
:
12945 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
12946 r
= tsubst (t
, args
, complain
, in_decl
);
12947 else if (local_variable_p (t
))
12949 r
= retrieve_local_specialization (t
);
12950 if (r
== NULL_TREE
)
12952 /* First try name lookup to find the instantiation. */
12953 r
= lookup_name (DECL_NAME (t
));
12956 /* Make sure that the one we found is the one we want. */
12957 tree ctx
= tsubst (DECL_CONTEXT (t
), args
,
12958 complain
, in_decl
);
12959 if (ctx
!= DECL_CONTEXT (r
))
12967 /* This can happen for a variable used in a
12968 late-specified return type of a local lambda, or for a
12969 local static or constant. Building a new VAR_DECL
12970 should be OK in all those cases. */
12971 r
= tsubst_decl (t
, args
, complain
);
12972 if (decl_maybe_constant_var_p (r
))
12974 /* We can't call cp_finish_decl, so handle the
12975 initializer by hand. */
12976 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
12977 complain
, in_decl
);
12978 if (!processing_template_decl
)
12979 init
= maybe_constant_init (init
);
12980 if (processing_template_decl
12981 ? potential_constant_expression (init
)
12982 : reduced_constant_expression_p (init
))
12983 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
12984 = TREE_CONSTANT (r
) = true;
12985 DECL_INITIAL (r
) = init
;
12987 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
12988 || decl_constant_var_p (r
)
12989 || errorcount
|| sorrycount
);
12990 if (!processing_template_decl
)
12992 if (TREE_STATIC (r
))
12993 rest_of_decl_compilation (r
, toplevel_bindings_p (),
12995 else if (decl_constant_var_p (r
))
12996 /* A use of a local constant decays to its value.
12997 FIXME update for core DR 696. */
12998 r
= scalar_constant_value (r
);
13001 /* Remember this for subsequent uses. */
13002 if (local_specializations
)
13003 register_local_specialization (r
, t
);
13011 case NAMESPACE_DECL
:
13015 /* An OVERLOAD will always be a non-dependent overload set; an
13016 overload set from function scope will just be represented with an
13017 IDENTIFIER_NODE, and from class scope with a BASELINK. */
13018 gcc_assert (!uses_template_parms (t
));
13022 return tsubst_baselink (t
, current_nonlambda_class_type (),
13023 args
, complain
, in_decl
);
13025 case TEMPLATE_DECL
:
13026 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13027 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
13028 args
, complain
, in_decl
);
13029 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
13030 return tsubst (t
, args
, complain
, in_decl
);
13031 else if (DECL_CLASS_SCOPE_P (t
)
13032 && uses_template_parms (DECL_CONTEXT (t
)))
13034 /* Template template argument like the following example need
13037 template <template <class> class TT> struct C {};
13038 template <class T> struct D {
13039 template <class U> struct E {};
13044 We are processing the template argument `E' in #1 for
13045 the template instantiation #2. Originally, `E' is a
13046 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13047 have to substitute this with one having context `D<int>'. */
13049 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
13050 return lookup_field (context
, DECL_NAME(t
), 0, false);
13053 /* Ordinary template template argument. */
13057 case REINTERPRET_CAST_EXPR
:
13058 case CONST_CAST_EXPR
:
13059 case STATIC_CAST_EXPR
:
13060 case DYNAMIC_CAST_EXPR
:
13061 case IMPLICIT_CONV_EXPR
:
13065 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13066 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13067 return build1 (code
, type
, op0
);
13071 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
13074 tree expanded
, op
= TREE_OPERAND (t
, 0);
13077 if (SIZEOF_EXPR_TYPE_P (t
))
13078 op
= TREE_TYPE (op
);
13080 ++cp_unevaluated_operand
;
13081 ++c_inhibit_evaluation_warnings
;
13082 /* We only want to compute the number of arguments. */
13083 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
13084 --cp_unevaluated_operand
;
13085 --c_inhibit_evaluation_warnings
;
13087 if (TREE_CODE (expanded
) == TREE_VEC
)
13088 len
= TREE_VEC_LENGTH (expanded
);
13090 if (expanded
== error_mark_node
)
13091 return error_mark_node
;
13092 else if (PACK_EXPANSION_P (expanded
)
13093 || (TREE_CODE (expanded
) == TREE_VEC
13095 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
13097 if (TREE_CODE (expanded
) == TREE_VEC
)
13098 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
13100 if (TYPE_P (expanded
))
13101 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
13102 complain
& tf_error
);
13104 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
13105 complain
& tf_error
);
13108 return build_int_cst (size_type_node
, len
);
13110 if (SIZEOF_EXPR_TYPE_P (t
))
13112 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
13113 args
, complain
, in_decl
);
13114 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
13115 r
= build1 (SIZEOF_EXPR
,
13116 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
13117 SIZEOF_EXPR_TYPE_P (r
) = 1;
13124 case TRUTH_NOT_EXPR
:
13127 case UNARY_PLUS_EXPR
: /* Unary + */
13129 case AT_ENCODE_EXPR
:
13133 case REALPART_EXPR
:
13134 case IMAGPART_EXPR
:
13137 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13138 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13139 return build1 (code
, type
, op0
);
13142 case COMPONENT_REF
:
13147 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13148 name
= TREE_OPERAND (t
, 1);
13149 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
13151 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13152 complain
, in_decl
);
13153 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13155 else if (TREE_CODE (name
) == SCOPE_REF
13156 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
13158 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13159 complain
, in_decl
);
13160 name
= TREE_OPERAND (name
, 1);
13161 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13162 complain
, in_decl
);
13163 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13164 name
= build_qualified_name (/*type=*/NULL_TREE
,
13166 /*template_p=*/false);
13168 else if (BASELINK_P (name
))
13169 name
= tsubst_baselink (name
,
13170 non_reference (TREE_TYPE (object
)),
13174 name
= tsubst_copy (name
, args
, complain
, in_decl
);
13175 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
13181 case TRUNC_DIV_EXPR
:
13182 case CEIL_DIV_EXPR
:
13183 case FLOOR_DIV_EXPR
:
13184 case ROUND_DIV_EXPR
:
13185 case EXACT_DIV_EXPR
:
13189 case TRUNC_MOD_EXPR
:
13190 case FLOOR_MOD_EXPR
:
13191 case TRUTH_ANDIF_EXPR
:
13192 case TRUTH_ORIF_EXPR
:
13193 case TRUTH_AND_EXPR
:
13194 case TRUTH_OR_EXPR
:
13207 case COMPOUND_EXPR
:
13210 case PREDECREMENT_EXPR
:
13211 case PREINCREMENT_EXPR
:
13212 case POSTDECREMENT_EXPR
:
13213 case POSTINCREMENT_EXPR
:
13215 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13216 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13217 return build_nt (code
, op0
, op1
);
13222 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13223 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13224 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
13225 QUALIFIED_NAME_IS_TEMPLATE (t
));
13230 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13231 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13232 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13237 int n
= VL_EXP_OPERAND_LENGTH (t
);
13238 tree result
= build_vl_exp (CALL_EXPR
, n
);
13240 for (i
= 0; i
< n
; i
++)
13241 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13242 complain
, in_decl
);
13248 case PSEUDO_DTOR_EXPR
:
13249 case VEC_PERM_EXPR
:
13251 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13252 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13253 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13254 r
= build_nt (code
, op0
, op1
, op2
);
13255 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13261 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13262 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13263 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13264 r
= build_nt (code
, op0
, op1
, op2
);
13265 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13271 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13272 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13273 r
= build_nt (code
, op0
, op1
);
13274 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13275 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13279 case TEMPLATE_ID_EXPR
:
13281 /* Substituted template arguments */
13282 tree fn
= TREE_OPERAND (t
, 0);
13283 tree targs
= TREE_OPERAND (t
, 1);
13285 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13287 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13289 return lookup_template_function (fn
, targs
);
13294 tree purpose
, value
, chain
;
13296 if (t
== void_list_node
)
13299 purpose
= TREE_PURPOSE (t
);
13301 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13302 value
= TREE_VALUE (t
);
13304 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13305 chain
= TREE_CHAIN (t
);
13306 if (chain
&& chain
!= void_type_node
)
13307 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13308 if (purpose
== TREE_PURPOSE (t
)
13309 && value
== TREE_VALUE (t
)
13310 && chain
== TREE_CHAIN (t
))
13312 return tree_cons (purpose
, value
, chain
);
13317 case ENUMERAL_TYPE
:
13319 case TEMPLATE_TYPE_PARM
:
13320 case TEMPLATE_TEMPLATE_PARM
:
13321 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13322 case TEMPLATE_PARM_INDEX
:
13324 case REFERENCE_TYPE
:
13326 case FUNCTION_TYPE
:
13329 case TYPENAME_TYPE
:
13330 case UNBOUND_CLASS_TEMPLATE
:
13332 case DECLTYPE_TYPE
:
13334 return tsubst (t
, args
, complain
, in_decl
);
13338 /* Fall through. */
13339 case IDENTIFIER_NODE
:
13340 if (IDENTIFIER_TYPENAME_P (t
))
13342 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13343 return mangle_conv_op_name_for_type (new_type
);
13349 /* This is handled by tsubst_copy_and_build. */
13350 gcc_unreachable ();
13354 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13355 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13356 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13359 case CLEANUP_POINT_EXPR
:
13360 /* We shouldn't have built any of these during initial template
13361 generation. Instead, they should be built during instantiation
13362 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13363 gcc_unreachable ();
13367 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13368 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13369 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13370 r
= build2 (code
, type
, op0
, op1
);
13371 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13372 mark_used (TREE_OPERAND (r
, 1));
13376 case EXPR_PACK_EXPANSION
:
13377 error ("invalid use of pack expansion expression");
13378 return error_mark_node
;
13380 case NONTYPE_ARGUMENT_PACK
:
13381 error ("use %<...%> to expand argument pack");
13382 return error_mark_node
;
13385 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13393 /* Instantiate any typedefs in the type. */
13394 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13395 r
= fold_convert (type
, t
);
13396 gcc_assert (TREE_CODE (r
) == code
);
13401 /* These can sometimes show up in a partial instantiation, but never
13402 involve template parms. */
13403 gcc_assert (!uses_template_parms (t
));
13407 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13408 gcc_checking_assert (false);
13413 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13416 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13417 tree args
, tsubst_flags_t complain
, tree in_decl
)
13419 tree new_clauses
= NULL
, nc
, oc
;
13421 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13423 nc
= copy_node (oc
);
13424 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13427 switch (OMP_CLAUSE_CODE (nc
))
13429 case OMP_CLAUSE_LASTPRIVATE
:
13430 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13432 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13433 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13434 in_decl
, /*integral_constant_expression_p=*/false);
13435 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13436 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13439 case OMP_CLAUSE_PRIVATE
:
13440 case OMP_CLAUSE_SHARED
:
13441 case OMP_CLAUSE_FIRSTPRIVATE
:
13442 case OMP_CLAUSE_COPYIN
:
13443 case OMP_CLAUSE_COPYPRIVATE
:
13444 case OMP_CLAUSE_IF
:
13445 case OMP_CLAUSE_NUM_THREADS
:
13446 case OMP_CLAUSE_SCHEDULE
:
13447 case OMP_CLAUSE_COLLAPSE
:
13448 case OMP_CLAUSE_FINAL
:
13449 case OMP_CLAUSE_DEPEND
:
13450 case OMP_CLAUSE_FROM
:
13451 case OMP_CLAUSE_TO
:
13452 case OMP_CLAUSE_UNIFORM
:
13453 case OMP_CLAUSE_MAP
:
13454 case OMP_CLAUSE_DEVICE
:
13455 case OMP_CLAUSE_DIST_SCHEDULE
:
13456 case OMP_CLAUSE_NUM_TEAMS
:
13457 case OMP_CLAUSE_THREAD_LIMIT
:
13458 case OMP_CLAUSE_SAFELEN
:
13459 case OMP_CLAUSE_SIMDLEN
:
13460 OMP_CLAUSE_OPERAND (nc
, 0)
13461 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13462 in_decl
, /*integral_constant_expression_p=*/false);
13464 case OMP_CLAUSE_REDUCTION
:
13465 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13467 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13468 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13470 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13471 complain
, in_decl
);
13472 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13473 = build_qualified_name (NULL_TREE
, scope
,
13474 TREE_OPERAND (placeholder
, 1),
13478 gcc_assert (identifier_p (placeholder
));
13480 OMP_CLAUSE_OPERAND (nc
, 0)
13481 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13482 in_decl
, /*integral_constant_expression_p=*/false);
13484 case OMP_CLAUSE_LINEAR
:
13485 case OMP_CLAUSE_ALIGNED
:
13486 OMP_CLAUSE_OPERAND (nc
, 0)
13487 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13488 in_decl
, /*integral_constant_expression_p=*/false);
13489 OMP_CLAUSE_OPERAND (nc
, 1)
13490 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13491 in_decl
, /*integral_constant_expression_p=*/false);
13494 case OMP_CLAUSE_NOWAIT
:
13495 case OMP_CLAUSE_ORDERED
:
13496 case OMP_CLAUSE_DEFAULT
:
13497 case OMP_CLAUSE_UNTIED
:
13498 case OMP_CLAUSE_MERGEABLE
:
13499 case OMP_CLAUSE_INBRANCH
:
13500 case OMP_CLAUSE_NOTINBRANCH
:
13501 case OMP_CLAUSE_PROC_BIND
:
13502 case OMP_CLAUSE_FOR
:
13503 case OMP_CLAUSE_PARALLEL
:
13504 case OMP_CLAUSE_SECTIONS
:
13505 case OMP_CLAUSE_TASKGROUP
:
13508 gcc_unreachable ();
13512 new_clauses
= nreverse (new_clauses
);
13514 new_clauses
= finish_omp_clauses (new_clauses
);
13515 return new_clauses
;
13518 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13521 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13524 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13526 tree purpose
, value
, chain
;
13531 if (TREE_CODE (t
) != TREE_LIST
)
13532 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13533 /*function_p=*/false,
13534 /*integral_constant_expression_p=*/false);
13536 if (t
== void_list_node
)
13539 purpose
= TREE_PURPOSE (t
);
13541 purpose
= RECUR (purpose
);
13542 value
= TREE_VALUE (t
);
13545 if (TREE_CODE (value
) != LABEL_DECL
)
13546 value
= RECUR (value
);
13549 value
= lookup_label (DECL_NAME (value
));
13550 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13551 TREE_USED (value
) = 1;
13554 chain
= TREE_CHAIN (t
);
13555 if (chain
&& chain
!= void_type_node
)
13556 chain
= RECUR (chain
);
13557 return tree_cons (purpose
, value
, chain
);
13561 /* Substitute one OMP_FOR iterator. */
13564 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13565 tree condv
, tree incrv
, tree
*clauses
,
13566 tree args
, tsubst_flags_t complain
, tree in_decl
,
13567 bool integral_constant_expression_p
)
13569 #define RECUR(NODE) \
13570 tsubst_expr ((NODE), args, complain, in_decl, \
13571 integral_constant_expression_p)
13572 tree decl
, init
, cond
, incr
;
13574 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13575 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13576 decl
= TREE_OPERAND (init
, 0);
13577 init
= TREE_OPERAND (init
, 1);
13578 tree decl_expr
= NULL_TREE
;
13579 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13581 /* We need to jump through some hoops to handle declarations in the
13582 for-init-statement, since we might need to handle auto deduction,
13583 but we need to keep control of initialization. */
13585 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13586 decl
= tsubst_decl (decl
, args
, complain
);
13589 decl
= RECUR (decl
);
13590 init
= RECUR (init
);
13592 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13593 if (auto_node
&& init
)
13595 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13597 gcc_assert (!type_dependent_expression_p (decl
));
13599 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13603 /* Declare the variable, but don't let that initialize it. */
13604 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13605 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13607 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13610 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13611 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13612 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13614 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13615 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13616 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13617 NOP_EXPR
, rhs
, complain
);
13620 incr
= RECUR (incr
);
13621 TREE_VEC_ELT (declv
, i
) = decl
;
13622 TREE_VEC_ELT (initv
, i
) = init
;
13623 TREE_VEC_ELT (condv
, i
) = cond
;
13624 TREE_VEC_ELT (incrv
, i
) = incr
;
13630 /* Declare and initialize the variable. */
13637 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13639 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13640 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13641 && OMP_CLAUSE_DECL (c
) == decl
)
13643 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13644 && OMP_CLAUSE_DECL (c
) == decl
)
13645 error ("iteration variable %qD should not be firstprivate", decl
);
13646 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13647 && OMP_CLAUSE_DECL (c
) == decl
)
13648 error ("iteration variable %qD should not be reduction", decl
);
13652 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13653 OMP_CLAUSE_DECL (c
) = decl
;
13654 c
= finish_omp_clauses (c
);
13657 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13662 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13663 if (COMPARISON_CLASS_P (cond
))
13665 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13666 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13667 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13670 cond
= RECUR (cond
);
13671 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13672 switch (TREE_CODE (incr
))
13674 case PREINCREMENT_EXPR
:
13675 case PREDECREMENT_EXPR
:
13676 case POSTINCREMENT_EXPR
:
13677 case POSTDECREMENT_EXPR
:
13678 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13679 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13682 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13683 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13685 tree rhs
= TREE_OPERAND (incr
, 1);
13686 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13687 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13688 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13689 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13690 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13694 incr
= RECUR (incr
);
13697 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13698 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13700 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13701 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13702 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13703 TREE_TYPE (decl
), lhs
,
13704 RECUR (TREE_OPERAND (incr
, 2))));
13706 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13707 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13708 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13710 tree rhs
= TREE_OPERAND (incr
, 2);
13711 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13712 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13713 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13714 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13715 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13719 incr
= RECUR (incr
);
13722 incr
= RECUR (incr
);
13726 TREE_VEC_ELT (declv
, i
) = decl
;
13727 TREE_VEC_ELT (initv
, i
) = init
;
13728 TREE_VEC_ELT (condv
, i
) = cond
;
13729 TREE_VEC_ELT (incrv
, i
) = incr
;
13733 /* Like tsubst_copy for expressions, etc. but also does semantic
13737 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13738 bool integral_constant_expression_p
)
13740 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13741 #define RECUR(NODE) \
13742 tsubst_expr ((NODE), args, complain, in_decl, \
13743 integral_constant_expression_p)
13749 if (t
== NULL_TREE
|| t
== error_mark_node
)
13752 loc
= input_location
;
13753 if (EXPR_HAS_LOCATION (t
))
13754 input_location
= EXPR_LOCATION (t
);
13755 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13756 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13758 switch (TREE_CODE (t
))
13760 case STATEMENT_LIST
:
13762 tree_stmt_iterator i
;
13763 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13764 RECUR (tsi_stmt (i
));
13768 case CTOR_INITIALIZER
:
13769 finish_mem_initializers (tsubst_initializer_list
13770 (TREE_OPERAND (t
, 0), args
));
13774 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13778 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13779 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13780 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13782 finish_expr_stmt (tmp
);
13786 do_using_directive (USING_STMT_NAMESPACE (t
));
13791 tree decl
, pattern_decl
;
13794 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13795 if (TREE_CODE (decl
) == LABEL_DECL
)
13796 finish_label_decl (DECL_NAME (decl
));
13797 else if (TREE_CODE (decl
) == USING_DECL
)
13799 tree scope
= USING_DECL_SCOPE (decl
);
13800 tree name
= DECL_NAME (decl
);
13803 scope
= tsubst (scope
, args
, complain
, in_decl
);
13804 decl
= lookup_qualified_name (scope
, name
,
13805 /*is_type_p=*/false,
13806 /*complain=*/false);
13807 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13808 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13810 do_local_using_decl (decl
, scope
, name
);
13812 else if (DECL_PACK_P (decl
))
13814 /* Don't build up decls for a variadic capture proxy, we'll
13815 instantiate the elements directly as needed. */
13820 init
= DECL_INITIAL (decl
);
13821 decl
= tsubst (decl
, args
, complain
, in_decl
);
13822 if (decl
!= error_mark_node
)
13824 /* By marking the declaration as instantiated, we avoid
13825 trying to instantiate it. Since instantiate_decl can't
13826 handle local variables, and since we've already done
13827 all that needs to be done, that's the right thing to
13830 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13832 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13833 /* Anonymous aggregates are a special case. */
13834 finish_anon_union (decl
);
13835 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13837 DECL_CONTEXT (decl
) = current_function_decl
;
13838 if (DECL_NAME (decl
) == this_identifier
)
13840 tree lam
= DECL_CONTEXT (current_function_decl
);
13841 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13842 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13844 insert_capture_proxy (decl
);
13846 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13847 /* We already did a pushtag. */;
13848 else if (TREE_CODE (decl
) == FUNCTION_DECL
13849 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13850 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13852 DECL_CONTEXT (decl
) = NULL_TREE
;
13854 DECL_CONTEXT (decl
) = current_function_decl
;
13855 cp_check_omp_declare_reduction (decl
);
13859 int const_init
= false;
13860 maybe_push_decl (decl
);
13862 && DECL_PRETTY_FUNCTION_P (decl
))
13864 /* For __PRETTY_FUNCTION__ we have to adjust the
13866 const char *const name
13867 = cxx_printable_name (current_function_decl
, 2);
13868 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13871 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
13874 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13876 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13885 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13886 RECUR (FOR_INIT_STMT (t
));
13887 finish_for_init_stmt (stmt
);
13888 tmp
= RECUR (FOR_COND (t
));
13889 finish_for_cond (tmp
, stmt
, false);
13890 tmp
= RECUR (FOR_EXPR (t
));
13891 finish_for_expr (tmp
, stmt
);
13892 RECUR (FOR_BODY (t
));
13893 finish_for_stmt (stmt
);
13896 case RANGE_FOR_STMT
:
13899 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13900 decl
= RANGE_FOR_DECL (t
);
13901 decl
= tsubst (decl
, args
, complain
, in_decl
);
13902 maybe_push_decl (decl
);
13903 expr
= RECUR (RANGE_FOR_EXPR (t
));
13904 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13905 RECUR (RANGE_FOR_BODY (t
));
13906 finish_for_stmt (stmt
);
13911 stmt
= begin_while_stmt ();
13912 tmp
= RECUR (WHILE_COND (t
));
13913 finish_while_stmt_cond (tmp
, stmt
, false);
13914 RECUR (WHILE_BODY (t
));
13915 finish_while_stmt (stmt
);
13919 stmt
= begin_do_stmt ();
13920 RECUR (DO_BODY (t
));
13921 finish_do_body (stmt
);
13922 tmp
= RECUR (DO_COND (t
));
13923 finish_do_stmt (tmp
, stmt
, false);
13927 stmt
= begin_if_stmt ();
13928 tmp
= RECUR (IF_COND (t
));
13929 finish_if_stmt_cond (tmp
, stmt
);
13930 RECUR (THEN_CLAUSE (t
));
13931 finish_then_clause (stmt
);
13933 if (ELSE_CLAUSE (t
))
13935 begin_else_clause (stmt
);
13936 RECUR (ELSE_CLAUSE (t
));
13937 finish_else_clause (stmt
);
13940 finish_if_stmt (stmt
);
13944 if (BIND_EXPR_BODY_BLOCK (t
))
13945 stmt
= begin_function_body ();
13947 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
13948 ? BCS_TRY_BLOCK
: 0);
13950 RECUR (BIND_EXPR_BODY (t
));
13952 if (BIND_EXPR_BODY_BLOCK (t
))
13953 finish_function_body (stmt
);
13955 finish_compound_stmt (stmt
);
13959 finish_break_stmt ();
13962 case CONTINUE_STMT
:
13963 finish_continue_stmt ();
13967 stmt
= begin_switch_stmt ();
13968 tmp
= RECUR (SWITCH_STMT_COND (t
));
13969 finish_switch_cond (tmp
, stmt
);
13970 RECUR (SWITCH_STMT_BODY (t
));
13971 finish_switch_stmt (stmt
);
13974 case CASE_LABEL_EXPR
:
13976 tree low
= RECUR (CASE_LOW (t
));
13977 tree high
= RECUR (CASE_HIGH (t
));
13978 finish_case_label (EXPR_LOCATION (t
), low
, high
);
13984 tree decl
= LABEL_EXPR_LABEL (t
);
13987 label
= finish_label_stmt (DECL_NAME (decl
));
13988 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13989 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13994 tmp
= GOTO_DESTINATION (t
);
13995 if (TREE_CODE (tmp
) != LABEL_DECL
)
13996 /* Computed goto's must be tsubst'd into. On the other hand,
13997 non-computed gotos must not be; the identifier in question
13998 will have no binding. */
14001 tmp
= DECL_NAME (tmp
);
14002 finish_goto_stmt (tmp
);
14007 tree string
= RECUR (ASM_STRING (t
));
14008 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
14009 complain
, in_decl
);
14010 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
14011 complain
, in_decl
);
14012 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
14013 complain
, in_decl
);
14014 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
14015 complain
, in_decl
);
14016 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
14018 tree asm_expr
= tmp
;
14019 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
14020 asm_expr
= TREE_OPERAND (asm_expr
, 0);
14021 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
14028 stmt
= begin_try_block ();
14029 RECUR (TRY_STMTS (t
));
14030 finish_cleanup_try_block (stmt
);
14031 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
14035 tree compound_stmt
= NULL_TREE
;
14037 if (FN_TRY_BLOCK_P (t
))
14038 stmt
= begin_function_try_block (&compound_stmt
);
14040 stmt
= begin_try_block ();
14042 RECUR (TRY_STMTS (t
));
14044 if (FN_TRY_BLOCK_P (t
))
14045 finish_function_try_block (stmt
);
14047 finish_try_block (stmt
);
14049 RECUR (TRY_HANDLERS (t
));
14050 if (FN_TRY_BLOCK_P (t
))
14051 finish_function_handler_sequence (stmt
, compound_stmt
);
14053 finish_handler_sequence (stmt
);
14059 tree decl
= HANDLER_PARMS (t
);
14063 decl
= tsubst (decl
, args
, complain
, in_decl
);
14064 /* Prevent instantiate_decl from trying to instantiate
14065 this variable. We've already done all that needs to be
14067 if (decl
!= error_mark_node
)
14068 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
14070 stmt
= begin_handler ();
14071 finish_handler_parms (decl
, stmt
);
14072 RECUR (HANDLER_BODY (t
));
14073 finish_handler (stmt
);
14078 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
14079 if (CLASS_TYPE_P (tmp
))
14081 /* Local classes are not independent templates; they are
14082 instantiated along with their containing function. And this
14083 way we don't have to deal with pushing out of one local class
14084 to instantiate a member of another local class. */
14086 /* Closures are handled by the LAMBDA_EXPR. */
14087 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
14088 complete_type (tmp
);
14089 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
14090 if (!DECL_ARTIFICIAL (fn
))
14091 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
14095 case STATIC_ASSERT
:
14099 ++c_inhibit_evaluation_warnings
;
14101 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
14104 /*integral_constant_expression_p=*/true);
14105 --c_inhibit_evaluation_warnings
;
14107 finish_static_assert (condition
,
14108 STATIC_ASSERT_MESSAGE (t
),
14109 STATIC_ASSERT_SOURCE_LOCATION (t
),
14110 /*member_p=*/false);
14115 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
14116 args
, complain
, in_decl
);
14117 stmt
= begin_omp_parallel ();
14118 RECUR (OMP_PARALLEL_BODY (t
));
14119 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
14120 = OMP_PARALLEL_COMBINED (t
);
14124 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
14125 args
, complain
, in_decl
);
14126 stmt
= begin_omp_task ();
14127 RECUR (OMP_TASK_BODY (t
));
14128 finish_omp_task (tmp
, stmt
);
14135 case OMP_DISTRIBUTE
:
14137 tree clauses
, body
, pre_body
;
14138 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
14139 tree incrv
= NULL_TREE
;
14142 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
14143 args
, complain
, in_decl
);
14144 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14146 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14147 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14148 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14149 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14152 stmt
= begin_omp_structured_block ();
14154 pre_body
= push_stmt_list ();
14155 RECUR (OMP_FOR_PRE_BODY (t
));
14156 pre_body
= pop_stmt_list (pre_body
);
14158 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14159 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
14160 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
14161 &clauses
, args
, complain
, in_decl
,
14162 integral_constant_expression_p
);
14164 body
= push_stmt_list ();
14165 RECUR (OMP_FOR_BODY (t
));
14166 body
= pop_stmt_list (body
);
14168 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14169 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
14170 condv
, incrv
, body
, pre_body
, clauses
);
14173 t
= make_node (TREE_CODE (t
));
14174 TREE_TYPE (t
) = void_type_node
;
14175 OMP_FOR_BODY (t
) = body
;
14176 OMP_FOR_PRE_BODY (t
) = pre_body
;
14177 OMP_FOR_CLAUSES (t
) = clauses
;
14178 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
14182 add_stmt (finish_omp_structured_block (stmt
));
14189 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14190 args
, complain
, in_decl
);
14191 stmt
= push_stmt_list ();
14192 RECUR (OMP_BODY (t
));
14193 stmt
= pop_stmt_list (stmt
);
14196 OMP_BODY (t
) = stmt
;
14197 OMP_CLAUSES (t
) = tmp
;
14201 case OMP_TARGET_DATA
:
14203 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14204 args
, complain
, in_decl
);
14205 keep_next_level (true);
14206 stmt
= begin_omp_structured_block ();
14208 RECUR (OMP_BODY (t
));
14209 stmt
= finish_omp_structured_block (stmt
);
14212 OMP_BODY (t
) = stmt
;
14213 OMP_CLAUSES (t
) = tmp
;
14217 case OMP_TARGET_UPDATE
:
14218 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
14219 args
, complain
, in_decl
);
14221 OMP_CLAUSES (t
) = tmp
;
14228 case OMP_TASKGROUP
:
14230 stmt
= push_stmt_list ();
14231 RECUR (OMP_BODY (t
));
14232 stmt
= pop_stmt_list (stmt
);
14235 OMP_BODY (t
) = stmt
;
14240 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14241 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14243 tree op1
= TREE_OPERAND (t
, 1);
14244 tree rhs1
= NULL_TREE
;
14246 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14248 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14249 op1
= TREE_OPERAND (op1
, 1);
14251 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14252 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14253 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14254 NULL_TREE
, NULL_TREE
, rhs1
,
14255 OMP_ATOMIC_SEQ_CST (t
));
14259 tree op1
= TREE_OPERAND (t
, 1);
14260 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14261 tree rhs1
= NULL_TREE
;
14262 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14263 enum tree_code opcode
= NOP_EXPR
;
14264 if (code
== OMP_ATOMIC_READ
)
14266 v
= RECUR (TREE_OPERAND (op1
, 0));
14267 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14269 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14270 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14272 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14273 v
= RECUR (TREE_OPERAND (op1
, 0));
14274 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14275 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14277 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14278 op11
= TREE_OPERAND (op11
, 1);
14280 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14281 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14282 opcode
= TREE_CODE (op11
);
14283 if (opcode
== MODIFY_EXPR
)
14289 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14290 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14292 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14293 OMP_ATOMIC_SEQ_CST (t
));
14297 case TRANSACTION_EXPR
:
14300 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14301 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14303 if (TRANSACTION_EXPR_IS_STMT (t
))
14305 tree body
= TRANSACTION_EXPR_BODY (t
);
14306 tree noex
= NULL_TREE
;
14307 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14309 noex
= MUST_NOT_THROW_COND (body
);
14310 if (noex
== NULL_TREE
)
14311 noex
= boolean_true_node
;
14312 body
= TREE_OPERAND (body
, 0);
14314 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14316 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14320 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14321 RECUR (TRANSACTION_EXPR_BODY (t
)),
14328 case MUST_NOT_THROW_EXPR
:
14330 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14331 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14332 RETURN (build_must_not_throw_expr (op0
, cond
));
14335 case EXPR_PACK_EXPANSION
:
14336 error ("invalid use of pack expansion expression");
14337 RETURN (error_mark_node
);
14339 case NONTYPE_ARGUMENT_PACK
:
14340 error ("use %<...%> to expand argument pack");
14341 RETURN (error_mark_node
);
14343 case CILK_SPAWN_STMT
:
14344 cfun
->calls_cilk_spawn
= 1;
14345 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14347 case CILK_SYNC_STMT
:
14348 RETURN (build_cilk_sync ());
14350 case COMPOUND_EXPR
:
14351 tmp
= RECUR (TREE_OPERAND (t
, 0));
14352 if (tmp
== NULL_TREE
)
14353 /* If the first operand was a statement, we're done with it. */
14354 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14355 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14356 RECUR (TREE_OPERAND (t
, 1)),
14359 case ANNOTATE_EXPR
:
14360 tmp
= RECUR (TREE_OPERAND (t
, 0));
14361 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14362 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14365 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14367 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14368 /*function_p=*/false,
14369 integral_constant_expression_p
));
14372 RETURN (NULL_TREE
);
14374 input_location
= loc
;
14380 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14381 function. For description of the body see comment above
14382 cp_parser_omp_declare_reduction_exprs. */
14385 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14387 if (t
== NULL_TREE
|| t
== error_mark_node
)
14390 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14392 tree_stmt_iterator tsi
;
14395 memset (stmts
, 0, sizeof stmts
);
14396 for (i
= 0, tsi
= tsi_start (t
);
14397 i
< 7 && !tsi_end_p (tsi
);
14398 i
++, tsi_next (&tsi
))
14399 stmts
[i
] = tsi_stmt (tsi
);
14400 gcc_assert (tsi_end_p (tsi
));
14404 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14405 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14406 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14407 args
, complain
, in_decl
);
14408 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14409 args
, complain
, in_decl
);
14410 DECL_CONTEXT (omp_out
) = current_function_decl
;
14411 DECL_CONTEXT (omp_in
) = current_function_decl
;
14412 keep_next_level (true);
14413 tree block
= begin_omp_structured_block ();
14414 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14415 block
= finish_omp_structured_block (block
);
14416 block
= maybe_cleanup_point_expr_void (block
);
14417 add_decl_expr (omp_out
);
14418 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14419 TREE_NO_WARNING (omp_out
) = 1;
14420 add_decl_expr (omp_in
);
14421 finish_expr_stmt (block
);
14425 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14426 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14427 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14428 args
, complain
, in_decl
);
14429 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14430 args
, complain
, in_decl
);
14431 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14432 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14433 keep_next_level (true);
14434 tree block
= begin_omp_structured_block ();
14435 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14436 block
= finish_omp_structured_block (block
);
14437 block
= maybe_cleanup_point_expr_void (block
);
14438 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14439 add_decl_expr (omp_priv
);
14440 add_decl_expr (omp_orig
);
14441 finish_expr_stmt (block
);
14443 add_decl_expr (omp_orig
);
14447 /* T is a postfix-expression that is not being used in a function
14448 call. Return the substituted version of T. */
14451 tsubst_non_call_postfix_expression (tree t
, tree args
,
14452 tsubst_flags_t complain
,
14455 if (TREE_CODE (t
) == SCOPE_REF
)
14456 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14457 /*done=*/false, /*address_p=*/false);
14459 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14460 /*function_p=*/false,
14461 /*integral_constant_expression_p=*/false);
14466 /* Like tsubst but deals with expressions and performs semantic
14467 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14470 tsubst_copy_and_build (tree t
,
14472 tsubst_flags_t complain
,
14475 bool integral_constant_expression_p
)
14477 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14478 #define RECUR(NODE) \
14479 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14480 /*function_p=*/false, \
14481 integral_constant_expression_p)
14486 if (t
== NULL_TREE
|| t
== error_mark_node
)
14489 loc
= input_location
;
14490 if (EXPR_HAS_LOCATION (t
))
14491 input_location
= EXPR_LOCATION (t
);
14493 /* N3276 decltype magic only applies to calls at the top level or on the
14494 right side of a comma. */
14495 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14496 complain
&= ~tf_decltype
;
14498 switch (TREE_CODE (t
))
14502 /* Fall through. */
14503 case IDENTIFIER_NODE
:
14507 bool non_integral_constant_expression_p
;
14508 const char *error_msg
;
14510 if (IDENTIFIER_TYPENAME_P (t
))
14512 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14513 t
= mangle_conv_op_name_for_type (new_type
);
14516 /* Look up the name. */
14517 decl
= lookup_name (t
);
14519 /* By convention, expressions use ERROR_MARK_NODE to indicate
14520 failure, not NULL_TREE. */
14521 if (decl
== NULL_TREE
)
14522 decl
= error_mark_node
;
14524 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14526 integral_constant_expression_p
,
14527 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14528 &non_integral_constant_expression_p
,
14529 /*template_p=*/false,
14531 /*address_p=*/false,
14532 /*template_arg_p=*/false,
14537 if (!function_p
&& identifier_p (decl
))
14539 if (complain
& tf_error
)
14540 unqualified_name_lookup_error (decl
);
14541 decl
= error_mark_node
;
14546 case TEMPLATE_ID_EXPR
:
14549 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14550 tree targs
= TREE_OPERAND (t
, 1);
14553 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14555 if (TREE_CODE (templ
) == COMPONENT_REF
)
14557 object
= TREE_OPERAND (templ
, 0);
14558 templ
= TREE_OPERAND (templ
, 1);
14561 object
= NULL_TREE
;
14562 templ
= lookup_template_function (templ
, targs
);
14565 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14566 object
, templ
, NULL_TREE
));
14568 RETURN (baselink_for_fns (templ
));
14573 tree r
= RECUR (TREE_OPERAND (t
, 0));
14575 if (REFERENCE_REF_P (t
))
14577 /* A type conversion to reference type will be enclosed in
14578 such an indirect ref, but the substitution of the cast
14579 will have also added such an indirect ref. */
14580 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14581 r
= convert_from_reference (r
);
14584 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14585 complain
|decltype_flag
);
14591 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14592 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14593 RETURN (build_nop (type
, op0
));
14596 case IMPLICIT_CONV_EXPR
:
14598 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14599 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14600 int flags
= LOOKUP_IMPLICIT
;
14601 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14602 flags
= LOOKUP_NORMAL
;
14603 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14609 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14610 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14611 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14615 case REINTERPRET_CAST_EXPR
:
14616 case CONST_CAST_EXPR
:
14617 case DYNAMIC_CAST_EXPR
:
14618 case STATIC_CAST_EXPR
:
14621 tree op
, r
= NULL_TREE
;
14623 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14624 if (integral_constant_expression_p
14625 && !cast_valid_in_integral_constant_expression_p (type
))
14627 if (complain
& tf_error
)
14628 error ("a cast to a type other than an integral or "
14629 "enumeration type cannot appear in a constant-expression");
14630 RETURN (error_mark_node
);
14633 op
= RECUR (TREE_OPERAND (t
, 0));
14635 warning_sentinel
s(warn_useless_cast
);
14636 switch (TREE_CODE (t
))
14639 r
= build_functional_cast (type
, op
, complain
);
14641 case REINTERPRET_CAST_EXPR
:
14642 r
= build_reinterpret_cast (type
, op
, complain
);
14644 case CONST_CAST_EXPR
:
14645 r
= build_const_cast (type
, op
, complain
);
14647 case DYNAMIC_CAST_EXPR
:
14648 r
= build_dynamic_cast (type
, op
, complain
);
14650 case STATIC_CAST_EXPR
:
14651 r
= build_static_cast (type
, op
, complain
);
14654 gcc_unreachable ();
14660 case POSTDECREMENT_EXPR
:
14661 case POSTINCREMENT_EXPR
:
14662 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14663 args
, complain
, in_decl
);
14664 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14665 complain
|decltype_flag
));
14667 case PREDECREMENT_EXPR
:
14668 case PREINCREMENT_EXPR
:
14672 case TRUTH_NOT_EXPR
:
14673 case UNARY_PLUS_EXPR
: /* Unary + */
14674 case REALPART_EXPR
:
14675 case IMAGPART_EXPR
:
14676 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14677 RECUR (TREE_OPERAND (t
, 0)),
14678 complain
|decltype_flag
));
14680 case FIX_TRUNC_EXPR
:
14681 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14685 op1
= TREE_OPERAND (t
, 0);
14686 if (TREE_CODE (op1
) == LABEL_DECL
)
14687 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14688 EXPR_LOCATION (op1
)));
14689 if (TREE_CODE (op1
) == SCOPE_REF
)
14690 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14691 /*done=*/true, /*address_p=*/true);
14693 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14695 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14696 complain
|decltype_flag
));
14701 case TRUNC_DIV_EXPR
:
14702 case CEIL_DIV_EXPR
:
14703 case FLOOR_DIV_EXPR
:
14704 case ROUND_DIV_EXPR
:
14705 case EXACT_DIV_EXPR
:
14709 case TRUNC_MOD_EXPR
:
14710 case FLOOR_MOD_EXPR
:
14711 case TRUTH_ANDIF_EXPR
:
14712 case TRUTH_ORIF_EXPR
:
14713 case TRUTH_AND_EXPR
:
14714 case TRUTH_OR_EXPR
:
14730 warning_sentinel
s1(warn_type_limits
);
14731 warning_sentinel
s2(warn_div_by_zero
);
14732 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14733 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14734 tree r
= build_x_binary_op
14735 (input_location
, TREE_CODE (t
),
14737 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14739 : TREE_CODE (TREE_OPERAND (t
, 0))),
14741 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14743 : TREE_CODE (TREE_OPERAND (t
, 1))),
14745 complain
|decltype_flag
);
14746 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14747 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14752 case POINTER_PLUS_EXPR
:
14754 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14755 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14756 return fold_build_pointer_plus (op0
, op1
);
14760 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14761 /*address_p=*/false));
14763 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14764 args
, complain
, in_decl
);
14765 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14766 RECUR (TREE_OPERAND (t
, 1)),
14767 complain
|decltype_flag
));
14769 case ARRAY_NOTATION_REF
:
14771 tree start_index
, length
, stride
;
14772 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14773 args
, complain
, in_decl
);
14774 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14775 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14776 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14777 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14778 length
, stride
, TREE_TYPE (op1
)));
14781 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14782 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14789 op1
= TREE_OPERAND (t
, 0);
14790 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14791 op1
= TREE_TYPE (op1
);
14794 /* When there are no ARGS, we are trying to evaluate a
14795 non-dependent expression from the parser. Trying to do
14796 the substitutions may not work. */
14798 op1
= TREE_TYPE (op1
);
14802 ++cp_unevaluated_operand
;
14803 ++c_inhibit_evaluation_warnings
;
14805 op1
= tsubst (op1
, args
, complain
, in_decl
);
14807 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14808 /*function_p=*/false,
14809 /*integral_constant_expression_p=*/
14811 --cp_unevaluated_operand
;
14812 --c_inhibit_evaluation_warnings
;
14815 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14816 complain
& tf_error
);
14818 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14819 complain
& tf_error
);
14820 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14822 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14824 if (!processing_template_decl
&& TYPE_P (op1
))
14826 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14827 build1 (NOP_EXPR
, op1
, error_mark_node
));
14828 SIZEOF_EXPR_TYPE_P (r
) = 1;
14831 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14832 TREE_SIDE_EFFECTS (r
) = 0;
14833 TREE_READONLY (r
) = 1;
14835 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14840 case AT_ENCODE_EXPR
:
14842 op1
= TREE_OPERAND (t
, 0);
14843 ++cp_unevaluated_operand
;
14844 ++c_inhibit_evaluation_warnings
;
14845 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14846 /*function_p=*/false,
14847 /*integral_constant_expression_p=*/false);
14848 --cp_unevaluated_operand
;
14849 --c_inhibit_evaluation_warnings
;
14850 RETURN (objc_build_encode_expr (op1
));
14853 case NOEXCEPT_EXPR
:
14854 op1
= TREE_OPERAND (t
, 0);
14855 ++cp_unevaluated_operand
;
14856 ++c_inhibit_evaluation_warnings
;
14857 ++cp_noexcept_operand
;
14858 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14859 /*function_p=*/false,
14860 /*integral_constant_expression_p=*/false);
14861 --cp_unevaluated_operand
;
14862 --c_inhibit_evaluation_warnings
;
14863 --cp_noexcept_operand
;
14864 RETURN (finish_noexcept_expr (op1
, complain
));
14868 warning_sentinel
s(warn_div_by_zero
);
14869 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
14870 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
14871 tree r
= build_x_modify_expr
14872 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
14873 complain
|decltype_flag
);
14874 /* TREE_NO_WARNING must be set if either the expression was
14875 parenthesized or it uses an operator such as >>= rather
14876 than plain assignment. In the former case, it was already
14877 set and must be copied. In the latter case,
14878 build_x_modify_expr sets it and it must not be reset
14880 if (TREE_NO_WARNING (t
))
14881 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14887 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14888 args
, complain
, in_decl
);
14889 /* Remember that there was a reference to this entity. */
14892 RETURN (build_x_arrow (input_location
, op1
, complain
));
14896 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14897 tree init
= RECUR (TREE_OPERAND (t
, 3));
14898 vec
<tree
, va_gc
> *placement_vec
;
14899 vec
<tree
, va_gc
> *init_vec
;
14902 if (placement
== NULL_TREE
)
14903 placement_vec
= NULL
;
14906 placement_vec
= make_tree_vector ();
14907 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14908 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14911 /* If there was an initializer in the original tree, but it
14912 instantiated to an empty list, then we should pass a
14913 non-NULL empty vector to tell build_new that it was an
14914 empty initializer() rather than no initializer. This can
14915 only happen when the initializer is a pack expansion whose
14916 parameter packs are of length zero. */
14917 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
14921 init_vec
= make_tree_vector ();
14922 if (init
== void_node
)
14923 gcc_assert (init_vec
!= NULL
);
14926 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
14927 vec_safe_push (init_vec
, TREE_VALUE (init
));
14931 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14932 tree op2
= RECUR (TREE_OPERAND (t
, 2));
14933 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
14934 NEW_EXPR_USE_GLOBAL (t
),
14937 if (placement_vec
!= NULL
)
14938 release_tree_vector (placement_vec
);
14939 if (init_vec
!= NULL
)
14940 release_tree_vector (init_vec
);
14947 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14948 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14949 RETURN (delete_sanity (op0
, op1
,
14950 DELETE_EXPR_USE_VEC (t
),
14951 DELETE_EXPR_USE_GLOBAL (t
),
14955 case COMPOUND_EXPR
:
14957 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
14958 complain
& ~tf_decltype
, in_decl
,
14959 /*function_p=*/false,
14960 integral_constant_expression_p
);
14961 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
14963 RECUR (TREE_OPERAND (t
, 1)),
14964 complain
|decltype_flag
));
14970 vec
<tree
, va_gc
> *call_args
;
14971 unsigned int nargs
, i
;
14976 function
= CALL_EXPR_FN (t
);
14977 /* When we parsed the expression, we determined whether or
14978 not Koenig lookup should be performed. */
14979 koenig_p
= KOENIG_LOOKUP_P (t
);
14980 if (TREE_CODE (function
) == SCOPE_REF
)
14982 qualified_p
= true;
14983 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
14985 /*address_p=*/false);
14987 else if (koenig_p
&& identifier_p (function
))
14989 /* Do nothing; calling tsubst_copy_and_build on an identifier
14990 would incorrectly perform unqualified lookup again.
14992 Note that we can also have an IDENTIFIER_NODE if the earlier
14993 unqualified lookup found a member function; in that case
14994 koenig_p will be false and we do want to do the lookup
14995 again to find the instantiated member function.
14997 FIXME but doing that causes c++/15272, so we need to stop
14998 using IDENTIFIER_NODE in that situation. */
14999 qualified_p
= false;
15003 if (TREE_CODE (function
) == COMPONENT_REF
)
15005 tree op
= TREE_OPERAND (function
, 1);
15007 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
15008 || (BASELINK_P (op
)
15009 && BASELINK_QUALIFIED_P (op
)));
15012 qualified_p
= false;
15014 if (TREE_CODE (function
) == ADDR_EXPR
15015 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
15016 /* Avoid error about taking the address of a constructor. */
15017 function
= TREE_OPERAND (function
, 0);
15019 function
= tsubst_copy_and_build (function
, args
, complain
,
15022 integral_constant_expression_p
);
15024 if (BASELINK_P (function
))
15025 qualified_p
= true;
15028 nargs
= call_expr_nargs (t
);
15029 call_args
= make_tree_vector ();
15030 for (i
= 0; i
< nargs
; ++i
)
15032 tree arg
= CALL_EXPR_ARG (t
, i
);
15034 if (!PACK_EXPANSION_P (arg
))
15035 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
15038 /* Expand the pack expansion and push each entry onto
15040 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
15041 if (TREE_CODE (arg
) == TREE_VEC
)
15043 unsigned int len
, j
;
15045 len
= TREE_VEC_LENGTH (arg
);
15046 for (j
= 0; j
< len
; ++j
)
15048 tree value
= TREE_VEC_ELT (arg
, j
);
15049 if (value
!= NULL_TREE
)
15050 value
= convert_from_reference (value
);
15051 vec_safe_push (call_args
, value
);
15056 /* A partial substitution. Add one entry. */
15057 vec_safe_push (call_args
, arg
);
15062 /* We do not perform argument-dependent lookup if normal
15063 lookup finds a non-function, in accordance with the
15064 expected resolution of DR 218. */
15066 && ((is_overloaded_fn (function
)
15067 /* If lookup found a member function, the Koenig lookup is
15068 not appropriate, even if an unqualified-name was used
15069 to denote the function. */
15070 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
15071 || identifier_p (function
))
15072 /* Only do this when substitution turns a dependent call
15073 into a non-dependent call. */
15074 && type_dependent_expression_p_push (t
)
15075 && !any_type_dependent_arguments_p (call_args
))
15076 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
15078 if (identifier_p (function
)
15079 && !any_type_dependent_arguments_p (call_args
))
15081 if (koenig_p
&& (complain
& tf_warning_or_error
))
15083 /* For backwards compatibility and good diagnostics, try
15084 the unqualified lookup again if we aren't in SFINAE
15086 tree unq
= (tsubst_copy_and_build
15087 (function
, args
, complain
, in_decl
, true,
15088 integral_constant_expression_p
));
15089 if (unq
== error_mark_node
)
15090 RETURN (error_mark_node
);
15092 if (unq
!= function
)
15095 if (INDIRECT_REF_P (fn
))
15096 fn
= TREE_OPERAND (fn
, 0);
15097 if (TREE_CODE (fn
) == COMPONENT_REF
)
15098 fn
= TREE_OPERAND (fn
, 1);
15099 if (is_overloaded_fn (fn
))
15100 fn
= get_first_fn (fn
);
15101 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
15102 "%qD was not declared in this scope, "
15103 "and no declarations were found by "
15104 "argument-dependent lookup at the point "
15105 "of instantiation", function
))
15108 /* Can't say anything more. */;
15109 else if (DECL_CLASS_SCOPE_P (fn
))
15111 location_t loc
= EXPR_LOC_OR_LOC (t
,
15114 "declarations in dependent base %qT are "
15115 "not found by unqualified lookup",
15116 DECL_CLASS_CONTEXT (fn
));
15117 if (current_class_ptr
)
15119 "use %<this->%D%> instead", function
);
15122 "use %<%T::%D%> instead",
15123 current_class_name
, function
);
15126 inform (0, "%q+D declared here, later in the "
15127 "translation unit", fn
);
15132 if (identifier_p (function
))
15134 if (complain
& tf_error
)
15135 unqualified_name_lookup_error (function
);
15136 release_tree_vector (call_args
);
15137 RETURN (error_mark_node
);
15141 /* Remember that there was a reference to this entity. */
15142 if (DECL_P (function
))
15143 mark_used (function
, complain
);
15145 /* Put back tf_decltype for the actual call. */
15146 complain
|= decltype_flag
;
15148 if (TREE_CODE (function
) == OFFSET_REF
)
15149 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
15151 else if (TREE_CODE (function
) == COMPONENT_REF
)
15153 tree instance
= TREE_OPERAND (function
, 0);
15154 tree fn
= TREE_OPERAND (function
, 1);
15156 if (processing_template_decl
15157 && (type_dependent_expression_p (instance
)
15158 || (!BASELINK_P (fn
)
15159 && TREE_CODE (fn
) != FIELD_DECL
)
15160 || type_dependent_expression_p (fn
)
15161 || any_type_dependent_arguments_p (call_args
)))
15162 ret
= build_nt_call_vec (function
, call_args
);
15163 else if (!BASELINK_P (fn
))
15164 ret
= finish_call_expr (function
, &call_args
,
15165 /*disallow_virtual=*/false,
15166 /*koenig_p=*/false,
15169 ret
= (build_new_method_call
15171 &call_args
, NULL_TREE
,
15172 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
15177 ret
= finish_call_expr (function
, &call_args
,
15178 /*disallow_virtual=*/qualified_p
,
15182 release_tree_vector (call_args
);
15189 tree cond
= RECUR (TREE_OPERAND (t
, 0));
15190 tree folded_cond
= fold_non_dependent_expr (cond
);
15193 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
15195 if (integer_zerop (folded_cond
))
15197 ++c_inhibit_evaluation_warnings
;
15198 exp1
= RECUR (TREE_OPERAND (t
, 1));
15199 --c_inhibit_evaluation_warnings
;
15200 exp2
= RECUR (TREE_OPERAND (t
, 2));
15204 exp1
= RECUR (TREE_OPERAND (t
, 1));
15205 ++c_inhibit_evaluation_warnings
;
15206 exp2
= RECUR (TREE_OPERAND (t
, 2));
15207 --c_inhibit_evaluation_warnings
;
15209 cond
= folded_cond
;
15213 exp1
= RECUR (TREE_OPERAND (t
, 1));
15214 exp2
= RECUR (TREE_OPERAND (t
, 2));
15217 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
15218 cond
, exp1
, exp2
, complain
));
15221 case PSEUDO_DTOR_EXPR
:
15223 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15224 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15225 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15226 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
15232 tree purpose
, value
, chain
;
15234 if (t
== void_list_node
)
15237 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15238 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15240 /* We have pack expansions, so expand those and
15241 create a new list out of it. */
15242 tree purposevec
= NULL_TREE
;
15243 tree valuevec
= NULL_TREE
;
15247 /* Expand the argument expressions. */
15248 if (TREE_PURPOSE (t
))
15249 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15250 complain
, in_decl
);
15251 if (TREE_VALUE (t
))
15252 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15253 complain
, in_decl
);
15255 /* Build the rest of the list. */
15256 chain
= TREE_CHAIN (t
);
15257 if (chain
&& chain
!= void_type_node
)
15258 chain
= RECUR (chain
);
15260 /* Determine the number of arguments. */
15261 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15263 len
= TREE_VEC_LENGTH (purposevec
);
15264 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15266 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15267 len
= TREE_VEC_LENGTH (valuevec
);
15270 /* Since we only performed a partial substitution into
15271 the argument pack, we only RETURN (a single list
15273 if (purposevec
== TREE_PURPOSE (t
)
15274 && valuevec
== TREE_VALUE (t
)
15275 && chain
== TREE_CHAIN (t
))
15278 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15281 /* Convert the argument vectors into a TREE_LIST */
15285 /* Grab the Ith values. */
15287 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15290 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15293 /* Build the list (backwards). */
15294 chain
= tree_cons (purpose
, value
, chain
);
15300 purpose
= TREE_PURPOSE (t
);
15302 purpose
= RECUR (purpose
);
15303 value
= TREE_VALUE (t
);
15305 value
= RECUR (value
);
15306 chain
= TREE_CHAIN (t
);
15307 if (chain
&& chain
!= void_type_node
)
15308 chain
= RECUR (chain
);
15309 if (purpose
== TREE_PURPOSE (t
)
15310 && value
== TREE_VALUE (t
)
15311 && chain
== TREE_CHAIN (t
))
15313 RETURN (tree_cons (purpose
, value
, chain
));
15316 case COMPONENT_REF
:
15323 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15324 args
, complain
, in_decl
);
15325 /* Remember that there was a reference to this entity. */
15326 if (DECL_P (object
))
15327 mark_used (object
);
15328 object_type
= TREE_TYPE (object
);
15330 member
= TREE_OPERAND (t
, 1);
15331 if (BASELINK_P (member
))
15332 member
= tsubst_baselink (member
,
15333 non_reference (TREE_TYPE (object
)),
15334 args
, complain
, in_decl
);
15336 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15337 if (member
== error_mark_node
)
15338 RETURN (error_mark_node
);
15340 if (type_dependent_expression_p (object
))
15341 /* We can't do much here. */;
15342 else if (!CLASS_TYPE_P (object_type
))
15344 if (scalarish_type_p (object_type
))
15346 tree s
= NULL_TREE
;
15347 tree dtor
= member
;
15349 if (TREE_CODE (dtor
) == SCOPE_REF
)
15351 s
= TREE_OPERAND (dtor
, 0);
15352 dtor
= TREE_OPERAND (dtor
, 1);
15354 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15356 dtor
= TREE_OPERAND (dtor
, 0);
15358 RETURN (finish_pseudo_destructor_expr
15359 (object
, s
, dtor
, input_location
));
15363 else if (TREE_CODE (member
) == SCOPE_REF
15364 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15366 /* Lookup the template functions now that we know what the
15368 tree scope
= TREE_OPERAND (member
, 0);
15369 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15370 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15371 member
= lookup_qualified_name (scope
, tmpl
,
15372 /*is_type_p=*/false,
15373 /*complain=*/false);
15374 if (BASELINK_P (member
))
15376 BASELINK_FUNCTIONS (member
)
15377 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15379 member
= (adjust_result_of_qualified_name_lookup
15380 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15385 qualified_name_lookup_error (scope
, tmpl
, member
,
15387 RETURN (error_mark_node
);
15390 else if (TREE_CODE (member
) == SCOPE_REF
15391 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15392 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15394 if (complain
& tf_error
)
15396 if (TYPE_P (TREE_OPERAND (member
, 0)))
15397 error ("%qT is not a class or namespace",
15398 TREE_OPERAND (member
, 0));
15400 error ("%qD is not a class or namespace",
15401 TREE_OPERAND (member
, 0));
15403 RETURN (error_mark_node
);
15405 else if (TREE_CODE (member
) == FIELD_DECL
)
15407 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15408 if (TREE_CODE (r
) == COMPONENT_REF
)
15409 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15413 r
= finish_class_member_access_expr (object
, member
,
15414 /*template_p=*/false,
15416 if (TREE_CODE (r
) == COMPONENT_REF
)
15417 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15422 RETURN (build_throw
15423 (RECUR (TREE_OPERAND (t
, 0))));
15427 vec
<constructor_elt
, va_gc
> *n
;
15428 constructor_elt
*ce
;
15429 unsigned HOST_WIDE_INT idx
;
15430 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15431 bool process_index_p
;
15433 bool need_copy_p
= false;
15436 if (type
== error_mark_node
)
15437 RETURN (error_mark_node
);
15439 /* digest_init will do the wrong thing if we let it. */
15440 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15443 /* We do not want to process the index of aggregate
15444 initializers as they are identifier nodes which will be
15445 looked up by digest_init. */
15446 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15448 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15449 newlen
= vec_safe_length (n
);
15450 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15452 if (ce
->index
&& process_index_p
15453 /* An identifier index is looked up in the type
15454 being initialized, not the current scope. */
15455 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15456 ce
->index
= RECUR (ce
->index
);
15458 if (PACK_EXPANSION_P (ce
->value
))
15460 /* Substitute into the pack expansion. */
15461 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15464 if (ce
->value
== error_mark_node
15465 || PACK_EXPANSION_P (ce
->value
))
15467 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15468 /* Just move the argument into place. */
15469 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15472 /* Update the length of the final CONSTRUCTOR
15473 arguments vector, and note that we will need to
15475 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15476 need_copy_p
= true;
15480 ce
->value
= RECUR (ce
->value
);
15485 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15487 vec_alloc (n
, newlen
);
15488 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15490 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15492 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15493 for (i
= 0; i
< len
; ++i
)
15494 CONSTRUCTOR_APPEND_ELT (n
, 0,
15495 TREE_VEC_ELT (ce
->value
, i
));
15498 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15502 r
= build_constructor (init_list_type_node
, n
);
15503 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15505 if (TREE_HAS_CONSTRUCTOR (t
))
15506 RETURN (finish_compound_literal (type
, r
, complain
));
15508 TREE_TYPE (r
) = type
;
15514 tree operand_0
= TREE_OPERAND (t
, 0);
15515 if (TYPE_P (operand_0
))
15517 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15518 RETURN (get_typeid (operand_0
, complain
));
15522 operand_0
= RECUR (operand_0
);
15523 RETURN (build_typeid (operand_0
, complain
));
15530 else if (DECL_PACK_P (t
))
15532 /* We don't build decls for an instantiation of a
15533 variadic capture proxy, we instantiate the elements
15535 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15536 return RECUR (DECL_VALUE_EXPR (t
));
15542 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15543 /* ??? We're doing a subset of finish_id_expression here. */
15545 && !processing_template_decl
15546 && !cp_unevaluated_operand
15547 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
15548 && DECL_THREAD_LOCAL_P (r
))
15550 if (tree wrap
= get_tls_wrapper_fn (r
))
15551 /* Replace an evaluated use of the thread_local variable with
15552 a call to its wrapper. */
15553 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
15555 else if (outer_automatic_var_p (r
))
15556 r
= process_outer_var_ref (r
, complain
);
15558 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15559 /* If the original type was a reference, we'll be wrapped in
15560 the appropriate INDIRECT_REF. */
15561 r
= convert_from_reference (r
);
15567 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15568 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15569 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15572 case OFFSETOF_EXPR
:
15573 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0)),
15574 EXPR_LOCATION (t
)));
15578 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15579 complain
, in_decl
);
15581 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15582 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
15583 type2
= RECUR (type2
);
15585 type2
= tsubst (type2
, args
, complain
, in_decl
);
15587 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15592 tree old_stmt_expr
= cur_stmt_expr
;
15593 tree stmt_expr
= begin_stmt_expr ();
15595 cur_stmt_expr
= stmt_expr
;
15596 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15597 integral_constant_expression_p
);
15598 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15599 cur_stmt_expr
= old_stmt_expr
;
15601 /* If the resulting list of expression statement is empty,
15602 fold it further into void_node. */
15603 if (empty_expr_stmt_p (stmt_expr
))
15604 stmt_expr
= void_node
;
15606 RETURN (stmt_expr
);
15611 tree r
= build_lambda_expr ();
15613 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15614 LAMBDA_EXPR_CLOSURE (r
) = type
;
15615 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15617 LAMBDA_EXPR_LOCATION (r
)
15618 = LAMBDA_EXPR_LOCATION (t
);
15619 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15620 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15621 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15622 LAMBDA_EXPR_DISCRIMINATOR (r
)
15623 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15624 /* For a function scope, we want to use tsubst so that we don't
15625 complain about referring to an auto function before its return
15626 type has been deduced. Otherwise, we want to use tsubst_copy so
15627 that we look up the existing field/parameter/variable rather
15628 than build a new one. */
15629 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15630 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15631 scope
= tsubst (scope
, args
, complain
, in_decl
);
15632 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15634 /* Look up the parameter we want directly, as tsubst_copy
15635 doesn't do what we need. */
15636 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15637 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15638 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15639 parm
= DECL_CHAIN (parm
);
15641 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15642 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15643 DECL_CONTEXT (scope
) = fn
;
15646 scope
= RECUR (scope
);
15647 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15648 LAMBDA_EXPR_RETURN_TYPE (r
)
15649 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15651 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15652 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15654 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15655 determine_visibility (TYPE_NAME (type
));
15656 /* Now that we know visibility, instantiate the type so we have a
15657 declaration of the op() for later calls to lambda_function. */
15658 complete_type (type
);
15660 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15662 RETURN (build_lambda_object (r
));
15666 /* We can get here for a constant initializer of non-dependent type.
15667 FIXME stop folding in cp_parser_initializer_clause. */
15669 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15674 case TRANSACTION_EXPR
:
15675 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15676 integral_constant_expression_p
));
15679 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15681 case VEC_PERM_EXPR
:
15683 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15684 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15685 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15686 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15691 /* Handle Objective-C++ constructs, if appropriate. */
15694 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15695 in_decl
, /*function_p=*/false);
15699 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15705 input_location
= loc
;
15709 /* Verify that the instantiated ARGS are valid. For type arguments,
15710 make sure that the type's linkage is ok. For non-type arguments,
15711 make sure they are constants if they are integral or enumerations.
15712 Emit an error under control of COMPLAIN, and return TRUE on error. */
15715 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15717 if (dependent_template_arg_p (t
))
15719 if (ARGUMENT_PACK_P (t
))
15721 tree vec
= ARGUMENT_PACK_ARGS (t
);
15722 int len
= TREE_VEC_LENGTH (vec
);
15723 bool result
= false;
15726 for (i
= 0; i
< len
; ++i
)
15727 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15731 else if (TYPE_P (t
))
15733 /* [basic.link]: A name with no linkage (notably, the name
15734 of a class or enumeration declared in a local scope)
15735 shall not be used to declare an entity with linkage.
15736 This implies that names with no linkage cannot be used as
15739 DR 757 relaxes this restriction for C++0x. */
15740 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15741 : no_linkage_check (t
, /*relaxed_p=*/false));
15745 /* DR 488 makes use of a type with no linkage cause
15746 type deduction to fail. */
15747 if (complain
& tf_error
)
15749 if (TYPE_ANONYMOUS_P (nt
))
15750 error ("%qT is/uses anonymous type", t
);
15752 error ("template argument for %qD uses local type %qT",
15757 /* In order to avoid all sorts of complications, we do not
15758 allow variably-modified types as template arguments. */
15759 else if (variably_modified_type_p (t
, NULL_TREE
))
15761 if (complain
& tf_error
)
15762 error ("%qT is a variably modified type", t
);
15766 /* Class template and alias template arguments should be OK. */
15767 else if (DECL_TYPE_TEMPLATE_P (t
))
15769 /* A non-type argument of integral or enumerated type must be a
15771 else if (TREE_TYPE (t
)
15772 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15773 && !REFERENCE_REF_P (t
)
15774 && !TREE_CONSTANT (t
))
15776 if (complain
& tf_error
)
15777 error ("integral expression %qE is not constant", t
);
15784 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15786 int ix
, len
= DECL_NTPARMS (tmpl
);
15787 bool result
= false;
15789 for (ix
= 0; ix
!= len
; ix
++)
15791 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15794 if (result
&& (complain
& tf_error
))
15795 error (" trying to instantiate %qD", tmpl
);
15799 /* We're out of SFINAE context now, so generate diagnostics for the access
15800 errors we saw earlier when instantiating D from TMPL and ARGS. */
15803 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15805 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15806 tree type
= TREE_TYPE (pattern
);
15807 location_t loc
= input_location
;
15809 push_access_scope (d
);
15810 push_deferring_access_checks (dk_no_deferred
);
15811 input_location
= DECL_SOURCE_LOCATION (pattern
);
15812 tsubst (type
, args
, tf_warning_or_error
, d
);
15813 input_location
= loc
;
15814 pop_deferring_access_checks ();
15815 pop_access_scope (d
);
15818 /* Instantiate the indicated variable, function, or alias template TMPL with
15819 the template arguments in TARG_PTR. */
15822 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15824 tree targ_ptr
= orig_args
;
15828 bool access_ok
= true;
15830 if (tmpl
== error_mark_node
)
15831 return error_mark_node
;
15833 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15835 /* If this function is a clone, handle it specially. */
15836 if (DECL_CLONED_FUNCTION_P (tmpl
))
15841 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15842 DECL_CLONED_FUNCTION. */
15843 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15844 targ_ptr
, complain
);
15845 if (spec
== error_mark_node
)
15846 return error_mark_node
;
15848 /* Look for the clone. */
15849 FOR_EACH_CLONE (clone
, spec
)
15850 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15852 /* We should always have found the clone by now. */
15853 gcc_unreachable ();
15857 if (targ_ptr
== error_mark_node
)
15858 return error_mark_node
;
15860 /* Check to see if we already have this specialization. */
15861 gen_tmpl
= most_general_template (tmpl
);
15862 if (tmpl
!= gen_tmpl
)
15863 /* The TMPL is a partial instantiation. To get a full set of
15864 arguments we must add the arguments used to perform the
15865 partial instantiation. */
15866 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15869 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15870 but it doesn't seem to be on the hot path. */
15871 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15873 gcc_assert (tmpl
== gen_tmpl
15874 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15876 || fndecl
== NULL_TREE
);
15878 if (spec
!= NULL_TREE
)
15880 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15882 if (complain
& tf_error
)
15883 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15884 return error_mark_node
;
15889 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15891 return error_mark_node
;
15893 /* We are building a FUNCTION_DECL, during which the access of its
15894 parameters and return types have to be checked. However this
15895 FUNCTION_DECL which is the desired context for access checking
15896 is not built yet. We solve this chicken-and-egg problem by
15897 deferring all checks until we have the FUNCTION_DECL. */
15898 push_deferring_access_checks (dk_deferred
);
15900 /* Instantiation of the function happens in the context of the function
15901 template, not the context of the overload resolution we're doing. */
15902 push_to_top_level ();
15903 /* If there are dependent arguments, e.g. because we're doing partial
15904 ordering, make sure processing_template_decl stays set. */
15905 if (uses_template_parms (targ_ptr
))
15906 ++processing_template_decl
;
15907 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15909 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15910 complain
, gen_tmpl
, true);
15911 push_nested_class (ctx
);
15914 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
15916 if (VAR_P (pattern
))
15918 /* We need to determine if we're using a partial or explicit
15919 specialization now, because the type of the variable could be
15921 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
15922 tree elt
= most_specialized_partial_spec (tid
, complain
);
15923 if (elt
== error_mark_node
)
15924 pattern
= error_mark_node
;
15927 tmpl
= TREE_VALUE (elt
);
15928 pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15929 targ_ptr
= TREE_PURPOSE (elt
);
15933 /* Substitute template parameters to obtain the specialization. */
15934 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
15935 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15936 pop_nested_class ();
15937 pop_from_top_level ();
15939 if (fndecl
== error_mark_node
)
15941 pop_deferring_access_checks ();
15942 return error_mark_node
;
15945 /* The DECL_TI_TEMPLATE should always be the immediate parent
15946 template, not the most general template. */
15947 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
15949 /* Now we know the specialization, compute access previously
15951 push_access_scope (fndecl
);
15952 if (!perform_deferred_access_checks (complain
))
15954 pop_access_scope (fndecl
);
15955 pop_deferring_access_checks ();
15957 /* If we've just instantiated the main entry point for a function,
15958 instantiate all the alternate entry points as well. We do this
15959 by cloning the instantiation of the main entry point, not by
15960 instantiating the template clones. */
15961 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
15962 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
15966 if (!(complain
& tf_error
))
15968 /* Remember to reinstantiate when we're out of SFINAE so the user
15969 can see the errors. */
15970 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
15972 return error_mark_node
;
15977 /* Wrapper for instantiate_template_1. */
15980 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15983 timevar_push (TV_TEMPLATE_INST
);
15984 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
15985 timevar_pop (TV_TEMPLATE_INST
);
15989 /* Instantiate the alias template TMPL with ARGS. Also push a template
15990 instantiation level, which instantiate_template doesn't do because
15991 functions and variables have sufficient context established by the
15995 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
15997 struct pending_template
*old_last_pend
= last_pending_template
;
15998 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15999 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
16000 return error_mark_node
;
16001 tree tinst
= build_tree_list (tmpl
, args
);
16002 if (!push_tinst_level (tinst
))
16005 return error_mark_node
;
16009 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
16010 args
, tmpl
, complain
,
16011 /*require_all_args=*/true,
16012 /*use_default_args=*/true);
16014 tree r
= instantiate_template (tmpl
, args
, complain
);
16015 pop_tinst_level ();
16016 /* We can't free this if a pending_template entry or last_error_tinst_level
16017 is pointing at it. */
16018 if (last_pending_template
== old_last_pend
16019 && last_error_tinst_level
== old_error_tinst
)
16025 /* PARM is a template parameter pack for FN. Returns true iff
16026 PARM is used in a deducible way in the argument list of FN. */
16029 pack_deducible_p (tree parm
, tree fn
)
16031 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
16032 for (; t
; t
= TREE_CHAIN (t
))
16034 tree type
= TREE_VALUE (t
);
16036 if (!PACK_EXPANSION_P (type
))
16038 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
16039 packs
; packs
= TREE_CHAIN (packs
))
16040 if (template_args_equal (TREE_VALUE (packs
), parm
))
16042 /* The template parameter pack is used in a function parameter
16043 pack. If this is the end of the parameter list, the
16044 template parameter pack is deducible. */
16045 if (TREE_CHAIN (t
) == void_list_node
)
16048 /* Otherwise, not. Well, it could be deduced from
16049 a non-pack parameter, but doing so would end up with
16050 a deduction mismatch, so don't bother. */
16054 /* The template parameter pack isn't used in any function parameter
16055 packs, but it might be used deeper, e.g. tuple<Args...>. */
16059 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
16060 NARGS elements of the arguments that are being used when calling
16061 it. TARGS is a vector into which the deduced template arguments
16064 Returns either a FUNCTION_DECL for the matching specialization of FN or
16065 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
16066 true, diagnostics will be printed to explain why it failed.
16068 If FN is a conversion operator, or we are trying to produce a specific
16069 specialization, RETURN_TYPE is the return type desired.
16071 The EXPLICIT_TARGS are explicit template arguments provided via a
16074 The parameter STRICT is one of:
16077 We are deducing arguments for a function call, as in
16078 [temp.deduct.call].
16081 We are deducing arguments for a conversion function, as in
16082 [temp.deduct.conv].
16085 We are deducing arguments when doing an explicit instantiation
16086 as in [temp.explicit], when determining an explicit specialization
16087 as in [temp.expl.spec], or when taking the address of a function
16088 template, as in [temp.deduct.funcaddr]. */
16091 fn_type_unification (tree fn
,
16092 tree explicit_targs
,
16095 unsigned int nargs
,
16097 unification_kind_t strict
,
16104 tree decl
= NULL_TREE
;
16105 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
16107 static int deduction_depth
;
16108 struct pending_template
*old_last_pend
= last_pending_template
;
16109 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16110 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
16112 tree r
= error_mark_node
;
16115 complain
|= tf_decltype
;
16117 /* In C++0x, it's possible to have a function template whose type depends
16118 on itself recursively. This is most obvious with decltype, but can also
16119 occur with enumeration scope (c++/48969). So we need to catch infinite
16120 recursion and reject the substitution at deduction time; this function
16121 will return error_mark_node for any repeated substitution.
16123 This also catches excessive recursion such as when f<N> depends on
16124 f<N-1> across all integers, and returns error_mark_node for all the
16125 substitutions back up to the initial one.
16127 This is, of course, not reentrant. */
16128 if (excessive_deduction_depth
)
16129 return error_mark_node
;
16130 tinst
= build_tree_list (fn
, NULL_TREE
);
16133 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
16135 fntype
= TREE_TYPE (fn
);
16136 if (explicit_targs
)
16140 The specified template arguments must match the template
16141 parameters in kind (i.e., type, nontype, template), and there
16142 must not be more arguments than there are parameters;
16143 otherwise type deduction fails.
16145 Nontype arguments must match the types of the corresponding
16146 nontype template parameters, or must be convertible to the
16147 types of the corresponding nontype parameters as specified in
16148 _temp.arg.nontype_, otherwise type deduction fails.
16150 All references in the function type of the function template
16151 to the corresponding template parameters are replaced by the
16152 specified template argument values. If a substitution in a
16153 template parameter or in the function type of the function
16154 template results in an invalid type, type deduction fails. */
16155 int i
, len
= TREE_VEC_LENGTH (tparms
);
16156 location_t loc
= input_location
;
16157 bool incomplete
= false;
16159 /* Adjust any explicit template arguments before entering the
16160 substitution context. */
16162 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
16164 /*require_all_args=*/false,
16165 /*use_default_args=*/false));
16166 if (explicit_targs
== error_mark_node
)
16169 /* Substitute the explicit args into the function type. This is
16170 necessary so that, for instance, explicitly declared function
16171 arguments can match null pointed constants. If we were given
16172 an incomplete set of explicit args, we must not do semantic
16173 processing during substitution as we could create partial
16175 for (i
= 0; i
< len
; i
++)
16177 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16178 bool parameter_pack
= false;
16179 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
16181 /* Dig out the actual parm. */
16182 if (TREE_CODE (parm
) == TYPE_DECL
16183 || TREE_CODE (parm
) == TEMPLATE_DECL
)
16185 parm
= TREE_TYPE (parm
);
16186 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
16188 else if (TREE_CODE (parm
) == PARM_DECL
)
16190 parm
= DECL_INITIAL (parm
);
16191 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
16194 if (!parameter_pack
&& targ
== NULL_TREE
)
16195 /* No explicit argument for this template parameter. */
16198 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
16200 /* Mark the argument pack as "incomplete". We could
16201 still deduce more arguments during unification.
16202 We remove this mark in type_unification_real. */
16205 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
16206 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
16207 = ARGUMENT_PACK_ARGS (targ
);
16210 /* We have some incomplete argument packs. */
16215 TREE_VALUE (tinst
) = explicit_targs
;
16216 if (!push_tinst_level (tinst
))
16218 excessive_deduction_depth
= true;
16221 processing_template_decl
+= incomplete
;
16222 input_location
= DECL_SOURCE_LOCATION (fn
);
16223 /* Ignore any access checks; we'll see them again in
16224 instantiate_template and they might have the wrong
16225 access path at this point. */
16226 push_deferring_access_checks (dk_deferred
);
16227 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
16228 complain
| tf_partial
, NULL_TREE
);
16229 pop_deferring_access_checks ();
16230 input_location
= loc
;
16231 processing_template_decl
-= incomplete
;
16232 pop_tinst_level ();
16234 if (fntype
== error_mark_node
)
16237 /* Place the explicitly specified arguments in TARGS. */
16238 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
16239 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
16242 /* Never do unification on the 'this' parameter. */
16243 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
16249 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
16250 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
16251 new_args
[0] = return_type
;
16252 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
16257 /* We allow incomplete unification without an error message here
16258 because the standard doesn't seem to explicitly prohibit it. Our
16259 callers must be ready to deal with unification failures in any
16262 TREE_VALUE (tinst
) = targs
;
16263 /* If we aren't explaining yet, push tinst context so we can see where
16264 any errors (e.g. from class instantiations triggered by instantiation
16265 of default template arguments) come from. If we are explaining, this
16266 context is redundant. */
16267 if (!explain_p
&& !push_tinst_level (tinst
))
16269 excessive_deduction_depth
= true;
16273 /* type_unification_real will pass back any access checks from default
16274 template argument substitution. */
16275 vec
<deferred_access_check
, va_gc
> *checks
;
16278 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16279 targs
, parms
, args
, nargs
, /*subr=*/0,
16280 strict
, flags
, &checks
, explain_p
);
16282 pop_tinst_level ();
16286 /* Now that we have bindings for all of the template arguments,
16287 ensure that the arguments deduced for the template template
16288 parameters have compatible template parameter lists. We cannot
16289 check this property before we have deduced all template
16290 arguments, because the template parameter types of a template
16291 template parameter might depend on prior template parameters
16292 deduced after the template template parameter. The following
16293 ill-formed example illustrates this issue:
16295 template<typename T, template<T> class C> void f(C<5>, T);
16297 template<int N> struct X {};
16300 f(X<5>(), 5l); // error: template argument deduction fails
16303 The template parameter list of 'C' depends on the template type
16304 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16305 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16306 time that we deduce 'C'. */
16307 if (!template_template_parm_bindings_ok_p
16308 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16310 unify_inconsistent_template_template_parameters (explain_p
);
16314 /* All is well so far. Now, check:
16318 When all template arguments have been deduced, all uses of
16319 template parameters in nondeduced contexts are replaced with
16320 the corresponding deduced argument values. If the
16321 substitution results in an invalid type, as described above,
16322 type deduction fails. */
16323 TREE_VALUE (tinst
) = targs
;
16324 if (!push_tinst_level (tinst
))
16326 excessive_deduction_depth
= true;
16330 /* Also collect access checks from the instantiation. */
16331 reopen_deferring_access_checks (checks
);
16333 decl
= instantiate_template (fn
, targs
, complain
);
16335 checks
= get_deferred_access_checks ();
16336 pop_deferring_access_checks ();
16338 pop_tinst_level ();
16340 if (decl
== error_mark_node
)
16343 /* Now perform any access checks encountered during substitution. */
16344 push_access_scope (decl
);
16345 ok
= perform_access_checks (checks
, complain
);
16346 pop_access_scope (decl
);
16350 /* If we're looking for an exact match, check that what we got
16351 is indeed an exact match. It might not be if some template
16352 parameters are used in non-deduced contexts. But don't check
16353 for an exact match if we have dependent template arguments;
16354 in that case we're doing partial ordering, and we already know
16355 that we have two candidates that will provide the actual type. */
16356 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16358 tree substed
= TREE_TYPE (decl
);
16362 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16364 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16365 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16366 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16368 unify_type_mismatch (explain_p
, args
[i
],
16369 TREE_VALUE (sarg
));
16378 if (excessive_deduction_depth
)
16380 if (deduction_depth
== 0)
16381 /* Reset once we're all the way out. */
16382 excessive_deduction_depth
= false;
16385 /* We can't free this if a pending_template entry or last_error_tinst_level
16386 is pointing at it. */
16387 if (last_pending_template
== old_last_pend
16388 && last_error_tinst_level
== old_error_tinst
)
16394 /* Adjust types before performing type deduction, as described in
16395 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16396 sections are symmetric. PARM is the type of a function parameter
16397 or the return type of the conversion function. ARG is the type of
16398 the argument passed to the call, or the type of the value
16399 initialized with the result of the conversion function.
16400 ARG_EXPR is the original argument expression, which may be null. */
16403 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16417 /* Swap PARM and ARG throughout the remainder of this
16418 function; the handling is precisely symmetric since PARM
16419 will initialize ARG rather than vice versa. */
16427 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16428 too, but here handle it by stripping the reference from PARM
16429 rather than by adding it to ARG. */
16430 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16431 && TYPE_REF_IS_RVALUE (*parm
)
16432 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16433 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16434 && TREE_CODE (*arg
) == REFERENCE_TYPE
16435 && !TYPE_REF_IS_RVALUE (*arg
))
16436 *parm
= TREE_TYPE (*parm
);
16437 /* Nothing else to do in this case. */
16441 gcc_unreachable ();
16444 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16446 /* [temp.deduct.call]
16448 If P is not a reference type:
16450 --If A is an array type, the pointer type produced by the
16451 array-to-pointer standard conversion (_conv.array_) is
16452 used in place of A for type deduction; otherwise,
16454 --If A is a function type, the pointer type produced by
16455 the function-to-pointer standard conversion
16456 (_conv.func_) is used in place of A for type deduction;
16459 --If A is a cv-qualified type, the top level
16460 cv-qualifiers of A's type are ignored for type
16462 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16463 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16464 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16465 *arg
= build_pointer_type (*arg
);
16467 *arg
= TYPE_MAIN_VARIANT (*arg
);
16470 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16471 of the form T&&, where T is a template parameter, and the argument
16472 is an lvalue, T is deduced as A& */
16473 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16474 && TYPE_REF_IS_RVALUE (*parm
)
16475 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16476 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16477 && (arg_expr
? real_lvalue_p (arg_expr
)
16478 /* try_one_overload doesn't provide an arg_expr, but
16479 functions are always lvalues. */
16480 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16481 *arg
= build_reference_type (*arg
);
16483 /* [temp.deduct.call]
16485 If P is a cv-qualified type, the top level cv-qualifiers
16486 of P's type are ignored for type deduction. If P is a
16487 reference type, the type referred to by P is used for
16489 *parm
= TYPE_MAIN_VARIANT (*parm
);
16490 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16492 *parm
= TREE_TYPE (*parm
);
16493 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16496 /* DR 322. For conversion deduction, remove a reference type on parm
16497 too (which has been swapped into ARG). */
16498 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16499 *arg
= TREE_TYPE (*arg
);
16504 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16505 template which does contain any deducible template parameters; check if
16506 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16507 unify_one_argument. */
16510 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16511 int flags
, bool explain_p
)
16516 type
= TREE_TYPE (arg
);
16520 if (same_type_p (parm
, type
))
16521 return unify_success (explain_p
);
16523 if (strict
== DEDUCE_CONV
)
16525 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16526 explain_p
? tf_warning_or_error
: tf_none
))
16527 return unify_success (explain_p
);
16529 else if (strict
!= DEDUCE_EXACT
)
16531 if (can_convert_arg (parm
, type
,
16532 TYPE_P (arg
) ? NULL_TREE
: arg
,
16533 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16534 return unify_success (explain_p
);
16537 if (strict
== DEDUCE_EXACT
)
16538 return unify_type_mismatch (explain_p
, parm
, arg
);
16540 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16543 static bool uses_deducible_template_parms (tree type
);
16545 /* Returns true iff the expression EXPR is one from which a template
16546 argument can be deduced. In other words, if it's an undecorated
16547 use of a template non-type parameter. */
16550 deducible_expression (tree expr
)
16552 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16555 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16556 deducible way; that is, if it has a max value of <PARM> - 1. */
16559 deducible_array_bound (tree domain
)
16561 if (domain
== NULL_TREE
)
16564 tree max
= TYPE_MAX_VALUE (domain
);
16565 if (TREE_CODE (max
) != MINUS_EXPR
)
16568 return deducible_expression (TREE_OPERAND (max
, 0));
16571 /* Returns true iff the template arguments ARGS use a template parameter
16572 in a deducible way. */
16575 deducible_template_args (tree args
)
16577 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16580 tree elt
= TREE_VEC_ELT (args
, i
);
16581 if (ARGUMENT_PACK_P (elt
))
16582 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16585 if (PACK_EXPANSION_P (elt
))
16586 elt
= PACK_EXPANSION_PATTERN (elt
);
16587 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16589 else if (TYPE_P (elt
))
16590 deducible
= uses_deducible_template_parms (elt
);
16592 deducible
= deducible_expression (elt
);
16600 /* Returns true iff TYPE contains any deducible references to template
16601 parameters, as per 14.8.2.5. */
16604 uses_deducible_template_parms (tree type
)
16606 if (PACK_EXPANSION_P (type
))
16607 type
= PACK_EXPANSION_PATTERN (type
);
16614 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16615 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16621 if (POINTER_TYPE_P (type
))
16622 return uses_deducible_template_parms (TREE_TYPE (type
));
16624 /* T[integer-constant ]
16626 if (TREE_CODE (type
) == ARRAY_TYPE
)
16627 return (uses_deducible_template_parms (TREE_TYPE (type
))
16628 || deducible_array_bound (TYPE_DOMAIN (type
)));
16640 if (TYPE_PTRMEM_P (type
))
16641 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16642 || (uses_deducible_template_parms
16643 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16645 /* template-name <T> (where template-name refers to a class template)
16646 template-name <i> (where template-name refers to a class template) */
16647 if (CLASS_TYPE_P (type
)
16648 && CLASSTYPE_TEMPLATE_INFO (type
)
16649 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16650 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16651 (CLASSTYPE_TI_ARGS (type
)));
16656 if (TREE_CODE (type
) == FUNCTION_TYPE
16657 || TREE_CODE (type
) == METHOD_TYPE
)
16659 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16661 tree parm
= TYPE_ARG_TYPES (type
);
16662 if (TREE_CODE (type
) == METHOD_TYPE
)
16663 parm
= TREE_CHAIN (parm
);
16664 for (; parm
; parm
= TREE_CHAIN (parm
))
16665 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16672 /* Subroutine of type_unification_real and unify_pack_expansion to
16673 handle unification of a single P/A pair. Parameters are as
16674 for those functions. */
16677 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16678 int subr
, unification_kind_t strict
, int flags
,
16681 tree arg_expr
= NULL_TREE
;
16684 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16685 return unify_invalid (explain_p
);
16686 if (arg
== unknown_type_node
)
16687 /* We can't deduce anything from this, but we might get all the
16688 template args from other function args. */
16689 return unify_success (explain_p
);
16691 /* Implicit conversions (Clause 4) will be performed on a function
16692 argument to convert it to the type of the corresponding function
16693 parameter if the parameter type contains no template-parameters that
16694 participate in template argument deduction. */
16695 if (TYPE_P (parm
) && !uses_template_parms (parm
))
16696 /* For function parameters that contain no template-parameters at all,
16697 we have historically checked for convertibility in order to shortcut
16698 consideration of this candidate. */
16699 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
16701 else if (strict
== DEDUCE_CALL
16702 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16703 /* For function parameters with only non-deducible template parameters,
16705 return unify_success (explain_p
);
16710 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16711 | UNIFY_ALLOW_MORE_CV_QUAL
16712 | UNIFY_ALLOW_DERIVED
);
16716 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16720 arg_strict
= UNIFY_ALLOW_NONE
;
16724 gcc_unreachable ();
16727 /* We only do these transformations if this is the top-level
16728 parameter_type_list in a call or declaration matching; in other
16729 situations (nested function declarators, template argument lists) we
16730 won't be comparing a type to an expression, and we don't do any type
16736 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16737 if (type_unknown_p (arg
))
16739 /* [temp.deduct.type] A template-argument can be
16740 deduced from a pointer to function or pointer
16741 to member function argument if the set of
16742 overloaded functions does not contain function
16743 templates and at most one of a set of
16744 overloaded functions provides a unique
16747 if (resolve_overloaded_unification
16748 (tparms
, targs
, parm
, arg
, strict
,
16749 arg_strict
, explain_p
))
16750 return unify_success (explain_p
);
16751 return unify_overload_resolution_failure (explain_p
, arg
);
16755 arg
= unlowered_expr_type (arg
);
16756 if (arg
== error_mark_node
)
16757 return unify_invalid (explain_p
);
16761 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16764 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16765 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
16766 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16768 /* For deduction from an init-list we need the actual list. */
16769 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16771 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16774 /* Most parms like fn_type_unification.
16776 If SUBR is 1, we're being called recursively (to unify the
16777 arguments of a function or method parameter of a function
16780 CHECKS is a pointer to a vector of access checks encountered while
16781 substituting default template arguments. */
16784 type_unification_real (tree tparms
,
16788 unsigned int xnargs
,
16790 unification_kind_t strict
,
16792 vec
<deferred_access_check
, va_gc
> **checks
,
16797 int ntparms
= TREE_VEC_LENGTH (tparms
);
16798 int saw_undeduced
= 0;
16801 unsigned int nargs
;
16804 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16805 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16806 gcc_assert (ntparms
> 0);
16808 /* Reset the number of non-defaulted template arguments contained
16810 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16818 while (parms
&& parms
!= void_list_node
16821 parm
= TREE_VALUE (parms
);
16823 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16824 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16825 /* For a function parameter pack that occurs at the end of the
16826 parameter-declaration-list, the type A of each remaining
16827 argument of the call is compared with the type P of the
16828 declarator-id of the function parameter pack. */
16831 parms
= TREE_CHAIN (parms
);
16833 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16834 /* For a function parameter pack that does not occur at the
16835 end of the parameter-declaration-list, the type of the
16836 parameter pack is a non-deduced context. */
16842 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16848 && parms
!= void_list_node
16849 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16851 /* Unify the remaining arguments with the pack expansion type. */
16853 tree parmvec
= make_tree_vec (1);
16855 /* Allocate a TREE_VEC and copy in all of the arguments */
16856 argvec
= make_tree_vec (nargs
- ia
);
16857 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16858 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16860 /* Copy the parameter into parmvec. */
16861 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16862 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16863 /*subr=*/subr
, explain_p
))
16866 /* Advance to the end of the list of parameters. */
16867 parms
= TREE_CHAIN (parms
);
16870 /* Fail if we've reached the end of the parm list, and more args
16871 are present, and the parm list isn't variadic. */
16872 if (ia
< nargs
&& parms
== void_list_node
)
16873 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16874 /* Fail if parms are left and they don't have default values and
16875 they aren't all deduced as empty packs (c++/57397). This is
16876 consistent with sufficient_parms_p. */
16877 if (parms
&& parms
!= void_list_node
16878 && TREE_PURPOSE (parms
) == NULL_TREE
)
16880 unsigned int count
= nargs
;
16885 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
16888 p
= TREE_CHAIN (p
);
16890 while (p
&& p
!= void_list_node
);
16891 if (count
!= nargs
)
16892 return unify_too_few_arguments (explain_p
, ia
, count
,
16898 tsubst_flags_t complain
= (explain_p
16899 ? tf_warning_or_error
16902 for (i
= 0; i
< ntparms
; i
++)
16904 tree targ
= TREE_VEC_ELT (targs
, i
);
16905 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16907 /* Clear the "incomplete" flags on all argument packs now so that
16908 substituting them into later default arguments works. */
16909 if (targ
&& ARGUMENT_PACK_P (targ
))
16911 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16912 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16915 if (targ
|| tparm
== error_mark_node
)
16917 tparm
= TREE_VALUE (tparm
);
16919 /* If this is an undeduced nontype parameter that depends on
16920 a type parameter, try another pass; its type may have been
16921 deduced from a later argument than the one from which
16922 this parameter can be deduced. */
16923 if (TREE_CODE (tparm
) == PARM_DECL
16924 && uses_template_parms (TREE_TYPE (tparm
))
16925 && !saw_undeduced
++)
16928 /* Core issue #226 (C++0x) [temp.deduct]:
16930 If a template argument has not been deduced, its
16931 default template argument, if any, is used.
16933 When we are in C++98 mode, TREE_PURPOSE will either
16934 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16935 to explicitly check cxx_dialect here. */
16936 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
16938 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16939 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
16940 reopen_deferring_access_checks (*checks
);
16941 location_t save_loc
= input_location
;
16943 input_location
= DECL_SOURCE_LOCATION (parm
);
16944 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
16945 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
16947 input_location
= save_loc
;
16948 *checks
= get_deferred_access_checks ();
16949 pop_deferring_access_checks ();
16950 if (arg
== error_mark_node
)
16954 TREE_VEC_ELT (targs
, i
) = arg
;
16955 /* The position of the first default template argument,
16956 is also the number of non-defaulted arguments in TARGS.
16958 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16959 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
16964 /* If the type parameter is a parameter pack, then it will
16965 be deduced to an empty parameter pack. */
16966 if (template_parameter_pack_p (tparm
))
16970 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
16972 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
16973 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
16974 TREE_CONSTANT (arg
) = 1;
16977 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16979 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
16981 TREE_VEC_ELT (targs
, i
) = arg
;
16985 return unify_parameter_deduction_failure (explain_p
, tparm
);
16988 #ifdef ENABLE_CHECKING
16989 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16990 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
16993 return unify_success (explain_p
);
16996 /* Subroutine of type_unification_real. Args are like the variables
16997 at the call site. ARG is an overloaded function (or template-id);
16998 we try deducing template args from each of the overloads, and if
16999 only one succeeds, we go with that. Modifies TARGS and returns
17000 true on success. */
17003 resolve_overloaded_unification (tree tparms
,
17007 unification_kind_t strict
,
17011 tree tempargs
= copy_node (targs
);
17013 tree goodfn
= NULL_TREE
;
17016 if (TREE_CODE (arg
) == ADDR_EXPR
)
17018 arg
= TREE_OPERAND (arg
, 0);
17024 if (TREE_CODE (arg
) == COMPONENT_REF
)
17025 /* Handle `&x' where `x' is some static or non-static member
17027 arg
= TREE_OPERAND (arg
, 1);
17029 if (TREE_CODE (arg
) == OFFSET_REF
)
17030 arg
= TREE_OPERAND (arg
, 1);
17032 /* Strip baselink information. */
17033 if (BASELINK_P (arg
))
17034 arg
= BASELINK_FUNCTIONS (arg
);
17036 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
17038 /* If we got some explicit template args, we need to plug them into
17039 the affected templates before we try to unify, in case the
17040 explicit args will completely resolve the templates in question. */
17043 tree expl_subargs
= TREE_OPERAND (arg
, 1);
17044 arg
= TREE_OPERAND (arg
, 0);
17046 for (; arg
; arg
= OVL_NEXT (arg
))
17048 tree fn
= OVL_CURRENT (arg
);
17049 tree subargs
, elem
;
17051 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17054 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17055 expl_subargs
, NULL_TREE
, tf_none
,
17056 /*require_all_args=*/true,
17057 /*use_default_args=*/true);
17058 if (subargs
!= error_mark_node
17059 && !any_dependent_template_arguments_p (subargs
))
17061 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
17062 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17063 elem
, strict
, sub_strict
, addr_p
, explain_p
)
17064 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
17073 /* If no templates (or more than one) are fully resolved by the
17074 explicit arguments, this template-id is a non-deduced context; it
17075 could still be OK if we deduce all template arguments for the
17076 enclosing call through other arguments. */
17080 else if (TREE_CODE (arg
) != OVERLOAD
17081 && TREE_CODE (arg
) != FUNCTION_DECL
)
17082 /* If ARG is, for example, "(0, &f)" then its type will be unknown
17083 -- but the deduction does not succeed because the expression is
17084 not just the function on its own. */
17087 for (; arg
; arg
= OVL_NEXT (arg
))
17088 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17089 TREE_TYPE (OVL_CURRENT (arg
)),
17090 strict
, sub_strict
, addr_p
, explain_p
)
17091 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
17093 goodfn
= OVL_CURRENT (arg
);
17097 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17098 to function or pointer to member function argument if the set of
17099 overloaded functions does not contain function templates and at most
17100 one of a set of overloaded functions provides a unique match.
17102 So if we found multiple possibilities, we return success but don't
17103 deduce anything. */
17107 int i
= TREE_VEC_LENGTH (targs
);
17109 if (TREE_VEC_ELT (tempargs
, i
))
17111 tree old
= TREE_VEC_ELT (targs
, i
);
17112 tree new_
= TREE_VEC_ELT (tempargs
, i
);
17113 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
17114 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
17115 /* Don't forget explicit template arguments in a pack. */
17116 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
17117 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
17118 TREE_VEC_ELT (targs
, i
) = new_
;
17127 /* Core DR 115: In contexts where deduction is done and fails, or in
17128 contexts where deduction is not done, if a template argument list is
17129 specified and it, along with any default template arguments, identifies
17130 a single function template specialization, then the template-id is an
17131 lvalue for the function template specialization. */
17134 resolve_nondeduced_context (tree orig_expr
)
17136 tree expr
, offset
, baselink
;
17139 if (!type_unknown_p (orig_expr
))
17144 offset
= NULL_TREE
;
17145 baselink
= NULL_TREE
;
17147 if (TREE_CODE (expr
) == ADDR_EXPR
)
17149 expr
= TREE_OPERAND (expr
, 0);
17152 if (TREE_CODE (expr
) == OFFSET_REF
)
17155 expr
= TREE_OPERAND (expr
, 1);
17157 if (BASELINK_P (expr
))
17160 expr
= BASELINK_FUNCTIONS (expr
);
17163 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
17166 tree goodfn
= NULL_TREE
;
17168 /* If we got some explicit template args, we need to plug them into
17169 the affected templates before we try to unify, in case the
17170 explicit args will completely resolve the templates in question. */
17172 tree expl_subargs
= TREE_OPERAND (expr
, 1);
17173 tree arg
= TREE_OPERAND (expr
, 0);
17174 tree badfn
= NULL_TREE
;
17175 tree badargs
= NULL_TREE
;
17177 for (; arg
; arg
= OVL_NEXT (arg
))
17179 tree fn
= OVL_CURRENT (arg
);
17180 tree subargs
, elem
;
17182 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17185 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17186 expl_subargs
, NULL_TREE
, tf_none
,
17187 /*require_all_args=*/true,
17188 /*use_default_args=*/true);
17189 if (subargs
!= error_mark_node
17190 && !any_dependent_template_arguments_p (subargs
))
17192 elem
= instantiate_template (fn
, subargs
, tf_none
);
17193 if (elem
== error_mark_node
)
17198 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
17207 mark_used (goodfn
);
17210 expr
= build_baselink (BASELINK_BINFO (baselink
),
17211 BASELINK_ACCESS_BINFO (baselink
),
17212 expr
, BASELINK_OPTYPE (baselink
));
17216 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
17217 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
17220 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
17223 else if (good
== 0 && badargs
)
17224 /* There were no good options and at least one bad one, so let the
17225 user know what the problem is. */
17226 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
17231 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17232 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17233 different overloads deduce different arguments for a given parm.
17234 ADDR_P is true if the expression for which deduction is being
17235 performed was of the form "& fn" rather than simply "fn".
17237 Returns 1 on success. */
17240 try_one_overload (tree tparms
,
17245 unification_kind_t strict
,
17254 if (arg
== error_mark_node
)
17257 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17258 to function or pointer to member function argument if the set of
17259 overloaded functions does not contain function templates and at most
17260 one of a set of overloaded functions provides a unique match.
17262 So if this is a template, just return success. */
17264 if (uses_template_parms (arg
))
17267 if (TREE_CODE (arg
) == METHOD_TYPE
)
17268 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
17270 arg
= build_pointer_type (arg
);
17272 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
17274 /* We don't copy orig_targs for this because if we have already deduced
17275 some template args from previous args, unify would complain when we
17276 try to deduce a template parameter for the same argument, even though
17277 there isn't really a conflict. */
17278 nargs
= TREE_VEC_LENGTH (targs
);
17279 tempargs
= make_tree_vec (nargs
);
17281 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
17284 /* First make sure we didn't deduce anything that conflicts with
17285 explicitly specified args. */
17286 for (i
= nargs
; i
--; )
17288 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17289 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17293 else if (uses_template_parms (elt
))
17294 /* Since we're unifying against ourselves, we will fill in
17295 template args used in the function parm list with our own
17296 template parms. Discard them. */
17297 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17298 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17302 for (i
= nargs
; i
--; )
17304 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17307 TREE_VEC_ELT (targs
, i
) = elt
;
17313 /* PARM is a template class (perhaps with unbound template
17314 parameters). ARG is a fully instantiated type. If ARG can be
17315 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17316 TARGS are as for unify. */
17319 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17322 tree copy_of_targs
;
17324 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17325 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17326 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17329 /* We need to make a new template argument vector for the call to
17330 unify. If we used TARGS, we'd clutter it up with the result of
17331 the attempted unification, even if this class didn't work out.
17332 We also don't want to commit ourselves to all the unifications
17333 we've already done, since unification is supposed to be done on
17334 an argument-by-argument basis. In other words, consider the
17335 following pathological case:
17337 template <int I, int J, int K>
17340 template <int I, int J>
17341 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17343 template <int I, int J, int K>
17344 void f(S<I, J, K>, S<I, I, I>);
17353 Now, by the time we consider the unification involving `s2', we
17354 already know that we must have `f<0, 0, 0>'. But, even though
17355 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17356 because there are two ways to unify base classes of S<0, 1, 2>
17357 with S<I, I, I>. If we kept the already deduced knowledge, we
17358 would reject the possibility I=1. */
17359 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17361 /* If unification failed, we're done. */
17362 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17363 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17369 /* Given a template type PARM and a class type ARG, find the unique
17370 base type in ARG that is an instance of PARM. We do not examine
17371 ARG itself; only its base-classes. If there is not exactly one
17372 appropriate base class, return NULL_TREE. PARM may be the type of
17373 a partial specialization, as well as a plain template type. Used
17376 static enum template_base_result
17377 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17378 bool explain_p
, tree
*result
)
17380 tree rval
= NULL_TREE
;
17383 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17385 binfo
= TYPE_BINFO (complete_type (arg
));
17388 /* The type could not be completed. */
17389 *result
= NULL_TREE
;
17390 return tbr_incomplete_type
;
17393 /* Walk in inheritance graph order. The search order is not
17394 important, and this avoids multiple walks of virtual bases. */
17395 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17397 tree r
= try_class_unification (tparms
, targs
, parm
,
17398 BINFO_TYPE (binfo
), explain_p
);
17402 /* If there is more than one satisfactory baseclass, then:
17406 If they yield more than one possible deduced A, the type
17410 if (rval
&& !same_type_p (r
, rval
))
17412 *result
= NULL_TREE
;
17413 return tbr_ambiguous_baseclass
;
17421 return tbr_success
;
17424 /* Returns the level of DECL, which declares a template parameter. */
17427 template_decl_level (tree decl
)
17429 switch (TREE_CODE (decl
))
17432 case TEMPLATE_DECL
:
17433 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17436 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17439 gcc_unreachable ();
17444 /* Decide whether ARG can be unified with PARM, considering only the
17445 cv-qualifiers of each type, given STRICT as documented for unify.
17446 Returns nonzero iff the unification is OK on that basis. */
17449 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17451 int arg_quals
= cp_type_quals (arg
);
17452 int parm_quals
= cp_type_quals (parm
);
17454 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17455 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17457 /* Although a CVR qualifier is ignored when being applied to a
17458 substituted template parameter ([8.3.2]/1 for example), that
17459 does not allow us to unify "const T" with "int&" because both
17460 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17461 It is ok when we're allowing additional CV qualifiers
17462 at the outer level [14.8.2.1]/3,1st bullet. */
17463 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17464 || TREE_CODE (arg
) == FUNCTION_TYPE
17465 || TREE_CODE (arg
) == METHOD_TYPE
)
17466 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17469 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17470 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17474 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17475 && (arg_quals
& parm_quals
) != parm_quals
)
17478 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17479 && (parm_quals
& arg_quals
) != arg_quals
)
17485 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17487 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17489 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17490 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17491 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17493 *index
= TEMPLATE_TYPE_IDX (parm
);
17494 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17498 *index
= TEMPLATE_PARM_IDX (parm
);
17499 *level
= TEMPLATE_PARM_LEVEL (parm
);
17503 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17505 if (unify (TP, TA, P, A, S, EP)) \
17509 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17510 expansion at the end of PACKED_PARMS. Returns 0 if the type
17511 deduction succeeds, 1 otherwise. STRICT is the same as in
17512 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17513 call argument list. We'll need to adjust the arguments to make them
17514 types. SUBR tells us if this is from a recursive call to
17515 type_unification_real, or for comparing two template argument
17519 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17520 tree packed_args
, unification_kind_t strict
,
17521 bool subr
, bool explain_p
)
17524 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17525 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17526 tree pack
, packs
= NULL_TREE
;
17527 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17529 packed_args
= expand_template_argument_pack (packed_args
);
17531 int len
= TREE_VEC_LENGTH (packed_args
);
17533 /* Determine the parameter packs we will be deducing from the
17534 pattern, and record their current deductions. */
17535 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17536 pack
; pack
= TREE_CHAIN (pack
))
17538 tree parm_pack
= TREE_VALUE (pack
);
17541 /* Determine the index and level of this parameter pack. */
17542 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17544 /* Keep track of the parameter packs and their corresponding
17546 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17547 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17550 /* Loop through all of the arguments that have not yet been
17551 unified and unify each with the pattern. */
17552 for (i
= start
; i
< len
; i
++)
17555 bool any_explicit
= false;
17556 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17558 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17559 or the element of its argument pack at the current index if
17560 this argument was explicitly specified. */
17561 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17565 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17568 if (TREE_VALUE (pack
)
17569 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17570 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17572 any_explicit
= true;
17573 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17575 TMPL_ARG (targs
, level
, idx
) = arg
;
17578 /* If we had explicit template arguments, substitute them into the
17579 pattern before deduction. */
17582 /* Some arguments might still be unspecified or dependent. */
17584 ++processing_template_decl
;
17585 dependent
= any_dependent_template_arguments_p (targs
);
17587 --processing_template_decl
;
17588 parm
= tsubst (pattern
, targs
,
17589 explain_p
? tf_warning_or_error
: tf_none
,
17592 --processing_template_decl
;
17593 if (parm
== error_mark_node
)
17599 /* Unify the pattern with the current argument. */
17600 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17601 LOOKUP_IMPLICIT
, explain_p
))
17604 /* For each parameter pack, collect the deduced value. */
17605 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17608 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17610 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17611 TMPL_ARG (targs
, level
, idx
);
17615 /* Verify that the results of unification with the parameter packs
17616 produce results consistent with what we've seen before, and make
17617 the deduced argument packs available. */
17618 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17620 tree old_pack
= TREE_VALUE (pack
);
17621 tree new_args
= TREE_TYPE (pack
);
17622 int i
, len
= TREE_VEC_LENGTH (new_args
);
17624 bool nondeduced_p
= false;
17626 /* By default keep the original deduced argument pack.
17627 If necessary, more specific code is going to update the
17628 resulting deduced argument later down in this function. */
17629 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17630 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17632 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17633 actually deduce anything. */
17634 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17635 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17636 nondeduced_p
= true;
17640 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17642 /* If we had fewer function args than explicit template args,
17643 just use the explicits. */
17644 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17645 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17646 if (len
< explicit_len
)
17647 new_args
= explicit_args
;
17653 /* Build the deduced *_ARGUMENT_PACK. */
17654 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17656 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17657 TREE_TYPE (result
) =
17658 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17659 TREE_CONSTANT (result
) = 1;
17662 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17664 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17666 /* Note the deduced argument packs for this parameter
17668 TMPL_ARG (targs
, level
, idx
) = result
;
17670 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17671 && (ARGUMENT_PACK_ARGS (old_pack
)
17672 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17674 /* We only had the explicitly-provided arguments before, but
17675 now we have a complete set of arguments. */
17676 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17678 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17679 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17680 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17684 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17685 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17687 if (!comp_template_args_with_info (old_args
, new_args
,
17688 &bad_old_arg
, &bad_new_arg
))
17689 /* Inconsistent unification of this parameter pack. */
17690 return unify_parameter_pack_inconsistent (explain_p
,
17696 return unify_success (explain_p
);
17699 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17700 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17701 parameters and return value are as for unify. */
17704 unify_array_domain (tree tparms
, tree targs
,
17705 tree parm_dom
, tree arg_dom
,
17713 /* Our representation of array types uses "N - 1" as the
17714 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17715 not an integer constant. We cannot unify arbitrarily
17716 complex expressions, so we eliminate the MINUS_EXPRs
17718 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17719 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17722 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17723 parm_max
= TREE_OPERAND (parm_max
, 0);
17725 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17726 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17729 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17730 trying to unify the type of a variable with the type
17731 of a template parameter. For example:
17733 template <unsigned int N>
17734 void f (char (&) [N]);
17741 Here, the type of the ARG will be "int [g(i)]", and
17742 may be a SAVE_EXPR, etc. */
17743 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17744 return unify_vla_arg (explain_p
, arg_dom
);
17745 arg_max
= TREE_OPERAND (arg_max
, 0);
17748 /* If only one of the bounds used a MINUS_EXPR, compensate
17749 by adding one to the other bound. */
17750 if (parm_cst
&& !arg_cst
)
17751 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17755 else if (arg_cst
&& !parm_cst
)
17756 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17761 return unify (tparms
, targs
, parm_max
, arg_max
,
17762 UNIFY_ALLOW_INTEGER
, explain_p
);
17765 /* Deduce the value of template parameters. TPARMS is the (innermost)
17766 set of template parameters to a template. TARGS is the bindings
17767 for those template parameters, as determined thus far; TARGS may
17768 include template arguments for outer levels of template parameters
17769 as well. PARM is a parameter to a template function, or a
17770 subcomponent of that parameter; ARG is the corresponding argument.
17771 This function attempts to match PARM with ARG in a manner
17772 consistent with the existing assignments in TARGS. If more values
17773 are deduced, then TARGS is updated.
17775 Returns 0 if the type deduction succeeds, 1 otherwise. The
17776 parameter STRICT is a bitwise or of the following flags:
17779 Require an exact match between PARM and ARG.
17780 UNIFY_ALLOW_MORE_CV_QUAL:
17781 Allow the deduced ARG to be more cv-qualified (by qualification
17782 conversion) than ARG.
17783 UNIFY_ALLOW_LESS_CV_QUAL:
17784 Allow the deduced ARG to be less cv-qualified than ARG.
17785 UNIFY_ALLOW_DERIVED:
17786 Allow the deduced ARG to be a template base class of ARG,
17787 or a pointer to a template base class of the type pointed to by
17789 UNIFY_ALLOW_INTEGER:
17790 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17791 case for more information.
17792 UNIFY_ALLOW_OUTER_LEVEL:
17793 This is the outermost level of a deduction. Used to determine validity
17794 of qualification conversions. A valid qualification conversion must
17795 have const qualified pointers leading up to the inner type which
17796 requires additional CV quals, except at the outer level, where const
17797 is not required [conv.qual]. It would be normal to set this flag in
17798 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17799 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17800 This is the outermost level of a deduction, and PARM can be more CV
17801 qualified at this point.
17802 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17803 This is the outermost level of a deduction, and PARM can be less CV
17804 qualified at this point. */
17807 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17813 int strict_in
= strict
;
17815 /* I don't think this will do the right thing with respect to types.
17816 But the only case I've seen it in so far has been array bounds, where
17817 signedness is the only information lost, and I think that will be
17819 while (TREE_CODE (parm
) == NOP_EXPR
)
17820 parm
= TREE_OPERAND (parm
, 0);
17822 if (arg
== error_mark_node
)
17823 return unify_invalid (explain_p
);
17824 if (arg
== unknown_type_node
17825 || arg
== init_list_type_node
)
17826 /* We can't deduce anything from this, but we might get all the
17827 template args from other function args. */
17828 return unify_success (explain_p
);
17830 /* If PARM uses template parameters, then we can't bail out here,
17831 even if ARG == PARM, since we won't record unifications for the
17832 template parameters. We might need them if we're trying to
17833 figure out which of two things is more specialized. */
17834 if (arg
== parm
&& !uses_template_parms (parm
))
17835 return unify_success (explain_p
);
17837 /* Handle init lists early, so the rest of the function can assume
17838 we're dealing with a type. */
17839 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17843 tree orig_parm
= parm
;
17845 /* Replace T with std::initializer_list<T> for deduction. */
17846 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17847 && flag_deduce_init_list
)
17848 parm
= listify (parm
);
17850 if (!is_std_init_list (parm
)
17851 && TREE_CODE (parm
) != ARRAY_TYPE
)
17852 /* We can only deduce from an initializer list argument if the
17853 parameter is std::initializer_list or an array; otherwise this
17854 is a non-deduced context. */
17855 return unify_success (explain_p
);
17857 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17858 elttype
= TREE_TYPE (parm
);
17861 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17862 /* Deduction is defined in terms of a single type, so just punt
17863 on the (bizarre) std::initializer_list<T...>. */
17864 if (PACK_EXPANSION_P (elttype
))
17865 return unify_success (explain_p
);
17868 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
17870 int elt_strict
= strict
;
17872 if (elt
== error_mark_node
)
17873 return unify_invalid (explain_p
);
17875 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
17877 tree type
= TREE_TYPE (elt
);
17878 /* It should only be possible to get here for a call. */
17879 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
17880 elt_strict
|= maybe_adjust_types_for_deduction
17881 (DEDUCE_CALL
, &elttype
, &type
, elt
);
17885 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
17889 if (TREE_CODE (parm
) == ARRAY_TYPE
17890 && deducible_array_bound (TYPE_DOMAIN (parm
)))
17892 /* Also deduce from the length of the initializer list. */
17893 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
17894 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
17895 if (idx
== error_mark_node
)
17896 return unify_invalid (explain_p
);
17897 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17901 /* If the std::initializer_list<T> deduction worked, replace the
17902 deduced A with std::initializer_list<A>. */
17903 if (orig_parm
!= parm
)
17905 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
17906 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17907 targ
= listify (targ
);
17908 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
17910 return unify_success (explain_p
);
17913 /* Immediately reject some pairs that won't unify because of
17914 cv-qualification mismatches. */
17915 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17917 /* It is the elements of the array which hold the cv quals of an array
17918 type, and the elements might be template type parms. We'll check
17919 when we recurse. */
17920 && TREE_CODE (arg
) != ARRAY_TYPE
17921 /* We check the cv-qualifiers when unifying with template type
17922 parameters below. We want to allow ARG `const T' to unify with
17923 PARM `T' for example, when computing which of two templates
17924 is more specialized, for example. */
17925 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
17926 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
17927 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17929 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
17930 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
17931 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
17932 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
17933 strict
&= ~UNIFY_ALLOW_DERIVED
;
17934 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17935 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
17937 switch (TREE_CODE (parm
))
17939 case TYPENAME_TYPE
:
17941 case UNBOUND_CLASS_TEMPLATE
:
17942 /* In a type which contains a nested-name-specifier, template
17943 argument values cannot be deduced for template parameters used
17944 within the nested-name-specifier. */
17945 return unify_success (explain_p
);
17947 case TEMPLATE_TYPE_PARM
:
17948 case TEMPLATE_TEMPLATE_PARM
:
17949 case BOUND_TEMPLATE_TEMPLATE_PARM
:
17950 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17951 if (error_operand_p (tparm
))
17952 return unify_invalid (explain_p
);
17954 if (TEMPLATE_TYPE_LEVEL (parm
)
17955 != template_decl_level (tparm
))
17956 /* The PARM is not one we're trying to unify. Just check
17957 to see if it matches ARG. */
17959 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17960 && (is_auto (parm
) ? is_auto (arg
)
17961 : same_type_p (parm
, arg
)))
17962 return unify_success (explain_p
);
17964 return unify_type_mismatch (explain_p
, parm
, arg
);
17966 idx
= TEMPLATE_TYPE_IDX (parm
);
17967 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17968 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
17969 if (error_operand_p (tparm
))
17970 return unify_invalid (explain_p
);
17972 /* Check for mixed types and values. */
17973 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17974 && TREE_CODE (tparm
) != TYPE_DECL
)
17975 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17976 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
17977 gcc_unreachable ();
17979 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17981 /* ARG must be constructed from a template class or a template
17982 template parameter. */
17983 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
17984 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
17985 return unify_template_deduction_failure (explain_p
, parm
, arg
);
17987 tree parmvec
= TYPE_TI_ARGS (parm
);
17988 /* An alias template name is never deduced. */
17989 if (TYPE_ALIAS_P (arg
))
17990 arg
= strip_typedefs (arg
);
17991 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
17992 tree full_argvec
= add_to_template_args (targs
, argvec
);
17994 = DECL_INNERMOST_TEMPLATE_PARMS
17995 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
17997 int parm_variadic_p
= 0;
17999 /* The resolution to DR150 makes clear that default
18000 arguments for an N-argument may not be used to bind T
18001 to a template template parameter with fewer than N
18002 parameters. It is not safe to permit the binding of
18003 default arguments as an extension, as that may change
18004 the meaning of a conforming program. Consider:
18006 struct Dense { static const unsigned int dim = 1; };
18008 template <template <typename> class View,
18010 void operator+(float, View<Block> const&);
18012 template <typename Block,
18013 unsigned int Dim = Block::dim>
18014 struct Lvalue_proxy { operator float() const; };
18018 Lvalue_proxy<Dense> p;
18023 Here, if Lvalue_proxy is permitted to bind to View, then
18024 the global operator+ will be used; if they are not, the
18025 Lvalue_proxy will be converted to float. */
18026 if (coerce_template_parms (parm_parms
,
18028 TYPE_TI_TEMPLATE (parm
),
18030 ? tf_warning_or_error
18032 /*require_all_args=*/true,
18033 /*use_default_args=*/false)
18034 == error_mark_node
)
18037 /* Deduce arguments T, i from TT<T> or TT<i>.
18038 We check each element of PARMVEC and ARGVEC individually
18039 rather than the whole TREE_VEC since they can have
18040 different number of elements. */
18042 parmvec
= expand_template_argument_pack (parmvec
);
18043 argvec
= expand_template_argument_pack (argvec
);
18045 len
= TREE_VEC_LENGTH (parmvec
);
18047 /* Check if the parameters end in a pack, making them
18050 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
18051 parm_variadic_p
= 1;
18053 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18054 /* If the template argument list of P contains a pack
18055 expansion that is not the last template argument, the
18056 entire template argument list is a non-deduced
18058 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
18059 return unify_success (explain_p
);
18061 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
18062 return unify_too_few_arguments (explain_p
,
18063 TREE_VEC_LENGTH (argvec
), len
);
18065 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18067 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18068 TREE_VEC_ELT (parmvec
, i
),
18069 TREE_VEC_ELT (argvec
, i
),
18070 UNIFY_ALLOW_NONE
, explain_p
);
18073 if (parm_variadic_p
18074 && unify_pack_expansion (tparms
, targs
,
18077 /*subr=*/true, explain_p
))
18080 arg
= TYPE_TI_TEMPLATE (arg
);
18082 /* Fall through to deduce template name. */
18085 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18086 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18088 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
18090 /* Simple cases: Value already set, does match or doesn't. */
18091 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
18092 return unify_success (explain_p
);
18094 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18098 /* If PARM is `const T' and ARG is only `int', we don't have
18099 a match unless we are allowing additional qualification.
18100 If ARG is `const int' and PARM is just `T' that's OK;
18101 that binds `const int' to `T'. */
18102 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
18104 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18106 /* Consider the case where ARG is `const volatile int' and
18107 PARM is `const T'. Then, T should be `volatile int'. */
18108 arg
= cp_build_qualified_type_real
18109 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
18110 if (arg
== error_mark_node
)
18111 return unify_invalid (explain_p
);
18113 /* Simple cases: Value already set, does match or doesn't. */
18114 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
18115 return unify_success (explain_p
);
18117 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18119 /* Make sure that ARG is not a variable-sized array. (Note
18120 that were talking about variable-sized arrays (like
18121 `int[n]'), rather than arrays of unknown size (like
18122 `int[]').) We'll get very confused by such a type since
18123 the bound of the array is not constant, and therefore
18124 not mangleable. Besides, such types are not allowed in
18125 ISO C++, so we can do as we please here. We do allow
18126 them for 'auto' deduction, since that isn't ABI-exposed. */
18127 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
18128 return unify_vla_arg (explain_p
, arg
);
18130 /* Strip typedefs as in convert_template_argument. */
18131 arg
= canonicalize_type_argument (arg
, tf_none
);
18134 /* If ARG is a parameter pack or an expansion, we cannot unify
18135 against it unless PARM is also a parameter pack. */
18136 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18137 && !template_parameter_pack_p (parm
))
18138 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18140 /* If the argument deduction results is a METHOD_TYPE,
18141 then there is a problem.
18142 METHOD_TYPE doesn't map to any real C++ type the result of
18143 the deduction can not be of that type. */
18144 if (TREE_CODE (arg
) == METHOD_TYPE
)
18145 return unify_method_type_error (explain_p
, arg
);
18147 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18148 return unify_success (explain_p
);
18150 case TEMPLATE_PARM_INDEX
:
18151 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18152 if (error_operand_p (tparm
))
18153 return unify_invalid (explain_p
);
18155 if (TEMPLATE_PARM_LEVEL (parm
)
18156 != template_decl_level (tparm
))
18158 /* The PARM is not one we're trying to unify. Just check
18159 to see if it matches ARG. */
18160 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
18161 && cp_tree_equal (parm
, arg
));
18163 unify_expression_unequal (explain_p
, parm
, arg
);
18167 idx
= TEMPLATE_PARM_IDX (parm
);
18168 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18172 int x
= !cp_tree_equal (targ
, arg
);
18174 unify_inconsistency (explain_p
, parm
, targ
, arg
);
18178 /* [temp.deduct.type] If, in the declaration of a function template
18179 with a non-type template-parameter, the non-type
18180 template-parameter is used in an expression in the function
18181 parameter-list and, if the corresponding template-argument is
18182 deduced, the template-argument type shall match the type of the
18183 template-parameter exactly, except that a template-argument
18184 deduced from an array bound may be of any integral type.
18185 The non-type parameter might use already deduced type parameters. */
18186 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
18187 if (!TREE_TYPE (arg
))
18188 /* Template-parameter dependent expression. Just accept it for now.
18189 It will later be processed in convert_template_argument. */
18191 else if (same_type_p (TREE_TYPE (arg
), tparm
))
18193 else if ((strict
& UNIFY_ALLOW_INTEGER
)
18194 && CP_INTEGRAL_TYPE_P (tparm
))
18195 /* Convert the ARG to the type of PARM; the deduced non-type
18196 template argument must exactly match the types of the
18197 corresponding parameter. */
18198 arg
= fold (build_nop (tparm
, arg
));
18199 else if (uses_template_parms (tparm
))
18200 /* We haven't deduced the type of this parameter yet. Try again
18202 return unify_success (explain_p
);
18204 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
18206 /* If ARG is a parameter pack or an expansion, we cannot unify
18207 against it unless PARM is also a parameter pack. */
18208 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18209 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
18210 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18212 arg
= strip_typedefs_expr (arg
);
18213 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18214 return unify_success (explain_p
);
18218 /* A pointer-to-member constant can be unified only with
18219 another constant. */
18220 if (TREE_CODE (arg
) != PTRMEM_CST
)
18221 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
18223 /* Just unify the class member. It would be useless (and possibly
18224 wrong, depending on the strict flags) to unify also
18225 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18226 arg refer to the same variable, even if through different
18227 classes. For instance:
18229 struct A { int x; };
18232 Unification of &A::x and &B::x must succeed. */
18233 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
18234 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
18239 if (!TYPE_PTR_P (arg
))
18240 return unify_type_mismatch (explain_p
, parm
, arg
);
18242 /* [temp.deduct.call]
18244 A can be another pointer or pointer to member type that can
18245 be converted to the deduced A via a qualification
18246 conversion (_conv.qual_).
18248 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18249 This will allow for additional cv-qualification of the
18250 pointed-to types if appropriate. */
18252 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
18253 /* The derived-to-base conversion only persists through one
18254 level of pointers. */
18255 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
18257 return unify (tparms
, targs
, TREE_TYPE (parm
),
18258 TREE_TYPE (arg
), strict
, explain_p
);
18261 case REFERENCE_TYPE
:
18262 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
18263 return unify_type_mismatch (explain_p
, parm
, arg
);
18264 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18265 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18268 if (TREE_CODE (arg
) != ARRAY_TYPE
)
18269 return unify_type_mismatch (explain_p
, parm
, arg
);
18270 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
18271 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
18272 return unify_type_mismatch (explain_p
, parm
, arg
);
18273 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18274 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18275 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
18276 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18277 TYPE_DOMAIN (arg
), explain_p
);
18278 return unify_success (explain_p
);
18285 case ENUMERAL_TYPE
:
18288 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18289 return unify_type_mismatch (explain_p
, parm
, arg
);
18291 /* We have already checked cv-qualification at the top of the
18293 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
18294 return unify_type_mismatch (explain_p
, parm
, arg
);
18296 /* As far as unification is concerned, this wins. Later checks
18297 will invalidate it if necessary. */
18298 return unify_success (explain_p
);
18300 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18301 /* Type INTEGER_CST can come from ordinary constant template args. */
18303 while (TREE_CODE (arg
) == NOP_EXPR
)
18304 arg
= TREE_OPERAND (arg
, 0);
18306 if (TREE_CODE (arg
) != INTEGER_CST
)
18307 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18308 return (tree_int_cst_equal (parm
, arg
)
18309 ? unify_success (explain_p
)
18310 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18314 int i
, len
, argslen
;
18315 int parm_variadic_p
= 0;
18317 if (TREE_CODE (arg
) != TREE_VEC
)
18318 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18320 len
= TREE_VEC_LENGTH (parm
);
18321 argslen
= TREE_VEC_LENGTH (arg
);
18323 /* Check for pack expansions in the parameters. */
18324 for (i
= 0; i
< len
; ++i
)
18326 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18329 /* We can unify against something with a trailing
18331 parm_variadic_p
= 1;
18333 /* [temp.deduct.type]/9: If the template argument list of
18334 P contains a pack expansion that is not the last
18335 template argument, the entire template argument list
18336 is a non-deduced context. */
18337 return unify_success (explain_p
);
18341 /* If we don't have enough arguments to satisfy the parameters
18342 (not counting the pack expression at the end), or we have
18343 too many arguments for a parameter list that doesn't end in
18344 a pack expression, we can't unify. */
18345 if (parm_variadic_p
18346 ? argslen
< len
- parm_variadic_p
18348 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18350 /* Unify all of the parameters that precede the (optional)
18351 pack expression. */
18352 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18354 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18355 TREE_VEC_ELT (parm
, i
),
18356 TREE_VEC_ELT (arg
, i
),
18357 UNIFY_ALLOW_NONE
, explain_p
);
18359 if (parm_variadic_p
)
18360 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18362 /*subr=*/true, explain_p
);
18363 return unify_success (explain_p
);
18368 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18369 return unify_type_mismatch (explain_p
, parm
, arg
);
18371 if (TYPE_PTRMEMFUNC_P (parm
))
18373 if (!TYPE_PTRMEMFUNC_P (arg
))
18374 return unify_type_mismatch (explain_p
, parm
, arg
);
18376 return unify (tparms
, targs
,
18377 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18378 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18379 strict
, explain_p
);
18381 else if (TYPE_PTRMEMFUNC_P (arg
))
18382 return unify_type_mismatch (explain_p
, parm
, arg
);
18384 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18386 tree t
= NULL_TREE
;
18388 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18390 /* First, we try to unify the PARM and ARG directly. */
18391 t
= try_class_unification (tparms
, targs
,
18392 parm
, arg
, explain_p
);
18396 /* Fallback to the special case allowed in
18397 [temp.deduct.call]:
18399 If P is a class, and P has the form
18400 template-id, then A can be a derived class of
18401 the deduced A. Likewise, if P is a pointer to
18402 a class of the form template-id, A can be a
18403 pointer to a derived class pointed to by the
18405 enum template_base_result r
;
18406 r
= get_template_base (tparms
, targs
, parm
, arg
,
18410 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18413 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18414 && (CLASSTYPE_TI_TEMPLATE (parm
)
18415 == CLASSTYPE_TI_TEMPLATE (arg
)))
18416 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18417 Then, we should unify `int' and `U'. */
18420 /* There's no chance of unification succeeding. */
18421 return unify_type_mismatch (explain_p
, parm
, arg
);
18423 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18424 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18426 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18427 return unify_type_mismatch (explain_p
, parm
, arg
);
18428 return unify_success (explain_p
);
18431 case FUNCTION_TYPE
:
18433 unsigned int nargs
;
18438 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18439 return unify_type_mismatch (explain_p
, parm
, arg
);
18441 /* CV qualifications for methods can never be deduced, they must
18442 match exactly. We need to check them explicitly here,
18443 because type_unification_real treats them as any other
18444 cv-qualified parameter. */
18445 if (TREE_CODE (parm
) == METHOD_TYPE
18446 && (!check_cv_quals_for_unify
18448 class_of_this_parm (arg
),
18449 class_of_this_parm (parm
))))
18450 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18452 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18453 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18455 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18456 args
= XALLOCAVEC (tree
, nargs
);
18457 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18458 a
!= NULL_TREE
&& a
!= void_list_node
;
18459 a
= TREE_CHAIN (a
), ++i
)
18460 args
[i
] = TREE_VALUE (a
);
18463 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18464 args
, nargs
, 1, DEDUCE_EXACT
,
18465 LOOKUP_NORMAL
, NULL
, explain_p
);
18469 /* Unify a pointer to member with a pointer to member function, which
18470 deduces the type of the member as a function type. */
18471 if (TYPE_PTRMEMFUNC_P (arg
))
18473 /* Check top-level cv qualifiers */
18474 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18475 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18477 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18478 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18479 UNIFY_ALLOW_NONE
, explain_p
);
18481 /* Determine the type of the function we are unifying against. */
18482 tree fntype
= static_fn_type (arg
);
18484 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18487 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18488 return unify_type_mismatch (explain_p
, parm
, arg
);
18489 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18490 TYPE_OFFSET_BASETYPE (arg
),
18491 UNIFY_ALLOW_NONE
, explain_p
);
18492 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18493 strict
, explain_p
);
18496 if (DECL_TEMPLATE_PARM_P (parm
))
18497 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18498 if (arg
!= scalar_constant_value (parm
))
18499 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18500 return unify_success (explain_p
);
18503 case TEMPLATE_DECL
:
18504 /* Matched cases are handled by the ARG == PARM test above. */
18505 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18508 /* A non-type template parameter that is a variable should be a
18509 an integral constant, in which case, it whould have been
18510 folded into its (constant) value. So we should not be getting
18511 a variable here. */
18512 gcc_unreachable ();
18514 case TYPE_ARGUMENT_PACK
:
18515 case NONTYPE_ARGUMENT_PACK
:
18516 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18517 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18520 case DECLTYPE_TYPE
:
18521 case UNDERLYING_TYPE
:
18522 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18523 or UNDERLYING_TYPE nodes. */
18524 return unify_success (explain_p
);
18527 /* Unification fails if we hit an error node. */
18528 return unify_invalid (explain_p
);
18531 if (REFERENCE_REF_P (parm
))
18533 if (REFERENCE_REF_P (arg
))
18534 arg
= TREE_OPERAND (arg
, 0);
18535 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18536 strict
, explain_p
);
18541 /* An unresolved overload is a nondeduced context. */
18542 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18543 return unify_success (explain_p
);
18544 gcc_assert (EXPR_P (parm
));
18546 /* We must be looking at an expression. This can happen with
18550 void foo(S<I>, S<I + 2>);
18552 This is a "nondeduced context":
18556 The nondeduced contexts are:
18558 --A type that is a template-id in which one or more of
18559 the template-arguments is an expression that references
18560 a template-parameter.
18562 In these cases, we assume deduction succeeded, but don't
18563 actually infer any unifications. */
18565 if (!uses_template_parms (parm
)
18566 && !template_args_equal (parm
, arg
))
18567 return unify_expression_unequal (explain_p
, parm
, arg
);
18569 return unify_success (explain_p
);
18572 #undef RECUR_AND_CHECK_FAILURE
18574 /* Note that DECL can be defined in this translation unit, if
18578 mark_definable (tree decl
)
18581 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18582 FOR_EACH_CLONE (clone
, decl
)
18583 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18586 /* Called if RESULT is explicitly instantiated, or is a member of an
18587 explicitly instantiated class. */
18590 mark_decl_instantiated (tree result
, int extern_p
)
18592 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18594 /* If this entity has already been written out, it's too late to
18595 make any modifications. */
18596 if (TREE_ASM_WRITTEN (result
))
18599 /* For anonymous namespace we don't need to do anything. */
18600 if (decl_anon_ns_mem_p (result
))
18602 gcc_assert (!TREE_PUBLIC (result
));
18606 if (TREE_CODE (result
) != FUNCTION_DECL
)
18607 /* The TREE_PUBLIC flag for function declarations will have been
18608 set correctly by tsubst. */
18609 TREE_PUBLIC (result
) = 1;
18611 /* This might have been set by an earlier implicit instantiation. */
18612 DECL_COMDAT (result
) = 0;
18615 DECL_NOT_REALLY_EXTERN (result
) = 0;
18618 mark_definable (result
);
18619 mark_needed (result
);
18620 /* Always make artificials weak. */
18621 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18622 comdat_linkage (result
);
18623 /* For WIN32 we also want to put explicit instantiations in
18624 linkonce sections. */
18625 else if (TREE_PUBLIC (result
))
18626 maybe_make_one_only (result
);
18629 /* If EXTERN_P, then this function will not be emitted -- unless
18630 followed by an explicit instantiation, at which point its linkage
18631 will be adjusted. If !EXTERN_P, then this function will be
18632 emitted here. In neither circumstance do we want
18633 import_export_decl to adjust the linkage. */
18634 DECL_INTERFACE_KNOWN (result
) = 1;
18637 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18638 important template arguments. If any are missing, we check whether
18639 they're important by using error_mark_node for substituting into any
18640 args that were used for partial ordering (the ones between ARGS and END)
18641 and seeing if it bubbles up. */
18644 check_undeduced_parms (tree targs
, tree args
, tree end
)
18646 bool found
= false;
18648 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18649 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18652 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18656 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18657 if (substed
== error_mark_node
)
18663 /* Given two function templates PAT1 and PAT2, return:
18665 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18666 -1 if PAT2 is more specialized than PAT1.
18667 0 if neither is more specialized.
18669 LEN indicates the number of parameters we should consider
18670 (defaulted parameters should not be considered).
18672 The 1998 std underspecified function template partial ordering, and
18673 DR214 addresses the issue. We take pairs of arguments, one from
18674 each of the templates, and deduce them against each other. One of
18675 the templates will be more specialized if all the *other*
18676 template's arguments deduce against its arguments and at least one
18677 of its arguments *does* *not* deduce against the other template's
18678 corresponding argument. Deduction is done as for class templates.
18679 The arguments used in deduction have reference and top level cv
18680 qualifiers removed. Iff both arguments were originally reference
18681 types *and* deduction succeeds in both directions, an lvalue reference
18682 wins against an rvalue reference and otherwise the template
18683 with the more cv-qualified argument wins for that pairing (if
18684 neither is more cv-qualified, they both are equal). Unlike regular
18685 deduction, after all the arguments have been deduced in this way,
18686 we do *not* verify the deduced template argument values can be
18687 substituted into non-deduced contexts.
18689 The logic can be a bit confusing here, because we look at deduce1 and
18690 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18691 can find template arguments for pat1 to make arg1 look like arg2, that
18692 means that arg2 is at least as specialized as arg1. */
18695 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18697 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18698 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18699 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18700 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18701 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18702 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18703 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18704 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18705 tree origs1
, origs2
;
18706 bool lose1
= false;
18707 bool lose2
= false;
18709 /* Remove the this parameter from non-static member functions. If
18710 one is a non-static member function and the other is not a static
18711 member function, remove the first parameter from that function
18712 also. This situation occurs for operator functions where we
18713 locate both a member function (with this pointer) and non-member
18714 operator (with explicit first operand). */
18715 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18717 len
--; /* LEN is the number of significant arguments for DECL1 */
18718 args1
= TREE_CHAIN (args1
);
18719 if (!DECL_STATIC_FUNCTION_P (decl2
))
18720 args2
= TREE_CHAIN (args2
);
18722 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18724 args2
= TREE_CHAIN (args2
);
18725 if (!DECL_STATIC_FUNCTION_P (decl1
))
18728 args1
= TREE_CHAIN (args1
);
18732 /* If only one is a conversion operator, they are unordered. */
18733 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18736 /* Consider the return type for a conversion function */
18737 if (DECL_CONV_FN_P (decl1
))
18739 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18740 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18744 processing_template_decl
++;
18750 /* Stop when an ellipsis is seen. */
18751 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18753 tree arg1
= TREE_VALUE (args1
);
18754 tree arg2
= TREE_VALUE (args2
);
18755 int deduce1
, deduce2
;
18761 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18762 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18764 /* When both arguments are pack expansions, we need only
18765 unify the patterns themselves. */
18766 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18767 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18769 /* This is the last comparison we need to do. */
18773 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18775 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18776 arg1
= TREE_TYPE (arg1
);
18777 quals1
= cp_type_quals (arg1
);
18780 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18782 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18783 arg2
= TREE_TYPE (arg2
);
18784 quals2
= cp_type_quals (arg2
);
18787 arg1
= TYPE_MAIN_VARIANT (arg1
);
18788 arg2
= TYPE_MAIN_VARIANT (arg2
);
18790 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18792 int i
, len2
= list_length (args2
);
18793 tree parmvec
= make_tree_vec (1);
18794 tree argvec
= make_tree_vec (len2
);
18797 /* Setup the parameter vector, which contains only ARG1. */
18798 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18800 /* Setup the argument vector, which contains the remaining
18802 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18803 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18805 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18806 argvec
, DEDUCE_EXACT
,
18807 /*subr=*/true, /*explain_p=*/false)
18810 /* We cannot deduce in the other direction, because ARG1 is
18811 a pack expansion but ARG2 is not. */
18814 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18816 int i
, len1
= list_length (args1
);
18817 tree parmvec
= make_tree_vec (1);
18818 tree argvec
= make_tree_vec (len1
);
18821 /* Setup the parameter vector, which contains only ARG1. */
18822 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18824 /* Setup the argument vector, which contains the remaining
18826 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18827 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18829 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18830 argvec
, DEDUCE_EXACT
,
18831 /*subr=*/true, /*explain_p=*/false)
18834 /* We cannot deduce in the other direction, because ARG2 is
18835 a pack expansion but ARG1 is not.*/
18841 /* The normal case, where neither argument is a pack
18843 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18844 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18846 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18847 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18851 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18852 arg2, then arg2 is not as specialized as arg1. */
18858 /* "If, for a given type, deduction succeeds in both directions
18859 (i.e., the types are identical after the transformations above)
18860 and both P and A were reference types (before being replaced with
18861 the type referred to above):
18862 - if the type from the argument template was an lvalue reference and
18863 the type from the parameter template was not, the argument type is
18864 considered to be more specialized than the other; otherwise,
18865 - if the type from the argument template is more cv-qualified
18866 than the type from the parameter template (as described above),
18867 the argument type is considered to be more specialized than the other;
18869 - neither type is more specialized than the other." */
18871 if (deduce1
&& deduce2
)
18873 if (ref1
&& ref2
&& ref1
!= ref2
)
18880 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
18882 if ((quals1
& quals2
) == quals2
)
18884 if ((quals1
& quals2
) == quals1
)
18889 if (lose1
&& lose2
)
18890 /* We've failed to deduce something in either direction.
18891 These must be unordered. */
18894 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18895 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18896 /* We have already processed all of the arguments in our
18897 handing of the pack expansion type. */
18900 args1
= TREE_CHAIN (args1
);
18901 args2
= TREE_CHAIN (args2
);
18904 /* "In most cases, all template parameters must have values in order for
18905 deduction to succeed, but for partial ordering purposes a template
18906 parameter may remain without a value provided it is not used in the
18907 types being used for partial ordering."
18909 Thus, if we are missing any of the targs1 we need to substitute into
18910 origs1, then pat2 is not as specialized as pat1. This can happen when
18911 there is a nondeduced context. */
18912 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
18914 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
18917 processing_template_decl
--;
18919 /* All things being equal, if the next argument is a pack expansion
18920 for one function but not for the other, prefer the
18921 non-variadic function. FIXME this is bogus; see c++/41958. */
18923 && args1
&& TREE_VALUE (args1
)
18924 && args2
&& TREE_VALUE (args2
))
18926 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
18927 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
18930 if (lose1
== lose2
)
18938 /* Determine which of two partial specializations of TMPL is more
18941 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
18942 to the first partial specialization. The TREE_PURPOSE is the
18943 innermost set of template parameters for the partial
18944 specialization. PAT2 is similar, but for the second template.
18946 Return 1 if the first partial specialization is more specialized;
18947 -1 if the second is more specialized; 0 if neither is more
18950 See [temp.class.order] for information about determining which of
18951 two templates is more specialized. */
18954 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
18958 bool any_deductions
= false;
18960 tree tmpl1
= TREE_VALUE (pat1
);
18961 tree tmpl2
= TREE_VALUE (pat2
);
18962 tree parms1
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl1
);
18963 tree parms2
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl2
);
18964 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
18965 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
18967 /* Just like what happens for functions, if we are ordering between
18968 different template specializations, we may encounter dependent
18969 types in the arguments, and we need our dependency check functions
18970 to behave correctly. */
18971 ++processing_template_decl
;
18972 targs
= get_partial_spec_bindings (tmpl
, parms1
, specargs1
, specargs2
);
18976 any_deductions
= true;
18979 targs
= get_partial_spec_bindings (tmpl
, parms2
, specargs2
, specargs1
);
18983 any_deductions
= true;
18985 --processing_template_decl
;
18987 /* In the case of a tie where at least one of the templates
18988 has a parameter pack at the end, the template with the most
18989 non-packed parameters wins. */
18992 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
18993 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
18995 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
18996 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
18997 int len1
= TREE_VEC_LENGTH (args1
);
18998 int len2
= TREE_VEC_LENGTH (args2
);
19000 /* We don't count the pack expansion at the end. */
19001 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
19003 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
19008 else if (len1
< len2
)
19015 /* Return the template arguments that will produce the function signature
19016 DECL from the function template FN, with the explicit template
19017 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
19018 also match. Return NULL_TREE if no satisfactory arguments could be
19022 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
19024 int ntparms
= DECL_NTPARMS (fn
);
19025 tree targs
= make_tree_vec (ntparms
);
19026 tree decl_type
= TREE_TYPE (decl
);
19027 tree decl_arg_types
;
19029 unsigned int nargs
, ix
;
19032 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
19034 /* Never do unification on the 'this' parameter. */
19035 decl_arg_types
= skip_artificial_parms_for (decl
,
19036 TYPE_ARG_TYPES (decl_type
));
19038 nargs
= list_length (decl_arg_types
);
19039 args
= XALLOCAVEC (tree
, nargs
);
19040 for (arg
= decl_arg_types
, ix
= 0;
19041 arg
!= NULL_TREE
&& arg
!= void_list_node
;
19042 arg
= TREE_CHAIN (arg
), ++ix
)
19043 args
[ix
] = TREE_VALUE (arg
);
19045 if (fn_type_unification (fn
, explicit_args
, targs
,
19047 (check_rettype
|| DECL_CONV_FN_P (fn
)
19048 ? TREE_TYPE (decl_type
) : NULL_TREE
),
19049 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
19051 == error_mark_node
)
19057 /* Return the innermost template arguments that, when applied to a partial
19058 specialization of TMPL whose innermost template parameters are
19059 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
19062 For example, suppose we have:
19064 template <class T, class U> struct S {};
19065 template <class T> struct S<T*, int> {};
19067 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
19068 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
19069 int}. The resulting vector will be {double}, indicating that `T'
19070 is bound to `double'. */
19073 get_partial_spec_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
19075 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
19077 tree innermost_deduced_args
;
19079 innermost_deduced_args
= make_tree_vec (ntparms
);
19080 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19082 deduced_args
= copy_node (args
);
19083 SET_TMPL_ARGS_LEVEL (deduced_args
,
19084 TMPL_ARGS_DEPTH (deduced_args
),
19085 innermost_deduced_args
);
19088 deduced_args
= innermost_deduced_args
;
19090 if (unify (tparms
, deduced_args
,
19091 INNERMOST_TEMPLATE_ARGS (spec_args
),
19092 INNERMOST_TEMPLATE_ARGS (args
),
19093 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
19096 for (i
= 0; i
< ntparms
; ++i
)
19097 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
19100 /* Verify that nondeduced template arguments agree with the type
19101 obtained from argument deduction.
19105 struct A { typedef int X; };
19106 template <class T, class U> struct C {};
19107 template <class T> struct C<T, typename T::X> {};
19109 Then with the instantiation `C<A, int>', we can deduce that
19110 `T' is `A' but unify () does not check whether `typename T::X'
19112 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
19113 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19115 tf_none
, false, false);
19116 if (spec_args
== error_mark_node
19117 /* We only need to check the innermost arguments; the other
19118 arguments will always agree. */
19119 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
19120 INNERMOST_TEMPLATE_ARGS (args
)))
19123 /* Now that we have bindings for all of the template arguments,
19124 ensure that the arguments deduced for the template template
19125 parameters have compatible template parameter lists. See the use
19126 of template_template_parm_bindings_ok_p in fn_type_unification
19127 for more information. */
19128 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
19131 return deduced_args
;
19134 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19135 Return the TREE_LIST node with the most specialized template, if
19136 any. If there is no most specialized template, the error_mark_node
19139 Note that this function does not look at, or modify, the
19140 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19141 returned is one of the elements of INSTANTIATIONS, callers may
19142 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19143 and retrieve it from the value returned. */
19146 most_specialized_instantiation (tree templates
)
19150 ++processing_template_decl
;
19153 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
19157 if (get_bindings (TREE_VALUE (champ
),
19158 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19159 NULL_TREE
, /*check_ret=*/true))
19162 if (get_bindings (TREE_VALUE (fn
),
19163 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19164 NULL_TREE
, /*check_ret=*/true))
19171 /* Equally specialized, move to next function. If there
19172 is no next function, nothing's most specialized. */
19173 fn
= TREE_CHAIN (fn
);
19181 /* Now verify that champ is better than everything earlier in the
19182 instantiation list. */
19183 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
19184 if (get_bindings (TREE_VALUE (champ
),
19185 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19186 NULL_TREE
, /*check_ret=*/true)
19187 || !get_bindings (TREE_VALUE (fn
),
19188 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19189 NULL_TREE
, /*check_ret=*/true))
19195 processing_template_decl
--;
19198 return error_mark_node
;
19203 /* If DECL is a specialization of some template, return the most
19204 general such template. Otherwise, returns NULL_TREE.
19206 For example, given:
19208 template <class T> struct S { template <class U> void f(U); };
19210 if TMPL is `template <class U> void S<int>::f(U)' this will return
19211 the full template. This function will not trace past partial
19212 specializations, however. For example, given in addition:
19214 template <class T> struct S<T*> { template <class U> void f(U); };
19216 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19217 `template <class T> template <class U> S<T*>::f(U)'. */
19220 most_general_template (tree decl
)
19222 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19224 if (tree tinfo
= get_template_info (decl
))
19225 decl
= TI_TEMPLATE (tinfo
);
19226 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19227 template friend, or a FIELD_DECL for a capture pack. */
19228 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19232 /* Look for more and more general templates. */
19233 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
19235 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19236 (See cp-tree.h for details.) */
19237 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
19240 if (CLASS_TYPE_P (TREE_TYPE (decl
))
19241 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
19242 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
19245 /* Stop if we run into an explicitly specialized class template. */
19246 if (!DECL_NAMESPACE_SCOPE_P (decl
)
19247 && DECL_CONTEXT (decl
)
19248 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
19251 decl
= DECL_TI_TEMPLATE (decl
);
19257 /* Return the most specialized of the template partial specializations
19258 which can produce TARGET, a specialization of some class or variable
19259 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
19260 a TEMPLATE_DECL node corresponding to the partial specialization, while
19261 the TREE_PURPOSE is the set of template arguments that must be
19262 substituted into the template pattern in order to generate TARGET.
19264 If the choice of partial specialization is ambiguous, a diagnostic
19265 is issued, and the error_mark_node is returned. If there are no
19266 partial specializations matching TARGET, then NULL_TREE is
19267 returned, indicating that the primary template should be used. */
19270 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
19272 tree list
= NULL_TREE
;
19277 tree outer_args
= NULL_TREE
;
19280 if (TYPE_P (target
))
19282 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
19283 tmpl
= TI_TEMPLATE (tinfo
);
19284 args
= TI_ARGS (tinfo
);
19286 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
19288 tmpl
= TREE_OPERAND (target
, 0);
19289 args
= TREE_OPERAND (target
, 1);
19291 else if (VAR_P (target
))
19293 tree tinfo
= DECL_TEMPLATE_INFO (target
);
19294 tmpl
= TI_TEMPLATE (tinfo
);
19295 args
= TI_ARGS (tinfo
);
19298 gcc_unreachable ();
19300 tree main_tmpl
= most_general_template (tmpl
);
19302 /* For determining which partial specialization to use, only the
19303 innermost args are interesting. */
19304 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19306 outer_args
= strip_innermost_template_args (args
, 1);
19307 args
= INNERMOST_TEMPLATE_ARGS (args
);
19310 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
19312 tree partial_spec_args
;
19314 tree spec_tmpl
= TREE_VALUE (t
);
19316 partial_spec_args
= TREE_PURPOSE (t
);
19318 ++processing_template_decl
;
19322 /* Discard the outer levels of args, and then substitute in the
19323 template args from the enclosing class. */
19324 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19325 partial_spec_args
= tsubst_template_args
19326 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19328 /* And the same for the partial specialization TEMPLATE_DECL. */
19329 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19332 partial_spec_args
=
19333 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19336 /*require_all_args=*/true,
19337 /*use_default_args=*/true);
19339 --processing_template_decl
;
19341 if (partial_spec_args
== error_mark_node
)
19342 return error_mark_node
;
19343 if (spec_tmpl
== error_mark_node
)
19344 return error_mark_node
;
19346 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19347 spec_args
= get_partial_spec_bindings (tmpl
, parms
,
19353 spec_args
= add_to_template_args (outer_args
, spec_args
);
19354 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
19355 TREE_TYPE (list
) = TREE_TYPE (t
);
19362 ambiguous_p
= false;
19365 t
= TREE_CHAIN (t
);
19366 for (; t
; t
= TREE_CHAIN (t
))
19368 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19375 t
= TREE_CHAIN (t
);
19378 ambiguous_p
= true;
19387 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19389 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19392 ambiguous_p
= true;
19400 char *spaces
= NULL
;
19401 if (!(complain
& tf_error
))
19402 return error_mark_node
;
19403 if (TYPE_P (target
))
19404 error ("ambiguous template instantiation for %q#T", target
);
19406 error ("ambiguous template instantiation for %q#D", target
);
19407 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19408 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19410 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
19411 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
19412 "%s %#S", spaces
? spaces
: str
, subst
);
19413 spaces
= spaces
? spaces
: get_spaces (str
);
19416 return error_mark_node
;
19422 /* Explicitly instantiate DECL. */
19425 do_decl_instantiation (tree decl
, tree storage
)
19427 tree result
= NULL_TREE
;
19430 if (!decl
|| decl
== error_mark_node
)
19431 /* An error occurred, for which grokdeclarator has already issued
19432 an appropriate message. */
19434 else if (! DECL_LANG_SPECIFIC (decl
))
19436 error ("explicit instantiation of non-template %q#D", decl
);
19440 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
19441 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
19443 if (VAR_P (decl
) && !var_templ
)
19445 /* There is an asymmetry here in the way VAR_DECLs and
19446 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19447 the latter, the DECL we get back will be marked as a
19448 template instantiation, and the appropriate
19449 DECL_TEMPLATE_INFO will be set up. This does not happen for
19450 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19451 should handle VAR_DECLs as it currently handles
19453 if (!DECL_CLASS_SCOPE_P (decl
))
19455 error ("%qD is not a static data member of a class template", decl
);
19458 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19459 if (!result
|| !VAR_P (result
))
19461 error ("no matching template for %qD found", decl
);
19464 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19466 error ("type %qT for explicit instantiation %qD does not match "
19467 "declared type %qT", TREE_TYPE (result
), decl
,
19472 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
19474 error ("explicit instantiation of %q#D", decl
);
19480 /* Check for various error cases. Note that if the explicit
19481 instantiation is valid the RESULT will currently be marked as an
19482 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19483 until we get here. */
19485 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19487 /* DR 259 [temp.spec].
19489 Both an explicit instantiation and a declaration of an explicit
19490 specialization shall not appear in a program unless the explicit
19491 instantiation follows a declaration of the explicit specialization.
19493 For a given set of template parameters, if an explicit
19494 instantiation of a template appears after a declaration of an
19495 explicit specialization for that template, the explicit
19496 instantiation has no effect. */
19499 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19503 No program shall explicitly instantiate any template more
19506 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19507 the first instantiation was `extern' and the second is not,
19508 and EXTERN_P for the opposite case. */
19509 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19510 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19511 /* If an "extern" explicit instantiation follows an ordinary
19512 explicit instantiation, the template is instantiated. */
19516 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19518 error ("no matching template for %qD found", result
);
19521 else if (!DECL_TEMPLATE_INFO (result
))
19523 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19527 if (storage
== NULL_TREE
)
19529 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19531 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19532 pedwarn (input_location
, OPT_Wpedantic
,
19533 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19538 error ("storage class %qD applied to template instantiation", storage
);
19540 check_explicit_instantiation_namespace (result
);
19541 mark_decl_instantiated (result
, extern_p
);
19543 instantiate_decl (result
, /*defer_ok=*/1,
19544 /*expl_inst_class_mem_p=*/false);
19548 mark_class_instantiated (tree t
, int extern_p
)
19550 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19551 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19552 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19553 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19556 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19557 rest_of_type_compilation (t
, 1);
19561 /* Called from do_type_instantiation through binding_table_foreach to
19562 do recursive instantiation for the type bound in ENTRY. */
19564 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19566 tree storage
= *(tree
*) data
;
19568 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19569 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19570 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19573 /* Called from do_type_instantiation to instantiate a member
19574 (a member function or a static member variable) of an
19575 explicitly instantiated class template. */
19577 instantiate_class_member (tree decl
, int extern_p
)
19579 mark_decl_instantiated (decl
, extern_p
);
19581 instantiate_decl (decl
, /*defer_ok=*/1,
19582 /*expl_inst_class_mem_p=*/true);
19585 /* Perform an explicit instantiation of template class T. STORAGE, if
19586 non-null, is the RID for extern, inline or static. COMPLAIN is
19587 nonzero if this is called from the parser, zero if called recursively,
19588 since the standard is unclear (as detailed below). */
19591 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19596 int previous_instantiation_extern_p
= 0;
19598 if (TREE_CODE (t
) == TYPE_DECL
)
19601 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19604 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19606 error ("explicit instantiation of non-class template %qD", tmpl
);
19608 error ("explicit instantiation of non-template type %qT", t
);
19614 if (!COMPLETE_TYPE_P (t
))
19616 if (complain
& tf_error
)
19617 error ("explicit instantiation of %q#T before definition of template",
19622 if (storage
!= NULL_TREE
)
19624 if (!in_system_header_at (input_location
))
19626 if (storage
== ridpointers
[(int) RID_EXTERN
])
19628 if (cxx_dialect
== cxx98
)
19629 pedwarn (input_location
, OPT_Wpedantic
,
19630 "ISO C++ 1998 forbids the use of %<extern%> on "
19631 "explicit instantiations");
19634 pedwarn (input_location
, OPT_Wpedantic
,
19635 "ISO C++ forbids the use of %qE"
19636 " on explicit instantiations", storage
);
19639 if (storage
== ridpointers
[(int) RID_INLINE
])
19641 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19643 else if (storage
== ridpointers
[(int) RID_STATIC
])
19647 error ("storage class %qD applied to template instantiation",
19653 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19655 /* DR 259 [temp.spec].
19657 Both an explicit instantiation and a declaration of an explicit
19658 specialization shall not appear in a program unless the explicit
19659 instantiation follows a declaration of the explicit specialization.
19661 For a given set of template parameters, if an explicit
19662 instantiation of a template appears after a declaration of an
19663 explicit specialization for that template, the explicit
19664 instantiation has no effect. */
19667 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19671 No program shall explicitly instantiate any template more
19674 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19675 instantiation was `extern'. If EXTERN_P then the second is.
19676 These cases are OK. */
19677 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19679 if (!previous_instantiation_extern_p
&& !extern_p
19680 && (complain
& tf_error
))
19681 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19683 /* If we've already instantiated the template, just return now. */
19684 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19688 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19689 mark_class_instantiated (t
, extern_p
);
19697 /* In contrast to implicit instantiation, where only the
19698 declarations, and not the definitions, of members are
19699 instantiated, we have here:
19703 The explicit instantiation of a class template specialization
19704 implies the instantiation of all of its members not
19705 previously explicitly specialized in the translation unit
19706 containing the explicit instantiation.
19708 Of course, we can't instantiate member template classes, since
19709 we don't have any arguments for them. Note that the standard
19710 is unclear on whether the instantiation of the members are
19711 *explicit* instantiations or not. However, the most natural
19712 interpretation is that it should be an explicit instantiation. */
19715 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19716 if (TREE_CODE (tmp
) == FUNCTION_DECL
19717 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19718 instantiate_class_member (tmp
, extern_p
);
19720 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19721 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19722 instantiate_class_member (tmp
, extern_p
);
19724 if (CLASSTYPE_NESTED_UTDS (t
))
19725 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19726 bt_instantiate_type_proc
, &storage
);
19730 /* Given a function DECL, which is a specialization of TMPL, modify
19731 DECL to be a re-instantiation of TMPL with the same template
19732 arguments. TMPL should be the template into which tsubst'ing
19733 should occur for DECL, not the most general template.
19735 One reason for doing this is a scenario like this:
19738 void f(const T&, int i);
19740 void g() { f(3, 7); }
19743 void f(const T& t, const int i) { }
19745 Note that when the template is first instantiated, with
19746 instantiate_template, the resulting DECL will have no name for the
19747 first parameter, and the wrong type for the second. So, when we go
19748 to instantiate the DECL, we regenerate it. */
19751 regenerate_decl_from_template (tree decl
, tree tmpl
)
19753 /* The arguments used to instantiate DECL, from the most general
19758 args
= DECL_TI_ARGS (decl
);
19759 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19761 /* Make sure that we can see identifiers, and compute access
19763 push_access_scope (decl
);
19765 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19773 args_depth
= TMPL_ARGS_DEPTH (args
);
19774 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19775 if (args_depth
> parms_depth
)
19776 args
= get_innermost_template_args (args
, parms_depth
);
19778 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19779 args
, tf_error
, NULL_TREE
,
19780 /*defer_ok*/false);
19781 if (specs
&& specs
!= error_mark_node
)
19782 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19785 /* Merge parameter declarations. */
19786 decl_parm
= skip_artificial_parms_for (decl
,
19787 DECL_ARGUMENTS (decl
));
19789 = skip_artificial_parms_for (code_pattern
,
19790 DECL_ARGUMENTS (code_pattern
));
19791 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19796 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19797 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19798 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19800 parm_type
= type_decays_to (parm_type
);
19801 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19802 TREE_TYPE (decl_parm
) = parm_type
;
19803 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19804 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19806 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19807 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19809 decl_parm
= DECL_CHAIN (decl_parm
);
19810 pattern_parm
= DECL_CHAIN (pattern_parm
);
19812 /* Merge any parameters that match with the function parameter
19814 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19817 tree expanded_types
;
19818 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19819 the parameters in this function parameter pack. */
19820 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19821 args
, tf_error
, NULL_TREE
);
19822 len
= TREE_VEC_LENGTH (expanded_types
);
19823 for (i
= 0; i
< len
; i
++)
19828 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19829 /* Rename the parameter to include the index. */
19830 DECL_NAME (decl_parm
) =
19831 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19832 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19833 parm_type
= type_decays_to (parm_type
);
19834 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19835 TREE_TYPE (decl_parm
) = parm_type
;
19836 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19837 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19839 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19840 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19842 decl_parm
= DECL_CHAIN (decl_parm
);
19845 /* Merge additional specifiers from the CODE_PATTERN. */
19846 if (DECL_DECLARED_INLINE_P (code_pattern
)
19847 && !DECL_DECLARED_INLINE_P (decl
))
19848 DECL_DECLARED_INLINE_P (decl
) = 1;
19850 else if (VAR_P (decl
))
19852 DECL_INITIAL (decl
) =
19853 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19854 tf_error
, DECL_TI_TEMPLATE (decl
),
19855 /*integral_constant_expression_p=*/false);
19856 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19857 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19858 tf_error
, DECL_TI_TEMPLATE (decl
));
19861 gcc_unreachable ();
19863 pop_access_scope (decl
);
19866 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19867 substituted to get DECL. */
19870 template_for_substitution (tree decl
)
19872 tree tmpl
= DECL_TI_TEMPLATE (decl
);
19874 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19875 for the instantiation. This is not always the most general
19876 template. Consider, for example:
19879 struct S { template <class U> void f();
19880 template <> void f<int>(); };
19882 and an instantiation of S<double>::f<int>. We want TD to be the
19883 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19884 while (/* An instantiation cannot have a definition, so we need a
19885 more general template. */
19886 DECL_TEMPLATE_INSTANTIATION (tmpl
)
19887 /* We must also deal with friend templates. Given:
19889 template <class T> struct S {
19890 template <class U> friend void f() {};
19893 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19894 so far as the language is concerned, but that's still
19895 where we get the pattern for the instantiation from. On
19896 other hand, if the definition comes outside the class, say:
19898 template <class T> struct S {
19899 template <class U> friend void f();
19901 template <class U> friend void f() {}
19903 we don't need to look any further. That's what the check for
19904 DECL_INITIAL is for. */
19905 || (TREE_CODE (decl
) == FUNCTION_DECL
19906 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
19907 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
19909 /* The present template, TD, should not be a definition. If it
19910 were a definition, we should be using it! Note that we
19911 cannot restructure the loop to just keep going until we find
19912 a template with a definition, since that might go too far if
19913 a specialization was declared, but not defined. */
19915 /* Fetch the more general template. */
19916 tmpl
= DECL_TI_TEMPLATE (tmpl
);
19922 /* Returns true if we need to instantiate this template instance even if we
19923 know we aren't going to emit it.. */
19926 always_instantiate_p (tree decl
)
19928 /* We always instantiate inline functions so that we can inline them. An
19929 explicit instantiation declaration prohibits implicit instantiation of
19930 non-inline functions. With high levels of optimization, we would
19931 normally inline non-inline functions -- but we're not allowed to do
19932 that for "extern template" functions. Therefore, we check
19933 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19934 return ((TREE_CODE (decl
) == FUNCTION_DECL
19935 && (DECL_DECLARED_INLINE_P (decl
)
19936 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
19937 /* And we need to instantiate static data members so that
19938 their initializers are available in integral constant
19941 && decl_maybe_constant_var_p (decl
)));
19944 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19945 instantiate it now, modifying TREE_TYPE (fn). */
19948 maybe_instantiate_noexcept (tree fn
)
19950 tree fntype
, spec
, noex
, clone
;
19952 /* Don't instantiate a noexcept-specification from template context. */
19953 if (processing_template_decl
)
19956 if (DECL_CLONED_FUNCTION_P (fn
))
19957 fn
= DECL_CLONED_FUNCTION (fn
);
19958 fntype
= TREE_TYPE (fn
);
19959 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
19961 if (!spec
|| !TREE_PURPOSE (spec
))
19964 noex
= TREE_PURPOSE (spec
);
19966 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
19968 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
19969 spec
= get_defaulted_eh_spec (fn
);
19970 else if (push_tinst_level (fn
))
19972 push_access_scope (fn
);
19973 push_deferring_access_checks (dk_no_deferred
);
19974 input_location
= DECL_SOURCE_LOCATION (fn
);
19975 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
19976 DEFERRED_NOEXCEPT_ARGS (noex
),
19977 tf_warning_or_error
, fn
,
19978 /*function_p=*/false,
19979 /*integral_constant_expression_p=*/true);
19980 pop_deferring_access_checks ();
19981 pop_access_scope (fn
);
19982 pop_tinst_level ();
19983 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
19984 if (spec
== error_mark_node
)
19985 spec
= noexcept_false_spec
;
19988 spec
= noexcept_false_spec
;
19990 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
19993 FOR_EACH_CLONE (clone
, fn
)
19995 if (TREE_TYPE (clone
) == fntype
)
19996 TREE_TYPE (clone
) = TREE_TYPE (fn
);
19998 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
20002 /* Produce the definition of D, a _DECL generated from a template. If
20003 DEFER_OK is nonzero, then we don't have to actually do the
20004 instantiation now; we just have to do it sometime. Normally it is
20005 an error if this is an explicit instantiation but D is undefined.
20006 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
20007 explicitly instantiated class template. */
20010 instantiate_decl (tree d
, int defer_ok
,
20011 bool expl_inst_class_mem_p
)
20013 tree tmpl
= DECL_TI_TEMPLATE (d
);
20020 bool pattern_defined
;
20021 location_t saved_loc
= input_location
;
20022 int saved_unevaluated_operand
= cp_unevaluated_operand
;
20023 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
20029 /* This function should only be used to instantiate templates for
20030 functions and static member variables. */
20031 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
20033 /* Variables are never deferred; if instantiation is required, they
20034 are instantiated right away. That allows for better code in the
20035 case that an expression refers to the value of the variable --
20036 if the variable has a constant value the referring expression can
20037 take advantage of that fact. */
20039 || DECL_DECLARED_CONSTEXPR_P (d
))
20042 /* Don't instantiate cloned functions. Instead, instantiate the
20043 functions they cloned. */
20044 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
20045 d
= DECL_CLONED_FUNCTION (d
);
20047 if (DECL_TEMPLATE_INSTANTIATED (d
)
20048 || (TREE_CODE (d
) == FUNCTION_DECL
20049 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
20050 || DECL_TEMPLATE_SPECIALIZATION (d
))
20051 /* D has already been instantiated or explicitly specialized, so
20052 there's nothing for us to do here.
20054 It might seem reasonable to check whether or not D is an explicit
20055 instantiation, and, if so, stop here. But when an explicit
20056 instantiation is deferred until the end of the compilation,
20057 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
20058 the instantiation. */
20061 /* Check to see whether we know that this template will be
20062 instantiated in some other file, as with "extern template"
20064 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
20066 /* In general, we do not instantiate such templates. */
20067 if (external_p
&& !always_instantiate_p (d
))
20070 gen_tmpl
= most_general_template (tmpl
);
20071 gen_args
= DECL_TI_ARGS (d
);
20073 if (tmpl
!= gen_tmpl
)
20074 /* We should already have the extra args. */
20075 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
20076 == TMPL_ARGS_DEPTH (gen_args
));
20077 /* And what's in the hash table should match D. */
20078 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
20079 || spec
== NULL_TREE
);
20081 /* This needs to happen before any tsubsting. */
20082 if (! push_tinst_level (d
))
20085 timevar_push (TV_TEMPLATE_INST
);
20087 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
20088 for the instantiation. */
20089 td
= template_for_substitution (d
);
20090 code_pattern
= DECL_TEMPLATE_RESULT (td
);
20092 /* We should never be trying to instantiate a member of a class
20093 template or partial specialization. */
20094 gcc_assert (d
!= code_pattern
);
20096 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
20097 || DECL_TEMPLATE_SPECIALIZATION (td
))
20098 /* In the case of a friend template whose definition is provided
20099 outside the class, we may have too many arguments. Drop the
20100 ones we don't need. The same is true for specializations. */
20101 args
= get_innermost_template_args
20102 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
20106 if (TREE_CODE (d
) == FUNCTION_DECL
)
20108 deleted_p
= DECL_DELETED_FN (code_pattern
);
20109 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
20110 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
20116 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
20119 /* We may be in the middle of deferred access check. Disable it now. */
20120 push_deferring_access_checks (dk_no_deferred
);
20122 /* Unless an explicit instantiation directive has already determined
20123 the linkage of D, remember that a definition is available for
20125 if (pattern_defined
20126 && !DECL_INTERFACE_KNOWN (d
)
20127 && !DECL_NOT_REALLY_EXTERN (d
))
20128 mark_definable (d
);
20130 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
20131 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
20132 input_location
= DECL_SOURCE_LOCATION (d
);
20134 /* If D is a member of an explicitly instantiated class template,
20135 and no definition is available, treat it like an implicit
20137 if (!pattern_defined
&& expl_inst_class_mem_p
20138 && DECL_EXPLICIT_INSTANTIATION (d
))
20140 /* Leave linkage flags alone on instantiations with anonymous
20142 if (TREE_PUBLIC (d
))
20144 DECL_NOT_REALLY_EXTERN (d
) = 0;
20145 DECL_INTERFACE_KNOWN (d
) = 0;
20147 SET_DECL_IMPLICIT_INSTANTIATION (d
);
20150 /* Defer all other templates, unless we have been explicitly
20151 forbidden from doing so. */
20152 if (/* If there is no definition, we cannot instantiate the
20155 /* If it's OK to postpone instantiation, do so. */
20157 /* If this is a static data member that will be defined
20158 elsewhere, we don't want to instantiate the entire data
20159 member, but we do want to instantiate the initializer so that
20160 we can substitute that elsewhere. */
20161 || (external_p
&& VAR_P (d
))
20162 /* Handle here a deleted function too, avoid generating
20163 its body (c++/61080). */
20166 /* The definition of the static data member is now required so
20167 we must substitute the initializer. */
20169 && !DECL_INITIAL (d
)
20170 && DECL_INITIAL (code_pattern
))
20174 bool const_init
= false;
20175 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20177 ns
= decl_namespace_context (d
);
20178 push_nested_namespace (ns
);
20180 push_nested_class (DECL_CONTEXT (d
));
20181 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
20183 tf_warning_or_error
, NULL_TREE
,
20184 /*integral_constant_expression_p=*/false);
20185 /* If instantiating the initializer involved instantiating this
20186 again, don't call cp_finish_decl twice. */
20187 if (!DECL_INITIAL (d
))
20189 /* Make sure the initializer is still constant, in case of
20190 circular dependency (template/instantiate6.C). */
20192 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20193 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
20194 /*asmspec_tree=*/NULL_TREE
,
20195 LOOKUP_ONLYCONVERTING
);
20198 pop_nested_class ();
20199 pop_nested_namespace (ns
);
20202 /* We restore the source position here because it's used by
20203 add_pending_template. */
20204 input_location
= saved_loc
;
20206 if (at_eof
&& !pattern_defined
20207 && DECL_EXPLICIT_INSTANTIATION (d
)
20208 && DECL_NOT_REALLY_EXTERN (d
))
20211 The definition of a non-exported function template, a
20212 non-exported member function template, or a non-exported
20213 member function or static data member of a class template
20214 shall be present in every translation unit in which it is
20215 explicitly instantiated. */
20216 permerror (input_location
, "explicit instantiation of %qD "
20217 "but no definition available", d
);
20219 /* If we're in unevaluated context, we just wanted to get the
20220 constant value; this isn't an odr use, so don't queue
20221 a full instantiation. */
20222 if (cp_unevaluated_operand
!= 0)
20224 /* ??? Historically, we have instantiated inline functions, even
20225 when marked as "extern template". */
20226 if (!(external_p
&& VAR_P (d
)))
20227 add_pending_template (d
);
20230 /* Tell the repository that D is available in this translation unit
20231 -- and see if it is supposed to be instantiated here. */
20232 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
20234 /* In a PCH file, despite the fact that the repository hasn't
20235 requested instantiation in the PCH it is still possible that
20236 an instantiation will be required in a file that includes the
20239 add_pending_template (d
);
20240 /* Instantiate inline functions so that the inliner can do its
20241 job, even though we'll not be emitting a copy of this
20243 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
20247 fn_context
= decl_function_context (d
);
20248 nested
= (current_function_decl
!= NULL_TREE
);
20250 push_to_top_level ();
20254 push_function_context ();
20255 cp_unevaluated_operand
= 0;
20256 c_inhibit_evaluation_warnings
= 0;
20259 /* Mark D as instantiated so that recursive calls to
20260 instantiate_decl do not try to instantiate it again. */
20261 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
20263 /* Regenerate the declaration in case the template has been modified
20264 by a subsequent redeclaration. */
20265 regenerate_decl_from_template (d
, td
);
20267 /* We already set the file and line above. Reset them now in case
20268 they changed as a result of calling regenerate_decl_from_template. */
20269 input_location
= DECL_SOURCE_LOCATION (d
);
20274 bool const_init
= false;
20276 /* Clear out DECL_RTL; whatever was there before may not be right
20277 since we've reset the type of the declaration. */
20278 SET_DECL_RTL (d
, NULL
);
20279 DECL_IN_AGGR_P (d
) = 0;
20281 /* The initializer is placed in DECL_INITIAL by
20282 regenerate_decl_from_template so we don't need to
20283 push/pop_access_scope again here. Pull it out so that
20284 cp_finish_decl can process it. */
20285 init
= DECL_INITIAL (d
);
20286 DECL_INITIAL (d
) = NULL_TREE
;
20287 DECL_INITIALIZED_P (d
) = 0;
20289 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20290 initializer. That function will defer actual emission until
20291 we have a chance to determine linkage. */
20292 DECL_EXTERNAL (d
) = 0;
20294 /* Enter the scope of D so that access-checking works correctly. */
20295 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20297 push_nested_class (DECL_CONTEXT (d
));
20299 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20300 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
20303 pop_nested_class ();
20305 if (variable_template_p (td
))
20306 note_variable_template_instantiation (d
);
20308 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
20309 synthesize_method (d
);
20310 else if (TREE_CODE (d
) == FUNCTION_DECL
)
20312 hash_map
<tree
, tree
> *saved_local_specializations
;
20316 tree block
= NULL_TREE
;
20318 /* Save away the current list, in case we are instantiating one
20319 template from within the body of another. */
20320 saved_local_specializations
= local_specializations
;
20322 /* Set up the list of local specializations. */
20323 local_specializations
= new hash_map
<tree
, tree
>;
20325 /* Set up context. */
20326 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20327 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20328 block
= push_stmt_list ();
20330 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
20332 /* Some typedefs referenced from within the template code need to be
20333 access checked at template instantiation time, i.e now. These
20334 types were added to the template at parsing time. Let's get those
20335 and perform the access checks then. */
20336 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20339 /* Create substitution entries for the parameters. */
20340 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20341 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20342 spec_parm
= DECL_ARGUMENTS (d
);
20343 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20345 register_local_specialization (spec_parm
, tmpl_parm
);
20346 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20347 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20349 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20351 if (!DECL_PACK_P (tmpl_parm
))
20353 register_local_specialization (spec_parm
, tmpl_parm
);
20354 spec_parm
= DECL_CHAIN (spec_parm
);
20358 /* Register the (value) argument pack as a specialization of
20359 TMPL_PARM, then move on. */
20360 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20361 register_local_specialization (argpack
, tmpl_parm
);
20364 gcc_assert (!spec_parm
);
20366 /* Substitute into the body of the function. */
20367 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20368 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20369 tf_warning_or_error
, tmpl
);
20372 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20373 tf_warning_or_error
, tmpl
,
20374 /*integral_constant_expression_p=*/false);
20376 /* Set the current input_location to the end of the function
20377 so that finish_function knows where we are. */
20379 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20381 /* Remember if we saw an infinite loop in the template. */
20382 current_function_infinite_loop
20383 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20386 /* We don't need the local specializations any more. */
20387 delete local_specializations
;
20388 local_specializations
= saved_local_specializations
;
20390 /* Finish the function. */
20391 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20392 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20393 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20396 d
= finish_function (0);
20397 expand_or_defer_fn (d
);
20400 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20401 cp_check_omp_declare_reduction (d
);
20404 /* We're not deferring instantiation any more. */
20405 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20408 pop_from_top_level ();
20410 pop_function_context ();
20413 input_location
= saved_loc
;
20414 cp_unevaluated_operand
= saved_unevaluated_operand
;
20415 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20416 pop_deferring_access_checks ();
20417 pop_tinst_level ();
20419 timevar_pop (TV_TEMPLATE_INST
);
20424 /* Run through the list of templates that we wish we could
20425 instantiate, and instantiate any we can. RETRIES is the
20426 number of times we retry pending template instantiation. */
20429 instantiate_pending_templates (int retries
)
20432 location_t saved_loc
= input_location
;
20434 /* Instantiating templates may trigger vtable generation. This in turn
20435 may require further template instantiations. We place a limit here
20436 to avoid infinite loop. */
20437 if (pending_templates
&& retries
>= max_tinst_depth
)
20439 tree decl
= pending_templates
->tinst
->decl
;
20441 fatal_error ("template instantiation depth exceeds maximum of %d"
20442 " instantiating %q+D, possibly from virtual table generation"
20443 " (use -ftemplate-depth= to increase the maximum)",
20444 max_tinst_depth
, decl
);
20445 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20446 /* Pretend that we defined it. */
20447 DECL_INITIAL (decl
) = error_mark_node
;
20453 struct pending_template
**t
= &pending_templates
;
20454 struct pending_template
*last
= NULL
;
20458 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20459 bool complete
= false;
20461 if (TYPE_P (instantiation
))
20465 if (!COMPLETE_TYPE_P (instantiation
))
20467 instantiate_class_template (instantiation
);
20468 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20469 for (fn
= TYPE_METHODS (instantiation
);
20471 fn
= TREE_CHAIN (fn
))
20472 if (! DECL_ARTIFICIAL (fn
))
20473 instantiate_decl (fn
,
20475 /*expl_inst_class_mem_p=*/false);
20476 if (COMPLETE_TYPE_P (instantiation
))
20480 complete
= COMPLETE_TYPE_P (instantiation
);
20484 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20485 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20488 = instantiate_decl (instantiation
,
20490 /*expl_inst_class_mem_p=*/false);
20491 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20495 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20496 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20500 /* If INSTANTIATION has been instantiated, then we don't
20501 need to consider it again in the future. */
20509 current_tinst_level
= NULL
;
20511 last_pending_template
= last
;
20513 while (reconsider
);
20515 input_location
= saved_loc
;
20518 /* Substitute ARGVEC into T, which is a list of initializers for
20519 either base class or a non-static data member. The TREE_PURPOSEs
20520 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20521 instantiate_decl. */
20524 tsubst_initializer_list (tree t
, tree argvec
)
20526 tree inits
= NULL_TREE
;
20528 for (; t
; t
= TREE_CHAIN (t
))
20532 tree expanded_bases
= NULL_TREE
;
20533 tree expanded_arguments
= NULL_TREE
;
20536 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20541 /* Expand the base class expansion type into separate base
20543 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20544 tf_warning_or_error
,
20546 if (expanded_bases
== error_mark_node
)
20549 /* We'll be building separate TREE_LISTs of arguments for
20551 len
= TREE_VEC_LENGTH (expanded_bases
);
20552 expanded_arguments
= make_tree_vec (len
);
20553 for (i
= 0; i
< len
; i
++)
20554 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20556 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20557 expand each argument in the TREE_VALUE of t. */
20558 expr
= make_node (EXPR_PACK_EXPANSION
);
20559 PACK_EXPANSION_LOCAL_P (expr
) = true;
20560 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20561 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20563 if (TREE_VALUE (t
) == void_type_node
)
20564 /* VOID_TYPE_NODE is used to indicate
20565 value-initialization. */
20567 for (i
= 0; i
< len
; i
++)
20568 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20572 /* Substitute parameter packs into each argument in the
20574 in_base_initializer
= 1;
20575 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20577 tree expanded_exprs
;
20579 /* Expand the argument. */
20580 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20582 = tsubst_pack_expansion (expr
, argvec
,
20583 tf_warning_or_error
,
20585 if (expanded_exprs
== error_mark_node
)
20588 /* Prepend each of the expanded expressions to the
20589 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20590 for (i
= 0; i
< len
; i
++)
20592 TREE_VEC_ELT (expanded_arguments
, i
) =
20593 tree_cons (NULL_TREE
,
20594 TREE_VEC_ELT (expanded_exprs
, i
),
20595 TREE_VEC_ELT (expanded_arguments
, i
));
20598 in_base_initializer
= 0;
20600 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20601 since we built them backwards. */
20602 for (i
= 0; i
< len
; i
++)
20604 TREE_VEC_ELT (expanded_arguments
, i
) =
20605 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20610 for (i
= 0; i
< len
; ++i
)
20612 if (expanded_bases
)
20614 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20615 decl
= expand_member_init (decl
);
20616 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20621 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20622 tf_warning_or_error
, NULL_TREE
);
20624 decl
= expand_member_init (decl
);
20625 if (decl
&& !DECL_P (decl
))
20626 in_base_initializer
= 1;
20628 init
= TREE_VALUE (t
);
20630 if (init
!= void_type_node
)
20631 init
= tsubst_expr (init
, argvec
,
20632 tf_warning_or_error
, NULL_TREE
,
20633 /*integral_constant_expression_p=*/false);
20634 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20635 /* If we had an initializer but it instantiated to nothing,
20636 value-initialize the object. This will only occur when
20637 the initializer was a pack expansion where the parameter
20638 packs used in that expansion were of length zero. */
20639 init
= void_type_node
;
20640 in_base_initializer
= 0;
20645 init
= build_tree_list (decl
, init
);
20646 TREE_CHAIN (init
) = inits
;
20654 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20657 set_current_access_from_decl (tree decl
)
20659 if (TREE_PRIVATE (decl
))
20660 current_access_specifier
= access_private_node
;
20661 else if (TREE_PROTECTED (decl
))
20662 current_access_specifier
= access_protected_node
;
20664 current_access_specifier
= access_public_node
;
20667 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20668 is the instantiation (which should have been created with
20669 start_enum) and ARGS are the template arguments to use. */
20672 tsubst_enum (tree tag
, tree newtag
, tree args
)
20676 if (SCOPED_ENUM_P (newtag
))
20677 begin_scope (sk_scoped_enum
, newtag
);
20679 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20684 decl
= TREE_VALUE (e
);
20685 /* Note that in a template enum, the TREE_VALUE is the
20686 CONST_DECL, not the corresponding INTEGER_CST. */
20687 value
= tsubst_expr (DECL_INITIAL (decl
),
20688 args
, tf_warning_or_error
, NULL_TREE
,
20689 /*integral_constant_expression_p=*/true);
20691 /* Give this enumeration constant the correct access. */
20692 set_current_access_from_decl (decl
);
20694 /* Actually build the enumerator itself. */
20696 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
20699 if (SCOPED_ENUM_P (newtag
))
20702 finish_enum_value_list (newtag
);
20703 finish_enum (newtag
);
20705 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20706 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20709 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20710 its type -- but without substituting the innermost set of template
20711 arguments. So, innermost set of template parameters will appear in
20715 get_mostly_instantiated_function_type (tree decl
)
20723 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
20724 targs
= DECL_TI_ARGS (decl
);
20725 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
20726 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
20728 /* There should be as many levels of arguments as there are levels
20730 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
20732 fn_type
= TREE_TYPE (tmpl
);
20734 if (parm_depth
== 1)
20735 /* No substitution is necessary. */
20742 /* Replace the innermost level of the TARGS with NULL_TREEs to
20743 let tsubst know not to substitute for those parameters. */
20744 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20745 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
20746 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
20747 TMPL_ARGS_LEVEL (targs
, i
));
20748 SET_TMPL_ARGS_LEVEL (partial_args
,
20749 TMPL_ARGS_DEPTH (targs
),
20750 make_tree_vec (DECL_NTPARMS (tmpl
)));
20752 /* Make sure that we can see identifiers, and compute access
20754 push_access_scope (decl
);
20756 ++processing_template_decl
;
20757 /* Now, do the (partial) substitution to figure out the
20758 appropriate function type. */
20759 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
20760 --processing_template_decl
;
20762 /* Substitute into the template parameters to obtain the real
20763 innermost set of parameters. This step is important if the
20764 innermost set of template parameters contains value
20765 parameters whose types depend on outer template parameters. */
20766 TREE_VEC_LENGTH (partial_args
)--;
20767 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
20769 pop_access_scope (decl
);
20775 /* Return truthvalue if we're processing a template different from
20776 the last one involved in diagnostics. */
20778 problematic_instantiation_changed (void)
20780 return current_tinst_level
!= last_error_tinst_level
;
20783 /* Remember current template involved in diagnostics. */
20785 record_last_problematic_instantiation (void)
20787 last_error_tinst_level
= current_tinst_level
;
20790 struct tinst_level
*
20791 current_instantiation (void)
20793 return current_tinst_level
;
20796 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20797 type. Return zero for ok, nonzero for disallowed. Issue error and
20798 warning messages under control of COMPLAIN. */
20801 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20803 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20805 else if (POINTER_TYPE_P (type
))
20807 else if (TYPE_PTRMEM_P (type
))
20809 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20811 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20813 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20815 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20818 if (complain
& tf_error
)
20820 if (type
== error_mark_node
)
20821 inform (input_location
, "invalid template non-type parameter");
20823 error ("%q#T is not a valid type for a template non-type parameter",
20829 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20830 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20833 dependent_type_p_r (tree type
)
20839 A type is dependent if it is:
20841 -- a template parameter. Template template parameters are types
20842 for us (since TYPE_P holds true for them) so we handle
20844 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20845 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20847 /* -- a qualified-id with a nested-name-specifier which contains a
20848 class-name that names a dependent type or whose unqualified-id
20849 names a dependent type. */
20850 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20852 /* -- a cv-qualified type where the cv-unqualified type is
20854 No code is necessary for this bullet; the code below handles
20855 cv-qualified types, and we don't want to strip aliases with
20856 TYPE_MAIN_VARIANT because of DR 1558. */
20857 /* -- a compound type constructed from any dependent type. */
20858 if (TYPE_PTRMEM_P (type
))
20859 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20860 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20862 else if (TYPE_PTR_P (type
)
20863 || TREE_CODE (type
) == REFERENCE_TYPE
)
20864 return dependent_type_p (TREE_TYPE (type
));
20865 else if (TREE_CODE (type
) == FUNCTION_TYPE
20866 || TREE_CODE (type
) == METHOD_TYPE
)
20870 if (dependent_type_p (TREE_TYPE (type
)))
20872 for (arg_type
= TYPE_ARG_TYPES (type
);
20874 arg_type
= TREE_CHAIN (arg_type
))
20875 if (dependent_type_p (TREE_VALUE (arg_type
)))
20879 /* -- an array type constructed from any dependent type or whose
20880 size is specified by a constant expression that is
20883 We checked for type- and value-dependence of the bounds in
20884 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20885 if (TREE_CODE (type
) == ARRAY_TYPE
)
20887 if (TYPE_DOMAIN (type
)
20888 && dependent_type_p (TYPE_DOMAIN (type
)))
20890 return dependent_type_p (TREE_TYPE (type
));
20893 /* -- a template-id in which either the template name is a template
20895 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20897 /* ... or any of the template arguments is a dependent type or
20898 an expression that is type-dependent or value-dependent. */
20899 else if (TYPE_TEMPLATE_INFO (type
)
20900 && (any_dependent_template_arguments_p
20901 (INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (type
)))))
20904 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20905 dependent; if the argument of the `typeof' expression is not
20906 type-dependent, then it should already been have resolved. */
20907 if (TREE_CODE (type
) == TYPEOF_TYPE
20908 || TREE_CODE (type
) == DECLTYPE_TYPE
20909 || TREE_CODE (type
) == UNDERLYING_TYPE
)
20912 /* A template argument pack is dependent if any of its packed
20914 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
20916 tree args
= ARGUMENT_PACK_ARGS (type
);
20917 int i
, len
= TREE_VEC_LENGTH (args
);
20918 for (i
= 0; i
< len
; ++i
)
20919 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20923 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20924 be template parameters. */
20925 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
20928 /* The standard does not specifically mention types that are local
20929 to template functions or local classes, but they should be
20930 considered dependent too. For example:
20932 template <int I> void f() {
20937 The size of `E' cannot be known until the value of `I' has been
20938 determined. Therefore, `E' must be considered dependent. */
20939 scope
= TYPE_CONTEXT (type
);
20940 if (scope
&& TYPE_P (scope
))
20941 return dependent_type_p (scope
);
20942 /* Don't use type_dependent_expression_p here, as it can lead
20943 to infinite recursion trying to determine whether a lambda
20944 nested in a lambda is dependent (c++/47687). */
20945 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
20946 && DECL_LANG_SPECIFIC (scope
)
20947 && DECL_TEMPLATE_INFO (scope
)
20948 && (any_dependent_template_arguments_p
20949 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
20952 /* Other types are non-dependent. */
20956 /* Returns TRUE if TYPE is dependent, in the sense of
20957 [temp.dep.type]. Note that a NULL type is considered dependent. */
20960 dependent_type_p (tree type
)
20962 /* If there are no template parameters in scope, then there can't be
20963 any dependent types. */
20964 if (!processing_template_decl
)
20966 /* If we are not processing a template, then nobody should be
20967 providing us with a dependent type. */
20969 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
20973 /* If the type is NULL, we have not computed a type for the entity
20974 in question; in that case, the type is dependent. */
20978 /* Erroneous types can be considered non-dependent. */
20979 if (type
== error_mark_node
)
20982 /* If we have not already computed the appropriate value for TYPE,
20984 if (!TYPE_DEPENDENT_P_VALID (type
))
20986 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
20987 TYPE_DEPENDENT_P_VALID (type
) = 1;
20990 return TYPE_DEPENDENT_P (type
);
20993 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20994 lookup. In other words, a dependent type that is not the current
20998 dependent_scope_p (tree scope
)
21000 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
21001 && !currently_open_class (scope
));
21004 /* T is a SCOPE_REF; return whether we need to consider it
21005 instantiation-dependent so that we can check access at instantiation
21006 time even though we know which member it resolves to. */
21009 instantiation_dependent_scope_ref_p (tree t
)
21011 if (DECL_P (TREE_OPERAND (t
, 1))
21012 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
21013 && accessible_in_template_p (TREE_OPERAND (t
, 0),
21014 TREE_OPERAND (t
, 1)))
21020 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
21021 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
21024 /* Note that this predicate is not appropriate for general expressions;
21025 only constant expressions (that satisfy potential_constant_expression)
21026 can be tested for value dependence. */
21029 value_dependent_expression_p (tree expression
)
21031 if (!processing_template_decl
)
21034 /* A name declared with a dependent type. */
21035 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
21038 switch (TREE_CODE (expression
))
21040 case IDENTIFIER_NODE
:
21041 /* A name that has not been looked up -- must be dependent. */
21044 case TEMPLATE_PARM_INDEX
:
21045 /* A non-type template parm. */
21049 /* A non-type template parm. */
21050 if (DECL_TEMPLATE_PARM_P (expression
))
21052 return value_dependent_expression_p (DECL_INITIAL (expression
));
21055 /* A constant with literal type and is initialized
21056 with an expression that is value-dependent.
21058 Note that a non-dependent parenthesized initializer will have
21059 already been replaced with its constant value, so if we see
21060 a TREE_LIST it must be dependent. */
21061 if (DECL_INITIAL (expression
)
21062 && decl_constant_var_p (expression
)
21063 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
21064 /* cp_finish_decl doesn't fold reference initializers. */
21065 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
21066 || value_dependent_expression_p (DECL_INITIAL (expression
))))
21070 case DYNAMIC_CAST_EXPR
:
21071 case STATIC_CAST_EXPR
:
21072 case CONST_CAST_EXPR
:
21073 case REINTERPRET_CAST_EXPR
:
21075 /* These expressions are value-dependent if the type to which
21076 the cast occurs is dependent or the expression being casted
21077 is value-dependent. */
21079 tree type
= TREE_TYPE (expression
);
21081 if (dependent_type_p (type
))
21084 /* A functional cast has a list of operands. */
21085 expression
= TREE_OPERAND (expression
, 0);
21088 /* If there are no operands, it must be an expression such
21089 as "int()". This should not happen for aggregate types
21090 because it would form non-constant expressions. */
21091 gcc_assert (cxx_dialect
>= cxx11
21092 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
21097 if (TREE_CODE (expression
) == TREE_LIST
)
21098 return any_value_dependent_elements_p (expression
);
21100 return value_dependent_expression_p (expression
);
21104 if (SIZEOF_EXPR_TYPE_P (expression
))
21105 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
21109 /* A `sizeof' expression is value-dependent if the operand is
21110 type-dependent or is a pack expansion. */
21111 expression
= TREE_OPERAND (expression
, 0);
21112 if (PACK_EXPANSION_P (expression
))
21114 else if (TYPE_P (expression
))
21115 return dependent_type_p (expression
);
21116 return instantiation_dependent_expression_p (expression
);
21118 case AT_ENCODE_EXPR
:
21119 /* An 'encode' expression is value-dependent if the operand is
21121 expression
= TREE_OPERAND (expression
, 0);
21122 return dependent_type_p (expression
);
21124 case NOEXCEPT_EXPR
:
21125 expression
= TREE_OPERAND (expression
, 0);
21126 return instantiation_dependent_expression_p (expression
);
21129 /* All instantiation-dependent expressions should also be considered
21130 value-dependent. */
21131 return instantiation_dependent_scope_ref_p (expression
);
21133 case COMPONENT_REF
:
21134 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
21135 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
21137 case NONTYPE_ARGUMENT_PACK
:
21138 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
21139 is value-dependent. */
21141 tree values
= ARGUMENT_PACK_ARGS (expression
);
21142 int i
, len
= TREE_VEC_LENGTH (values
);
21144 for (i
= 0; i
< len
; ++i
)
21145 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
21153 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
21154 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
21155 || (type2
? dependent_type_p (type2
) : false));
21159 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21160 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
21163 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21164 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
21168 tree op
= TREE_OPERAND (expression
, 0);
21169 return (value_dependent_expression_p (op
)
21170 || has_value_dependent_address (op
));
21175 tree fn
= get_callee_fndecl (expression
);
21177 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
21179 nargs
= call_expr_nargs (expression
);
21180 for (i
= 0; i
< nargs
; ++i
)
21182 tree op
= CALL_EXPR_ARG (expression
, i
);
21183 /* In a call to a constexpr member function, look through the
21184 implicit ADDR_EXPR on the object argument so that it doesn't
21185 cause the call to be considered value-dependent. We also
21186 look through it in potential_constant_expression. */
21187 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
21188 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
21189 && TREE_CODE (op
) == ADDR_EXPR
)
21190 op
= TREE_OPERAND (op
, 0);
21191 if (value_dependent_expression_p (op
))
21197 case TEMPLATE_ID_EXPR
:
21198 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21200 return type_dependent_expression_p (expression
);
21206 if (dependent_type_p (TREE_TYPE (expression
)))
21208 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
21209 if (value_dependent_expression_p (val
))
21215 /* Treat a GNU statement expression as dependent to avoid crashing
21216 under instantiate_non_dependent_expr; it can't be constant. */
21220 /* A constant expression is value-dependent if any subexpression is
21221 value-dependent. */
21222 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
21224 case tcc_reference
:
21226 case tcc_comparison
:
21228 case tcc_expression
:
21231 int i
, len
= cp_tree_operand_length (expression
);
21233 for (i
= 0; i
< len
; i
++)
21235 tree t
= TREE_OPERAND (expression
, i
);
21237 /* In some cases, some of the operands may be missing.l
21238 (For example, in the case of PREDECREMENT_EXPR, the
21239 amount to increment by may be missing.) That doesn't
21240 make the expression dependent. */
21241 if (t
&& value_dependent_expression_p (t
))
21252 /* The expression is not value-dependent. */
21256 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21257 [temp.dep.expr]. Note that an expression with no type is
21258 considered dependent. Other parts of the compiler arrange for an
21259 expression with type-dependent subexpressions to have no type, so
21260 this function doesn't have to be fully recursive. */
21263 type_dependent_expression_p (tree expression
)
21265 if (!processing_template_decl
)
21268 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
21271 /* An unresolved name is always dependent. */
21272 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
21275 /* Some expression forms are never type-dependent. */
21276 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
21277 || TREE_CODE (expression
) == SIZEOF_EXPR
21278 || TREE_CODE (expression
) == ALIGNOF_EXPR
21279 || TREE_CODE (expression
) == AT_ENCODE_EXPR
21280 || TREE_CODE (expression
) == NOEXCEPT_EXPR
21281 || TREE_CODE (expression
) == TRAIT_EXPR
21282 || TREE_CODE (expression
) == TYPEID_EXPR
21283 || TREE_CODE (expression
) == DELETE_EXPR
21284 || TREE_CODE (expression
) == VEC_DELETE_EXPR
21285 || TREE_CODE (expression
) == THROW_EXPR
)
21288 /* The types of these expressions depends only on the type to which
21289 the cast occurs. */
21290 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
21291 || TREE_CODE (expression
) == STATIC_CAST_EXPR
21292 || TREE_CODE (expression
) == CONST_CAST_EXPR
21293 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
21294 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
21295 || TREE_CODE (expression
) == CAST_EXPR
)
21296 return dependent_type_p (TREE_TYPE (expression
));
21298 /* The types of these expressions depends only on the type created
21299 by the expression. */
21300 if (TREE_CODE (expression
) == NEW_EXPR
21301 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
21303 /* For NEW_EXPR tree nodes created inside a template, either
21304 the object type itself or a TREE_LIST may appear as the
21306 tree type
= TREE_OPERAND (expression
, 1);
21307 if (TREE_CODE (type
) == TREE_LIST
)
21308 /* This is an array type. We need to check array dimensions
21310 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
21311 || value_dependent_expression_p
21312 (TREE_OPERAND (TREE_VALUE (type
), 1));
21314 return dependent_type_p (type
);
21317 if (TREE_CODE (expression
) == SCOPE_REF
)
21319 tree scope
= TREE_OPERAND (expression
, 0);
21320 tree name
= TREE_OPERAND (expression
, 1);
21322 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21323 contains an identifier associated by name lookup with one or more
21324 declarations declared with a dependent type, or...a
21325 nested-name-specifier or qualified-id that names a member of an
21326 unknown specialization. */
21327 return (type_dependent_expression_p (name
)
21328 || dependent_scope_p (scope
));
21331 if (TREE_CODE (expression
) == FUNCTION_DECL
21332 && DECL_LANG_SPECIFIC (expression
)
21333 && DECL_TEMPLATE_INFO (expression
)
21334 && (any_dependent_template_arguments_p
21335 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
21338 if (TREE_CODE (expression
) == TEMPLATE_DECL
21339 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
21342 if (TREE_CODE (expression
) == STMT_EXPR
)
21343 expression
= stmt_expr_value_expr (expression
);
21345 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21350 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21352 if (type_dependent_expression_p (elt
))
21358 /* A static data member of the current instantiation with incomplete
21359 array type is type-dependent, as the definition and specializations
21360 can have different bounds. */
21361 if (VAR_P (expression
)
21362 && DECL_CLASS_SCOPE_P (expression
)
21363 && dependent_type_p (DECL_CONTEXT (expression
))
21364 && VAR_HAD_UNKNOWN_BOUND (expression
))
21367 /* An array of unknown bound depending on a variadic parameter, eg:
21369 template<typename... Args>
21370 void foo (Args... args)
21372 int arr[] = { args... };
21375 template<int... vals>
21378 int arr[] = { vals... };
21381 If the array has no length and has an initializer, it must be that
21382 we couldn't determine its length in cp_complete_array_type because
21383 it is dependent. */
21384 if (VAR_P (expression
)
21385 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21386 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21387 && DECL_INITIAL (expression
))
21390 /* A variable template specialization is type-dependent if it has any
21391 dependent template arguments. */
21392 if (VAR_P (expression
)
21393 && DECL_LANG_SPECIFIC (expression
)
21394 && DECL_TEMPLATE_INFO (expression
)
21395 && variable_template_p (DECL_TI_TEMPLATE (expression
)))
21396 return any_dependent_template_arguments_p (DECL_TI_ARGS (expression
));
21398 if (TREE_TYPE (expression
) == unknown_type_node
)
21400 if (TREE_CODE (expression
) == ADDR_EXPR
)
21401 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21402 if (TREE_CODE (expression
) == COMPONENT_REF
21403 || TREE_CODE (expression
) == OFFSET_REF
)
21405 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21407 expression
= TREE_OPERAND (expression
, 1);
21408 if (identifier_p (expression
))
21411 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21412 if (TREE_CODE (expression
) == SCOPE_REF
)
21415 /* Always dependent, on the number of arguments if nothing else. */
21416 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21419 if (BASELINK_P (expression
))
21421 if (BASELINK_OPTYPE (expression
)
21422 && dependent_type_p (BASELINK_OPTYPE (expression
)))
21424 expression
= BASELINK_FUNCTIONS (expression
);
21427 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21429 if (any_dependent_template_arguments_p
21430 (TREE_OPERAND (expression
, 1)))
21432 expression
= TREE_OPERAND (expression
, 0);
21434 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21435 || TREE_CODE (expression
) == FUNCTION_DECL
);
21439 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21441 expression
= OVL_NEXT (expression
);
21446 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21448 return (dependent_type_p (TREE_TYPE (expression
)));
21451 /* walk_tree callback function for instantiation_dependent_expression_p,
21452 below. Returns non-zero if a dependent subexpression is found. */
21455 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21460 /* We don't have to worry about decltype currently because decltype
21461 of an instantiation-dependent expr is a dependent type. This
21462 might change depending on the resolution of DR 1172. */
21463 *walk_subtrees
= false;
21466 enum tree_code code
= TREE_CODE (*tp
);
21469 /* Don't treat an argument list as dependent just because it has no
21477 /* A constant with a dependent initializer is dependent. */
21478 if (value_dependent_expression_p (*tp
))
21482 case TEMPLATE_PARM_INDEX
:
21485 /* Handle expressions with type operands. */
21489 case AT_ENCODE_EXPR
:
21491 tree op
= TREE_OPERAND (*tp
, 0);
21492 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21493 op
= TREE_TYPE (op
);
21496 if (dependent_type_p (op
))
21500 *walk_subtrees
= false;
21508 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21509 || (TRAIT_EXPR_TYPE2 (*tp
)
21510 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21512 *walk_subtrees
= false;
21515 case COMPONENT_REF
:
21516 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21517 /* In a template, finish_class_member_access_expr creates a
21518 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21519 type-dependent, so that we can check access control at
21520 instantiation time (PR 42277). See also Core issue 1273. */
21525 if (instantiation_dependent_scope_ref_p (*tp
))
21530 /* Treat statement-expressions as dependent. */
21538 if (type_dependent_expression_p (*tp
))
21544 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21545 sense defined by the ABI:
21547 "An expression is instantiation-dependent if it is type-dependent
21548 or value-dependent, or it has a subexpression that is type-dependent
21549 or value-dependent." */
21552 instantiation_dependent_expression_p (tree expression
)
21556 if (!processing_template_decl
)
21559 if (expression
== error_mark_node
)
21562 result
= cp_walk_tree_without_duplicates (&expression
,
21563 instantiation_dependent_r
, NULL
);
21564 return result
!= NULL_TREE
;
21567 /* Like type_dependent_expression_p, but it also works while not processing
21568 a template definition, i.e. during substitution or mangling. */
21571 type_dependent_expression_p_push (tree expr
)
21574 ++processing_template_decl
;
21575 b
= type_dependent_expression_p (expr
);
21576 --processing_template_decl
;
21580 /* Returns TRUE if ARGS contains a type-dependent expression. */
21583 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21588 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21590 if (type_dependent_expression_p (arg
))
21596 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21597 expressions) contains any type-dependent expressions. */
21600 any_type_dependent_elements_p (const_tree list
)
21602 for (; list
; list
= TREE_CHAIN (list
))
21603 if (type_dependent_expression_p (TREE_VALUE (list
)))
21609 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21610 expressions) contains any value-dependent expressions. */
21613 any_value_dependent_elements_p (const_tree list
)
21615 for (; list
; list
= TREE_CHAIN (list
))
21616 if (value_dependent_expression_p (TREE_VALUE (list
)))
21622 /* Returns TRUE if the ARG (a template argument) is dependent. */
21625 dependent_template_arg_p (tree arg
)
21627 if (!processing_template_decl
)
21630 /* Assume a template argument that was wrongly written by the user
21631 is dependent. This is consistent with what
21632 any_dependent_template_arguments_p [that calls this function]
21634 if (!arg
|| arg
== error_mark_node
)
21637 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21638 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21640 if (TREE_CODE (arg
) == TEMPLATE_DECL
21641 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21642 return dependent_template_p (arg
);
21643 else if (ARGUMENT_PACK_P (arg
))
21645 tree args
= ARGUMENT_PACK_ARGS (arg
);
21646 int i
, len
= TREE_VEC_LENGTH (args
);
21647 for (i
= 0; i
< len
; ++i
)
21649 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21655 else if (TYPE_P (arg
))
21656 return dependent_type_p (arg
);
21658 return (type_dependent_expression_p (arg
)
21659 || value_dependent_expression_p (arg
));
21662 /* Returns true if ARGS (a collection of template arguments) contains
21663 any types that require structural equality testing. */
21666 any_template_arguments_need_structural_equality_p (tree args
)
21673 if (args
== error_mark_node
)
21676 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21678 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21679 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21681 tree arg
= TREE_VEC_ELT (level
, j
);
21682 tree packed_args
= NULL_TREE
;
21685 if (ARGUMENT_PACK_P (arg
))
21687 /* Look inside the argument pack. */
21688 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21689 len
= TREE_VEC_LENGTH (packed_args
);
21692 for (k
= 0; k
< len
; ++k
)
21695 arg
= TREE_VEC_ELT (packed_args
, k
);
21697 if (error_operand_p (arg
))
21699 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21701 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21703 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21704 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21713 /* Returns true if ARGS (a collection of template arguments) contains
21714 any dependent arguments. */
21717 any_dependent_template_arguments_p (const_tree args
)
21724 if (args
== error_mark_node
)
21727 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21729 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21730 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21731 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21738 /* Returns TRUE if the template TMPL is dependent. */
21741 dependent_template_p (tree tmpl
)
21743 if (TREE_CODE (tmpl
) == OVERLOAD
)
21747 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21749 tmpl
= OVL_NEXT (tmpl
);
21754 /* Template template parameters are dependent. */
21755 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21756 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21758 /* So are names that have not been looked up. */
21759 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21761 /* So are member templates of dependent classes. */
21762 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21763 return dependent_type_p (DECL_CONTEXT (tmpl
));
21767 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21770 dependent_template_id_p (tree tmpl
, tree args
)
21772 return (dependent_template_p (tmpl
)
21773 || any_dependent_template_arguments_p (args
));
21776 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21780 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21784 if (!processing_template_decl
)
21787 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21789 tree decl
= TREE_VEC_ELT (declv
, i
);
21790 tree init
= TREE_VEC_ELT (initv
, i
);
21791 tree cond
= TREE_VEC_ELT (condv
, i
);
21792 tree incr
= TREE_VEC_ELT (incrv
, i
);
21794 if (type_dependent_expression_p (decl
))
21797 if (init
&& type_dependent_expression_p (init
))
21800 if (type_dependent_expression_p (cond
))
21803 if (COMPARISON_CLASS_P (cond
)
21804 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21805 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21808 if (TREE_CODE (incr
) == MODOP_EXPR
)
21810 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21811 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21814 else if (type_dependent_expression_p (incr
))
21816 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21818 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21820 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21822 tree t
= TREE_OPERAND (incr
, 1);
21823 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21824 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21833 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21834 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21835 no such TYPE can be found. Note that this function peers inside
21836 uninstantiated templates and therefore should be used only in
21837 extremely limited situations. ONLY_CURRENT_P restricts this
21838 peering to the currently open classes hierarchy (which is required
21839 when comparing types). */
21842 resolve_typename_type (tree type
, bool only_current_p
)
21851 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21853 scope
= TYPE_CONTEXT (type
);
21854 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21855 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21856 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21857 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21858 identifier of the TYPENAME_TYPE anymore.
21859 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21860 TYPENAME_TYPE instead, we avoid messing up with a possible
21861 typedef variant case. */
21862 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21864 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21865 it first before we can figure out what NAME refers to. */
21866 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21868 if (TYPENAME_IS_RESOLVING_P (scope
))
21869 /* Given a class template A with a dependent base with nested type C,
21870 typedef typename A::C::C C will land us here, as trying to resolve
21871 the initial A::C leads to the local C typedef, which leads back to
21872 A::C::C. So we break the recursion now. */
21875 scope
= resolve_typename_type (scope
, only_current_p
);
21877 /* If we don't know what SCOPE refers to, then we cannot resolve the
21879 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21881 /* If the SCOPE is a template type parameter, we have no way of
21882 resolving the name. */
21883 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21885 /* If the SCOPE is not the current instantiation, there's no reason
21886 to look inside it. */
21887 if (only_current_p
&& !currently_open_class (scope
))
21889 /* If this is a typedef, we don't want to look inside (c++/11987). */
21890 if (typedef_variant_p (type
))
21892 /* If SCOPE isn't the template itself, it will not have a valid
21893 TYPE_FIELDS list. */
21894 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21895 /* scope is either the template itself or a compatible instantiation
21896 like X<T>, so look up the name in the original template. */
21897 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
21899 /* scope is a partial instantiation, so we can't do the lookup or we
21900 will lose the template arguments. */
21902 /* Enter the SCOPE so that name lookup will be resolved as if we
21903 were in the class definition. In particular, SCOPE will no
21904 longer be considered a dependent type. */
21905 pushed_scope
= push_scope (scope
);
21906 /* Look up the declaration. */
21907 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
21908 tf_warning_or_error
);
21910 result
= NULL_TREE
;
21912 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21913 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21916 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
21917 && TREE_CODE (decl
) == TYPE_DECL
)
21919 result
= TREE_TYPE (decl
);
21920 if (result
== error_mark_node
)
21921 result
= NULL_TREE
;
21923 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
21924 && DECL_CLASS_TEMPLATE_P (decl
))
21928 /* Obtain the template and the arguments. */
21929 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
21930 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
21931 /* Instantiate the template. */
21932 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
21933 /*entering_scope=*/0,
21934 tf_error
| tf_user
);
21935 if (result
== error_mark_node
)
21936 result
= NULL_TREE
;
21939 /* Leave the SCOPE. */
21941 pop_scope (pushed_scope
);
21943 /* If we failed to resolve it, return the original typename. */
21947 /* If lookup found a typename type, resolve that too. */
21948 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
21950 /* Ill-formed programs can cause infinite recursion here, so we
21951 must catch that. */
21952 TYPENAME_IS_RESOLVING_P (type
) = 1;
21953 result
= resolve_typename_type (result
, only_current_p
);
21954 TYPENAME_IS_RESOLVING_P (type
) = 0;
21957 /* Qualify the resulting type. */
21958 quals
= cp_type_quals (type
);
21960 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
21965 /* EXPR is an expression which is not type-dependent. Return a proxy
21966 for EXPR that can be used to compute the types of larger
21967 expressions containing EXPR. */
21970 build_non_dependent_expr (tree expr
)
21974 #ifdef ENABLE_CHECKING
21975 /* Try to get a constant value for all non-dependent expressions in
21976 order to expose bugs in *_dependent_expression_p and constexpr. */
21977 if (cxx_dialect
>= cxx11
)
21978 fold_non_dependent_expr (expr
);
21981 /* Preserve OVERLOADs; the functions must be available to resolve
21984 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
21985 inner_expr
= stmt_expr_value_expr (inner_expr
);
21986 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
21987 inner_expr
= TREE_OPERAND (inner_expr
, 0);
21988 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
21989 inner_expr
= TREE_OPERAND (inner_expr
, 1);
21990 if (is_overloaded_fn (inner_expr
)
21991 || TREE_CODE (inner_expr
) == OFFSET_REF
)
21993 /* There is no need to return a proxy for a variable. */
21996 /* Preserve string constants; conversions from string constants to
21997 "char *" are allowed, even though normally a "const char *"
21998 cannot be used to initialize a "char *". */
21999 if (TREE_CODE (expr
) == STRING_CST
)
22001 /* Preserve void and arithmetic constants, as an optimization -- there is no
22002 reason to create a new node. */
22003 if (TREE_CODE (expr
) == VOID_CST
22004 || TREE_CODE (expr
) == INTEGER_CST
22005 || TREE_CODE (expr
) == REAL_CST
)
22007 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
22008 There is at least one place where we want to know that a
22009 particular expression is a throw-expression: when checking a ?:
22010 expression, there are special rules if the second or third
22011 argument is a throw-expression. */
22012 if (TREE_CODE (expr
) == THROW_EXPR
)
22015 /* Don't wrap an initializer list, we need to be able to look inside. */
22016 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
22019 /* Don't wrap a dummy object, we need to be able to test for it. */
22020 if (is_dummy_object (expr
))
22023 if (TREE_CODE (expr
) == COND_EXPR
)
22024 return build3 (COND_EXPR
,
22026 TREE_OPERAND (expr
, 0),
22027 (TREE_OPERAND (expr
, 1)
22028 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
22029 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
22030 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
22031 if (TREE_CODE (expr
) == COMPOUND_EXPR
22032 && !COMPOUND_EXPR_OVERLOADED (expr
))
22033 return build2 (COMPOUND_EXPR
,
22035 TREE_OPERAND (expr
, 0),
22036 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
22038 /* If the type is unknown, it can't really be non-dependent */
22039 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
22041 /* Otherwise, build a NON_DEPENDENT_EXPR. */
22042 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
22045 /* ARGS is a vector of expressions as arguments to a function call.
22046 Replace the arguments with equivalent non-dependent expressions.
22047 This modifies ARGS in place. */
22050 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
22055 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
22057 tree newarg
= build_non_dependent_expr (arg
);
22059 (*args
)[ix
] = newarg
;
22063 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
22064 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
22068 make_auto_1 (tree name
)
22070 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
22071 TYPE_NAME (au
) = build_decl (input_location
,
22072 TYPE_DECL
, name
, au
);
22073 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
22074 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
22075 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
22076 TYPE_NAME (au
), NULL_TREE
);
22077 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
22078 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
22079 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
22085 make_decltype_auto (void)
22087 return make_auto_1 (get_identifier ("decltype(auto)"));
22093 return make_auto_1 (get_identifier ("auto"));
22096 /* Given type ARG, return std::initializer_list<ARG>. */
22101 tree std_init_list
= namespace_binding
22102 (get_identifier ("initializer_list"), std_node
);
22104 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
22106 error ("deducing from brace-enclosed initializer list requires "
22107 "#include <initializer_list>");
22108 return error_mark_node
;
22110 argvec
= make_tree_vec (1);
22111 TREE_VEC_ELT (argvec
, 0) = arg
;
22112 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
22113 NULL_TREE
, 0, tf_warning_or_error
);
22116 /* Replace auto in TYPE with std::initializer_list<auto>. */
22119 listify_autos (tree type
, tree auto_node
)
22121 tree init_auto
= listify (auto_node
);
22122 tree argvec
= make_tree_vec (1);
22123 TREE_VEC_ELT (argvec
, 0) = init_auto
;
22124 if (processing_template_decl
)
22125 argvec
= add_to_template_args (current_template_args (), argvec
);
22126 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22129 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
22130 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
22133 do_auto_deduction (tree type
, tree init
, tree auto_node
)
22137 if (init
== error_mark_node
)
22138 return error_mark_node
;
22140 if (type_dependent_expression_p (init
))
22141 /* Defining a subset of type-dependent expressions that we can deduce
22142 from ahead of time isn't worth the trouble. */
22145 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
22146 with either a new invented type template parameter U or, if the
22147 initializer is a braced-init-list (8.5.4), with
22148 std::initializer_list<U>. */
22149 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
22151 if (!DIRECT_LIST_INIT_P (init
))
22152 type
= listify_autos (type
, auto_node
);
22153 else if (CONSTRUCTOR_NELTS (init
) == 1)
22154 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
22157 if (permerror (input_location
, "direct-list-initialization of "
22158 "%<auto%> requires exactly one element"))
22159 inform (input_location
,
22160 "for deduction to %<std::initializer_list%>, use copy-"
22161 "list-initialization (i.e. add %<=%> before the %<{%>)");
22162 type
= listify_autos (type
, auto_node
);
22166 init
= resolve_nondeduced_context (init
);
22168 targs
= make_tree_vec (1);
22169 if (AUTO_IS_DECLTYPE (auto_node
))
22171 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
22172 && !REF_PARENTHESIZED_P (init
)));
22173 TREE_VEC_ELT (targs
, 0)
22174 = finish_decltype_type (init
, id
, tf_warning_or_error
);
22175 if (type
!= auto_node
)
22177 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
22178 return error_mark_node
;
22183 tree parms
= build_tree_list (NULL_TREE
, type
);
22184 tree tparms
= make_tree_vec (1);
22187 TREE_VEC_ELT (tparms
, 0)
22188 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
22189 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
22190 DEDUCE_CALL
, LOOKUP_NORMAL
,
22191 NULL
, /*explain_p=*/false);
22194 if (processing_template_decl
)
22195 /* Try again at instantiation time. */
22197 if (type
&& type
!= error_mark_node
)
22198 /* If type is error_mark_node a diagnostic must have been
22199 emitted by now. Also, having a mention to '<type error>'
22200 in the diagnostic is not really useful to the user. */
22202 if (cfun
&& auto_node
== current_function_auto_return_pattern
22203 && LAMBDA_FUNCTION_P (current_function_decl
))
22204 error ("unable to deduce lambda return type from %qE", init
);
22206 error ("unable to deduce %qT from %qE", type
, init
);
22208 return error_mark_node
;
22212 /* If the list of declarators contains more than one declarator, the type
22213 of each declared variable is determined as described above. If the
22214 type deduced for the template parameter U is not the same in each
22215 deduction, the program is ill-formed. */
22216 if (TREE_TYPE (auto_node
)
22217 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
22219 if (cfun
&& auto_node
== current_function_auto_return_pattern
22220 && LAMBDA_FUNCTION_P (current_function_decl
))
22221 error ("inconsistent types %qT and %qT deduced for "
22222 "lambda return type", TREE_TYPE (auto_node
),
22223 TREE_VEC_ELT (targs
, 0));
22225 error ("inconsistent deduction for %qT: %qT and then %qT",
22226 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
22227 return error_mark_node
;
22229 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
22231 if (processing_template_decl
)
22232 targs
= add_to_template_args (current_template_args (), targs
);
22233 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
22236 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22240 splice_late_return_type (tree type
, tree late_return_type
)
22244 if (late_return_type
== NULL_TREE
)
22246 argvec
= make_tree_vec (1);
22247 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
22248 if (processing_template_parmlist
)
22249 /* For a late-specified return type in a template type-parameter, we
22250 need to add a dummy argument level for its parmlist. */
22251 argvec
= add_to_template_args
22252 (make_tree_vec (processing_template_parmlist
), argvec
);
22253 if (current_template_parms
)
22254 argvec
= add_to_template_args (current_template_args (), argvec
);
22255 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22258 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22259 'decltype(auto)'. */
22262 is_auto (const_tree type
)
22264 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
22265 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
22266 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
22272 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22273 a use of `auto'. Returns NULL_TREE otherwise. */
22276 type_uses_auto (tree type
)
22278 return find_type_usage (type
, is_auto
);
22281 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22282 'decltype(auto)' or a concept. */
22285 is_auto_or_concept (const_tree type
)
22287 return is_auto (type
); // or concept
22290 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22291 a concept identifier) iff TYPE contains a use of a generic type. Returns
22292 NULL_TREE otherwise. */
22295 type_uses_auto_or_concept (tree type
)
22297 return find_type_usage (type
, is_auto_or_concept
);
22301 /* For a given template T, return the vector of typedefs referenced
22302 in T for which access check is needed at T instantiation time.
22303 T is either a FUNCTION_DECL or a RECORD_TYPE.
22304 Those typedefs were added to T by the function
22305 append_type_to_template_for_access_check. */
22307 vec
<qualified_typedef_usage_t
, va_gc
> *
22308 get_types_needing_access_check (tree t
)
22311 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
22313 if (!t
|| t
== error_mark_node
)
22316 if (!(ti
= get_template_info (t
)))
22319 if (CLASS_TYPE_P (t
)
22320 || TREE_CODE (t
) == FUNCTION_DECL
)
22322 if (!TI_TEMPLATE (ti
))
22325 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
22331 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22332 tied to T. That list of typedefs will be access checked at
22333 T instantiation time.
22334 T is either a FUNCTION_DECL or a RECORD_TYPE.
22335 TYPE_DECL is a TYPE_DECL node representing a typedef.
22336 SCOPE is the scope through which TYPE_DECL is accessed.
22337 LOCATION is the location of the usage point of TYPE_DECL.
22339 This function is a subroutine of
22340 append_type_to_template_for_access_check. */
22343 append_type_to_template_for_access_check_1 (tree t
,
22346 location_t location
)
22348 qualified_typedef_usage_t typedef_usage
;
22351 if (!t
|| t
== error_mark_node
)
22354 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
22355 || CLASS_TYPE_P (t
))
22357 && TREE_CODE (type_decl
) == TYPE_DECL
22360 if (!(ti
= get_template_info (t
)))
22363 gcc_assert (TI_TEMPLATE (ti
));
22365 typedef_usage
.typedef_decl
= type_decl
;
22366 typedef_usage
.context
= scope
;
22367 typedef_usage
.locus
= location
;
22369 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22372 /* Append TYPE_DECL to the template TEMPL.
22373 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22374 At TEMPL instanciation time, TYPE_DECL will be checked to see
22375 if it can be accessed through SCOPE.
22376 LOCATION is the location of the usage point of TYPE_DECL.
22378 e.g. consider the following code snippet:
22385 template<class U> struct S
22387 C::myint mi; // <-- usage point of the typedef C::myint
22392 At S<char> instantiation time, we need to check the access of C::myint
22393 In other words, we need to check the access of the myint typedef through
22394 the C scope. For that purpose, this function will add the myint typedef
22395 and the scope C through which its being accessed to a list of typedefs
22396 tied to the template S. That list will be walked at template instantiation
22397 time and access check performed on each typedefs it contains.
22398 Note that this particular code snippet should yield an error because
22399 myint is private to C. */
22402 append_type_to_template_for_access_check (tree templ
,
22405 location_t location
)
22407 qualified_typedef_usage_t
*iter
;
22410 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22412 /* Make sure we don't append the type to the template twice. */
22413 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22414 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22417 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22421 /* Convert the generic type parameters in PARM that match the types given in the
22422 range [START_IDX, END_IDX) from the current_template_parms into generic type
22426 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22428 tree current
= current_template_parms
;
22429 int depth
= TMPL_PARMS_DEPTH (current
);
22430 current
= INNERMOST_TEMPLATE_PARMS (current
);
22431 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22433 for (int i
= 0; i
< start_idx
; ++i
)
22434 TREE_VEC_ELT (replacement
, i
)
22435 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22437 for (int i
= start_idx
; i
< end_idx
; ++i
)
22439 /* Create a distinct parameter pack type from the current parm and add it
22440 to the replacement args to tsubst below into the generic function
22443 tree o
= TREE_TYPE (TREE_VALUE
22444 (TREE_VEC_ELT (current
, i
)));
22445 tree t
= copy_type (o
);
22446 TEMPLATE_TYPE_PARM_INDEX (t
)
22447 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22449 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22450 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22451 TYPE_MAIN_VARIANT (t
) = t
;
22452 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22453 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22454 TREE_VEC_ELT (replacement
, i
) = t
;
22455 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22458 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22459 TREE_VEC_ELT (replacement
, i
)
22460 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22462 /* If there are more levels then build up the replacement with the outer
22465 replacement
= add_to_template_args (template_parms_to_args
22466 (TREE_CHAIN (current_template_parms
)),
22469 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22473 /* Set up the hash tables for template instantiations. */
22476 init_template_processing (void)
22478 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22479 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22482 /* Print stats about the template hash tables for -fstats. */
22485 print_template_statistics (void)
22487 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22488 "%f collisions\n", (long) decl_specializations
->size (),
22489 (long) decl_specializations
->elements (),
22490 decl_specializations
->collisions ());
22491 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22492 "%f collisions\n", (long) type_specializations
->size (),
22493 (long) type_specializations
->elements (),
22494 type_specializations
->collisions ());
22497 #include "gt-cp-pt.h"