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"
35 #include "stringpool.h"
38 #include "stor-layout.h"
42 #include "c-family/c-common.h"
43 #include "c-family/c-objc.h"
44 #include "cp-objcp-common.h"
45 #include "tree-inline.h"
49 #include "tree-iterator.h"
50 #include "type-utils.h"
53 /* The type of functions taking a tree, and some additional data, and
55 typedef int (*tree_fn_t
) (tree
, void*);
57 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
58 instantiations have been deferred, either because their definitions
59 were not yet available, or because we were putting off doing the work. */
60 struct GTY ((chain_next ("%h.next"))) pending_template
{
61 struct pending_template
*next
;
62 struct tinst_level
*tinst
;
65 static GTY(()) struct pending_template
*pending_templates
;
66 static GTY(()) struct pending_template
*last_pending_template
;
68 int processing_template_parmlist
;
69 static int template_header_count
;
71 static GTY(()) tree saved_trees
;
72 static vec
<int> inline_parm_levels
;
74 static GTY(()) struct tinst_level
*current_tinst_level
;
76 static GTY(()) tree saved_access_scope
;
78 /* Live only within one (recursive) call to tsubst_expr. We use
79 this to pass the statement expression node from the STMT_EXPR
80 to the EXPR_STMT that is its result. */
81 static tree cur_stmt_expr
;
83 /* True if we've recursed into fn_type_unification too many times. */
84 static bool excessive_deduction_depth
;
86 struct GTY((for_user
)) spec_entry
93 struct spec_hasher
: ggc_hasher
<spec_entry
*>
95 static hashval_t
hash (spec_entry
*);
96 static bool equal (spec_entry
*, spec_entry
*);
99 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
101 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
103 /* Contains canonical template parameter types. The vector is indexed by
104 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
105 TREE_LIST, whose TREE_VALUEs contain the canonical template
106 parameters of various types and levels. */
107 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
109 #define UNIFY_ALLOW_NONE 0
110 #define UNIFY_ALLOW_MORE_CV_QUAL 1
111 #define UNIFY_ALLOW_LESS_CV_QUAL 2
112 #define UNIFY_ALLOW_DERIVED 4
113 #define UNIFY_ALLOW_INTEGER 8
114 #define UNIFY_ALLOW_OUTER_LEVEL 16
115 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
116 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
118 enum template_base_result
{
120 tbr_ambiguous_baseclass
,
124 static void push_access_scope (tree
);
125 static void pop_access_scope (tree
);
126 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
127 unification_kind_t
, int,
129 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
130 unification_kind_t
, int, bool, bool);
131 static int unify (tree
, tree
, tree
, tree
, int, bool);
132 static void add_pending_template (tree
);
133 static tree
reopen_tinst_level (struct tinst_level
*);
134 static tree
tsubst_initializer_list (tree
, tree
);
135 static tree
get_partial_spec_bindings (tree
, tree
, tree
, tree
);
136 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
138 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
140 static void tsubst_enum (tree
, tree
, tree
);
141 static tree
add_to_template_args (tree
, tree
);
142 static tree
add_outermost_template_args (tree
, tree
);
143 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
144 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
146 static int type_unification_real (tree
, tree
, tree
, const tree
*,
147 unsigned int, int, unification_kind_t
, int,
148 vec
<deferred_access_check
, va_gc
> **,
150 static void note_template_header (int);
151 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
152 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
153 static tree
convert_template_argument (tree
, tree
, tree
,
154 tsubst_flags_t
, int, tree
);
155 static int for_each_template_parm (tree
, tree_fn_t
, void*,
156 hash_set
<tree
> *, bool);
157 static tree
expand_template_argument_pack (tree
);
158 static tree
build_template_parm_index (int, int, int, tree
, tree
);
159 static bool inline_needs_template_parms (tree
, bool);
160 static void push_inline_template_parms_recursive (tree
, int);
161 static tree
retrieve_local_specialization (tree
);
162 static void register_local_specialization (tree
, tree
);
163 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
164 static int mark_template_parm (tree
, void *);
165 static int template_parm_this_level_p (tree
, void *);
166 static tree
tsubst_friend_function (tree
, tree
);
167 static tree
tsubst_friend_class (tree
, tree
);
168 static int can_complete_type_without_circularity (tree
);
169 static tree
get_bindings (tree
, tree
, tree
, bool);
170 static int template_decl_level (tree
);
171 static int check_cv_quals_for_unify (int, tree
, tree
);
172 static void template_parm_level_and_index (tree
, int*, int*);
173 static int unify_pack_expansion (tree
, tree
, tree
,
174 tree
, unification_kind_t
, bool, bool);
175 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
176 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
177 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
178 static void regenerate_decl_from_template (tree
, tree
);
179 static tree
most_specialized_partial_spec (tree
, tsubst_flags_t
);
180 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
181 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
182 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
183 static bool check_specialization_scope (void);
184 static tree
process_partial_specialization (tree
);
185 static void set_current_access_from_decl (tree
);
186 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
188 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
189 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
191 static bool template_template_parm_bindings_ok_p (tree
, tree
);
192 static int template_args_equal (tree
, tree
);
193 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
194 static tree
for_each_template_parm_r (tree
*, int *, void *);
195 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
196 static void copy_default_args_to_explicit_spec (tree
);
197 static int invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
198 static bool dependent_template_arg_p (tree
);
199 static bool any_template_arguments_need_structural_equality_p (tree
);
200 static bool dependent_type_p_r (tree
);
201 static tree
tsubst_expr (tree
, tree
, tsubst_flags_t
, tree
, bool);
202 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
203 static tree
tsubst_pack_expansion (tree
, tree
, tsubst_flags_t
, tree
);
204 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
205 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
206 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
208 static tree
listify (tree
);
209 static tree
listify_autos (tree
, tree
);
210 static tree
template_parm_to_arg (tree t
);
211 static tree
current_template_args (void);
212 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
213 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
214 static bool complex_alias_template_p (const_tree tmpl
);
216 /* Make the current scope suitable for access checking when we are
217 processing T. T can be FUNCTION_DECL for instantiated function
218 template, VAR_DECL for static member variable, or TYPE_DECL for
219 alias template (needed by instantiate_decl). */
222 push_access_scope (tree t
)
224 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
225 || TREE_CODE (t
) == TYPE_DECL
);
227 if (DECL_FRIEND_CONTEXT (t
))
228 push_nested_class (DECL_FRIEND_CONTEXT (t
));
229 else if (DECL_CLASS_SCOPE_P (t
))
230 push_nested_class (DECL_CONTEXT (t
));
232 push_to_top_level ();
234 if (TREE_CODE (t
) == FUNCTION_DECL
)
236 saved_access_scope
= tree_cons
237 (NULL_TREE
, current_function_decl
, saved_access_scope
);
238 current_function_decl
= t
;
242 /* Restore the scope set up by push_access_scope. T is the node we
246 pop_access_scope (tree t
)
248 if (TREE_CODE (t
) == FUNCTION_DECL
)
250 current_function_decl
= TREE_VALUE (saved_access_scope
);
251 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
254 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
257 pop_from_top_level ();
260 /* Do any processing required when DECL (a member template
261 declaration) is finished. Returns the TEMPLATE_DECL corresponding
262 to DECL, unless it is a specialization, in which case the DECL
263 itself is returned. */
266 finish_member_template_decl (tree decl
)
268 if (decl
== error_mark_node
)
269 return error_mark_node
;
271 gcc_assert (DECL_P (decl
));
273 if (TREE_CODE (decl
) == TYPE_DECL
)
277 type
= TREE_TYPE (decl
);
278 if (type
== error_mark_node
)
279 return error_mark_node
;
280 if (MAYBE_CLASS_TYPE_P (type
)
281 && CLASSTYPE_TEMPLATE_INFO (type
)
282 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
284 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
285 check_member_template (tmpl
);
290 else if (TREE_CODE (decl
) == FIELD_DECL
)
291 error ("data member %qD cannot be a member template", decl
);
292 else if (DECL_TEMPLATE_INFO (decl
))
294 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
296 check_member_template (DECL_TI_TEMPLATE (decl
));
297 return DECL_TI_TEMPLATE (decl
);
303 error ("invalid member template declaration %qD", decl
);
305 return error_mark_node
;
308 /* Create a template info node. */
311 build_template_info (tree template_decl
, tree template_args
)
313 tree result
= make_node (TEMPLATE_INFO
);
314 TI_TEMPLATE (result
) = template_decl
;
315 TI_ARGS (result
) = template_args
;
319 /* Return the template info node corresponding to T, whatever T is. */
322 get_template_info (const_tree t
)
324 tree tinfo
= NULL_TREE
;
326 if (!t
|| t
== error_mark_node
)
329 if (TREE_CODE (t
) == NAMESPACE_DECL
)
332 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
333 tinfo
= DECL_TEMPLATE_INFO (t
);
335 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
338 if (OVERLOAD_TYPE_P (t
))
339 tinfo
= TYPE_TEMPLATE_INFO (t
);
340 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
341 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
346 /* Returns the template nesting level of the indicated class TYPE.
356 A<T>::B<U> has depth two, while A<T> has depth one.
357 Both A<T>::B<int> and A<int>::B<U> have depth one, if
358 they are instantiations, not specializations.
360 This function is guaranteed to return 0 if passed NULL_TREE so
361 that, for example, `template_class_depth (current_class_type)' is
365 template_class_depth (tree type
)
370 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
371 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
372 ? CP_DECL_CONTEXT (type
) : CP_TYPE_CONTEXT (type
))
374 tree tinfo
= get_template_info (type
);
376 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
377 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
384 /* Subroutine of maybe_begin_member_template_processing.
385 Returns true if processing DECL needs us to push template parms. */
388 inline_needs_template_parms (tree decl
, bool nsdmi
)
390 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
393 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
394 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
397 /* Subroutine of maybe_begin_member_template_processing.
398 Push the template parms in PARMS, starting from LEVELS steps into the
399 chain, and ending at the beginning, since template parms are listed
403 push_inline_template_parms_recursive (tree parmlist
, int levels
)
405 tree parms
= TREE_VALUE (parmlist
);
409 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
411 ++processing_template_decl
;
412 current_template_parms
413 = tree_cons (size_int (processing_template_decl
),
414 parms
, current_template_parms
);
415 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
417 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
419 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
421 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
423 if (error_operand_p (parm
))
426 gcc_assert (DECL_P (parm
));
428 switch (TREE_CODE (parm
))
437 /* Make a CONST_DECL as is done in process_template_parm.
438 It is ugly that we recreate this here; the original
439 version built in process_template_parm is no longer
441 tree decl
= build_decl (DECL_SOURCE_LOCATION (parm
),
442 CONST_DECL
, DECL_NAME (parm
),
444 DECL_ARTIFICIAL (decl
) = 1;
445 TREE_CONSTANT (decl
) = 1;
446 TREE_READONLY (decl
) = 1;
447 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
448 SET_DECL_TEMPLATE_PARM_P (decl
);
459 /* Restore the template parameter context for a member template, a
460 friend template defined in a class definition, or a non-template
461 member of template class. */
464 maybe_begin_member_template_processing (tree decl
)
468 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
472 tree ctx
= DECL_CONTEXT (decl
);
473 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
474 /* Disregard full specializations (c++/60999). */
475 && uses_template_parms (ctx
)
476 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
479 if (inline_needs_template_parms (decl
, nsdmi
))
481 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
482 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
484 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
487 parms
= TREE_CHAIN (parms
);
490 push_inline_template_parms_recursive (parms
, levels
);
493 /* Remember how many levels of template parameters we pushed so that
494 we can pop them later. */
495 inline_parm_levels
.safe_push (levels
);
498 /* Undo the effects of maybe_begin_member_template_processing. */
501 maybe_end_member_template_processing (void)
506 if (inline_parm_levels
.length () == 0)
509 last
= inline_parm_levels
.pop ();
510 for (i
= 0; i
< last
; ++i
)
512 --processing_template_decl
;
513 current_template_parms
= TREE_CHAIN (current_template_parms
);
518 /* Return a new template argument vector which contains all of ARGS,
519 but has as its innermost set of arguments the EXTRA_ARGS. */
522 add_to_template_args (tree args
, tree extra_args
)
529 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
532 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
533 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
535 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
536 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
538 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
539 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
544 /* Like add_to_template_args, but only the outermost ARGS are added to
545 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
546 (EXTRA_ARGS) levels are added. This function is used to combine
547 the template arguments from a partial instantiation with the
548 template arguments used to attain the full instantiation from the
549 partial instantiation. */
552 add_outermost_template_args (tree args
, tree extra_args
)
556 /* If there are more levels of EXTRA_ARGS than there are ARGS,
557 something very fishy is going on. */
558 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
560 /* If *all* the new arguments will be the EXTRA_ARGS, just return
562 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
565 /* For the moment, we make ARGS look like it contains fewer levels. */
566 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
568 new_args
= add_to_template_args (args
, extra_args
);
570 /* Now, we restore ARGS to its full dimensions. */
571 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
576 /* Return the N levels of innermost template arguments from the ARGS. */
579 get_innermost_template_args (tree args
, int n
)
587 /* If N is 1, just return the innermost set of template arguments. */
589 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
591 /* If we're not removing anything, just return the arguments we were
593 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
594 gcc_assert (extra_levels
>= 0);
595 if (extra_levels
== 0)
598 /* Make a new set of arguments, not containing the outer arguments. */
599 new_args
= make_tree_vec (n
);
600 for (i
= 1; i
<= n
; ++i
)
601 SET_TMPL_ARGS_LEVEL (new_args
, i
,
602 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
607 /* The inverse of get_innermost_template_args: Return all but the innermost
608 EXTRA_LEVELS levels of template arguments from the ARGS. */
611 strip_innermost_template_args (tree args
, int extra_levels
)
614 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
619 /* If N is 1, just return the outermost set of template arguments. */
621 return TMPL_ARGS_LEVEL (args
, 1);
623 /* If we're not removing anything, just return the arguments we were
625 gcc_assert (extra_levels
>= 0);
626 if (extra_levels
== 0)
629 /* Make a new set of arguments, not containing the inner arguments. */
630 new_args
= make_tree_vec (n
);
631 for (i
= 1; i
<= n
; ++i
)
632 SET_TMPL_ARGS_LEVEL (new_args
, i
,
633 TMPL_ARGS_LEVEL (args
, i
));
638 /* We've got a template header coming up; push to a new level for storing
642 begin_template_parm_list (void)
644 /* We use a non-tag-transparent scope here, which causes pushtag to
645 put tags in this scope, rather than in the enclosing class or
646 namespace scope. This is the right thing, since we want
647 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
648 global template class, push_template_decl handles putting the
649 TEMPLATE_DECL into top-level scope. For a nested template class,
652 template <class T> struct S1 {
653 template <class T> struct S2 {};
656 pushtag contains special code to call pushdecl_with_scope on the
657 TEMPLATE_DECL for S2. */
658 begin_scope (sk_template_parms
, NULL
);
659 ++processing_template_decl
;
660 ++processing_template_parmlist
;
661 note_template_header (0);
664 /* This routine is called when a specialization is declared. If it is
665 invalid to declare a specialization here, an error is reported and
666 false is returned, otherwise this routine will return true. */
669 check_specialization_scope (void)
671 tree scope
= current_scope ();
675 An explicit specialization shall be declared in the namespace of
676 which the template is a member, or, for member templates, in the
677 namespace of which the enclosing class or enclosing class
678 template is a member. An explicit specialization of a member
679 function, member class or static data member of a class template
680 shall be declared in the namespace of which the class template
682 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
684 error ("explicit specialization in non-namespace scope %qD", scope
);
690 In an explicit specialization declaration for a member of a class
691 template or a member template that appears in namespace scope,
692 the member template and some of its enclosing class templates may
693 remain unspecialized, except that the declaration shall not
694 explicitly specialize a class member template if its enclosing
695 class templates are not explicitly specialized as well. */
696 if (current_template_parms
)
698 error ("enclosing class templates are not explicitly specialized");
705 /* We've just seen template <>. */
708 begin_specialization (void)
710 begin_scope (sk_template_spec
, NULL
);
711 note_template_header (1);
712 return check_specialization_scope ();
715 /* Called at then end of processing a declaration preceded by
719 end_specialization (void)
722 reset_specialization ();
725 /* Any template <>'s that we have seen thus far are not referring to a
726 function specialization. */
729 reset_specialization (void)
731 processing_specialization
= 0;
732 template_header_count
= 0;
735 /* We've just seen a template header. If SPECIALIZATION is nonzero,
736 it was of the form template <>. */
739 note_template_header (int specialization
)
741 processing_specialization
= specialization
;
742 template_header_count
++;
745 /* We're beginning an explicit instantiation. */
748 begin_explicit_instantiation (void)
750 gcc_assert (!processing_explicit_instantiation
);
751 processing_explicit_instantiation
= true;
756 end_explicit_instantiation (void)
758 gcc_assert (processing_explicit_instantiation
);
759 processing_explicit_instantiation
= false;
762 /* An explicit specialization or partial specialization of TMPL is being
763 declared. Check that the namespace in which the specialization is
764 occurring is permissible. Returns false iff it is invalid to
765 specialize TMPL in the current namespace. */
768 check_specialization_namespace (tree tmpl
)
770 tree tpl_ns
= decl_namespace_context (tmpl
);
774 An explicit specialization shall be declared in the namespace of
775 which the template is a member, or, for member templates, in the
776 namespace of which the enclosing class or enclosing class
777 template is a member. An explicit specialization of a member
778 function, member class or static data member of a class template
779 shall be declared in the namespace of which the class template is
781 if (current_scope() != DECL_CONTEXT (tmpl
)
782 && !at_namespace_scope_p ())
784 error ("specialization of %qD must appear at namespace scope", tmpl
);
787 if (is_associated_namespace (current_namespace
, tpl_ns
))
788 /* Same or super-using namespace. */
792 permerror (input_location
, "specialization of %qD in different namespace", tmpl
);
793 permerror (input_location
, " from definition of %q+#D", tmpl
);
798 /* SPEC is an explicit instantiation. Check that it is valid to
799 perform this explicit instantiation in the current namespace. */
802 check_explicit_instantiation_namespace (tree spec
)
806 /* DR 275: An explicit instantiation shall appear in an enclosing
807 namespace of its template. */
808 ns
= decl_namespace_context (spec
);
809 if (!is_ancestor (current_namespace
, ns
))
810 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
811 "(which does not enclose namespace %qD)",
812 spec
, current_namespace
, ns
);
815 /* The TYPE is being declared. If it is a template type, that means it
816 is a partial specialization. Do appropriate error-checking. */
819 maybe_process_partial_specialization (tree type
)
823 if (type
== error_mark_node
)
824 return error_mark_node
;
826 /* A lambda that appears in specialization context is not itself a
828 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
831 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
833 error ("name of class shadows template template parameter %qD",
835 return error_mark_node
;
838 context
= TYPE_CONTEXT (type
);
840 if (TYPE_ALIAS_P (type
))
842 if (TYPE_TEMPLATE_INFO (type
)
843 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type
)))
844 error ("specialization of alias template %qD",
845 TYPE_TI_TEMPLATE (type
));
847 error ("explicit specialization of non-template %qT", type
);
848 return error_mark_node
;
850 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
852 /* This is for ordinary explicit specialization and partial
853 specialization of a template class such as:
855 template <> class C<int>;
859 template <class T> class C<T*>;
861 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
863 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
864 && !COMPLETE_TYPE_P (type
))
866 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type
))
867 && !at_namespace_scope_p ())
868 return error_mark_node
;
869 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
870 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
871 if (processing_template_decl
)
873 if (push_template_decl (TYPE_MAIN_DECL (type
))
875 return error_mark_node
;
878 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
879 error ("specialization of %qT after instantiation", type
);
880 else if (errorcount
&& !processing_specialization
881 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
882 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
883 /* Trying to define a specialization either without a template<> header
884 or in an inappropriate place. We've already given an error, so just
885 bail now so we don't actually define the specialization. */
886 return error_mark_node
;
888 else if (CLASS_TYPE_P (type
)
889 && !CLASSTYPE_USE_TEMPLATE (type
)
890 && CLASSTYPE_TEMPLATE_INFO (type
)
891 && context
&& CLASS_TYPE_P (context
)
892 && CLASSTYPE_TEMPLATE_INFO (context
))
894 /* This is for an explicit specialization of member class
895 template according to [temp.expl.spec/18]:
897 template <> template <class U> class C<int>::D;
899 The context `C<int>' must be an implicit instantiation.
900 Otherwise this is just a member class template declared
903 template <> class C<int> { template <class U> class D; };
904 template <> template <class U> class C<int>::D;
906 In the first case, `C<int>::D' is a specialization of `C<T>::D'
907 while in the second case, `C<int>::D' is a primary template
908 and `C<T>::D' may not exist. */
910 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
911 && !COMPLETE_TYPE_P (type
))
914 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
916 if (current_namespace
917 != decl_namespace_context (tmpl
))
919 permerror (input_location
, "specializing %q#T in different namespace", type
);
920 permerror (input_location
, " from definition of %q+#D", tmpl
);
923 /* Check for invalid specialization after instantiation:
925 template <> template <> class C<int>::D<int>;
926 template <> template <class U> class C<int>::D; */
928 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
929 t
; t
= TREE_CHAIN (t
))
931 tree inst
= TREE_VALUE (t
);
932 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
933 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
935 /* We already have a full specialization of this partial
936 instantiation, or a full specialization has been
937 looked up but not instantiated. Reassign it to the
938 new member specialization template. */
942 elt
.tmpl
= most_general_template (tmpl
);
943 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
946 type_specializations
->remove_elt (&elt
);
949 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
952 = type_specializations
->find_slot (&elt
, INSERT
);
953 entry
= ggc_alloc
<spec_entry
> ();
958 /* But if we've had an implicit instantiation, that's a
959 problem ([temp.expl.spec]/6). */
960 error ("specialization %qT after instantiation %qT",
964 /* Mark TYPE as a specialization. And as a result, we only
965 have one level of template argument for the innermost
967 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
968 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
969 CLASSTYPE_TI_ARGS (type
)
970 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
973 else if (processing_specialization
)
975 /* Someday C++0x may allow for enum template specialization. */
976 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
977 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
978 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
979 "of %qD not allowed by ISO C++", type
);
982 error ("explicit specialization of non-template %qT", type
);
983 return error_mark_node
;
990 /* Returns nonzero if we can optimize the retrieval of specializations
991 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
992 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
995 optimize_specialization_lookup_p (tree tmpl
)
997 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
998 && DECL_CLASS_SCOPE_P (tmpl
)
999 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1001 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1002 /* The optimized lookup depends on the fact that the
1003 template arguments for the member function template apply
1004 purely to the containing class, which is not true if the
1005 containing class is an explicit or partial
1007 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1008 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1009 && !DECL_CONV_FN_P (tmpl
)
1010 /* It is possible to have a template that is not a member
1011 template and is not a member of a template class:
1013 template <typename T>
1014 struct S { friend A::f(); };
1016 Here, the friend function is a template, but the context does
1017 not have template information. The optimized lookup relies
1018 on having ARGS be the template arguments for both the class
1019 and the function template. */
1020 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1023 /* Retrieve the specialization (in the sense of [temp.spec] - a
1024 specialization is either an instantiation or an explicit
1025 specialization) of TMPL for the given template ARGS. If there is
1026 no such specialization, return NULL_TREE. The ARGS are a vector of
1027 arguments, or a vector of vectors of arguments, in the case of
1028 templates with more than one level of parameters.
1030 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1031 then we search for a partial specialization matching ARGS. This
1032 parameter is ignored if TMPL is not a class template.
1034 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1035 result is a NONTYPE_ARGUMENT_PACK. */
1038 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1040 if (tmpl
== NULL_TREE
)
1043 if (args
== error_mark_node
)
1046 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1047 || TREE_CODE (tmpl
) == FIELD_DECL
);
1049 /* There should be as many levels of arguments as there are
1050 levels of parameters. */
1051 gcc_assert (TMPL_ARGS_DEPTH (args
)
1052 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1053 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1054 : template_class_depth (DECL_CONTEXT (tmpl
))));
1056 #ifdef ENABLE_CHECKING
1057 /* We should have gone through coerce_template_parms by now. */
1058 ++processing_template_decl
;
1059 if (!any_dependent_template_arguments_p (args
))
1060 gcc_assert (strip_typedefs_expr (args
, NULL
) == args
);
1061 --processing_template_decl
;
1064 if (optimize_specialization_lookup_p (tmpl
))
1066 tree class_template
;
1067 tree class_specialization
;
1068 vec
<tree
, va_gc
> *methods
;
1072 /* The template arguments actually apply to the containing
1073 class. Find the class specialization with those
1075 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1076 class_specialization
1077 = retrieve_specialization (class_template
, args
, 0);
1078 if (!class_specialization
)
1080 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1081 for the specialization. */
1082 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
1085 /* Iterate through the methods with the indicated name, looking
1086 for the one that has an instance of TMPL. */
1087 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
1088 for (fns
= (*methods
)[idx
]; fns
; fns
= OVL_NEXT (fns
))
1090 tree fn
= OVL_CURRENT (fns
);
1091 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1092 /* using-declarations can add base methods to the method vec,
1093 and we don't want those here. */
1094 && DECL_CONTEXT (fn
) == class_specialization
)
1103 hash_table
<spec_hasher
> *specializations
;
1107 elt
.spec
= NULL_TREE
;
1109 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1110 specializations
= type_specializations
;
1112 specializations
= decl_specializations
;
1115 hash
= spec_hasher::hash (&elt
);
1116 found
= specializations
->find_with_hash (&elt
, hash
);
1124 /* Like retrieve_specialization, but for local declarations. */
1127 retrieve_local_specialization (tree tmpl
)
1129 if (local_specializations
== NULL
)
1132 tree
*slot
= local_specializations
->get (tmpl
);
1133 return slot
? *slot
: NULL_TREE
;
1136 /* Returns nonzero iff DECL is a specialization of TMPL. */
1139 is_specialization_of (tree decl
, tree tmpl
)
1143 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1147 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1153 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1155 for (t
= TREE_TYPE (decl
);
1157 t
= CLASSTYPE_USE_TEMPLATE (t
)
1158 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1159 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1166 /* Returns nonzero iff DECL is a specialization of friend declaration
1167 FRIEND_DECL according to [temp.friend]. */
1170 is_specialization_of_friend (tree decl
, tree friend_decl
)
1172 bool need_template
= true;
1175 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1176 || TREE_CODE (decl
) == TYPE_DECL
);
1178 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1179 of a template class, we want to check if DECL is a specialization
1181 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1182 && DECL_TEMPLATE_INFO (friend_decl
)
1183 && !DECL_USE_TEMPLATE (friend_decl
))
1185 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1186 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1187 need_template
= false;
1189 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1190 && !PRIMARY_TEMPLATE_P (friend_decl
))
1191 need_template
= false;
1193 /* There is nothing to do if this is not a template friend. */
1194 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1197 if (is_specialization_of (decl
, friend_decl
))
1201 A member of a class template may be declared to be a friend of a
1202 non-template class. In this case, the corresponding member of
1203 every specialization of the class template is a friend of the
1204 class granting friendship.
1206 For example, given a template friend declaration
1208 template <class T> friend void A<T>::f();
1210 the member function below is considered a friend
1212 template <> struct A<int> {
1216 For this type of template friend, TEMPLATE_DEPTH below will be
1217 nonzero. To determine if DECL is a friend of FRIEND, we first
1218 check if the enclosing class is a specialization of another. */
1220 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1222 && DECL_CLASS_SCOPE_P (decl
)
1223 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1224 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1226 /* Next, we check the members themselves. In order to handle
1227 a few tricky cases, such as when FRIEND_DECL's are
1229 template <class T> friend void A<T>::g(T t);
1230 template <class T> template <T t> friend void A<T>::h();
1234 void A<int>::g(int);
1235 template <int> void A<int>::h();
1237 we need to figure out ARGS, the template arguments from
1238 the context of DECL. This is required for template substitution
1239 of `T' in the function parameter of `g' and template parameter
1240 of `h' in the above examples. Here ARGS corresponds to `int'. */
1242 tree context
= DECL_CONTEXT (decl
);
1243 tree args
= NULL_TREE
;
1244 int current_depth
= 0;
1246 while (current_depth
< template_depth
)
1248 if (CLASSTYPE_TEMPLATE_INFO (context
))
1250 if (current_depth
== 0)
1251 args
= TYPE_TI_ARGS (context
);
1253 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1256 context
= TYPE_CONTEXT (context
);
1259 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1264 tree friend_args_type
;
1265 tree decl_args_type
;
1267 /* Make sure that both DECL and FRIEND_DECL are templates or
1269 is_template
= DECL_TEMPLATE_INFO (decl
)
1270 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1271 if (need_template
^ is_template
)
1273 else if (is_template
)
1275 /* If both are templates, check template parameter list. */
1277 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1279 if (!comp_template_parms
1280 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1284 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1287 decl_type
= TREE_TYPE (decl
);
1289 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1290 tf_none
, NULL_TREE
);
1291 if (friend_type
== error_mark_node
)
1294 /* Check if return types match. */
1295 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1298 /* Check if function parameter types match, ignoring the
1299 `this' parameter. */
1300 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1301 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1302 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1303 friend_args_type
= TREE_CHAIN (friend_args_type
);
1304 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1305 decl_args_type
= TREE_CHAIN (decl_args_type
);
1307 return compparms (decl_args_type
, friend_args_type
);
1311 /* DECL is a TYPE_DECL */
1313 tree decl_type
= TREE_TYPE (decl
);
1315 /* Make sure that both DECL and FRIEND_DECL are templates or
1318 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1319 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1321 if (need_template
^ is_template
)
1323 else if (is_template
)
1326 /* If both are templates, check the name of the two
1327 TEMPLATE_DECL's first because is_friend didn't. */
1328 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1329 != DECL_NAME (friend_decl
))
1332 /* Now check template parameter list. */
1334 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1336 return comp_template_parms
1337 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1341 return (DECL_NAME (decl
)
1342 == DECL_NAME (friend_decl
));
1348 /* Register the specialization SPEC as a specialization of TMPL with
1349 the indicated ARGS. IS_FRIEND indicates whether the specialization
1350 is actually just a friend declaration. Returns SPEC, or an
1351 equivalent prior declaration, if available.
1353 We also store instantiations of field packs in the hash table, even
1354 though they are not themselves templates, to make lookup easier. */
1357 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1361 spec_entry
**slot
= NULL
;
1364 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1365 || (TREE_CODE (tmpl
) == FIELD_DECL
1366 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1368 if (TREE_CODE (spec
) == FUNCTION_DECL
1369 && uses_template_parms (DECL_TI_ARGS (spec
)))
1370 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1371 register it; we want the corresponding TEMPLATE_DECL instead.
1372 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1373 the more obvious `uses_template_parms (spec)' to avoid problems
1374 with default function arguments. In particular, given
1375 something like this:
1377 template <class T> void f(T t1, T t = T())
1379 the default argument expression is not substituted for in an
1380 instantiation unless and until it is actually needed. */
1383 if (optimize_specialization_lookup_p (tmpl
))
1384 /* We don't put these specializations in the hash table, but we might
1385 want to give an error about a mismatch. */
1386 fn
= retrieve_specialization (tmpl
, args
, 0);
1394 hash
= spec_hasher::hash (&elt
);
1397 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1399 fn
= ((spec_entry
*) *slot
)->spec
;
1404 /* We can sometimes try to re-register a specialization that we've
1405 already got. In particular, regenerate_decl_from_template calls
1406 duplicate_decls which will update the specialization list. But,
1407 we'll still get called again here anyhow. It's more convenient
1408 to simply allow this than to try to prevent it. */
1411 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1413 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1415 if (DECL_ODR_USED (fn
)
1416 || DECL_EXPLICIT_INSTANTIATION (fn
))
1418 error ("specialization of %qD after instantiation",
1420 return error_mark_node
;
1425 /* This situation should occur only if the first
1426 specialization is an implicit instantiation, the
1427 second is an explicit specialization, and the
1428 implicit instantiation has not yet been used. That
1429 situation can occur if we have implicitly
1430 instantiated a member function and then specialized
1433 We can also wind up here if a friend declaration that
1434 looked like an instantiation turns out to be a
1437 template <class T> void foo(T);
1438 class S { friend void foo<>(int) };
1439 template <> void foo(int);
1441 We transform the existing DECL in place so that any
1442 pointers to it become pointers to the updated
1445 If there was a definition for the template, but not
1446 for the specialization, we want this to look as if
1447 there were no definition, and vice versa. */
1448 DECL_INITIAL (fn
) = NULL_TREE
;
1449 duplicate_decls (spec
, fn
, is_friend
);
1450 /* The call to duplicate_decls will have applied
1453 An explicit specialization of a function template
1454 is inline only if it is explicitly declared to be,
1455 and independently of whether its function template
1458 to the primary function; now copy the inline bits to
1459 the various clones. */
1460 FOR_EACH_CLONE (clone
, fn
)
1462 DECL_DECLARED_INLINE_P (clone
)
1463 = DECL_DECLARED_INLINE_P (fn
);
1464 DECL_SOURCE_LOCATION (clone
)
1465 = DECL_SOURCE_LOCATION (fn
);
1466 DECL_DELETED_FN (clone
)
1467 = DECL_DELETED_FN (fn
);
1469 check_specialization_namespace (tmpl
);
1474 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1476 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1477 /* Dup decl failed, but this is a new definition. Set the
1478 line number so any errors match this new
1480 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1486 return duplicate_decls (spec
, fn
, is_friend
);
1488 /* A specialization must be declared in the same namespace as the
1489 template it is specializing. */
1490 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1491 && !check_specialization_namespace (tmpl
))
1492 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1494 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1496 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1497 gcc_assert (tmpl
&& args
&& spec
);
1500 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1501 && PRIMARY_TEMPLATE_P (tmpl
)
1502 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1503 || variable_template_p (tmpl
))
1504 /* If TMPL is a forward declaration of a template function, keep a list
1505 of all specializations in case we need to reassign them to a friend
1506 template later in tsubst_friend_function.
1508 Also keep a list of all variable template instantiations so that
1509 process_partial_specialization can check whether a later partial
1510 specialization would have used it. */
1511 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1512 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1518 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1519 TMPL and ARGS members, ignores SPEC. */
1521 int comparing_specializations
;
1524 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1528 ++comparing_specializations
;
1529 equal
= (e1
->tmpl
== e2
->tmpl
1530 && comp_template_args (e1
->args
, e2
->args
));
1531 --comparing_specializations
;
1536 /* Returns a hash for a template TMPL and template arguments ARGS. */
1539 hash_tmpl_and_args (tree tmpl
, tree args
)
1541 hashval_t val
= DECL_UID (tmpl
);
1542 return iterative_hash_template_arg (args
, val
);
1545 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1549 spec_hasher::hash (spec_entry
*e
)
1551 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1554 /* Recursively calculate a hash value for a template argument ARG, for use
1555 in the hash tables of template specializations. */
1558 iterative_hash_template_arg (tree arg
, hashval_t val
)
1560 unsigned HOST_WIDE_INT i
;
1561 enum tree_code code
;
1564 if (arg
== NULL_TREE
)
1565 return iterative_hash_object (arg
, val
);
1570 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1571 /* We can get one of these when re-hashing a previous entry in the middle
1572 of substituting into a pack expansion. Just look through it. */
1573 arg
= ARGUMENT_PACK_SELECT_FROM_PACK (arg
);
1575 code
= TREE_CODE (arg
);
1576 tclass
= TREE_CODE_CLASS (code
);
1578 val
= iterative_hash_object (code
, val
);
1585 case IDENTIFIER_NODE
:
1586 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1590 int i
, len
= TREE_VEC_LENGTH (arg
);
1591 for (i
= 0; i
< len
; ++i
)
1592 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1596 case TYPE_PACK_EXPANSION
:
1597 case EXPR_PACK_EXPANSION
:
1598 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1599 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1601 case TYPE_ARGUMENT_PACK
:
1602 case NONTYPE_ARGUMENT_PACK
:
1603 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1606 for (; arg
; arg
= TREE_CHAIN (arg
))
1607 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1611 for (; arg
; arg
= OVL_NEXT (arg
))
1612 val
= iterative_hash_template_arg (OVL_CURRENT (arg
), val
);
1618 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1619 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1621 val
= iterative_hash_template_arg (field
, val
);
1622 val
= iterative_hash_template_arg (value
, val
);
1628 if (!DECL_ARTIFICIAL (arg
))
1630 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1631 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1633 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1636 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1639 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1640 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1642 case TEMPLATE_PARM_INDEX
:
1643 val
= iterative_hash_template_arg
1644 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1645 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1646 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1649 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1650 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1651 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1654 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1656 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1660 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1661 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1662 val
= iterative_hash_object (code
, val
);
1663 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1666 /* A lambda can't appear in a template arg, but don't crash on
1668 gcc_assert (seen_error ());
1672 case IMPLICIT_CONV_EXPR
:
1673 case STATIC_CAST_EXPR
:
1674 case REINTERPRET_CAST_EXPR
:
1675 case CONST_CAST_EXPR
:
1676 case DYNAMIC_CAST_EXPR
:
1678 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1679 /* Now hash operands as usual. */
1689 if (alias_template_specialization_p (arg
))
1691 // We want an alias specialization that survived strip_typedefs
1692 // to hash differently from its TYPE_CANONICAL, to avoid hash
1693 // collisions that compare as different in template_args_equal.
1694 // These could be dependent specializations that strip_typedefs
1695 // left alone, or untouched specializations because
1696 // coerce_template_parms returns the unconverted template
1697 // arguments if it sees incomplete argument packs.
1698 tree ti
= TYPE_TEMPLATE_INFO (arg
);
1699 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1701 if (TYPE_CANONICAL (arg
))
1702 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1704 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1705 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1706 /* Otherwise just compare the types during lookup. */
1709 case tcc_declaration
:
1711 return iterative_hash_expr (arg
, val
);
1714 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1716 unsigned n
= cp_tree_operand_length (arg
);
1717 for (i
= 0; i
< n
; ++i
)
1718 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1726 /* Unregister the specialization SPEC as a specialization of TMPL.
1727 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1728 if the SPEC was listed as a specialization of TMPL.
1730 Note that SPEC has been ggc_freed, so we can't look inside it. */
1733 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1738 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1739 elt
.args
= TI_ARGS (tinfo
);
1740 elt
.spec
= NULL_TREE
;
1742 entry
= decl_specializations
->find (&elt
);
1745 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1746 gcc_assert (new_spec
!= NULL_TREE
);
1747 entry
->spec
= new_spec
;
1754 /* Like register_specialization, but for local declarations. We are
1755 registering SPEC, an instantiation of TMPL. */
1758 register_local_specialization (tree spec
, tree tmpl
)
1760 local_specializations
->put (tmpl
, spec
);
1763 /* TYPE is a class type. Returns true if TYPE is an explicitly
1764 specialized class. */
1767 explicit_class_specialization_p (tree type
)
1769 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1771 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1774 /* Print the list of functions at FNS, going through all the overloads
1775 for each element of the list. Alternatively, FNS can not be a
1776 TREE_LIST, in which case it will be printed together with all the
1779 MORE and *STR should respectively be FALSE and NULL when the function
1780 is called from the outside. They are used internally on recursive
1781 calls. print_candidates manages the two parameters and leaves NULL
1782 in *STR when it ends. */
1785 print_candidates_1 (tree fns
, bool more
, const char **str
)
1788 char *spaces
= NULL
;
1790 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
1791 if (TREE_CODE (fn
) == TREE_LIST
)
1793 for (fn2
= fn
; fn2
!= NULL_TREE
; fn2
= TREE_CHAIN (fn2
))
1794 print_candidates_1 (TREE_VALUE (fn2
),
1795 TREE_CHAIN (fn2
) || more
, str
);
1799 tree cand
= OVL_CURRENT (fn
);
1802 /* Pick the prefix string. */
1803 if (!more
&& !OVL_NEXT (fns
))
1805 inform (DECL_SOURCE_LOCATION (cand
),
1806 "candidate is: %#D", cand
);
1810 *str
= _("candidates are:");
1811 spaces
= get_spaces (*str
);
1813 inform (DECL_SOURCE_LOCATION (cand
), "%s %#D", *str
, cand
);
1814 *str
= spaces
? spaces
: *str
;
1824 /* Print the list of candidate FNS in an error message. FNS can also
1825 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1828 print_candidates (tree fns
)
1830 const char *str
= NULL
;
1831 print_candidates_1 (fns
, false, &str
);
1832 gcc_assert (str
== NULL
);
1835 /* Returns the template (one of the functions given by TEMPLATE_ID)
1836 which can be specialized to match the indicated DECL with the
1837 explicit template args given in TEMPLATE_ID. The DECL may be
1838 NULL_TREE if none is available. In that case, the functions in
1839 TEMPLATE_ID are non-members.
1841 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1842 specialization of a member template.
1844 The TEMPLATE_COUNT is the number of references to qualifying
1845 template classes that appeared in the name of the function. See
1846 check_explicit_specialization for a more accurate description.
1848 TSK indicates what kind of template declaration (if any) is being
1849 declared. TSK_TEMPLATE indicates that the declaration given by
1850 DECL, though a FUNCTION_DECL, has template parameters, and is
1851 therefore a template function.
1853 The template args (those explicitly specified and those deduced)
1854 are output in a newly created vector *TARGS_OUT.
1856 If it is impossible to determine the result, an error message is
1857 issued. The error_mark_node is returned to indicate failure. */
1860 determine_specialization (tree template_id
,
1863 int need_member_template
,
1869 tree explicit_targs
;
1870 tree candidates
= NULL_TREE
;
1871 /* A TREE_LIST of templates of which DECL may be a specialization.
1872 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1873 corresponding TREE_PURPOSE is the set of template arguments that,
1874 when used to instantiate the template, would produce a function
1875 with the signature of DECL. */
1876 tree templates
= NULL_TREE
;
1878 cp_binding_level
*b
;
1880 *targs_out
= NULL_TREE
;
1882 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
1883 return error_mark_node
;
1885 /* We shouldn't be specializing a member template of an
1886 unspecialized class template; we already gave an error in
1887 check_specialization_scope, now avoid crashing. */
1888 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
1889 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
1891 gcc_assert (errorcount
);
1892 return error_mark_node
;
1895 fns
= TREE_OPERAND (template_id
, 0);
1896 explicit_targs
= TREE_OPERAND (template_id
, 1);
1898 if (fns
== error_mark_node
)
1899 return error_mark_node
;
1901 /* Check for baselinks. */
1902 if (BASELINK_P (fns
))
1903 fns
= BASELINK_FUNCTIONS (fns
);
1905 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
1907 error ("%qD is not a function template", fns
);
1908 return error_mark_node
;
1910 else if (VAR_P (decl
) && !variable_template_p (fns
))
1912 error ("%qD is not a variable template", fns
);
1913 return error_mark_node
;
1916 /* Count the number of template headers specified for this
1919 for (b
= current_binding_level
;
1920 b
->kind
== sk_template_parms
;
1924 if (variable_template_p (fns
))
1926 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
1927 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
1928 tf_warning_or_error
,
1929 /*req_all*/true, /*use_defarg*/true);
1930 templates
= tree_cons (targs
, fns
, templates
);
1932 else for (; fns
; fns
= OVL_NEXT (fns
))
1934 tree fn
= OVL_CURRENT (fns
);
1936 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1938 tree decl_arg_types
;
1942 /* In case of explicit specialization, we need to check if
1943 the number of template headers appearing in the specialization
1944 is correct. This is usually done in check_explicit_specialization,
1945 but the check done there cannot be exhaustive when specializing
1946 member functions. Consider the following code:
1948 template <> void A<int>::f(int);
1949 template <> template <> void A<int>::f(int);
1951 Assuming that A<int> is not itself an explicit specialization
1952 already, the first line specializes "f" which is a non-template
1953 member function, whilst the second line specializes "f" which
1954 is a template member function. So both lines are syntactically
1955 correct, and check_explicit_specialization does not reject
1958 Here, we can do better, as we are matching the specialization
1959 against the declarations. We count the number of template
1960 headers, and we check if they match TEMPLATE_COUNT + 1
1961 (TEMPLATE_COUNT is the number of qualifying template classes,
1962 plus there must be another header for the member template
1965 Notice that if header_count is zero, this is not a
1966 specialization but rather a template instantiation, so there
1967 is no check we can perform here. */
1968 if (header_count
&& header_count
!= template_count
+ 1)
1971 /* Check that the number of template arguments at the
1972 innermost level for DECL is the same as for FN. */
1973 if (current_binding_level
->kind
== sk_template_parms
1974 && !current_binding_level
->explicit_spec_p
1975 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
1976 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1977 (current_template_parms
))))
1980 /* DECL might be a specialization of FN. */
1981 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1982 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1984 /* For a non-static member function, we need to make sure
1985 that the const qualification is the same. Since
1986 get_bindings does not try to merge the "this" parameter,
1987 we must do the comparison explicitly. */
1988 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1989 && !same_type_p (TREE_VALUE (fn_arg_types
),
1990 TREE_VALUE (decl_arg_types
)))
1993 /* Skip the "this" parameter and, for constructors of
1994 classes with virtual bases, the VTT parameter. A
1995 full specialization of a constructor will have a VTT
1996 parameter, but a template never will. */
1998 = skip_artificial_parms_for (decl
, decl_arg_types
);
2000 = skip_artificial_parms_for (fn
, fn_arg_types
);
2002 /* Function templates cannot be specializations; there are
2003 no partial specializations of functions. Therefore, if
2004 the type of DECL does not match FN, there is no
2006 if (tsk
== tsk_template
)
2008 if (compparms (fn_arg_types
, decl_arg_types
))
2009 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2013 /* See whether this function might be a specialization of this
2014 template. Suppress access control because we might be trying
2015 to make this specialization a friend, and we have already done
2016 access control for the declaration of the specialization. */
2017 push_deferring_access_checks (dk_no_check
);
2018 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2019 pop_deferring_access_checks ();
2022 /* We cannot deduce template arguments that when used to
2023 specialize TMPL will produce DECL. */
2026 /* Make sure that the deduced arguments actually work. */
2027 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
);
2028 if (insttype
== error_mark_node
)
2031 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2032 if (!compparms (fn_arg_types
, decl_arg_types
))
2035 /* Save this template, and the arguments deduced. */
2036 templates
= tree_cons (targs
, fn
, templates
);
2038 else if (need_member_template
)
2039 /* FN is an ordinary member function, and we need a
2040 specialization of a member template. */
2042 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2043 /* We can get IDENTIFIER_NODEs here in certain erroneous
2046 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2047 /* This is just an ordinary non-member function. Nothing can
2048 be a specialization of that. */
2050 else if (DECL_ARTIFICIAL (fn
))
2051 /* Cannot specialize functions that are created implicitly. */
2055 tree decl_arg_types
;
2057 /* This is an ordinary member function. However, since
2058 we're here, we can assume its enclosing class is a
2059 template class. For example,
2061 template <typename T> struct S { void f(); };
2062 template <> void S<int>::f() {}
2064 Here, S<int>::f is a non-template, but S<int> is a
2065 template class. If FN has the same type as DECL, we
2066 might be in business. */
2068 if (!DECL_TEMPLATE_INFO (fn
))
2069 /* Its enclosing class is an explicit specialization
2070 of a template class. This is not a candidate. */
2073 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2074 TREE_TYPE (TREE_TYPE (fn
))))
2075 /* The return types differ. */
2078 /* Adjust the type of DECL in case FN is a static member. */
2079 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2080 if (DECL_STATIC_FUNCTION_P (fn
)
2081 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2082 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2084 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2087 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2091 if (templates
&& TREE_CHAIN (templates
))
2097 It is possible for a specialization with a given function
2098 signature to be instantiated from more than one function
2099 template. In such cases, explicit specification of the
2100 template arguments must be used to uniquely identify the
2101 function template specialization being specialized.
2103 Note that here, there's no suggestion that we're supposed to
2104 determine which of the candidate templates is most
2105 specialized. However, we, also have:
2109 Partial ordering of overloaded function template
2110 declarations is used in the following contexts to select
2111 the function template to which a function template
2112 specialization refers:
2114 -- when an explicit specialization refers to a function
2117 So, we do use the partial ordering rules, at least for now.
2118 This extension can only serve to make invalid programs valid,
2119 so it's safe. And, there is strong anecdotal evidence that
2120 the committee intended the partial ordering rules to apply;
2121 the EDG front end has that behavior, and John Spicer claims
2122 that the committee simply forgot to delete the wording in
2123 [temp.expl.spec]. */
2124 tree tmpl
= most_specialized_instantiation (templates
);
2125 if (tmpl
!= error_mark_node
)
2128 TREE_CHAIN (templates
) = NULL_TREE
;
2132 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2134 error ("template-id %qD for %q+D does not match any template "
2135 "declaration", template_id
, decl
);
2136 if (header_count
&& header_count
!= template_count
+ 1)
2137 inform (input_location
, "saw %d %<template<>%>, need %d for "
2138 "specializing a member function template",
2139 header_count
, template_count
+ 1);
2140 return error_mark_node
;
2142 else if ((templates
&& TREE_CHAIN (templates
))
2143 || (candidates
&& TREE_CHAIN (candidates
))
2144 || (templates
&& candidates
))
2146 error ("ambiguous template specialization %qD for %q+D",
2148 candidates
= chainon (candidates
, templates
);
2149 print_candidates (candidates
);
2150 return error_mark_node
;
2153 /* We have one, and exactly one, match. */
2156 tree fn
= TREE_VALUE (candidates
);
2157 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2158 /* DECL is a re-declaration or partial instantiation of a template
2160 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2162 /* It was a specialization of an ordinary member function in a
2164 return DECL_TI_TEMPLATE (fn
);
2167 /* It was a specialization of a template. */
2168 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2169 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2171 *targs_out
= copy_node (targs
);
2172 SET_TMPL_ARGS_LEVEL (*targs_out
,
2173 TMPL_ARGS_DEPTH (*targs_out
),
2174 TREE_PURPOSE (templates
));
2177 *targs_out
= TREE_PURPOSE (templates
);
2178 return TREE_VALUE (templates
);
2181 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2182 but with the default argument values filled in from those in the
2186 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2189 tree new_spec_types
;
2194 if (spec_types
== void_list_node
)
2195 return void_list_node
;
2197 /* Substitute into the rest of the list. */
2199 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2200 TREE_CHAIN (tmpl_types
));
2202 /* Add the default argument for this parameter. */
2203 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2204 TREE_VALUE (spec_types
),
2208 /* DECL is an explicit specialization. Replicate default arguments
2209 from the template it specializes. (That way, code like:
2211 template <class T> void f(T = 3);
2212 template <> void f(double);
2215 works, as required.) An alternative approach would be to look up
2216 the correct default arguments at the call-site, but this approach
2217 is consistent with how implicit instantiations are handled. */
2220 copy_default_args_to_explicit_spec (tree decl
)
2225 tree new_spec_types
;
2229 tree object_type
= NULL_TREE
;
2230 tree in_charge
= NULL_TREE
;
2231 tree vtt
= NULL_TREE
;
2233 /* See if there's anything we need to do. */
2234 tmpl
= DECL_TI_TEMPLATE (decl
);
2235 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2236 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2237 if (TREE_PURPOSE (t
))
2242 old_type
= TREE_TYPE (decl
);
2243 spec_types
= TYPE_ARG_TYPES (old_type
);
2245 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2247 /* Remove the this pointer, but remember the object's type for
2249 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2250 spec_types
= TREE_CHAIN (spec_types
);
2251 tmpl_types
= TREE_CHAIN (tmpl_types
);
2253 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2255 /* DECL may contain more parameters than TMPL due to the extra
2256 in-charge parameter in constructors and destructors. */
2257 in_charge
= spec_types
;
2258 spec_types
= TREE_CHAIN (spec_types
);
2260 if (DECL_HAS_VTT_PARM_P (decl
))
2263 spec_types
= TREE_CHAIN (spec_types
);
2267 /* Compute the merged default arguments. */
2269 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2271 /* Compute the new FUNCTION_TYPE. */
2275 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2280 /* Put the in-charge parameter back. */
2281 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2282 TREE_VALUE (in_charge
),
2285 new_type
= build_method_type_directly (object_type
,
2286 TREE_TYPE (old_type
),
2290 new_type
= build_function_type (TREE_TYPE (old_type
),
2292 new_type
= cp_build_type_attribute_variant (new_type
,
2293 TYPE_ATTRIBUTES (old_type
));
2294 new_type
= build_exception_variant (new_type
,
2295 TYPE_RAISES_EXCEPTIONS (old_type
));
2297 if (TYPE_HAS_LATE_RETURN_TYPE (old_type
))
2298 TYPE_HAS_LATE_RETURN_TYPE (new_type
) = 1;
2300 TREE_TYPE (decl
) = new_type
;
2303 /* Return the number of template headers we expect to see for a definition
2304 or specialization of CTYPE or one of its non-template members. */
2307 num_template_headers_for_class (tree ctype
)
2309 int num_templates
= 0;
2311 while (ctype
&& CLASS_TYPE_P (ctype
))
2313 /* You're supposed to have one `template <...>' for every
2314 template class, but you don't need one for a full
2315 specialization. For example:
2317 template <class T> struct S{};
2318 template <> struct S<int> { void f(); };
2319 void S<int>::f () {}
2321 is correct; there shouldn't be a `template <>' for the
2322 definition of `S<int>::f'. */
2323 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2324 /* If CTYPE does not have template information of any
2325 kind, then it is not a template, nor is it nested
2326 within a template. */
2328 if (explicit_class_specialization_p (ctype
))
2330 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2333 ctype
= TYPE_CONTEXT (ctype
);
2336 return num_templates
;
2339 /* Do a simple sanity check on the template headers that precede the
2340 variable declaration DECL. */
2343 check_template_variable (tree decl
)
2345 tree ctx
= CP_DECL_CONTEXT (decl
);
2346 int wanted
= num_template_headers_for_class (ctx
);
2347 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2348 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2350 if (cxx_dialect
< cxx14
)
2351 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2352 "variable templates only available with "
2353 "-std=c++14 or -std=gnu++14");
2355 // Namespace-scope variable templates should have a template header.
2358 if (template_header_count
> wanted
)
2360 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2361 "too many template headers for %D (should be %d)",
2363 if (warned
&& CLASS_TYPE_P (ctx
)
2364 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2365 inform (DECL_SOURCE_LOCATION (decl
),
2366 "members of an explicitly specialized class are defined "
2367 "without a template header");
2371 /* Check to see if the function just declared, as indicated in
2372 DECLARATOR, and in DECL, is a specialization of a function
2373 template. We may also discover that the declaration is an explicit
2374 instantiation at this point.
2376 Returns DECL, or an equivalent declaration that should be used
2377 instead if all goes well. Issues an error message if something is
2378 amiss. Returns error_mark_node if the error is not easily
2381 FLAGS is a bitmask consisting of the following flags:
2383 2: The function has a definition.
2384 4: The function is a friend.
2386 The TEMPLATE_COUNT is the number of references to qualifying
2387 template classes that appeared in the name of the function. For
2390 template <class T> struct S { void f(); };
2393 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2394 classes are not counted in the TEMPLATE_COUNT, so that in
2396 template <class T> struct S {};
2397 template <> struct S<int> { void f(); }
2398 template <> void S<int>::f();
2400 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2401 invalid; there should be no template <>.)
2403 If the function is a specialization, it is marked as such via
2404 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2405 is set up correctly, and it is added to the list of specializations
2406 for that template. */
2409 check_explicit_specialization (tree declarator
,
2414 int have_def
= flags
& 2;
2415 int is_friend
= flags
& 4;
2416 int specialization
= 0;
2417 int explicit_instantiation
= 0;
2418 int member_specialization
= 0;
2419 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2420 tree dname
= DECL_NAME (decl
);
2425 if (!processing_specialization
)
2428 tsk
= tsk_excessive_parms
;
2431 tsk
= current_tmpl_spec_kind (template_count
);
2436 if (processing_specialization
&& TREE_CODE (decl
) != VAR_DECL
)
2439 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2441 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2444 /* This could be something like:
2446 template <class T> void f(T);
2447 class S { friend void f<>(int); } */
2451 /* This case handles bogus declarations like template <>
2452 template <class T> void f<int>(); */
2454 error ("template-id %qD in declaration of primary template",
2461 case tsk_invalid_member_spec
:
2462 /* The error has already been reported in
2463 check_specialization_scope. */
2464 return error_mark_node
;
2466 case tsk_invalid_expl_inst
:
2467 error ("template parameter list used in explicit instantiation");
2473 error ("definition provided for explicit instantiation");
2475 explicit_instantiation
= 1;
2478 case tsk_excessive_parms
:
2479 case tsk_insufficient_parms
:
2480 if (tsk
== tsk_excessive_parms
)
2481 error ("too many template parameter lists in declaration of %qD",
2483 else if (template_header_count
)
2484 error("too few template parameter lists in declaration of %qD", decl
);
2486 error("explicit specialization of %qD must be introduced by "
2487 "%<template <>%>", decl
);
2491 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2492 /* In cases like template<> constexpr bool v = true;
2493 We'll give an error in check_template_variable. */
2496 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2498 member_specialization
= 1;
2504 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2506 /* This case handles bogus declarations like template <>
2507 template <class T> void f<int>(); */
2509 if (!uses_template_parms (declarator
))
2510 error ("template-id %qD in declaration of primary template",
2512 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2514 /* Partial specialization of variable template. */
2515 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2519 else if (cxx_dialect
< cxx14
)
2520 error ("non-type partial specialization %qD "
2521 "is not allowed", declarator
);
2523 error ("non-class, non-variable partial specialization %qD "
2524 "is not allowed", declarator
);
2529 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2530 /* This is a specialization of a member template, without
2531 specialization the containing class. Something like:
2533 template <class T> struct S {
2534 template <class U> void f (U);
2536 template <> template <class U> void S<int>::f(U) {}
2538 That's a specialization -- but of the entire template. */
2546 if ((specialization
|| member_specialization
)
2547 /* This doesn't apply to variable templates. */
2548 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2549 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
2551 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2552 for (; t
; t
= TREE_CHAIN (t
))
2553 if (TREE_PURPOSE (t
))
2555 permerror (input_location
,
2556 "default argument specified in explicit specialization");
2561 if (specialization
|| member_specialization
|| explicit_instantiation
)
2563 tree tmpl
= NULL_TREE
;
2564 tree targs
= NULL_TREE
;
2565 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2567 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2568 if (!was_template_id
)
2572 gcc_assert (identifier_p (declarator
));
2577 /* If there is no class context, the explicit instantiation
2578 must be at namespace scope. */
2579 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2581 /* Find the namespace binding, using the declaration
2583 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2585 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2587 error ("%qD is not a template function", dname
);
2588 fns
= error_mark_node
;
2592 tree fn
= OVL_CURRENT (fns
);
2593 if (!is_associated_namespace (CP_DECL_CONTEXT (decl
),
2594 CP_DECL_CONTEXT (fn
)))
2595 error ("%qD is not declared in %qD",
2596 decl
, current_namespace
);
2600 declarator
= lookup_template_function (fns
, NULL_TREE
);
2603 if (declarator
== error_mark_node
)
2604 return error_mark_node
;
2606 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2608 if (!explicit_instantiation
)
2609 /* A specialization in class scope. This is invalid,
2610 but the error will already have been flagged by
2611 check_specialization_scope. */
2612 return error_mark_node
;
2615 /* It's not valid to write an explicit instantiation in
2618 class C { template void f(); }
2620 This case is caught by the parser. However, on
2623 template class C { void f(); };
2625 (which is invalid) we can get here. The error will be
2632 else if (ctype
!= NULL_TREE
2633 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2635 // We'll match variable templates in start_decl.
2639 /* Find the list of functions in ctype that have the same
2640 name as the declared function. */
2641 tree name
= TREE_OPERAND (declarator
, 0);
2642 tree fns
= NULL_TREE
;
2645 if (constructor_name_p (name
, ctype
))
2647 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2649 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2650 : !CLASSTYPE_DESTRUCTORS (ctype
))
2652 /* From [temp.expl.spec]:
2654 If such an explicit specialization for the member
2655 of a class template names an implicitly-declared
2656 special member function (clause _special_), the
2657 program is ill-formed.
2659 Similar language is found in [temp.explicit]. */
2660 error ("specialization of implicitly-declared special member function");
2661 return error_mark_node
;
2664 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2667 if (!DECL_CONV_FN_P (decl
))
2669 idx
= lookup_fnfields_1 (ctype
, name
);
2671 fns
= (*CLASSTYPE_METHOD_VEC (ctype
))[idx
];
2675 vec
<tree
, va_gc
> *methods
;
2678 /* For a type-conversion operator, we cannot do a
2679 name-based lookup. We might be looking for `operator
2680 int' which will be a specialization of `operator T'.
2681 So, we find *all* the conversion operators, and then
2682 select from them. */
2685 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2687 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2688 methods
->iterate (idx
, &ovl
);
2691 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2692 /* There are no more conversion functions. */
2695 /* Glue all these conversion functions together
2696 with those we already have. */
2697 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2698 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2702 if (fns
== NULL_TREE
)
2704 error ("no member function %qD declared in %qT", name
, ctype
);
2705 return error_mark_node
;
2708 TREE_OPERAND (declarator
, 0) = fns
;
2711 /* Figure out what exactly is being specialized at this point.
2712 Note that for an explicit instantiation, even one for a
2713 member function, we cannot tell apriori whether the
2714 instantiation is for a member template, or just a member
2715 function of a template class. Even if a member template is
2716 being instantiated, the member template arguments may be
2717 elided if they can be deduced from the rest of the
2719 tmpl
= determine_specialization (declarator
, decl
,
2721 member_specialization
,
2725 if (!tmpl
|| tmpl
== error_mark_node
)
2726 /* We couldn't figure out what this declaration was
2728 return error_mark_node
;
2731 tree gen_tmpl
= most_general_template (tmpl
);
2733 if (explicit_instantiation
)
2735 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2736 is done by do_decl_instantiation later. */
2738 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2739 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2741 if (arg_depth
> parm_depth
)
2743 /* If TMPL is not the most general template (for
2744 example, if TMPL is a friend template that is
2745 injected into namespace scope), then there will
2746 be too many levels of TARGS. Remove some of them
2751 new_targs
= make_tree_vec (parm_depth
);
2752 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2753 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2754 = TREE_VEC_ELT (targs
, i
);
2758 return instantiate_template (tmpl
, targs
, tf_error
);
2761 /* If we thought that the DECL was a member function, but it
2762 turns out to be specializing a static member function,
2763 make DECL a static member function as well. */
2764 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
2765 && DECL_STATIC_FUNCTION_P (tmpl
)
2766 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2767 revert_static_member_fn (decl
);
2769 /* If this is a specialization of a member template of a
2770 template class, we want to return the TEMPLATE_DECL, not
2771 the specialization of it. */
2772 if (tsk
== tsk_template
&& !was_template_id
)
2774 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
2775 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2776 DECL_INITIAL (result
) = NULL_TREE
;
2780 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2781 DECL_SOURCE_LOCATION (result
)
2782 = DECL_SOURCE_LOCATION (decl
);
2783 /* We want to use the argument list specified in the
2784 definition, not in the original declaration. */
2785 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
2786 for (parm
= DECL_ARGUMENTS (result
); parm
;
2787 parm
= DECL_CHAIN (parm
))
2788 DECL_CONTEXT (parm
) = result
;
2790 return register_specialization (tmpl
, gen_tmpl
, targs
,
2794 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2795 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
2797 if (was_template_id
)
2798 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
)) = true;
2800 /* Inherit default function arguments from the template
2801 DECL is specializing. */
2802 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
2803 copy_default_args_to_explicit_spec (decl
);
2805 /* This specialization has the same protection as the
2806 template it specializes. */
2807 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
2808 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
2810 /* 7.1.1-1 [dcl.stc]
2812 A storage-class-specifier shall not be specified in an
2813 explicit specialization...
2815 The parser rejects these, so unless action is taken here,
2816 explicit function specializations will always appear with
2819 The action recommended by the C++ CWG in response to C++
2820 defect report 605 is to make the storage class and linkage
2821 of the explicit specialization match the templated function:
2823 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2825 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
2827 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
2828 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
2830 /* This specialization has the same linkage and visibility as
2831 the function template it specializes. */
2832 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
2833 if (! TREE_PUBLIC (decl
))
2835 DECL_INTERFACE_KNOWN (decl
) = 1;
2836 DECL_NOT_REALLY_EXTERN (decl
) = 1;
2838 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
2839 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
2841 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
2842 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
2846 /* If DECL is a friend declaration, declared using an
2847 unqualified name, the namespace associated with DECL may
2848 have been set incorrectly. For example, in:
2850 template <typename T> void f(T);
2852 struct S { friend void f<int>(int); }
2855 we will have set the DECL_CONTEXT for the friend
2856 declaration to N, rather than to the global namespace. */
2857 if (DECL_NAMESPACE_SCOPE_P (decl
))
2858 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
2860 if (is_friend
&& !have_def
)
2861 /* This is not really a declaration of a specialization.
2862 It's just the name of an instantiation. But, it's not
2863 a request for an instantiation, either. */
2864 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
2865 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2866 /* A specialization is not necessarily COMDAT. */
2867 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
2868 && DECL_DECLARED_INLINE_P (decl
));
2869 else if (TREE_CODE (decl
) == VAR_DECL
)
2870 DECL_COMDAT (decl
) = false;
2872 /* Register this specialization so that we can find it
2874 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
, 0);
2876 /* A 'structor should already have clones. */
2877 gcc_assert (decl
== error_mark_node
2878 || variable_template_p (tmpl
)
2879 || !(DECL_CONSTRUCTOR_P (decl
)
2880 || DECL_DESTRUCTOR_P (decl
))
2881 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
2888 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2889 parameters. These are represented in the same format used for
2890 DECL_TEMPLATE_PARMS. */
2893 comp_template_parms (const_tree parms1
, const_tree parms2
)
2898 if (parms1
== parms2
)
2901 for (p1
= parms1
, p2
= parms2
;
2902 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2903 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2905 tree t1
= TREE_VALUE (p1
);
2906 tree t2
= TREE_VALUE (p2
);
2909 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2910 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2912 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2915 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2917 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2918 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2920 /* If either of the template parameters are invalid, assume
2921 they match for the sake of error recovery. */
2922 if (error_operand_p (parm1
) || error_operand_p (parm2
))
2925 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2928 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2929 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2930 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2932 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2937 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2938 /* One set of parameters has more parameters lists than the
2945 /* Determine whether PARM is a parameter pack. */
2948 template_parameter_pack_p (const_tree parm
)
2950 /* Determine if we have a non-type template parameter pack. */
2951 if (TREE_CODE (parm
) == PARM_DECL
)
2952 return (DECL_TEMPLATE_PARM_P (parm
)
2953 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2954 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
2955 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
2957 /* If this is a list of template parameters, we could get a
2958 TYPE_DECL or a TEMPLATE_DECL. */
2959 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2960 parm
= TREE_TYPE (parm
);
2962 /* Otherwise it must be a type template parameter. */
2963 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2964 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2965 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2968 /* Determine if T is a function parameter pack. */
2971 function_parameter_pack_p (const_tree t
)
2973 if (t
&& TREE_CODE (t
) == PARM_DECL
)
2974 return DECL_PACK_P (t
);
2978 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2979 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2982 get_function_template_decl (const_tree primary_func_tmpl_inst
)
2984 if (! primary_func_tmpl_inst
2985 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
2986 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
2989 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
2992 /* Return true iff the function parameter PARAM_DECL was expanded
2993 from the function parameter pack PACK. */
2996 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
2998 if (DECL_ARTIFICIAL (param_decl
)
2999 || !function_parameter_pack_p (pack
))
3002 /* The parameter pack and its pack arguments have the same
3004 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
3007 /* Determine whether ARGS describes a variadic template args list,
3008 i.e., one that is terminated by a template argument pack. */
3011 template_args_variadic_p (tree args
)
3016 if (args
== NULL_TREE
)
3019 args
= INNERMOST_TEMPLATE_ARGS (args
);
3020 nargs
= TREE_VEC_LENGTH (args
);
3025 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
3027 return ARGUMENT_PACK_P (last_parm
);
3030 /* Generate a new name for the parameter pack name NAME (an
3031 IDENTIFIER_NODE) that incorporates its */
3034 make_ith_pack_parameter_name (tree name
, int i
)
3036 /* Munge the name to include the parameter index. */
3037 #define NUMBUF_LEN 128
3038 char numbuf
[NUMBUF_LEN
];
3042 if (name
== NULL_TREE
)
3044 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
3045 newname_len
= IDENTIFIER_LENGTH (name
)
3046 + strlen (numbuf
) + 2;
3047 newname
= (char*)alloca (newname_len
);
3048 snprintf (newname
, newname_len
,
3049 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3050 return get_identifier (newname
);
3053 /* Return true if T is a primary function, class or alias template
3057 primary_template_instantiation_p (const_tree t
)
3062 if (TREE_CODE (t
) == FUNCTION_DECL
)
3063 return DECL_LANG_SPECIFIC (t
)
3064 && DECL_TEMPLATE_INSTANTIATION (t
)
3065 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
3066 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3067 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
3068 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
3069 else if (alias_template_specialization_p (t
))
3074 /* Return true if PARM is a template template parameter. */
3077 template_template_parameter_p (const_tree parm
)
3079 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3082 /* Return true iff PARM is a DECL representing a type template
3086 template_type_parameter_p (const_tree parm
)
3089 && (TREE_CODE (parm
) == TYPE_DECL
3090 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3091 && DECL_TEMPLATE_PARM_P (parm
));
3094 /* Return the template parameters of T if T is a
3095 primary template instantiation, NULL otherwise. */
3098 get_primary_template_innermost_parameters (const_tree t
)
3100 tree parms
= NULL
, template_info
= NULL
;
3102 if ((template_info
= get_template_info (t
))
3103 && primary_template_instantiation_p (t
))
3104 parms
= INNERMOST_TEMPLATE_PARMS
3105 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3110 /* Return the template parameters of the LEVELth level from the full list
3111 of template parameters PARMS. */
3114 get_template_parms_at_level (tree parms
, int level
)
3118 || TREE_CODE (parms
) != TREE_LIST
3119 || level
> TMPL_PARMS_DEPTH (parms
))
3122 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3123 if (TMPL_PARMS_DEPTH (p
) == level
)
3129 /* Returns the template arguments of T if T is a template instantiation,
3133 get_template_innermost_arguments (const_tree t
)
3135 tree args
= NULL
, template_info
= NULL
;
3137 if ((template_info
= get_template_info (t
))
3138 && TI_ARGS (template_info
))
3139 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3144 /* Return the argument pack elements of T if T is a template argument pack,
3148 get_template_argument_pack_elems (const_tree t
)
3150 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3151 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3154 return ARGUMENT_PACK_ARGS (t
);
3157 /* Structure used to track the progress of find_parameter_packs_r. */
3158 struct find_parameter_pack_data
3160 /* TREE_LIST that will contain all of the parameter packs found by
3162 tree
* parameter_packs
;
3164 /* Set of AST nodes that have been visited by the traversal. */
3165 hash_set
<tree
> *visited
;
3168 /* Identifies all of the argument packs that occur in a template
3169 argument and appends them to the TREE_LIST inside DATA, which is a
3170 find_parameter_pack_data structure. This is a subroutine of
3171 make_pack_expansion and uses_parameter_packs. */
3173 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3176 struct find_parameter_pack_data
* ppd
=
3177 (struct find_parameter_pack_data
*)data
;
3178 bool parameter_pack_p
= false;
3180 /* Handle type aliases/typedefs. */
3181 if (TYPE_ALIAS_P (t
))
3183 if (TYPE_TEMPLATE_INFO (t
))
3184 cp_walk_tree (&TYPE_TI_ARGS (t
),
3185 &find_parameter_packs_r
,
3191 /* Identify whether this is a parameter pack or not. */
3192 switch (TREE_CODE (t
))
3194 case TEMPLATE_PARM_INDEX
:
3195 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3196 parameter_pack_p
= true;
3199 case TEMPLATE_TYPE_PARM
:
3200 t
= TYPE_MAIN_VARIANT (t
);
3201 case TEMPLATE_TEMPLATE_PARM
:
3202 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3203 parameter_pack_p
= true;
3208 if (DECL_PACK_P (t
))
3210 /* We don't want to walk into the type of a PARM_DECL,
3211 because we don't want to see the type parameter pack. */
3213 parameter_pack_p
= true;
3217 /* Look through a lambda capture proxy to the field pack. */
3219 if (DECL_HAS_VALUE_EXPR_P (t
))
3221 tree v
= DECL_VALUE_EXPR (t
);
3223 &find_parameter_packs_r
,
3230 parameter_pack_p
= true;
3233 /* Not a parameter pack. */
3237 if (parameter_pack_p
)
3239 /* Add this parameter pack to the list. */
3240 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3244 cp_walk_tree (&TYPE_CONTEXT (t
),
3245 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3247 /* This switch statement will return immediately if we don't find a
3249 switch (TREE_CODE (t
))
3251 case TEMPLATE_PARM_INDEX
:
3254 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3255 /* Check the template itself. */
3256 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3257 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3258 /* Check the template arguments. */
3259 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3264 case TEMPLATE_TYPE_PARM
:
3265 case TEMPLATE_TEMPLATE_PARM
:
3272 if (TYPE_PTRMEMFUNC_P (t
))
3278 if (TYPE_TEMPLATE_INFO (t
))
3279 cp_walk_tree (&TYPE_TI_ARGS (t
),
3280 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3287 cp_walk_tree (&TREE_TYPE (t
),
3288 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3292 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3297 case TYPE_PACK_EXPANSION
:
3298 case EXPR_PACK_EXPANSION
:
3303 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3308 case IDENTIFIER_NODE
:
3309 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3321 /* Determines if the expression or type T uses any parameter packs. */
3323 uses_parameter_packs (tree t
)
3325 tree parameter_packs
= NULL_TREE
;
3326 struct find_parameter_pack_data ppd
;
3327 ppd
.parameter_packs
= ¶meter_packs
;
3328 ppd
.visited
= new hash_set
<tree
>;
3329 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3331 return parameter_packs
!= NULL_TREE
;
3334 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3335 representation a base-class initializer into a parameter pack
3336 expansion. If all goes well, the resulting node will be an
3337 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3340 make_pack_expansion (tree arg
)
3343 tree parameter_packs
= NULL_TREE
;
3344 bool for_types
= false;
3345 struct find_parameter_pack_data ppd
;
3347 if (!arg
|| arg
== error_mark_node
)
3350 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
3352 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3353 class initializer. In this case, the TREE_PURPOSE will be a
3354 _TYPE node (representing the base class expansion we're
3355 initializing) and the TREE_VALUE will be a TREE_LIST
3356 containing the initialization arguments.
3358 The resulting expansion looks somewhat different from most
3359 expansions. Rather than returning just one _EXPANSION, we
3360 return a TREE_LIST whose TREE_PURPOSE is a
3361 TYPE_PACK_EXPANSION containing the bases that will be
3362 initialized. The TREE_VALUE will be identical to the
3363 original TREE_VALUE, which is a list of arguments that will
3364 be passed to each base. We do not introduce any new pack
3365 expansion nodes into the TREE_VALUE (although it is possible
3366 that some already exist), because the TREE_PURPOSE and
3367 TREE_VALUE all need to be expanded together with the same
3368 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3369 resulting TREE_PURPOSE will mention the parameter packs in
3370 both the bases and the arguments to the bases. */
3373 tree parameter_packs
= NULL_TREE
;
3375 /* Determine which parameter packs will be used by the base
3377 ppd
.visited
= new hash_set
<tree
>;
3378 ppd
.parameter_packs
= ¶meter_packs
;
3379 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3382 if (parameter_packs
== NULL_TREE
)
3384 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3386 return error_mark_node
;
3389 if (TREE_VALUE (arg
) != void_type_node
)
3391 /* Collect the sets of parameter packs used in each of the
3392 initialization arguments. */
3393 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3395 /* Determine which parameter packs will be expanded in this
3397 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3404 /* Create the pack expansion type for the base type. */
3405 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3406 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3407 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3409 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3410 they will rarely be compared to anything. */
3411 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3413 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3416 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3419 /* Build the PACK_EXPANSION_* node. */
3421 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3422 : make_node (EXPR_PACK_EXPANSION
);
3423 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3424 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3426 /* Propagate type and const-expression information. */
3427 TREE_TYPE (result
) = TREE_TYPE (arg
);
3428 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3431 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3432 they will rarely be compared to anything. */
3433 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3435 /* Determine which parameter packs will be expanded. */
3436 ppd
.parameter_packs
= ¶meter_packs
;
3437 ppd
.visited
= new hash_set
<tree
>;
3438 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3441 /* Make sure we found some parameter packs. */
3442 if (parameter_packs
== NULL_TREE
)
3445 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3447 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3448 return error_mark_node
;
3450 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3452 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3457 /* Checks T for any "bare" parameter packs, which have not yet been
3458 expanded, and issues an error if any are found. This operation can
3459 only be done on full expressions or types (e.g., an expression
3460 statement, "if" condition, etc.), because we could have expressions like:
3462 foo(f(g(h(args)))...)
3464 where "args" is a parameter pack. check_for_bare_parameter_packs
3465 should not be called for the subexpressions args, h(args),
3466 g(h(args)), or f(g(h(args))), because we would produce erroneous
3469 Returns TRUE and emits an error if there were bare parameter packs,
3470 returns FALSE otherwise. */
3472 check_for_bare_parameter_packs (tree t
)
3474 tree parameter_packs
= NULL_TREE
;
3475 struct find_parameter_pack_data ppd
;
3477 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3480 if (TREE_CODE (t
) == TYPE_DECL
)
3483 ppd
.parameter_packs
= ¶meter_packs
;
3484 ppd
.visited
= new hash_set
<tree
>;
3485 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3488 if (parameter_packs
)
3490 error ("parameter packs not expanded with %<...%>:");
3491 while (parameter_packs
)
3493 tree pack
= TREE_VALUE (parameter_packs
);
3494 tree name
= NULL_TREE
;
3496 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3497 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3498 name
= TYPE_NAME (pack
);
3499 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3500 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3502 name
= DECL_NAME (pack
);
3505 inform (input_location
, " %qD", name
);
3507 inform (input_location
, " <anonymous>");
3509 parameter_packs
= TREE_CHAIN (parameter_packs
);
3518 /* Expand any parameter packs that occur in the template arguments in
3521 expand_template_argument_pack (tree args
)
3523 tree result_args
= NULL_TREE
;
3524 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3525 int num_result_args
= -1;
3526 int non_default_args_count
= -1;
3528 /* First, determine if we need to expand anything, and the number of
3529 slots we'll need. */
3530 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3532 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3533 if (arg
== NULL_TREE
)
3535 if (ARGUMENT_PACK_P (arg
))
3537 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3538 if (num_result_args
< 0)
3539 num_result_args
= in_arg
+ num_packed
;
3541 num_result_args
+= num_packed
;
3545 if (num_result_args
>= 0)
3550 /* If no expansion is necessary, we're done. */
3551 if (num_result_args
< 0)
3554 /* Expand arguments. */
3555 result_args
= make_tree_vec (num_result_args
);
3556 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3557 non_default_args_count
=
3558 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3559 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3561 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3562 if (ARGUMENT_PACK_P (arg
))
3564 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3565 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3566 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3567 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3568 if (non_default_args_count
> 0)
3569 non_default_args_count
+= num_packed
- 1;
3573 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3577 if (non_default_args_count
>= 0)
3578 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3582 /* Checks if DECL shadows a template parameter.
3584 [temp.local]: A template-parameter shall not be redeclared within its
3585 scope (including nested scopes).
3587 Emits an error and returns TRUE if the DECL shadows a parameter,
3588 returns FALSE otherwise. */
3591 check_template_shadow (tree decl
)
3595 /* If we're not in a template, we can't possibly shadow a template
3597 if (!current_template_parms
)
3600 /* Figure out what we're shadowing. */
3601 if (TREE_CODE (decl
) == OVERLOAD
)
3602 decl
= OVL_CURRENT (decl
);
3603 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3605 /* If there's no previous binding for this name, we're not shadowing
3606 anything, let alone a template parameter. */
3610 /* If we're not shadowing a template parameter, we're done. Note
3611 that OLDDECL might be an OVERLOAD (or perhaps even an
3612 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3614 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3617 /* We check for decl != olddecl to avoid bogus errors for using a
3618 name inside a class. We check TPFI to avoid duplicate errors for
3619 inline member templates. */
3621 || (DECL_TEMPLATE_PARM_P (decl
)
3622 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
3625 /* Don't complain about the injected class name, as we've already
3626 complained about the class itself. */
3627 if (DECL_SELF_REFERENCE_P (decl
))
3630 error ("declaration of %q+#D", decl
);
3631 error (" shadows template parm %q+#D", olddecl
);
3635 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3636 ORIG_LEVEL, DECL, and TYPE. */
3639 build_template_parm_index (int index
,
3645 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3646 TEMPLATE_PARM_IDX (t
) = index
;
3647 TEMPLATE_PARM_LEVEL (t
) = level
;
3648 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3649 TEMPLATE_PARM_DECL (t
) = decl
;
3650 TREE_TYPE (t
) = type
;
3651 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3652 TREE_READONLY (t
) = TREE_READONLY (decl
);
3657 /* Find the canonical type parameter for the given template type
3658 parameter. Returns the canonical type parameter, which may be TYPE
3659 if no such parameter existed. */
3662 canonical_type_parameter (tree type
)
3665 int idx
= TEMPLATE_TYPE_IDX (type
);
3666 if (!canonical_template_parms
)
3667 vec_alloc (canonical_template_parms
, idx
+1);
3669 while (canonical_template_parms
->length () <= (unsigned)idx
)
3670 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3672 list
= (*canonical_template_parms
)[idx
];
3673 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3674 list
= TREE_CHAIN (list
);
3677 return TREE_VALUE (list
);
3680 (*canonical_template_parms
)[idx
]
3681 = tree_cons (NULL_TREE
, type
,
3682 (*canonical_template_parms
)[idx
]);
3687 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3688 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3689 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3690 new one is created. */
3693 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3694 tsubst_flags_t complain
)
3696 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3697 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3698 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3699 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3701 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3704 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3705 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3706 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3707 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3708 DECL_ARTIFICIAL (decl
) = 1;
3709 SET_DECL_TEMPLATE_PARM_P (decl
);
3711 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3712 TEMPLATE_PARM_LEVEL (index
) - levels
,
3713 TEMPLATE_PARM_ORIG_LEVEL (index
),
3715 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3716 TEMPLATE_PARM_PARAMETER_PACK (t
)
3717 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3719 /* Template template parameters need this. */
3720 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3721 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3722 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
)),
3726 return TEMPLATE_PARM_DESCENDANTS (index
);
3729 /* Process information from new template parameter PARM and append it
3730 to the LIST being built. This new parameter is a non-type
3731 parameter iff IS_NON_TYPE is true. This new parameter is a
3732 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3736 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
3737 bool is_non_type
, bool is_parameter_pack
)
3743 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
3744 defval
= TREE_PURPOSE (parm
);
3748 tree p
= tree_last (list
);
3750 if (p
&& TREE_VALUE (p
) != error_mark_node
)
3753 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
3754 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
3756 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
3764 parm
= TREE_VALUE (parm
);
3766 SET_DECL_TEMPLATE_PARM_P (parm
);
3768 if (TREE_TYPE (parm
) != error_mark_node
)
3772 The top-level cv-qualifiers on the template-parameter are
3773 ignored when determining its type. */
3774 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
3775 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
3776 TREE_TYPE (parm
) = error_mark_node
;
3777 else if (uses_parameter_packs (TREE_TYPE (parm
))
3778 && !is_parameter_pack
3779 /* If we're in a nested template parameter list, the template
3780 template parameter could be a parameter pack. */
3781 && processing_template_parmlist
== 1)
3783 /* This template parameter is not a parameter pack, but it
3784 should be. Complain about "bare" parameter packs. */
3785 check_for_bare_parameter_packs (TREE_TYPE (parm
));
3787 /* Recover by calling this a parameter pack. */
3788 is_parameter_pack
= true;
3792 /* A template parameter is not modifiable. */
3793 TREE_CONSTANT (parm
) = 1;
3794 TREE_READONLY (parm
) = 1;
3795 decl
= build_decl (parm_loc
,
3796 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
3797 TREE_CONSTANT (decl
) = 1;
3798 TREE_READONLY (decl
) = 1;
3799 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
3800 = build_template_parm_index (idx
, processing_template_decl
,
3801 processing_template_decl
,
3802 decl
, TREE_TYPE (parm
));
3804 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
3805 = is_parameter_pack
;
3810 parm
= TREE_VALUE (TREE_VALUE (parm
));
3812 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
3814 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
3815 /* This is for distinguishing between real templates and template
3816 template parameters */
3817 TREE_TYPE (parm
) = t
;
3818 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
3823 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
3824 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3825 decl
= build_decl (parm_loc
,
3826 TYPE_DECL
, parm
, t
);
3829 TYPE_NAME (t
) = decl
;
3830 TYPE_STUB_DECL (t
) = decl
;
3832 TEMPLATE_TYPE_PARM_INDEX (t
)
3833 = build_template_parm_index (idx
, processing_template_decl
,
3834 processing_template_decl
,
3835 decl
, TREE_TYPE (parm
));
3836 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
3837 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
3839 DECL_ARTIFICIAL (decl
) = 1;
3840 SET_DECL_TEMPLATE_PARM_P (decl
);
3842 parm
= build_tree_list (defval
, parm
);
3843 return chainon (list
, parm
);
3846 /* The end of a template parameter list has been reached. Process the
3847 tree list into a parameter vector, converting each parameter into a more
3848 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3852 end_template_parm_list (tree parms
)
3856 tree saved_parmlist
= make_tree_vec (list_length (parms
));
3858 current_template_parms
3859 = tree_cons (size_int (processing_template_decl
),
3860 saved_parmlist
, current_template_parms
);
3862 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3864 next
= TREE_CHAIN (parm
);
3865 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3866 TREE_CHAIN (parm
) = NULL_TREE
;
3869 --processing_template_parmlist
;
3871 return saved_parmlist
;
3874 /* end_template_decl is called after a template declaration is seen. */
3877 end_template_decl (void)
3879 reset_specialization ();
3881 if (! processing_template_decl
)
3884 /* This matches the pushlevel in begin_template_parm_list. */
3887 --processing_template_decl
;
3888 current_template_parms
= TREE_CHAIN (current_template_parms
);
3891 /* Takes a TREE_LIST representing a template parameter and convert it
3892 into an argument suitable to be passed to the type substitution
3893 functions. Note that If the TREE_LIST contains an error_mark
3894 node, the returned argument is error_mark_node. */
3897 template_parm_to_arg (tree t
)
3901 || TREE_CODE (t
) != TREE_LIST
)
3904 if (error_operand_p (TREE_VALUE (t
)))
3905 return error_mark_node
;
3909 if (TREE_CODE (t
) == TYPE_DECL
3910 || TREE_CODE (t
) == TEMPLATE_DECL
)
3914 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3916 /* Turn this argument into a TYPE_ARGUMENT_PACK
3917 with a single element, which expands T. */
3918 tree vec
= make_tree_vec (1);
3919 #ifdef ENABLE_CHECKING
3920 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3921 (vec
, TREE_VEC_LENGTH (vec
));
3923 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3925 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
3926 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3931 t
= DECL_INITIAL (t
);
3933 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3935 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3936 with a single element, which expands T. */
3937 tree vec
= make_tree_vec (1);
3938 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3939 #ifdef ENABLE_CHECKING
3940 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3941 (vec
, TREE_VEC_LENGTH (vec
));
3943 t
= convert_from_reference (t
);
3944 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3946 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3947 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3948 TREE_TYPE (t
) = type
;
3951 t
= convert_from_reference (t
);
3956 /* Given a set of template parameters, return them as a set of template
3957 arguments. The template parameters are represented as a TREE_VEC, in
3958 the form documented in cp-tree.h for template arguments. */
3961 template_parms_to_args (tree parms
)
3964 tree args
= NULL_TREE
;
3965 int length
= TMPL_PARMS_DEPTH (parms
);
3968 /* If there is only one level of template parameters, we do not
3969 create a TREE_VEC of TREE_VECs. Instead, we return a single
3970 TREE_VEC containing the arguments. */
3972 args
= make_tree_vec (length
);
3974 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
3976 tree a
= copy_node (TREE_VALUE (header
));
3979 TREE_TYPE (a
) = NULL_TREE
;
3980 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
3981 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
3983 #ifdef ENABLE_CHECKING
3984 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
3988 TREE_VEC_ELT (args
, --l
) = a
;
3993 if (length
> 1 && TREE_VEC_ELT (args
, 0) == NULL_TREE
)
3994 /* This can happen for template parms of a template template
3997 template<template<class T, class U> class TT> struct S;
3999 Consider the level of the parms of TT; T and U both have
4000 level 2; TT has no template parm of level 1. So in this case
4001 the first element of full_template_args is NULL_TREE. If we
4002 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
4003 of 2. This will make tsubst wrongly consider that T and U
4004 have level 1. Instead, let's create a dummy vector as the
4005 first element of full_template_args so that TMPL_ARGS_DEPTH
4006 returns the correct depth for args. */
4007 TREE_VEC_ELT (args
, 0) = make_tree_vec (1);
4011 /* Within the declaration of a template, return the currently active
4012 template parameters as an argument TREE_VEC. */
4015 current_template_args (void)
4017 return template_parms_to_args (current_template_parms
);
4020 /* Update the declared TYPE by doing any lookups which were thought to be
4021 dependent, but are not now that we know the SCOPE of the declarator. */
4024 maybe_update_decl_type (tree orig_type
, tree scope
)
4026 tree type
= orig_type
;
4028 if (type
== NULL_TREE
)
4031 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4032 type
= TREE_TYPE (type
);
4034 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4035 && dependent_type_p (type
)
4036 /* Don't bother building up the args in this case. */
4037 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4039 /* tsubst in the args corresponding to the template parameters,
4040 including auto if present. Most things will be unchanged, but
4041 make_typename_type and tsubst_qualified_id will resolve
4042 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4043 tree args
= current_template_args ();
4044 tree auto_node
= type_uses_auto (type
);
4048 tree auto_vec
= make_tree_vec (1);
4049 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4050 args
= add_to_template_args (args
, auto_vec
);
4052 pushed
= push_scope (scope
);
4053 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4058 if (type
== error_mark_node
)
4061 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4063 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4066 type
= TYPE_NAME (type
);
4071 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4072 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
4073 a member template. Used by push_template_decl below. */
4076 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4078 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4079 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4080 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4081 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4082 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4087 struct template_parm_data
4089 /* The level of the template parameters we are currently
4093 /* The index of the specialization argument we are currently
4097 /* An array whose size is the number of template parameters. The
4098 elements are nonzero if the parameter has been used in any one
4099 of the arguments processed so far. */
4102 /* An array whose size is the number of template arguments. The
4103 elements are nonzero if the argument makes use of template
4104 parameters of this level. */
4105 int* arg_uses_template_parms
;
4108 /* Subroutine of push_template_decl used to see if each template
4109 parameter in a partial specialization is used in the explicit
4110 argument list. If T is of the LEVEL given in DATA (which is
4111 treated as a template_parm_data*), then DATA->PARMS is marked
4115 mark_template_parm (tree t
, void* data
)
4119 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4121 template_parm_level_and_index (t
, &level
, &idx
);
4123 if (level
== tpd
->level
)
4125 tpd
->parms
[idx
] = 1;
4126 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4129 /* Return zero so that for_each_template_parm will continue the
4130 traversal of the tree; we want to mark *every* template parm. */
4134 /* Process the partial specialization DECL. */
4137 process_partial_specialization (tree decl
)
4139 tree type
= TREE_TYPE (decl
);
4140 tree tinfo
= get_template_info (decl
);
4141 tree maintmpl
= TI_TEMPLATE (tinfo
);
4142 tree specargs
= TI_ARGS (tinfo
);
4143 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4144 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4147 int nargs
= TREE_VEC_LENGTH (inner_args
);
4150 bool did_error_intro
= false;
4151 struct template_parm_data tpd
;
4152 struct template_parm_data tpd2
;
4154 gcc_assert (current_template_parms
);
4156 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4157 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4159 /* We check that each of the template parameters given in the
4160 partial specialization is used in the argument list to the
4161 specialization. For example:
4163 template <class T> struct S;
4164 template <class T> struct S<T*>;
4166 The second declaration is OK because `T*' uses the template
4167 parameter T, whereas
4169 template <class T> struct S<int>;
4171 is no good. Even trickier is:
4182 The S2<T> declaration is actually invalid; it is a
4183 full-specialization. Of course,
4186 struct S2<T (*)(U)>;
4188 or some such would have been OK. */
4189 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4190 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4191 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4193 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4194 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4195 for (i
= 0; i
< nargs
; ++i
)
4197 tpd
.current_arg
= i
;
4198 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4199 &mark_template_parm
,
4202 /*include_nondeduced_p=*/false);
4204 for (i
= 0; i
< ntparms
; ++i
)
4205 if (tpd
.parms
[i
] == 0)
4207 /* One of the template parms was not used in a deduced context in the
4209 if (!did_error_intro
)
4211 error ("template parameters not deducible in "
4212 "partial specialization:");
4213 did_error_intro
= true;
4216 inform (input_location
, " %qD",
4217 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4220 if (did_error_intro
)
4221 return error_mark_node
;
4223 /* [temp.class.spec]
4225 The argument list of the specialization shall not be identical to
4226 the implicit argument list of the primary template. */
4228 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4229 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
)))
4230 error ("partial specialization %qD does not specialize "
4231 "any template arguments", decl
);
4233 /* A partial specialization that replaces multiple parameters of the
4234 primary template with a pack expansion is less specialized for those
4236 if (nargs
< DECL_NTPARMS (maintmpl
))
4238 error ("partial specialization is not more specialized than the "
4239 "primary template because it replaces multiple parameters "
4240 "with a pack expansion");
4241 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4245 /* [temp.class.spec]
4247 A partially specialized non-type argument expression shall not
4248 involve template parameters of the partial specialization except
4249 when the argument expression is a simple identifier.
4251 The type of a template parameter corresponding to a specialized
4252 non-type argument shall not be dependent on a parameter of the
4255 Also, we verify that pack expansions only occur at the
4256 end of the argument list. */
4257 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4259 for (i
= 0; i
< nargs
; ++i
)
4261 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4262 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4263 tree packed_args
= NULL_TREE
;
4266 if (ARGUMENT_PACK_P (arg
))
4268 /* Extract the arguments from the argument pack. We'll be
4269 iterating over these in the following loop. */
4270 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4271 len
= TREE_VEC_LENGTH (packed_args
);
4274 for (j
= 0; j
< len
; j
++)
4277 /* Get the Jth argument in the parameter pack. */
4278 arg
= TREE_VEC_ELT (packed_args
, j
);
4280 if (PACK_EXPANSION_P (arg
))
4282 /* Pack expansions must come at the end of the
4284 if ((packed_args
&& j
< len
- 1)
4285 || (!packed_args
&& i
< nargs
- 1))
4287 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4288 error ("parameter pack argument %qE must be at the "
4289 "end of the template argument list", arg
);
4291 error ("parameter pack argument %qT must be at the "
4292 "end of the template argument list", arg
);
4296 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4297 /* We only care about the pattern. */
4298 arg
= PACK_EXPANSION_PATTERN (arg
);
4300 if (/* These first two lines are the `non-type' bit. */
4302 && TREE_CODE (arg
) != TEMPLATE_DECL
4303 /* This next two lines are the `argument expression is not just a
4304 simple identifier' condition and also the `specialized
4305 non-type argument' bit. */
4306 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4307 && !(REFERENCE_REF_P (arg
)
4308 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4310 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4311 || (packed_args
&& uses_template_parms (arg
)))
4312 error ("template argument %qE involves template parameter(s)",
4316 /* Look at the corresponding template parameter,
4317 marking which template parameters its type depends
4319 tree type
= TREE_TYPE (parm
);
4323 /* We haven't yet initialized TPD2. Do so now. */
4324 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4325 /* The number of parameters here is the number in the
4326 main template, which, as checked in the assertion
4328 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4330 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4333 /* Mark the template parameters. But this time, we're
4334 looking for the template parameters of the main
4335 template, not in the specialization. */
4336 tpd2
.current_arg
= i
;
4337 tpd2
.arg_uses_template_parms
[i
] = 0;
4338 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4339 for_each_template_parm (type
,
4340 &mark_template_parm
,
4343 /*include_nondeduced_p=*/false);
4345 if (tpd2
.arg_uses_template_parms
[i
])
4347 /* The type depended on some template parameters.
4348 If they are fully specialized in the
4349 specialization, that's OK. */
4352 for (j
= 0; j
< nargs
; ++j
)
4353 if (tpd2
.parms
[j
] != 0
4354 && tpd
.arg_uses_template_parms
[j
])
4357 error_n (input_location
, count
,
4358 "type %qT of template argument %qE depends "
4359 "on a template parameter",
4360 "type %qT of template argument %qE depends "
4361 "on template parameters",
4370 /* We should only get here once. */
4371 if (TREE_CODE (decl
) == TYPE_DECL
)
4372 gcc_assert (!COMPLETE_TYPE_P (type
));
4374 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4375 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4376 TREE_TYPE (tmpl
) = type
;
4377 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4378 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4379 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4380 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4382 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4383 = tree_cons (specargs
, tmpl
,
4384 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4385 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4387 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4388 inst
= TREE_CHAIN (inst
))
4390 tree instance
= TREE_VALUE (inst
);
4391 if (TYPE_P (instance
)
4392 ? (COMPLETE_TYPE_P (instance
)
4393 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
4394 : DECL_TEMPLATE_INSTANTIATION (instance
))
4396 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
4397 if (spec
&& TREE_VALUE (spec
) == tmpl
)
4399 tree inst_decl
= (DECL_P (instance
)
4400 ? instance
: TYPE_NAME (instance
));
4401 permerror (input_location
,
4402 "partial specialization of %qD after instantiation "
4403 "of %qD", decl
, inst_decl
);
4411 /* PARM is a template parameter of some form; return the corresponding
4412 TEMPLATE_PARM_INDEX. */
4415 get_template_parm_index (tree parm
)
4417 if (TREE_CODE (parm
) == PARM_DECL
4418 || TREE_CODE (parm
) == CONST_DECL
)
4419 parm
= DECL_INITIAL (parm
);
4420 else if (TREE_CODE (parm
) == TYPE_DECL
4421 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4422 parm
= TREE_TYPE (parm
);
4423 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4424 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
4425 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4426 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4427 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4431 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4432 parameter packs used by the template parameter PARM. */
4435 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4437 /* A type parm can't refer to another parm. */
4438 if (TREE_CODE (parm
) == TYPE_DECL
)
4440 else if (TREE_CODE (parm
) == PARM_DECL
)
4442 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4447 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4449 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4450 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4451 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4454 /* PARM is a template parameter pack. Return any parameter packs used in
4455 its type or the type of any of its template parameters. If there are
4456 any such packs, it will be instantiated into a fixed template parameter
4457 list by partial instantiation rather than be fully deduced. */
4460 fixed_parameter_pack_p (tree parm
)
4462 /* This can only be true in a member template. */
4463 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4465 /* This can only be true for a parameter pack. */
4466 if (!template_parameter_pack_p (parm
))
4468 /* A type parm can't refer to another parm. */
4469 if (TREE_CODE (parm
) == TYPE_DECL
)
4472 tree parameter_packs
= NULL_TREE
;
4473 struct find_parameter_pack_data ppd
;
4474 ppd
.parameter_packs
= ¶meter_packs
;
4475 ppd
.visited
= new hash_set
<tree
>;
4477 fixed_parameter_pack_p_1 (parm
, &ppd
);
4480 return parameter_packs
;
4483 /* Check that a template declaration's use of default arguments and
4484 parameter packs is not invalid. Here, PARMS are the template
4485 parameters. IS_PRIMARY is true if DECL is the thing declared by
4486 a primary template. IS_PARTIAL is true if DECL is a partial
4489 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4490 declaration (but not a definition); 1 indicates a declaration, 2
4491 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4492 emitted for extraneous default arguments.
4494 Returns TRUE if there were no errors found, FALSE otherwise. */
4497 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4498 bool is_partial
, int is_friend_decl
)
4501 int last_level_to_check
;
4503 bool no_errors
= true;
4507 A default template-argument shall not be specified in a
4508 function template declaration or a function template definition, nor
4509 in the template-parameter-list of the definition of a member of a
4512 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
4513 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
4514 /* You can't have a function template declaration in a local
4515 scope, nor you can you define a member of a class template in a
4519 if ((TREE_CODE (decl
) == TYPE_DECL
4521 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4522 || (TREE_CODE (decl
) == FUNCTION_DECL
4523 && LAMBDA_FUNCTION_P (decl
)))
4524 /* A lambda doesn't have an explicit declaration; don't complain
4525 about the parms of the enclosing class. */
4528 if (current_class_type
4529 && !TYPE_BEING_DEFINED (current_class_type
)
4530 && DECL_LANG_SPECIFIC (decl
)
4531 && DECL_DECLARES_FUNCTION_P (decl
)
4532 /* If this is either a friend defined in the scope of the class
4533 or a member function. */
4534 && (DECL_FUNCTION_MEMBER_P (decl
)
4535 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4536 : DECL_FRIEND_CONTEXT (decl
)
4537 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4539 /* And, if it was a member function, it really was defined in
4540 the scope of the class. */
4541 && (!DECL_FUNCTION_MEMBER_P (decl
)
4542 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4543 /* We already checked these parameters when the template was
4544 declared, so there's no need to do it again now. This function
4545 was defined in class scope, but we're processing its body now
4546 that the class is complete. */
4549 /* Core issue 226 (C++0x only): the following only applies to class
4552 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4556 If a template-parameter has a default template-argument, all
4557 subsequent template-parameters shall have a default
4558 template-argument supplied. */
4559 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4561 tree inner_parms
= TREE_VALUE (parm_level
);
4562 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4563 int seen_def_arg_p
= 0;
4566 for (i
= 0; i
< ntparms
; ++i
)
4568 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4570 if (parm
== error_mark_node
)
4573 if (TREE_PURPOSE (parm
))
4575 else if (seen_def_arg_p
4576 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4578 error ("no default argument for %qD", TREE_VALUE (parm
));
4579 /* For better subsequent error-recovery, we indicate that
4580 there should have been a default argument. */
4581 TREE_PURPOSE (parm
) = error_mark_node
;
4584 else if (!is_partial
4586 /* Don't complain about an enclosing partial
4588 && parm_level
== parms
4589 && TREE_CODE (decl
) == TYPE_DECL
4591 && template_parameter_pack_p (TREE_VALUE (parm
))
4592 /* A fixed parameter pack will be partially
4593 instantiated into a fixed length list. */
4594 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4596 /* A primary class template can only have one
4597 parameter pack, at the end of the template
4600 error ("parameter pack %q+D must be at the end of the"
4601 " template parameter list", TREE_VALUE (parm
));
4603 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4611 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4615 /* For an ordinary class template, default template arguments are
4616 allowed at the innermost level, e.g.:
4617 template <class T = int>
4619 but, in a partial specialization, they're not allowed even
4620 there, as we have in [temp.class.spec]:
4622 The template parameter list of a specialization shall not
4623 contain default template argument values.
4625 So, for a partial specialization, or for a function template
4626 (in C++98/C++03), we look at all of them. */
4629 /* But, for a primary class template that is not a partial
4630 specialization we look at all template parameters except the
4632 parms
= TREE_CHAIN (parms
);
4634 /* Figure out what error message to issue. */
4635 if (is_friend_decl
== 2)
4636 msg
= G_("default template arguments may not be used in function template "
4637 "friend re-declaration");
4638 else if (is_friend_decl
)
4639 msg
= G_("default template arguments may not be used in function template "
4640 "friend declarations");
4641 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4642 msg
= G_("default template arguments may not be used in function templates "
4643 "without -std=c++11 or -std=gnu++11");
4644 else if (is_partial
)
4645 msg
= G_("default template arguments may not be used in "
4646 "partial specializations");
4648 msg
= G_("default argument for template parameter for class enclosing %qD");
4650 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4651 /* If we're inside a class definition, there's no need to
4652 examine the parameters to the class itself. On the one
4653 hand, they will be checked when the class is defined, and,
4654 on the other, default arguments are valid in things like:
4655 template <class T = double>
4656 struct S { template <class U> void f(U); };
4657 Here the default argument for `S' has no bearing on the
4658 declaration of `f'. */
4659 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4661 /* Check everything. */
4662 last_level_to_check
= 0;
4664 for (parm_level
= parms
;
4665 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4666 parm_level
= TREE_CHAIN (parm_level
))
4668 tree inner_parms
= TREE_VALUE (parm_level
);
4672 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4673 for (i
= 0; i
< ntparms
; ++i
)
4675 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4678 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4683 if (is_friend_decl
== 2)
4690 /* Clear out the default argument so that we are not
4692 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
4696 /* At this point, if we're still interested in issuing messages,
4697 they must apply to classes surrounding the object declared. */
4699 msg
= G_("default argument for template parameter for class "
4706 /* Worker for push_template_decl_real, called via
4707 for_each_template_parm. DATA is really an int, indicating the
4708 level of the parameters we are interested in. If T is a template
4709 parameter of that level, return nonzero. */
4712 template_parm_this_level_p (tree t
, void* data
)
4714 int this_level
= *(int *)data
;
4717 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4718 level
= TEMPLATE_PARM_LEVEL (t
);
4720 level
= TEMPLATE_TYPE_LEVEL (t
);
4721 return level
== this_level
;
4724 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4725 parameters given by current_template_args, or reuses a
4726 previously existing one, if appropriate. Returns the DECL, or an
4727 equivalent one, if it is replaced via a call to duplicate_decls.
4729 If IS_FRIEND is true, DECL is a friend declaration. */
4732 push_template_decl_real (tree decl
, bool is_friend
)
4740 int new_template_p
= 0;
4741 /* True if the template is a member template, in the sense of
4743 bool member_template_p
= false;
4745 if (decl
== error_mark_node
|| !current_template_parms
)
4746 return error_mark_node
;
4748 /* See if this is a partial specialization. */
4749 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
4750 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
4751 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
4752 || (TREE_CODE (decl
) == VAR_DECL
4753 && DECL_LANG_SPECIFIC (decl
)
4754 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4755 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
4757 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
4761 /* For a friend, we want the context of the friend function, not
4762 the type of which it is a friend. */
4763 ctx
= CP_DECL_CONTEXT (decl
);
4764 else if (CP_DECL_CONTEXT (decl
)
4765 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4766 /* In the case of a virtual function, we want the class in which
4768 ctx
= CP_DECL_CONTEXT (decl
);
4770 /* Otherwise, if we're currently defining some class, the DECL
4771 is assumed to be a member of the class. */
4772 ctx
= current_scope ();
4774 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
4777 if (!DECL_CONTEXT (decl
))
4778 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
4780 /* See if this is a primary template. */
4781 if (is_friend
&& ctx
4782 && uses_template_parms_level (ctx
, processing_template_decl
))
4783 /* A friend template that specifies a class context, i.e.
4784 template <typename T> friend void A<T>::f();
4787 else if (TREE_CODE (decl
) == TYPE_DECL
4788 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4791 is_primary
= template_parm_scope_p ();
4795 if (DECL_CLASS_SCOPE_P (decl
))
4796 member_template_p
= true;
4797 if (TREE_CODE (decl
) == TYPE_DECL
4798 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
4800 error ("template class without a name");
4801 return error_mark_node
;
4803 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
4805 if (member_template_p
)
4807 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
4808 error ("member template %qD may not have virt-specifiers", decl
);
4810 if (DECL_DESTRUCTOR_P (decl
))
4814 A destructor shall not be a member template. */
4815 error ("destructor %qD declared as member template", decl
);
4816 return error_mark_node
;
4818 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
4819 && (!prototype_p (TREE_TYPE (decl
))
4820 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
4821 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
4822 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
4823 == void_list_node
)))
4825 /* [basic.stc.dynamic.allocation]
4827 An allocation function can be a function
4828 template. ... Template allocation functions shall
4829 have two or more parameters. */
4830 error ("invalid template declaration of %qD", decl
);
4831 return error_mark_node
;
4834 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4835 && CLASS_TYPE_P (TREE_TYPE (decl
)))
4837 else if (TREE_CODE (decl
) == TYPE_DECL
4838 && TYPE_DECL_ALIAS_P (decl
))
4839 /* alias-declaration */
4840 gcc_assert (!DECL_ARTIFICIAL (decl
));
4841 else if (VAR_P (decl
))
4842 /* C++14 variable template. */;
4845 error ("template declaration of %q#D", decl
);
4846 return error_mark_node
;
4850 /* Check to see that the rules regarding the use of default
4851 arguments are not being violated. */
4852 check_default_tmpl_args (decl
, current_template_parms
,
4853 is_primary
, is_partial
, /*is_friend_decl=*/0);
4855 /* Ensure that there are no parameter packs in the type of this
4856 declaration that have not been expanded. */
4857 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4859 /* Check each of the arguments individually to see if there are
4860 any bare parameter packs. */
4861 tree type
= TREE_TYPE (decl
);
4862 tree arg
= DECL_ARGUMENTS (decl
);
4863 tree argtype
= TYPE_ARG_TYPES (type
);
4865 while (arg
&& argtype
)
4867 if (!DECL_PACK_P (arg
)
4868 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
4870 /* This is a PARM_DECL that contains unexpanded parameter
4871 packs. We have already complained about this in the
4872 check_for_bare_parameter_packs call, so just replace
4873 these types with ERROR_MARK_NODE. */
4874 TREE_TYPE (arg
) = error_mark_node
;
4875 TREE_VALUE (argtype
) = error_mark_node
;
4878 arg
= DECL_CHAIN (arg
);
4879 argtype
= TREE_CHAIN (argtype
);
4882 /* Check for bare parameter packs in the return type and the
4883 exception specifiers. */
4884 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
4885 /* Errors were already issued, set return type to int
4886 as the frontend doesn't expect error_mark_node as
4888 TREE_TYPE (type
) = integer_type_node
;
4889 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
4890 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
4892 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
4893 && TYPE_DECL_ALIAS_P (decl
))
4894 ? DECL_ORIGINAL_TYPE (decl
)
4895 : TREE_TYPE (decl
)))
4897 TREE_TYPE (decl
) = error_mark_node
;
4898 return error_mark_node
;
4902 return process_partial_specialization (decl
);
4904 args
= current_template_args ();
4907 || TREE_CODE (ctx
) == FUNCTION_DECL
4908 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
4909 || (TREE_CODE (decl
) == TYPE_DECL
4910 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4911 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
4913 if (DECL_LANG_SPECIFIC (decl
)
4914 && DECL_TEMPLATE_INFO (decl
)
4915 && DECL_TI_TEMPLATE (decl
))
4916 tmpl
= DECL_TI_TEMPLATE (decl
);
4917 /* If DECL is a TYPE_DECL for a class-template, then there won't
4918 be DECL_LANG_SPECIFIC. The information equivalent to
4919 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4920 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4921 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
4922 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
4924 /* Since a template declaration already existed for this
4925 class-type, we must be redeclaring it here. Make sure
4926 that the redeclaration is valid. */
4927 redeclare_class_template (TREE_TYPE (decl
),
4928 current_template_parms
);
4929 /* We don't need to create a new TEMPLATE_DECL; just use the
4930 one we already had. */
4931 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
4935 tmpl
= build_template_decl (decl
, current_template_parms
,
4939 if (DECL_LANG_SPECIFIC (decl
)
4940 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4942 /* A specialization of a member template of a template
4944 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4945 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
4946 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
4952 tree a
, t
, current
, parms
;
4954 tree tinfo
= get_template_info (decl
);
4958 error ("template definition of non-template %q#D", decl
);
4959 return error_mark_node
;
4962 tmpl
= TI_TEMPLATE (tinfo
);
4964 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
4965 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
4966 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4967 && DECL_MEMBER_TEMPLATE_P (tmpl
))
4971 /* The declaration is a specialization of a member
4972 template, declared outside the class. Therefore, the
4973 innermost template arguments will be NULL, so we
4974 replace them with the arguments determined by the
4975 earlier call to check_explicit_specialization. */
4976 args
= DECL_TI_ARGS (decl
);
4979 = build_template_decl (decl
, current_template_parms
,
4981 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
4982 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
4983 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
4984 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
4985 DECL_TEMPLATE_INFO (new_tmpl
)
4986 = build_template_info (tmpl
, args
);
4988 register_specialization (new_tmpl
,
4989 most_general_template (tmpl
),
4995 /* Make sure the template headers we got make sense. */
4997 parms
= DECL_TEMPLATE_PARMS (tmpl
);
4998 i
= TMPL_PARMS_DEPTH (parms
);
4999 if (TMPL_ARGS_DEPTH (args
) != i
)
5001 error ("expected %d levels of template parms for %q#D, got %d",
5002 i
, decl
, TMPL_ARGS_DEPTH (args
));
5003 DECL_INTERFACE_KNOWN (decl
) = 1;
5004 return error_mark_node
;
5007 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5009 a
= TMPL_ARGS_LEVEL (args
, i
);
5010 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5012 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5014 if (current
== decl
)
5015 error ("got %d template parameters for %q#D",
5016 TREE_VEC_LENGTH (a
), decl
);
5018 error ("got %d template parameters for %q#T",
5019 TREE_VEC_LENGTH (a
), current
);
5020 error (" but %d required", TREE_VEC_LENGTH (t
));
5021 /* Avoid crash in import_export_decl. */
5022 DECL_INTERFACE_KNOWN (decl
) = 1;
5023 return error_mark_node
;
5026 if (current
== decl
)
5028 else if (current
== NULL_TREE
)
5029 /* Can happen in erroneous input. */
5032 current
= get_containing_scope (current
);
5035 /* Check that the parms are used in the appropriate qualifying scopes
5036 in the declarator. */
5037 if (!comp_template_args
5039 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5042 template arguments to %qD do not match original template %qD",
5043 decl
, DECL_TEMPLATE_RESULT (tmpl
));
5044 if (!uses_template_parms (TI_ARGS (tinfo
)))
5045 inform (input_location
, "use template<> for an explicit specialization");
5046 /* Avoid crash in import_export_decl. */
5047 DECL_INTERFACE_KNOWN (decl
) = 1;
5048 return error_mark_node
;
5052 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5053 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5055 /* Push template declarations for global functions and types. Note
5056 that we do not try to push a global template friend declared in a
5057 template class; such a thing may well depend on the template
5058 parameters of the class. */
5059 if (new_template_p
&& !ctx
5060 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5062 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5063 if (tmpl
== error_mark_node
)
5064 return error_mark_node
;
5066 /* Hide template friend classes that haven't been declared yet. */
5067 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5069 DECL_ANTICIPATED (tmpl
) = 1;
5070 DECL_FRIEND_P (tmpl
) = 1;
5076 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5079 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5080 if (DECL_CONV_FN_P (tmpl
))
5082 int depth
= TMPL_PARMS_DEPTH (parms
);
5084 /* It is a conversion operator. See if the type converted to
5085 depends on innermost template operands. */
5087 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
5089 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
5092 /* Give template template parms a DECL_CONTEXT of the template
5093 for which they are a parameter. */
5094 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5095 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5097 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5098 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5099 DECL_CONTEXT (parm
) = tmpl
;
5102 if (TREE_CODE (decl
) == TYPE_DECL
5103 && TYPE_DECL_ALIAS_P (decl
)
5104 && complex_alias_template_p (tmpl
))
5105 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
5108 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5109 back to its most general template. If TMPL is a specialization,
5110 ARGS may only have the innermost set of arguments. Add the missing
5111 argument levels if necessary. */
5112 if (DECL_TEMPLATE_INFO (tmpl
))
5113 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5115 info
= build_template_info (tmpl
, args
);
5117 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5118 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5121 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5122 retrofit_lang_decl (decl
);
5123 if (DECL_LANG_SPECIFIC (decl
))
5124 DECL_TEMPLATE_INFO (decl
) = info
;
5127 if (flag_implicit_templates
5129 && TREE_PUBLIC (decl
)
5130 && VAR_OR_FUNCTION_DECL_P (decl
))
5131 /* Set DECL_COMDAT on template instantiations; if we force
5132 them to be emitted by explicit instantiation or -frepo,
5133 mark_needed will tell cgraph to do the right thing. */
5134 DECL_COMDAT (decl
) = true;
5136 return DECL_TEMPLATE_RESULT (tmpl
);
5140 push_template_decl (tree decl
)
5142 return push_template_decl_real (decl
, false);
5145 /* FN is an inheriting constructor that inherits from the constructor
5146 template INHERITED; turn FN into a constructor template with a matching
5150 add_inherited_template_parms (tree fn
, tree inherited
)
5153 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5154 inner_parms
= copy_node (inner_parms
);
5156 = tree_cons (size_int (processing_template_decl
+ 1),
5157 inner_parms
, current_template_parms
);
5158 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5159 tree args
= template_parms_to_args (parms
);
5160 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5161 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5162 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5163 DECL_ARTIFICIAL (tmpl
) = true;
5164 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5168 /* Called when a class template TYPE is redeclared with the indicated
5169 template PARMS, e.g.:
5171 template <class T> struct S;
5172 template <class T> struct S {}; */
5175 redeclare_class_template (tree type
, tree parms
)
5181 if (!TYPE_TEMPLATE_INFO (type
))
5183 error ("%qT is not a template type", type
);
5187 tmpl
= TYPE_TI_TEMPLATE (type
);
5188 if (!PRIMARY_TEMPLATE_P (tmpl
))
5189 /* The type is nested in some template class. Nothing to worry
5190 about here; there are no new template parameters for the nested
5196 error ("template specifiers not specified in declaration of %qD",
5201 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5202 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5204 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5206 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5207 "redeclared with %d template parameter",
5208 "redeclared with %d template parameters",
5209 TREE_VEC_LENGTH (parms
));
5210 inform_n (input_location
, TREE_VEC_LENGTH (tmpl_parms
),
5211 "previous declaration %q+D used %d template parameter",
5212 "previous declaration %q+D used %d template parameters",
5213 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5217 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5224 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5225 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5228 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5229 if (error_operand_p (tmpl_parm
))
5232 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5233 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5234 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5236 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5238 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5239 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5240 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5241 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5242 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5243 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5244 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5245 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5246 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5248 error ("template parameter %q+#D", tmpl_parm
);
5249 error ("redeclared here as %q#D", parm
);
5253 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5255 /* We have in [temp.param]:
5257 A template-parameter may not be given default arguments
5258 by two different declarations in the same scope. */
5259 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5260 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5261 "original definition appeared here");
5265 if (parm_default
!= NULL_TREE
)
5266 /* Update the previous template parameters (which are the ones
5267 that will really count) with the new default value. */
5268 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5269 else if (tmpl_default
!= NULL_TREE
)
5270 /* Update the new parameters, too; they'll be used as the
5271 parameters for any members. */
5272 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5278 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5279 to be used when the caller has already checked
5280 (processing_template_decl
5281 && !instantiation_dependent_expression_p (expr)
5282 && potential_constant_expression (expr))
5283 and cleared processing_template_decl. */
5286 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
5288 return tsubst_copy_and_build (expr
,
5291 /*in_decl=*/NULL_TREE
,
5292 /*function_p=*/false,
5293 /*integral_constant_expression_p=*/true);
5296 /* Simplify EXPR if it is a non-dependent expression. Returns the
5297 (possibly simplified) expression. */
5300 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5302 if (expr
== NULL_TREE
)
5305 /* If we're in a template, but EXPR isn't value dependent, simplify
5306 it. We're supposed to treat:
5308 template <typename T> void f(T[1 + 1]);
5309 template <typename T> void f(T[2]);
5311 as two declarations of the same function, for example. */
5312 if (processing_template_decl
5313 && !instantiation_dependent_expression_p (expr
)
5314 && potential_constant_expression (expr
))
5316 processing_template_decl_sentinel s
;
5317 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
5323 instantiate_non_dependent_expr (tree expr
)
5325 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
5328 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5329 template declaration, or a TYPE_DECL for an alias declaration. */
5332 alias_type_or_template_p (tree t
)
5336 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5339 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5340 || DECL_ALIAS_TEMPLATE_P (t
));
5343 /* Return TRUE iff T is a specialization of an alias template. */
5346 alias_template_specialization_p (const_tree t
)
5348 /* It's an alias template specialization if it's an alias and its
5349 TYPE_NAME is a specialization of a primary template. */
5350 if (TYPE_ALIAS_P (t
))
5352 tree name
= TYPE_NAME (t
);
5353 if (DECL_LANG_SPECIFIC (name
))
5354 if (tree ti
= DECL_TEMPLATE_INFO (name
))
5356 tree tmpl
= TI_TEMPLATE (ti
);
5357 return PRIMARY_TEMPLATE_P (tmpl
);
5363 /* An alias template is complex from a SFINAE perspective if a template-id
5364 using that alias can be ill-formed when the expansion is not, as with
5365 the void_t template. We determine this by checking whether the
5366 expansion for the alias template uses all its template parameters. */
5368 struct uses_all_template_parms_data
5375 uses_all_template_parms_r (tree t
, void *data_
)
5377 struct uses_all_template_parms_data
&data
5378 = *(struct uses_all_template_parms_data
*)data_
;
5379 tree idx
= get_template_parm_index (t
);
5381 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
5382 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
5387 complex_alias_template_p (const_tree tmpl
)
5389 struct uses_all_template_parms_data data
;
5390 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5391 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5392 data
.level
= TMPL_PARMS_DEPTH (parms
);
5393 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
5394 data
.seen
= XALLOCAVEC (bool, len
);
5395 for (int i
= 0; i
< len
; ++i
)
5396 data
.seen
[i
] = false;
5398 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
5399 for (int i
= 0; i
< len
; ++i
)
5405 /* Return TRUE iff T is a specialization of a complex alias template with
5406 dependent template-arguments. */
5409 dependent_alias_template_spec_p (const_tree t
)
5411 return (alias_template_specialization_p (t
)
5412 && TEMPLATE_DECL_COMPLEX_ALIAS_P (DECL_TI_TEMPLATE (TYPE_NAME (t
)))
5413 && (any_dependent_template_arguments_p
5414 (INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (t
)))));
5417 /* Return the number of innermost template parameters in TMPL. */
5420 num_innermost_template_parms (tree tmpl
)
5422 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5423 return TREE_VEC_LENGTH (parms
);
5426 /* Return either TMPL or another template that it is equivalent to under DR
5427 1286: An alias that just changes the name of a template is equivalent to
5428 the other template. */
5431 get_underlying_template (tree tmpl
)
5433 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5434 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5436 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5437 if (TYPE_TEMPLATE_INFO (result
))
5439 tree sub
= TYPE_TI_TEMPLATE (result
);
5440 if (PRIMARY_TEMPLATE_P (sub
)
5441 && (num_innermost_template_parms (tmpl
)
5442 == num_innermost_template_parms (sub
)))
5444 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5445 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5446 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5448 /* The alias type is equivalent to the pattern of the
5449 underlying template, so strip the alias. */
5459 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5460 must be a function or a pointer-to-function type, as specified
5461 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5462 and check that the resulting function has external linkage. */
5465 convert_nontype_argument_function (tree type
, tree expr
,
5466 tsubst_flags_t complain
)
5470 linkage_kind linkage
;
5472 fn
= instantiate_type (type
, fns
, tf_none
);
5473 if (fn
== error_mark_node
)
5474 return error_mark_node
;
5477 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5478 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5479 if (BASELINK_P (fn_no_ptr
))
5480 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5482 /* [temp.arg.nontype]/1
5484 A template-argument for a non-type, non-template template-parameter
5487 -- the address of an object or function with external [C++11: or
5488 internal] linkage. */
5490 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5492 if (complain
& tf_error
)
5494 error ("%qE is not a valid template argument for type %qT",
5496 if (TYPE_PTR_P (type
))
5497 error ("it must be the address of a function with "
5498 "external linkage");
5500 error ("it must be the name of a function with "
5501 "external linkage");
5506 linkage
= decl_linkage (fn_no_ptr
);
5507 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5509 if (complain
& tf_error
)
5511 if (cxx_dialect
>= cxx11
)
5512 error ("%qE is not a valid template argument for type %qT "
5513 "because %qD has no linkage",
5514 expr
, type
, fn_no_ptr
);
5516 error ("%qE is not a valid template argument for type %qT "
5517 "because %qD does not have external linkage",
5518 expr
, type
, fn_no_ptr
);
5526 /* Subroutine of convert_nontype_argument.
5527 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5528 Emit an error otherwise. */
5531 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5532 tsubst_flags_t complain
)
5535 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5537 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5539 if (processing_template_decl
5540 && TREE_CODE (expr
) == ADDR_EXPR
5541 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
5543 if (complain
& tf_error
)
5545 error ("%qE is not a valid template argument for type %qT",
5547 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5552 /* Returns TRUE iff the address of OP is value-dependent.
5554 14.6.2.4 [temp.dep.temp]:
5555 A non-integral non-type template-argument is dependent if its type is
5556 dependent or it has either of the following forms
5559 and contains a nested-name-specifier which specifies a class-name that
5560 names a dependent type.
5562 We generalize this to just say that the address of a member of a
5563 dependent class is value-dependent; the above doesn't cover the
5564 address of a static data member named with an unqualified-id. */
5567 has_value_dependent_address (tree op
)
5569 /* We could use get_inner_reference here, but there's no need;
5570 this is only relevant for template non-type arguments, which
5571 can only be expressed as &id-expression. */
5574 tree ctx
= CP_DECL_CONTEXT (op
);
5575 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5582 /* The next set of functions are used for providing helpful explanatory
5583 diagnostics for failed overload resolution. Their messages should be
5584 indented by two spaces for consistency with the messages in
5588 unify_success (bool /*explain_p*/)
5594 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5597 inform (input_location
,
5598 " couldn't deduce template parameter %qD", parm
);
5603 unify_invalid (bool /*explain_p*/)
5609 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5612 inform (input_location
,
5613 " types %qT and %qT have incompatible cv-qualifiers",
5619 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5622 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5627 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5630 inform (input_location
,
5631 " template parameter %qD is not a parameter pack, but "
5638 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5641 inform (input_location
,
5642 " template argument %qE does not match "
5643 "pointer-to-member constant %qE",
5649 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5652 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5657 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5660 inform (input_location
,
5661 " inconsistent parameter pack deduction with %qT and %qT",
5667 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5672 inform (input_location
,
5673 " deduced conflicting types for parameter %qT (%qT and %qT)",
5674 parm
, first
, second
);
5676 inform (input_location
,
5677 " deduced conflicting values for non-type parameter "
5678 "%qE (%qE and %qE)", parm
, first
, second
);
5684 unify_vla_arg (bool explain_p
, tree arg
)
5687 inform (input_location
,
5688 " variable-sized array type %qT is not "
5689 "a valid template argument",
5695 unify_method_type_error (bool explain_p
, tree arg
)
5698 inform (input_location
,
5699 " member function type %qT is not a valid template argument",
5705 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
5710 inform_n (input_location
, wanted
,
5711 " candidate expects at least %d argument, %d provided",
5712 " candidate expects at least %d arguments, %d provided",
5715 inform_n (input_location
, wanted
,
5716 " candidate expects %d argument, %d provided",
5717 " candidate expects %d arguments, %d provided",
5724 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5726 return unify_arity (explain_p
, have
, wanted
);
5730 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
5731 bool least_p
= false)
5733 return unify_arity (explain_p
, have
, wanted
, least_p
);
5737 unify_arg_conversion (bool explain_p
, tree to_type
,
5738 tree from_type
, tree arg
)
5741 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5742 " cannot convert %qE (type %qT) to type %qT",
5743 arg
, from_type
, to_type
);
5748 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5749 tree parm
, tree arg
)
5754 case tbr_ambiguous_baseclass
:
5755 inform (input_location
, " %qT is an ambiguous base class of %qT",
5759 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5766 unify_inconsistent_template_template_parameters (bool explain_p
)
5769 inform (input_location
,
5770 " template parameters of a template template argument are "
5771 "inconsistent with other deduced template arguments");
5776 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5779 inform (input_location
,
5780 " can't deduce a template for %qT from non-template type %qT",
5786 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5789 inform (input_location
,
5790 " template argument %qE does not match %qD", arg
, parm
);
5795 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5798 inform (input_location
,
5799 " could not resolve address from overloaded function %qE",
5804 /* Attempt to convert the non-type template parameter EXPR to the
5805 indicated TYPE. If the conversion is successful, return the
5806 converted value. If the conversion is unsuccessful, return
5807 NULL_TREE if we issued an error message, or error_mark_node if we
5808 did not. We issue error messages for out-and-out bad template
5809 parameters, but not simply because the conversion failed, since we
5810 might be just trying to do argument deduction. Both TYPE and EXPR
5811 must be non-dependent.
5813 The conversion follows the special rules described in
5814 [temp.arg.nontype], and it is much more strict than an implicit
5817 This function is called twice for each template argument (see
5818 lookup_template_class for a more accurate description of this
5819 problem). This means that we need to handle expressions which
5820 are not valid in a C++ source, but can be created from the
5821 first call (for instance, casts to perform conversions). These
5822 hacks can go away after we fix the double coercion problem. */
5825 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5829 /* Detect immediately string literals as invalid non-type argument.
5830 This special-case is not needed for correctness (we would easily
5831 catch this later), but only to provide better diagnostic for this
5832 common user mistake. As suggested by DR 100, we do not mention
5833 linkage issues in the diagnostic as this is not the point. */
5834 /* FIXME we're making this OK. */
5835 if (TREE_CODE (expr
) == STRING_CST
)
5837 if (complain
& tf_error
)
5838 error ("%qE is not a valid template argument for type %qT "
5839 "because string literals can never be used in this context",
5844 /* Add the ADDR_EXPR now for the benefit of
5845 value_dependent_expression_p. */
5846 if (TYPE_PTROBV_P (type
)
5847 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5849 expr
= decay_conversion (expr
, complain
);
5850 if (expr
== error_mark_node
)
5851 return error_mark_node
;
5854 /* If we are in a template, EXPR may be non-dependent, but still
5855 have a syntactic, rather than semantic, form. For example, EXPR
5856 might be a SCOPE_REF, rather than the VAR_DECL to which the
5857 SCOPE_REF refers. Preserving the qualifying scope is necessary
5858 so that access checking can be performed when the template is
5859 instantiated -- but here we need the resolved form so that we can
5860 convert the argument. */
5861 bool non_dep
= false;
5862 if (TYPE_REF_OBJ_P (type
)
5863 && has_value_dependent_address (expr
))
5864 /* If we want the address and it's value-dependent, don't fold. */;
5865 else if (!type_unknown_p (expr
)
5866 && processing_template_decl
5867 && !instantiation_dependent_expression_p (expr
)
5868 && potential_constant_expression (expr
))
5870 if (error_operand_p (expr
))
5871 return error_mark_node
;
5872 expr_type
= TREE_TYPE (expr
);
5873 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5874 expr
= mark_lvalue_use (expr
);
5876 expr
= mark_rvalue_use (expr
);
5878 /* If the argument is non-dependent, perform any conversions in
5879 non-dependent context as well. */
5880 processing_template_decl_sentinel
s (non_dep
);
5882 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
5884 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5885 to a non-type argument of "nullptr". */
5886 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5887 expr
= convert (type
, expr
);
5889 /* In C++11, integral or enumeration non-type template arguments can be
5890 arbitrary constant expressions. Pointer and pointer to
5891 member arguments can be general constant expressions that evaluate
5892 to a null value, but otherwise still need to be of a specific form. */
5893 if (cxx_dialect
>= cxx11
)
5895 if (TREE_CODE (expr
) == PTRMEM_CST
)
5896 /* A PTRMEM_CST is already constant, and a valid template
5897 argument for a parameter of pointer to member type, we just want
5898 to leave it in that form rather than lower it to a
5900 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5901 expr
= maybe_constant_value (expr
);
5902 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5904 tree folded
= maybe_constant_value (expr
);
5905 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5906 : null_member_pointer_value_p (folded
))
5911 /* HACK: Due to double coercion, we can get a
5912 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5913 which is the tree that we built on the first call (see
5914 below when coercing to reference to object or to reference to
5915 function). We just strip everything and get to the arg.
5916 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5918 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5920 tree probe_type
, probe
= expr
;
5921 if (REFERENCE_REF_P (probe
))
5922 probe
= TREE_OPERAND (probe
, 0);
5923 probe_type
= TREE_TYPE (probe
);
5924 if (TREE_CODE (probe
) == NOP_EXPR
)
5926 /* ??? Maybe we could use convert_from_reference here, but we
5927 would need to relax its constraints because the NOP_EXPR
5928 could actually change the type to something more cv-qualified,
5929 and this is not folded by convert_from_reference. */
5930 tree addr
= TREE_OPERAND (probe
, 0);
5931 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5932 && TREE_CODE (addr
) == ADDR_EXPR
5933 && TYPE_PTR_P (TREE_TYPE (addr
))
5934 && (same_type_ignoring_top_level_qualifiers_p
5935 (TREE_TYPE (probe_type
),
5936 TREE_TYPE (TREE_TYPE (addr
)))))
5938 expr
= TREE_OPERAND (addr
, 0);
5939 expr_type
= TREE_TYPE (probe_type
);
5944 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5945 parameter is a pointer to object, through decay and
5946 qualification conversion. Let's strip everything. */
5947 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5951 if (TREE_CODE (probe
) == ADDR_EXPR
5952 && TYPE_PTR_P (TREE_TYPE (probe
)))
5954 /* Skip the ADDR_EXPR only if it is part of the decay for
5955 an array. Otherwise, it is part of the original argument
5956 in the source code. */
5957 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5958 probe
= TREE_OPERAND (probe
, 0);
5960 expr_type
= TREE_TYPE (expr
);
5964 /* [temp.arg.nontype]/5, bullet 1
5966 For a non-type template-parameter of integral or enumeration type,
5967 integral promotions (_conv.prom_) and integral conversions
5968 (_conv.integral_) are applied. */
5969 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5971 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5972 t
= maybe_constant_value (t
);
5973 if (t
!= error_mark_node
)
5976 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5977 return error_mark_node
;
5979 /* Notice that there are constant expressions like '4 % 0' which
5980 do not fold into integer constants. */
5981 if (TREE_CODE (expr
) != INTEGER_CST
)
5983 if (complain
& tf_error
)
5985 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
5986 if (processing_template_decl
5987 && !require_potential_constant_expression (expr
))
5989 expr
= cxx_constant_value (expr
);
5990 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
5991 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
5992 "in template argument for type %qT ", type
);
5993 if (expr
== error_mark_node
)
5995 /* else cxx_constant_value complained but gave us
5996 a real constant, so go ahead. */
5997 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
6003 /* Avoid typedef problems. */
6004 if (TREE_TYPE (expr
) != type
)
6005 expr
= fold_convert (type
, expr
);
6007 /* [temp.arg.nontype]/5, bullet 2
6009 For a non-type template-parameter of type pointer to object,
6010 qualification conversions (_conv.qual_) and the array-to-pointer
6011 conversion (_conv.array_) are applied. */
6012 else if (TYPE_PTROBV_P (type
))
6014 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6016 A template-argument for a non-type, non-template template-parameter
6017 shall be one of: [...]
6019 -- the name of a non-type template-parameter;
6020 -- the address of an object or function with external linkage, [...]
6021 expressed as "& id-expression" where the & is optional if the name
6022 refers to a function or array, or if the corresponding
6023 template-parameter is a reference.
6025 Here, we do not care about functions, as they are invalid anyway
6026 for a parameter of type pointer-to-object. */
6028 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
6029 /* Non-type template parameters are OK. */
6031 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6032 /* Null pointer values are OK in C++11. */;
6033 else if (TREE_CODE (expr
) != ADDR_EXPR
6034 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
6038 if (complain
& tf_error
)
6039 error ("%qD is not a valid template argument "
6040 "because %qD is a variable, not the address of "
6041 "a variable", expr
, expr
);
6044 if (POINTER_TYPE_P (expr_type
))
6046 if (complain
& tf_error
)
6047 error ("%qE is not a valid template argument for %qT "
6048 "because it is not the address of a variable",
6052 /* Other values, like integer constants, might be valid
6053 non-type arguments of some other type. */
6054 return error_mark_node
;
6060 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
6061 ? TREE_OPERAND (expr
, 0) : expr
);
6064 if (complain
& tf_error
)
6065 error ("%qE is not a valid template argument of type %qT "
6066 "because %qE is not a variable", expr
, type
, decl
);
6069 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6071 if (complain
& tf_error
)
6072 error ("%qE is not a valid template argument of type %qT "
6073 "because %qD does not have external linkage",
6077 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
6079 if (complain
& tf_error
)
6080 error ("%qE is not a valid template argument of type %qT "
6081 "because %qD has no linkage", expr
, type
, decl
);
6086 expr
= decay_conversion (expr
, complain
);
6087 if (expr
== error_mark_node
)
6088 return error_mark_node
;
6090 expr
= perform_qualification_conversions (type
, expr
);
6091 if (expr
== error_mark_node
)
6092 return error_mark_node
;
6094 /* [temp.arg.nontype]/5, bullet 3
6096 For a non-type template-parameter of type reference to object, no
6097 conversions apply. The type referred to by the reference may be more
6098 cv-qualified than the (otherwise identical) type of the
6099 template-argument. The template-parameter is bound directly to the
6100 template-argument, which must be an lvalue. */
6101 else if (TYPE_REF_OBJ_P (type
))
6103 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
6105 return error_mark_node
;
6107 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
6109 if (complain
& tf_error
)
6110 error ("%qE is not a valid template argument for type %qT "
6111 "because of conflicts in cv-qualification", expr
, type
);
6115 if (!real_lvalue_p (expr
))
6117 if (complain
& tf_error
)
6118 error ("%qE is not a valid template argument for type %qT "
6119 "because it is not an lvalue", expr
, type
);
6123 /* [temp.arg.nontype]/1
6125 A template-argument for a non-type, non-template template-parameter
6126 shall be one of: [...]
6128 -- the address of an object or function with external linkage. */
6129 if (INDIRECT_REF_P (expr
)
6130 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
6132 expr
= TREE_OPERAND (expr
, 0);
6135 if (complain
& tf_error
)
6136 error ("%q#D is not a valid template argument for type %qT "
6137 "because a reference variable does not have a constant "
6138 "address", expr
, type
);
6145 if (complain
& tf_error
)
6146 error ("%qE is not a valid template argument for type %qT "
6147 "because it is not an object with external linkage",
6152 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
6154 if (complain
& tf_error
)
6155 error ("%qE is not a valid template argument for type %qT "
6156 "because object %qD has not external linkage",
6161 expr
= build_nop (type
, build_address (expr
));
6163 /* [temp.arg.nontype]/5, bullet 4
6165 For a non-type template-parameter of type pointer to function, only
6166 the function-to-pointer conversion (_conv.func_) is applied. If the
6167 template-argument represents a set of overloaded functions (or a
6168 pointer to such), the matching function is selected from the set
6170 else if (TYPE_PTRFN_P (type
))
6172 /* If the argument is a template-id, we might not have enough
6173 context information to decay the pointer. */
6174 if (!type_unknown_p (expr_type
))
6176 expr
= decay_conversion (expr
, complain
);
6177 if (expr
== error_mark_node
)
6178 return error_mark_node
;
6181 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6182 /* Null pointer values are OK in C++11. */
6183 return perform_qualification_conversions (type
, expr
);
6185 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6186 if (!expr
|| expr
== error_mark_node
)
6189 /* [temp.arg.nontype]/5, bullet 5
6191 For a non-type template-parameter of type reference to function, no
6192 conversions apply. If the template-argument represents a set of
6193 overloaded functions, the matching function is selected from the set
6195 else if (TYPE_REFFN_P (type
))
6197 if (TREE_CODE (expr
) == ADDR_EXPR
)
6199 if (complain
& tf_error
)
6201 error ("%qE is not a valid template argument for type %qT "
6202 "because it is a pointer", expr
, type
);
6203 inform (input_location
, "try using %qE instead",
6204 TREE_OPERAND (expr
, 0));
6209 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6210 if (!expr
|| expr
== error_mark_node
)
6213 expr
= build_nop (type
, build_address (expr
));
6215 /* [temp.arg.nontype]/5, bullet 6
6217 For a non-type template-parameter of type pointer to member function,
6218 no conversions apply. If the template-argument represents a set of
6219 overloaded member functions, the matching member function is selected
6220 from the set (_over.over_). */
6221 else if (TYPE_PTRMEMFUNC_P (type
))
6223 expr
= instantiate_type (type
, expr
, tf_none
);
6224 if (expr
== error_mark_node
)
6225 return error_mark_node
;
6227 /* [temp.arg.nontype] bullet 1 says the pointer to member
6228 expression must be a pointer-to-member constant. */
6229 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6230 return error_mark_node
;
6232 /* There is no way to disable standard conversions in
6233 resolve_address_of_overloaded_function (called by
6234 instantiate_type). It is possible that the call succeeded by
6235 converting &B::I to &D::I (where B is a base of D), so we need
6236 to reject this conversion here.
6238 Actually, even if there was a way to disable standard conversions,
6239 it would still be better to reject them here so that we can
6240 provide a superior diagnostic. */
6241 if (!same_type_p (TREE_TYPE (expr
), type
))
6243 if (complain
& tf_error
)
6245 error ("%qE is not a valid template argument for type %qT "
6246 "because it is of type %qT", expr
, type
,
6248 /* If we are just one standard conversion off, explain. */
6249 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6250 inform (input_location
,
6251 "standard conversions are not allowed in this context");
6256 /* [temp.arg.nontype]/5, bullet 7
6258 For a non-type template-parameter of type pointer to data member,
6259 qualification conversions (_conv.qual_) are applied. */
6260 else if (TYPE_PTRDATAMEM_P (type
))
6262 /* [temp.arg.nontype] bullet 1 says the pointer to member
6263 expression must be a pointer-to-member constant. */
6264 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6265 return error_mark_node
;
6267 expr
= perform_qualification_conversions (type
, expr
);
6268 if (expr
== error_mark_node
)
6271 else if (NULLPTR_TYPE_P (type
))
6273 if (expr
!= nullptr_node
)
6275 if (complain
& tf_error
)
6276 error ("%qE is not a valid template argument for type %qT "
6277 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6282 /* A template non-type parameter must be one of the above. */
6286 /* Sanity check: did we actually convert the argument to the
6288 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6289 (type
, TREE_TYPE (expr
)));
6290 return convert_from_reference (expr
);
6293 /* Subroutine of coerce_template_template_parms, which returns 1 if
6294 PARM_PARM and ARG_PARM match using the rule for the template
6295 parameters of template template parameters. Both PARM and ARG are
6296 template parameters; the rest of the arguments are the same as for
6297 coerce_template_template_parms.
6300 coerce_template_template_parm (tree parm
,
6302 tsubst_flags_t complain
,
6306 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6307 || parm
== NULL_TREE
|| error_operand_p (parm
))
6310 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6313 switch (TREE_CODE (parm
))
6316 /* We encounter instantiations of templates like
6317 template <template <template <class> class> class TT>
6320 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6321 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6323 if (!coerce_template_template_parms
6324 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6330 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6331 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6332 /* Argument is a parameter pack but parameter is not. */
6337 /* The tsubst call is used to handle cases such as
6339 template <int> class C {};
6340 template <class T, template <T> class TT> class D {};
6343 i.e. the parameter list of TT depends on earlier parameters. */
6344 if (!uses_template_parms (TREE_TYPE (arg
))
6346 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6350 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6351 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6352 /* Argument is a parameter pack but parameter is not. */
6365 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6366 template template parameters. Both PARM_PARMS and ARG_PARMS are
6367 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6370 Consider the example:
6371 template <class T> class A;
6372 template<template <class U> class TT> class B;
6374 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6375 the parameters to A, and OUTER_ARGS contains A. */
6378 coerce_template_template_parms (tree parm_parms
,
6380 tsubst_flags_t complain
,
6384 int nparms
, nargs
, i
;
6388 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6389 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6391 nparms
= TREE_VEC_LENGTH (parm_parms
);
6392 nargs
= TREE_VEC_LENGTH (arg_parms
);
6394 /* Determine whether we have a parameter pack at the end of the
6395 template template parameter's template parameter list. */
6396 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6398 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6400 if (error_operand_p (parm
))
6403 switch (TREE_CODE (parm
))
6407 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6412 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6422 && !(variadic_p
&& nargs
>= nparms
- 1))
6425 /* Check all of the template parameters except the parameter pack at
6426 the end (if any). */
6427 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6429 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6430 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6433 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6434 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6436 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6444 /* Check each of the template parameters in the template
6445 argument against the template parameter pack at the end of
6446 the template template parameter. */
6447 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6450 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6452 for (; i
< nargs
; ++i
)
6454 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6457 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6459 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6468 /* Verifies that the deduced template arguments (in TARGS) for the
6469 template template parameters (in TPARMS) represent valid bindings,
6470 by comparing the template parameter list of each template argument
6471 to the template parameter list of its corresponding template
6472 template parameter, in accordance with DR150. This
6473 routine can only be called after all template arguments have been
6474 deduced. It will return TRUE if all of the template template
6475 parameter bindings are okay, FALSE otherwise. */
6477 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6479 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6482 /* We're dealing with template parms in this process. */
6483 ++processing_template_decl
;
6485 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6487 for (i
= 0; i
< ntparms
; ++i
)
6489 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6490 tree targ
= TREE_VEC_ELT (targs
, i
);
6492 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6494 tree packed_args
= NULL_TREE
;
6497 if (ARGUMENT_PACK_P (targ
))
6499 /* Look inside the argument pack. */
6500 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6501 len
= TREE_VEC_LENGTH (packed_args
);
6504 for (idx
= 0; idx
< len
; ++idx
)
6506 tree targ_parms
= NULL_TREE
;
6509 /* Extract the next argument from the argument
6511 targ
= TREE_VEC_ELT (packed_args
, idx
);
6513 if (PACK_EXPANSION_P (targ
))
6514 /* Look at the pattern of the pack expansion. */
6515 targ
= PACK_EXPANSION_PATTERN (targ
);
6517 /* Extract the template parameters from the template
6519 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6520 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6521 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6522 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6524 /* Verify that we can coerce the template template
6525 parameters from the template argument to the template
6526 parameter. This requires an exact match. */
6528 && !coerce_template_template_parms
6529 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6544 --processing_template_decl
;
6548 /* Since type attributes aren't mangled, we need to strip them from
6549 template type arguments. */
6552 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6554 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6556 bool removed_attributes
= false;
6557 tree canon
= strip_typedefs (arg
, &removed_attributes
);
6558 if (removed_attributes
6559 && (complain
& tf_warning
))
6560 warning (0, "ignoring attributes on template argument %qT", arg
);
6564 /* Convert the indicated template ARG as necessary to match the
6565 indicated template PARM. Returns the converted ARG, or
6566 error_mark_node if the conversion was unsuccessful. Error and
6567 warning messages are issued under control of COMPLAIN. This
6568 conversion is for the Ith parameter in the parameter list. ARGS is
6569 the full set of template arguments deduced so far. */
6572 convert_template_argument (tree parm
,
6575 tsubst_flags_t complain
,
6581 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6583 if (parm
== error_mark_node
)
6584 return error_mark_node
;
6586 if (TREE_CODE (arg
) == TREE_LIST
6587 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6589 /* The template argument was the name of some
6590 member function. That's usually
6591 invalid, but static members are OK. In any
6592 case, grab the underlying fields/functions
6593 and issue an error later if required. */
6594 orig_arg
= TREE_VALUE (arg
);
6595 TREE_TYPE (arg
) = unknown_type_node
;
6600 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6601 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6602 || requires_tmpl_type
);
6604 /* When determining whether an argument pack expansion is a template,
6605 look at the pattern. */
6606 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6607 arg
= PACK_EXPANSION_PATTERN (arg
);
6609 /* Deal with an injected-class-name used as a template template arg. */
6610 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6612 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6613 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6615 if (cxx_dialect
>= cxx11
)
6616 /* OK under DR 1004. */;
6617 else if (complain
& tf_warning_or_error
)
6618 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6619 " used as template template argument", TYPE_NAME (arg
));
6620 else if (flag_pedantic_errors
)
6628 ((TREE_CODE (arg
) == TEMPLATE_DECL
6629 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6630 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6631 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6632 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6635 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6636 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6637 arg
= TYPE_STUB_DECL (arg
);
6639 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6641 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6642 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6644 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6646 if (complain
& tf_error
)
6647 error ("invalid use of destructor %qE as a type", orig_arg
);
6648 return error_mark_node
;
6651 permerror (input_location
,
6652 "to refer to a type member of a template parameter, "
6653 "use %<typename %E%>", orig_arg
);
6655 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6656 TREE_OPERAND (arg
, 1),
6662 if (is_type
!= requires_type
)
6666 if (complain
& tf_error
)
6668 error ("type/value mismatch at argument %d in template "
6669 "parameter list for %qD",
6672 inform (input_location
,
6673 " expected a constant of type %qT, got %qT",
6675 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6676 else if (requires_tmpl_type
)
6677 inform (input_location
,
6678 " expected a class template, got %qE", orig_arg
);
6680 inform (input_location
,
6681 " expected a type, got %qE", orig_arg
);
6684 return error_mark_node
;
6686 if (is_tmpl_type
^ requires_tmpl_type
)
6688 if (in_decl
&& (complain
& tf_error
))
6690 error ("type/value mismatch at argument %d in template "
6691 "parameter list for %qD",
6694 inform (input_location
,
6695 " expected a type, got %qT", DECL_NAME (arg
));
6697 inform (input_location
,
6698 " expected a class template, got %qT", orig_arg
);
6700 return error_mark_node
;
6705 if (requires_tmpl_type
)
6707 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6709 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6710 /* The number of argument required is not known yet.
6711 Just accept it for now. */
6712 val
= TREE_TYPE (arg
);
6715 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6718 /* Strip alias templates that are equivalent to another
6720 arg
= get_underlying_template (arg
);
6721 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6723 if (coerce_template_template_parms (parmparm
, argparm
,
6729 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6731 if (val
!= error_mark_node
)
6733 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6734 val
= TREE_TYPE (val
);
6735 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6736 val
= make_pack_expansion (val
);
6741 if (in_decl
&& (complain
& tf_error
))
6743 error ("type/value mismatch at argument %d in "
6744 "template parameter list for %qD",
6746 inform (input_location
,
6747 " expected a template of type %qD, got %qT",
6751 val
= error_mark_node
;
6757 /* We only form one instance of each template specialization.
6758 Therefore, if we use a non-canonical variant (i.e., a
6759 typedef), any future messages referring to the type will use
6760 the typedef, which is confusing if those future uses do not
6761 themselves also use the typedef. */
6763 val
= canonicalize_type_argument (val
, complain
);
6767 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6769 if (invalid_nontype_parm_type_p (t
, complain
))
6770 return error_mark_node
;
6772 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6774 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6778 /* Not sure if this is reachable, but it doesn't hurt
6780 error ("type mismatch in nontype parameter pack");
6781 val
= error_mark_node
;
6784 else if (!dependent_template_arg_p (orig_arg
)
6785 && !uses_template_parms (t
))
6786 /* We used to call digest_init here. However, digest_init
6787 will report errors, which we don't want when complain
6788 is zero. More importantly, digest_init will try too
6789 hard to convert things: for example, `0' should not be
6790 converted to pointer type at this point according to
6791 the standard. Accepting this is not merely an
6792 extension, since deciding whether or not these
6793 conversions can occur is part of determining which
6794 function template to call, or whether a given explicit
6795 argument specification is valid. */
6796 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6799 bool removed_attr
= false;
6800 val
= strip_typedefs_expr (orig_arg
, &removed_attr
);
6803 if (val
== NULL_TREE
)
6804 val
= error_mark_node
;
6805 else if (val
== error_mark_node
&& (complain
& tf_error
))
6806 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6808 if (TREE_CODE (val
) == SCOPE_REF
)
6810 /* Strip typedefs from the SCOPE_REF. */
6811 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6812 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6814 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6815 QUALIFIED_NAME_IS_TEMPLATE (val
));
6822 /* Coerces the remaining template arguments in INNER_ARGS (from
6823 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6824 Returns the coerced argument pack. PARM_IDX is the position of this
6825 parameter in the template parameter list. ARGS is the original
6826 template argument list. */
6828 coerce_template_parameter_pack (tree parms
,
6836 tsubst_flags_t complain
)
6838 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6839 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6842 tree packed_parms
= NULL_TREE
;
6844 if (arg_idx
> nargs
)
6847 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6849 /* When the template parameter is a non-type template parameter pack
6850 or template template parameter pack whose type or template
6851 parameters use parameter packs, we know exactly how many arguments
6852 we are looking for. Build a vector of the instantiated decls for
6853 these template parameters in PACKED_PARMS. */
6854 /* We can't use make_pack_expansion here because it would interpret a
6855 _DECL as a use rather than a declaration. */
6856 tree decl
= TREE_VALUE (parm
);
6857 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6858 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6859 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6860 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6862 TREE_VEC_LENGTH (args
)--;
6863 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6864 TREE_VEC_LENGTH (args
)++;
6866 if (packed_parms
== error_mark_node
)
6867 return error_mark_node
;
6869 /* If we're doing a partial instantiation of a member template,
6870 verify that all of the types used for the non-type
6871 template parameter pack are, in fact, valid for non-type
6872 template parameters. */
6874 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6876 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6877 for (j
= 0; j
< len
; ++j
)
6879 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6880 if (invalid_nontype_parm_type_p (t
, complain
))
6881 return error_mark_node
;
6883 /* We don't know how many args we have yet, just
6884 use the unconverted ones for now. */
6888 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6891 packed_args
= make_tree_vec (nargs
- arg_idx
);
6893 /* Convert the remaining arguments, which will be a part of the
6894 parameter pack "parm". */
6895 for (; arg_idx
< nargs
; ++arg_idx
)
6897 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6898 tree actual_parm
= TREE_VALUE (parm
);
6899 int pack_idx
= arg_idx
- parm_idx
;
6903 /* Once we've packed as many args as we have types, stop. */
6904 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6906 else if (PACK_EXPANSION_P (arg
))
6907 /* We don't know how many args we have yet, just
6908 use the unconverted ones for now. */
6911 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6914 if (arg
== error_mark_node
)
6916 if (complain
& tf_error
)
6917 error ("template argument %d is invalid", arg_idx
+ 1);
6920 arg
= convert_template_argument (actual_parm
,
6921 arg
, new_args
, complain
, parm_idx
,
6923 if (arg
== error_mark_node
)
6925 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6928 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6929 && TREE_VEC_LENGTH (packed_args
) > 0)
6931 if (complain
& tf_error
)
6932 error ("wrong number of template arguments (%d, should be %d)",
6933 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6934 return error_mark_node
;
6937 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6938 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6939 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6942 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6943 TREE_TYPE (argument_pack
)
6944 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6945 TREE_CONSTANT (argument_pack
) = 1;
6948 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6949 #ifdef ENABLE_CHECKING
6950 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6951 TREE_VEC_LENGTH (packed_args
));
6953 return argument_pack
;
6956 /* Returns the number of pack expansions in the template argument vector
6960 pack_expansion_args_count (tree args
)
6965 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6967 tree elt
= TREE_VEC_ELT (args
, i
);
6968 if (elt
&& PACK_EXPANSION_P (elt
))
6974 /* Convert all template arguments to their appropriate types, and
6975 return a vector containing the innermost resulting template
6976 arguments. If any error occurs, return error_mark_node. Error and
6977 warning messages are issued under control of COMPLAIN.
6979 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6980 for arguments not specified in ARGS. Otherwise, if
6981 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6982 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6983 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6987 coerce_template_parms (tree parms
,
6990 tsubst_flags_t complain
,
6991 bool require_all_args
,
6992 bool use_default_args
)
6994 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6995 tree orig_inner_args
;
6998 tree new_inner_args
;
6999 int saved_unevaluated_operand
;
7000 int saved_inhibit_evaluation_warnings
;
7002 /* When used as a boolean value, indicates whether this is a
7003 variadic template parameter list. Since it's an int, we can also
7004 subtract it from nparms to get the number of non-variadic
7007 int variadic_args_p
= 0;
7008 int post_variadic_parms
= 0;
7010 /* Likewise for parameters with default arguments. */
7013 if (args
== error_mark_node
)
7014 return error_mark_node
;
7016 nparms
= TREE_VEC_LENGTH (parms
);
7018 /* Determine if there are any parameter packs or default arguments. */
7019 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
7021 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
7023 ++post_variadic_parms
;
7024 if (template_parameter_pack_p (TREE_VALUE (parm
)))
7026 if (TREE_PURPOSE (parm
))
7030 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
7031 /* If there are no parameters that follow a parameter pack, we need to
7032 expand any argument packs so that we can deduce a parameter pack from
7033 some non-packed args followed by an argument pack, as in variadic85.C.
7034 If there are such parameters, we need to leave argument packs intact
7035 so the arguments are assigned properly. This can happen when dealing
7036 with a nested class inside a partial specialization of a class
7037 template, as in variadic92.C, or when deducing a template parameter pack
7038 from a sub-declarator, as in variadic114.C. */
7039 if (!post_variadic_parms
)
7040 inner_args
= expand_template_argument_pack (inner_args
);
7042 /* Count any pack expansion args. */
7043 variadic_args_p
= pack_expansion_args_count (inner_args
);
7045 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
7046 if ((nargs
> nparms
&& !variadic_p
)
7047 || (nargs
< nparms
- variadic_p
7050 && (!use_default_args
7051 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
7052 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
7054 if (complain
& tf_error
)
7056 if (variadic_p
|| default_p
)
7058 nparms
-= variadic_p
+ default_p
;
7059 error ("wrong number of template arguments "
7060 "(%d, should be at least %d)", nargs
, nparms
);
7063 error ("wrong number of template arguments "
7064 "(%d, should be %d)", nargs
, nparms
);
7067 inform (input_location
, "provided for %q+D", in_decl
);
7070 return error_mark_node
;
7072 /* We can't pass a pack expansion to a non-pack parameter of an alias
7073 template (DR 1430). */
7074 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
7076 && nargs
- variadic_args_p
< nparms
- variadic_p
)
7078 if (complain
& tf_error
)
7080 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
7082 tree arg
= TREE_VEC_ELT (inner_args
, i
);
7083 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
7085 if (PACK_EXPANSION_P (arg
)
7086 && !template_parameter_pack_p (parm
))
7088 error ("pack expansion argument for non-pack parameter "
7089 "%qD of alias template %qD", parm
, in_decl
);
7090 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
7097 return error_mark_node
;
7100 /* We need to evaluate the template arguments, even though this
7101 template-id may be nested within a "sizeof". */
7102 saved_unevaluated_operand
= cp_unevaluated_operand
;
7103 cp_unevaluated_operand
= 0;
7104 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
7105 c_inhibit_evaluation_warnings
= 0;
7106 new_inner_args
= make_tree_vec (nparms
);
7107 new_args
= add_outermost_template_args (args
, new_inner_args
);
7108 int pack_adjust
= 0;
7109 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
7114 /* Get the Ith template parameter. */
7115 parm
= TREE_VEC_ELT (parms
, parm_idx
);
7117 if (parm
== error_mark_node
)
7119 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
7123 /* Calculate the next argument. */
7124 if (arg_idx
< nargs
)
7125 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
7129 if (template_parameter_pack_p (TREE_VALUE (parm
))
7130 && !(arg
&& ARGUMENT_PACK_P (arg
)))
7132 /* Some arguments will be placed in the
7133 template parameter pack PARM. */
7134 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
7135 inner_args
, arg_idx
,
7139 if (arg
== NULL_TREE
)
7141 /* We don't know how many args we have yet, just use the
7142 unconverted (and still packed) ones for now. */
7143 new_inner_args
= orig_inner_args
;
7148 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
7150 /* Store this argument. */
7151 if (arg
== error_mark_node
)
7154 /* We are done with all of the arguments. */
7159 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
7160 arg_idx
+= pack_adjust
;
7167 if (PACK_EXPANSION_P (arg
))
7169 /* "If every valid specialization of a variadic template
7170 requires an empty template parameter pack, the template is
7171 ill-formed, no diagnostic required." So check that the
7172 pattern works with this parameter. */
7173 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
7174 tree conv
= convert_template_argument (TREE_VALUE (parm
),
7178 if (conv
== error_mark_node
)
7180 inform (input_location
, "so any instantiation with a "
7181 "non-empty parameter pack would be ill-formed");
7184 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
7185 /* Recover from missing typename. */
7186 TREE_VEC_ELT (inner_args
, arg_idx
)
7187 = make_pack_expansion (conv
);
7189 /* We don't know how many args we have yet, just
7190 use the unconverted ones for now. */
7191 new_inner_args
= inner_args
;
7196 else if (require_all_args
)
7198 /* There must be a default arg in this case. */
7199 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
7201 /* The position of the first default template argument,
7202 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7204 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7205 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7206 arg_idx
- pack_adjust
);
7211 if (arg
== error_mark_node
)
7213 if (complain
& tf_error
)
7214 error ("template argument %d is invalid", arg_idx
+ 1);
7217 /* This only occurs if there was an error in the template
7218 parameter list itself (which we would already have
7219 reported) that we are trying to recover from, e.g., a class
7220 template with a parameter list such as
7221 template<typename..., typename>. */
7224 arg
= convert_template_argument (TREE_VALUE (parm
),
7225 arg
, new_args
, complain
,
7228 if (arg
== error_mark_node
)
7230 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7232 cp_unevaluated_operand
= saved_unevaluated_operand
;
7233 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7235 if (variadic_p
&& arg_idx
< nargs
)
7237 if (complain
& tf_error
)
7239 error ("wrong number of template arguments "
7240 "(%d, should be %d)", nargs
, arg_idx
);
7242 error ("provided for %q+D", in_decl
);
7244 return error_mark_node
;
7248 return error_mark_node
;
7250 #ifdef ENABLE_CHECKING
7251 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7252 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7253 TREE_VEC_LENGTH (new_inner_args
));
7256 return new_inner_args
;
7259 /* Like coerce_template_parms. If PARMS represents all template
7260 parameters levels, this function returns a vector of vectors
7261 representing all the resulting argument levels. Note that in this
7262 case, only the innermost arguments are coerced because the
7263 outermost ones are supposed to have been coerced already.
7265 Otherwise, if PARMS represents only (the innermost) vector of
7266 parameters, this function returns a vector containing just the
7267 innermost resulting arguments. */
7270 coerce_innermost_template_parms (tree parms
,
7273 tsubst_flags_t complain
,
7274 bool require_all_args
,
7275 bool use_default_args
)
7277 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7278 int args_depth
= TMPL_ARGS_DEPTH (args
);
7281 if (parms_depth
> 1)
7283 coerced_args
= make_tree_vec (parms_depth
);
7287 for (level
= parms
, cur_depth
= parms_depth
;
7288 parms_depth
> 0 && level
!= NULL_TREE
;
7289 level
= TREE_CHAIN (level
), --cur_depth
)
7292 if (cur_depth
== args_depth
)
7293 l
= coerce_template_parms (TREE_VALUE (level
),
7294 args
, in_decl
, complain
,
7298 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7300 if (l
== error_mark_node
)
7301 return error_mark_node
;
7303 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7307 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7308 args
, in_decl
, complain
,
7311 return coerced_args
;
7314 /* Returns 1 if template args OT and NT are equivalent. */
7317 template_args_equal (tree ot
, tree nt
)
7321 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7324 if (TREE_CODE (nt
) == TREE_VEC
)
7325 /* For member templates */
7326 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7327 else if (PACK_EXPANSION_P (ot
))
7328 return (PACK_EXPANSION_P (nt
)
7329 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7330 PACK_EXPANSION_PATTERN (nt
))
7331 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7332 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7333 else if (ARGUMENT_PACK_P (ot
))
7338 if (!ARGUMENT_PACK_P (nt
))
7341 opack
= ARGUMENT_PACK_ARGS (ot
);
7342 npack
= ARGUMENT_PACK_ARGS (nt
);
7343 len
= TREE_VEC_LENGTH (opack
);
7344 if (TREE_VEC_LENGTH (npack
) != len
)
7346 for (i
= 0; i
< len
; ++i
)
7347 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7348 TREE_VEC_ELT (npack
, i
)))
7352 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7354 /* We get here probably because we are in the middle of substituting
7355 into the pattern of a pack expansion. In that case the
7356 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7357 interested in. So we want to use the initial pack argument for
7359 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7360 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7361 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7362 return template_args_equal (ot
, nt
);
7364 else if (TYPE_P (nt
))
7368 /* Don't treat an alias template specialization with dependent
7369 arguments as equivalent to its underlying type when used as a
7370 template argument; we need them to be distinct so that we
7371 substitute into the specialization arguments at instantiation
7372 time. And aliases can't be equivalent without being ==, so
7373 we don't need to look any deeper. */
7374 if (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
))
7377 return same_type_p (ot
, nt
);
7379 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7383 /* Try to treat a template non-type argument that has been converted
7384 to the parameter type as equivalent to one that hasn't yet. */
7385 for (enum tree_code code1
= TREE_CODE (ot
);
7386 CONVERT_EXPR_CODE_P (code1
)
7387 || code1
== NON_LVALUE_EXPR
;
7388 code1
= TREE_CODE (ot
))
7389 ot
= TREE_OPERAND (ot
, 0);
7390 for (enum tree_code code2
= TREE_CODE (nt
);
7391 CONVERT_EXPR_CODE_P (code2
)
7392 || code2
== NON_LVALUE_EXPR
;
7393 code2
= TREE_CODE (nt
))
7394 nt
= TREE_OPERAND (nt
, 0);
7396 return cp_tree_equal (ot
, nt
);
7400 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7401 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7402 NEWARG_PTR with the offending arguments if they are non-NULL. */
7405 comp_template_args_with_info (tree oldargs
, tree newargs
,
7406 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7410 if (oldargs
== newargs
)
7413 if (!oldargs
|| !newargs
)
7416 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7419 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7421 tree nt
= TREE_VEC_ELT (newargs
, i
);
7422 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7424 if (! template_args_equal (ot
, nt
))
7426 if (oldarg_ptr
!= NULL
)
7428 if (newarg_ptr
!= NULL
)
7436 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7437 of template arguments. Returns 0 otherwise. */
7440 comp_template_args (tree oldargs
, tree newargs
)
7442 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7446 add_pending_template (tree d
)
7448 tree ti
= (TYPE_P (d
)
7449 ? CLASSTYPE_TEMPLATE_INFO (d
)
7450 : DECL_TEMPLATE_INFO (d
));
7451 struct pending_template
*pt
;
7454 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7457 /* We are called both from instantiate_decl, where we've already had a
7458 tinst_level pushed, and instantiate_template, where we haven't.
7460 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7463 push_tinst_level (d
);
7465 pt
= ggc_alloc
<pending_template
> ();
7467 pt
->tinst
= current_tinst_level
;
7468 if (last_pending_template
)
7469 last_pending_template
->next
= pt
;
7471 pending_templates
= pt
;
7473 last_pending_template
= pt
;
7475 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7482 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7483 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7484 documentation for TEMPLATE_ID_EXPR. */
7487 lookup_template_function (tree fns
, tree arglist
)
7491 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7492 return error_mark_node
;
7494 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7496 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7498 error ("%q#D is not a function template", fns
);
7499 return error_mark_node
;
7502 if (BASELINK_P (fns
))
7504 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7506 BASELINK_FUNCTIONS (fns
),
7511 type
= TREE_TYPE (fns
);
7512 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7513 type
= unknown_type_node
;
7515 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7518 /* Within the scope of a template class S<T>, the name S gets bound
7519 (in build_self_reference) to a TYPE_DECL for the class, not a
7520 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7521 or one of its enclosing classes, and that type is a template,
7522 return the associated TEMPLATE_DECL. Otherwise, the original
7525 Also handle the case when DECL is a TREE_LIST of ambiguous
7526 injected-class-names from different bases. */
7529 maybe_get_template_decl_from_type_decl (tree decl
)
7531 if (decl
== NULL_TREE
)
7534 /* DR 176: A lookup that finds an injected-class-name (10.2
7535 [class.member.lookup]) can result in an ambiguity in certain cases
7536 (for example, if it is found in more than one base class). If all of
7537 the injected-class-names that are found refer to specializations of
7538 the same class template, and if the name is followed by a
7539 template-argument-list, the reference refers to the class template
7540 itself and not a specialization thereof, and is not ambiguous. */
7541 if (TREE_CODE (decl
) == TREE_LIST
)
7543 tree t
, tmpl
= NULL_TREE
;
7544 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7546 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7549 else if (tmpl
!= elt
)
7552 if (tmpl
&& t
== NULL_TREE
)
7558 return (decl
!= NULL_TREE
7559 && DECL_SELF_REFERENCE_P (decl
)
7560 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7561 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7564 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7565 parameters, find the desired type.
7567 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7569 IN_DECL, if non-NULL, is the template declaration we are trying to
7572 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7573 the class we are looking up.
7575 Issue error and warning messages under control of COMPLAIN.
7577 If the template class is really a local class in a template
7578 function, then the FUNCTION_CONTEXT is the function in which it is
7581 ??? Note that this function is currently called *twice* for each
7582 template-id: the first time from the parser, while creating the
7583 incomplete type (finish_template_type), and the second type during the
7584 real instantiation (instantiate_template_class). This is surely something
7585 that we want to avoid. It also causes some problems with argument
7586 coercion (see convert_nontype_argument for more information on this). */
7589 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7590 int entering_scope
, tsubst_flags_t complain
)
7592 tree templ
= NULL_TREE
, parmlist
;
7599 if (identifier_p (d1
))
7601 tree value
= innermost_non_namespace_value (d1
);
7602 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7607 push_decl_namespace (context
);
7608 templ
= lookup_name (d1
);
7609 templ
= maybe_get_template_decl_from_type_decl (templ
);
7611 pop_decl_namespace ();
7614 context
= DECL_CONTEXT (templ
);
7616 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7618 tree type
= TREE_TYPE (d1
);
7620 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7621 an implicit typename for the second A. Deal with it. */
7622 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7623 type
= TREE_TYPE (type
);
7625 if (CLASSTYPE_TEMPLATE_INFO (type
))
7627 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7628 d1
= DECL_NAME (templ
);
7631 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7632 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7634 templ
= TYPE_TI_TEMPLATE (d1
);
7635 d1
= DECL_NAME (templ
);
7637 else if (DECL_TYPE_TEMPLATE_P (d1
))
7640 d1
= DECL_NAME (templ
);
7641 context
= DECL_CONTEXT (templ
);
7643 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7646 d1
= DECL_NAME (templ
);
7649 /* Issue an error message if we didn't find a template. */
7652 if (complain
& tf_error
)
7653 error ("%qT is not a template", d1
);
7654 return error_mark_node
;
7657 if (TREE_CODE (templ
) != TEMPLATE_DECL
7658 /* Make sure it's a user visible template, if it was named by
7660 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7661 && !PRIMARY_TEMPLATE_P (templ
)))
7663 if (complain
& tf_error
)
7665 error ("non-template type %qT used as a template", d1
);
7667 error ("for template declaration %q+D", in_decl
);
7669 return error_mark_node
;
7672 complain
&= ~tf_user
;
7674 /* An alias that just changes the name of a template is equivalent to the
7675 other template, so if any of the arguments are pack expansions, strip
7676 the alias to avoid problems with a pack expansion passed to a non-pack
7677 alias template parameter (DR 1430). */
7678 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7679 templ
= get_underlying_template (templ
);
7681 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7683 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7684 template arguments */
7690 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7692 /* Consider an example where a template template parameter declared as
7694 template <class T, class U = std::allocator<T> > class TT
7696 The template parameter level of T and U are one level larger than
7697 of TT. To proper process the default argument of U, say when an
7698 instantiation `TT<int>' is seen, we need to build the full
7699 arguments containing {int} as the innermost level. Outer levels,
7700 available when not appearing as default template argument, can be
7701 obtained from the arguments of the enclosing template.
7703 Suppose that TT is later substituted with std::vector. The above
7704 instantiation is `TT<int, std::allocator<T> >' with TT at
7705 level 1, and T at level 2, while the template arguments at level 1
7706 becomes {std::vector} and the inner level 2 is {int}. */
7708 outer
= DECL_CONTEXT (templ
);
7710 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7711 else if (current_template_parms
)
7712 /* This is an argument of the current template, so we haven't set
7713 DECL_CONTEXT yet. */
7714 outer
= current_template_args ();
7717 arglist
= add_to_template_args (outer
, arglist
);
7719 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7721 /*require_all_args=*/true,
7722 /*use_default_args=*/true);
7723 if (arglist2
== error_mark_node
7724 || (!uses_template_parms (arglist2
)
7725 && check_instantiated_args (templ
, arglist2
, complain
)))
7726 return error_mark_node
;
7728 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7733 tree template_type
= TREE_TYPE (templ
);
7736 tree found
= NULL_TREE
;
7739 int is_dependent_type
;
7740 int use_partial_inst_tmpl
= false;
7742 if (template_type
== error_mark_node
)
7743 /* An error occurred while building the template TEMPL, and a
7744 diagnostic has most certainly been emitted for that
7745 already. Let's propagate that error. */
7746 return error_mark_node
;
7748 gen_tmpl
= most_general_template (templ
);
7749 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7750 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7751 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7753 if (arg_depth
== 1 && parm_depth
> 1)
7755 /* We've been given an incomplete set of template arguments.
7758 template <class T> struct S1 {
7759 template <class U> struct S2 {};
7760 template <class U> struct S2<U*> {};
7763 we will be called with an ARGLIST of `U*', but the
7764 TEMPLATE will be `template <class T> template
7765 <class U> struct S1<T>::S2'. We must fill in the missing
7768 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7770 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7773 /* Now we should have enough arguments. */
7774 gcc_assert (parm_depth
== arg_depth
);
7776 /* From here on, we're only interested in the most general
7779 /* Calculate the BOUND_ARGS. These will be the args that are
7780 actually tsubst'd into the definition to create the
7782 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
7784 /*require_all_args=*/true,
7785 /*use_default_args=*/true);
7787 if (arglist
== error_mark_node
)
7788 /* We were unable to bind the arguments. */
7789 return error_mark_node
;
7791 /* In the scope of a template class, explicit references to the
7792 template class refer to the type of the template, not any
7793 instantiation of it. For example, in:
7795 template <class T> class C { void f(C<T>); }
7797 the `C<T>' is just the same as `C'. Outside of the
7798 class, however, such a reference is an instantiation. */
7800 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7801 || currently_open_class (template_type
))
7802 /* comp_template_args is expensive, check it last. */
7803 && comp_template_args (TYPE_TI_ARGS (template_type
),
7805 return template_type
;
7807 /* If we already have this specialization, return it. */
7808 elt
.tmpl
= gen_tmpl
;
7810 hash
= spec_hasher::hash (&elt
);
7811 entry
= type_specializations
->find_with_hash (&elt
, hash
);
7816 is_dependent_type
= uses_template_parms (arglist
);
7818 /* If the deduced arguments are invalid, then the binding
7820 if (!is_dependent_type
7821 && check_instantiated_args (gen_tmpl
,
7822 INNERMOST_TEMPLATE_ARGS (arglist
),
7824 return error_mark_node
;
7826 if (!is_dependent_type
7827 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7828 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7829 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7831 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7832 DECL_NAME (gen_tmpl
),
7833 /*tag_scope=*/ts_global
);
7837 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7839 if (context
== error_mark_node
)
7840 return error_mark_node
;
7843 context
= global_namespace
;
7845 /* Create the type. */
7846 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7848 /* The user referred to a specialization of an alias
7849 template represented by GEN_TMPL.
7851 [temp.alias]/2 says:
7853 When a template-id refers to the specialization of an
7854 alias template, it is equivalent to the associated
7855 type obtained by substitution of its
7856 template-arguments for the template-parameters in the
7857 type-id of the alias template. */
7859 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7860 /* Note that the call above (by indirectly calling
7861 register_specialization in tsubst_decl) registers the
7862 TYPE_DECL representing the specialization of the alias
7863 template. So next time someone substitutes ARGLIST for
7864 the template parms into the alias template (GEN_TMPL),
7865 she'll get that TYPE_DECL back. */
7867 if (t
== error_mark_node
)
7870 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7872 if (!is_dependent_type
)
7874 set_current_access_from_decl (TYPE_NAME (template_type
));
7875 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7876 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7877 arglist
, complain
, in_decl
),
7878 SCOPED_ENUM_P (template_type
), NULL
);
7880 if (t
== error_mark_node
)
7885 /* We don't want to call start_enum for this type, since
7886 the values for the enumeration constants may involve
7887 template parameters. And, no one should be interested
7888 in the enumeration constants for such a type. */
7889 t
= cxx_make_type (ENUMERAL_TYPE
);
7890 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7892 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7893 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7894 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7896 else if (CLASS_TYPE_P (template_type
))
7898 t
= make_class_type (TREE_CODE (template_type
));
7899 CLASSTYPE_DECLARED_CLASS (t
)
7900 = CLASSTYPE_DECLARED_CLASS (template_type
);
7901 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7902 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7904 /* A local class. Make sure the decl gets registered properly. */
7905 if (context
== current_function_decl
)
7906 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7908 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7909 /* This instantiation is another name for the primary
7910 template type. Set the TYPE_CANONICAL field
7912 TYPE_CANONICAL (t
) = template_type
;
7913 else if (any_template_arguments_need_structural_equality_p (arglist
))
7914 /* Some of the template arguments require structural
7915 equality testing, so this template class requires
7916 structural equality testing. */
7917 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7922 /* If we called start_enum or pushtag above, this information
7923 will already be set up. */
7926 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7928 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7929 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7930 DECL_SOURCE_LOCATION (type_decl
)
7931 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7934 type_decl
= TYPE_NAME (t
);
7936 if (CLASS_TYPE_P (template_type
))
7938 TREE_PRIVATE (type_decl
)
7939 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7940 TREE_PROTECTED (type_decl
)
7941 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7942 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7944 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7945 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7949 if (OVERLOAD_TYPE_P (t
)
7950 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7952 static const char *tags
[] = {"abi_tag", "may_alias"};
7954 for (unsigned ix
= 0; ix
!= 2; ix
++)
7957 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
7961 else if (!TREE_CHAIN (attributes
) && !TYPE_ATTRIBUTES (t
))
7962 TYPE_ATTRIBUTES (t
) = attributes
;
7965 = tree_cons (TREE_PURPOSE (attributes
),
7966 TREE_VALUE (attributes
),
7967 TYPE_ATTRIBUTES (t
));
7971 /* Let's consider the explicit specialization of a member
7972 of a class template specialization that is implicitly instantiated,
7977 template<class U> struct M {}; //#0
7982 struct S<int>::M<char> //#1
7986 [temp.expl.spec]/4 says this is valid.
7988 In this case, when we write:
7991 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7994 When we encounter #1, we want to store the partial instantiation
7995 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7997 For all cases other than this "explicit specialization of member of a
7998 class template", we just want to store the most general template into
7999 the CLASSTYPE_TI_TEMPLATE of M.
8001 This case of "explicit specialization of member of a class template"
8003 1/ the enclosing class is an instantiation of, and therefore not
8004 the same as, the context of the most general template, and
8005 2/ we aren't looking at the partial instantiation itself, i.e.
8006 the innermost arguments are not the same as the innermost parms of
8007 the most general template.
8009 So it's only when 1/ and 2/ happens that we want to use the partial
8010 instantiation of the member template in lieu of its most general
8013 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
8014 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
8015 /* the enclosing class must be an instantiation... */
8016 && CLASS_TYPE_P (context
)
8017 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
8019 tree partial_inst_args
;
8020 TREE_VEC_LENGTH (arglist
)--;
8021 ++processing_template_decl
;
8023 tsubst (INNERMOST_TEMPLATE_ARGS
8024 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
8025 arglist
, complain
, NULL_TREE
);
8026 --processing_template_decl
;
8027 TREE_VEC_LENGTH (arglist
)++;
8028 use_partial_inst_tmpl
=
8029 /*...and we must not be looking at the partial instantiation
8031 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
8035 if (!use_partial_inst_tmpl
)
8036 /* This case is easy; there are no member templates involved. */
8040 /* This is a full instantiation of a member template. Find
8041 the partial instantiation of which this is an instance. */
8043 /* Temporarily reduce by one the number of levels in the ARGLIST
8044 so as to avoid comparing the last set of arguments. */
8045 TREE_VEC_LENGTH (arglist
)--;
8046 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
8047 TREE_VEC_LENGTH (arglist
)++;
8048 /* FOUND is either a proper class type, or an alias
8049 template specialization. In the later case, it's a
8050 TYPE_DECL, resulting from the substituting of arguments
8051 for parameters in the TYPE_DECL of the alias template
8052 done earlier. So be careful while getting the template
8054 found
= TREE_CODE (found
) == TYPE_DECL
8055 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
8056 : CLASSTYPE_TI_TEMPLATE (found
);
8059 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
8062 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
8063 entry
= ggc_alloc
<spec_entry
> ();
8067 /* Note this use of the partial instantiation so we can check it
8068 later in maybe_process_partial_specialization. */
8069 DECL_TEMPLATE_INSTANTIATIONS (found
)
8070 = tree_cons (arglist
, t
,
8071 DECL_TEMPLATE_INSTANTIATIONS (found
));
8073 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
8074 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8075 /* Now that the type has been registered on the instantiations
8076 list, we set up the enumerators. Because the enumeration
8077 constants may involve the enumeration type itself, we make
8078 sure to register the type first, and then create the
8079 constants. That way, doing tsubst_expr for the enumeration
8080 constants won't result in recursive calls here; we'll find
8081 the instantiation and exit above. */
8082 tsubst_enum (template_type
, t
, arglist
);
8084 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
8085 /* If the type makes use of template parameters, the
8086 code that generates debugging information will crash. */
8087 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
8089 /* Possibly limit visibility based on template args. */
8090 TREE_PUBLIC (type_decl
) = 1;
8091 determine_visibility (type_decl
);
8093 inherit_targ_abi_tags (t
);
8099 /* Wrapper for lookup_template_class_1. */
8102 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
8103 int entering_scope
, tsubst_flags_t complain
)
8106 timevar_push (TV_TEMPLATE_INST
);
8107 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
8108 entering_scope
, complain
);
8109 timevar_pop (TV_TEMPLATE_INST
);
8113 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST.
8114 The type of the expression is the unknown_type_node since the
8115 template-id could refer to an explicit or partial specialization. */
8118 lookup_template_variable (tree templ
, tree arglist
)
8120 tree type
= unknown_type_node
;
8121 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
8124 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
8127 finish_template_variable (tree var
)
8129 tree templ
= TREE_OPERAND (var
, 0);
8131 tree arglist
= TREE_OPERAND (var
, 1);
8132 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
8133 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
8135 tree parms
= DECL_TEMPLATE_PARMS (templ
);
8136 tsubst_flags_t complain
= tf_warning_or_error
;
8137 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
8139 /*use_default*/true);
8141 return instantiate_template (templ
, arglist
, complain
);
8148 /* True when we should also visit template parameters that occur in
8149 non-deduced contexts. */
8150 bool include_nondeduced_p
;
8151 hash_set
<tree
> *visited
;
8154 /* Called from for_each_template_parm via walk_tree. */
8157 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
8160 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
8161 tree_fn_t fn
= pfd
->fn
;
8162 void *data
= pfd
->data
;
8165 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
8166 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
8167 pfd
->include_nondeduced_p
))
8168 return error_mark_node
;
8170 switch (TREE_CODE (t
))
8173 if (TYPE_PTRMEMFUNC_P (t
))
8179 if (!TYPE_TEMPLATE_INFO (t
))
8181 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
8182 fn
, data
, pfd
->visited
,
8183 pfd
->include_nondeduced_p
))
8184 return error_mark_node
;
8188 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
8189 fn
, data
, pfd
->visited
,
8190 pfd
->include_nondeduced_p
)
8191 || for_each_template_parm (TYPE_MAX_VALUE (t
),
8192 fn
, data
, pfd
->visited
,
8193 pfd
->include_nondeduced_p
))
8194 return error_mark_node
;
8198 /* Since we're not going to walk subtrees, we have to do this
8200 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
8201 pfd
->visited
, pfd
->include_nondeduced_p
))
8202 return error_mark_node
;
8206 /* Check the return type. */
8207 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8208 pfd
->include_nondeduced_p
))
8209 return error_mark_node
;
8211 /* Check the parameter types. Since default arguments are not
8212 instantiated until they are needed, the TYPE_ARG_TYPES may
8213 contain expressions that involve template parameters. But,
8214 no-one should be looking at them yet. And, once they're
8215 instantiated, they don't contain template parameters, so
8216 there's no point in looking at them then, either. */
8220 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
8221 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
8222 pfd
->visited
, pfd
->include_nondeduced_p
))
8223 return error_mark_node
;
8225 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8226 want walk_tree walking into them itself. */
8232 case UNDERLYING_TYPE
:
8233 if (pfd
->include_nondeduced_p
8234 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
8236 pfd
->include_nondeduced_p
))
8237 return error_mark_node
;
8242 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
8243 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
8244 pfd
->visited
, pfd
->include_nondeduced_p
))
8245 return error_mark_node
;
8250 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
8251 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
8252 pfd
->visited
, pfd
->include_nondeduced_p
))
8253 return error_mark_node
;
8254 if (DECL_CONTEXT (t
)
8255 && pfd
->include_nondeduced_p
8256 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
8257 pfd
->visited
, pfd
->include_nondeduced_p
))
8258 return error_mark_node
;
8261 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8262 /* Record template parameters such as `T' inside `TT<T>'. */
8263 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
8264 pfd
->include_nondeduced_p
))
8265 return error_mark_node
;
8268 case TEMPLATE_TEMPLATE_PARM
:
8269 case TEMPLATE_TYPE_PARM
:
8270 case TEMPLATE_PARM_INDEX
:
8271 if (fn
&& (*fn
)(t
, data
))
8272 return error_mark_node
;
8274 return error_mark_node
;
8278 /* A template template parameter is encountered. */
8279 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
8280 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8281 pfd
->include_nondeduced_p
))
8282 return error_mark_node
;
8284 /* Already substituted template template parameter */
8290 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8292 pfd
->include_nondeduced_p
))
8293 return error_mark_node
;
8297 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8298 && pfd
->include_nondeduced_p
8299 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8300 (TREE_TYPE (t
)), fn
, data
,
8301 pfd
->visited
, pfd
->include_nondeduced_p
))
8302 return error_mark_node
;
8307 /* If there's no type, then this thing must be some expression
8308 involving template parameters. */
8309 if (!fn
&& !TREE_TYPE (t
))
8310 return error_mark_node
;
8315 case IMPLICIT_CONV_EXPR
:
8316 case REINTERPRET_CAST_EXPR
:
8317 case CONST_CAST_EXPR
:
8318 case STATIC_CAST_EXPR
:
8319 case DYNAMIC_CAST_EXPR
:
8323 case PSEUDO_DTOR_EXPR
:
8325 return error_mark_node
;
8332 /* We didn't find any template parameters we liked. */
8336 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8337 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8338 call FN with the parameter and the DATA.
8339 If FN returns nonzero, the iteration is terminated, and
8340 for_each_template_parm returns 1. Otherwise, the iteration
8341 continues. If FN never returns a nonzero value, the value
8342 returned by for_each_template_parm is 0. If FN is NULL, it is
8343 considered to be the function which always returns 1.
8345 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8346 parameters that occur in non-deduced contexts. When false, only
8347 visits those template parameters that can be deduced. */
8350 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8351 hash_set
<tree
> *visited
,
8352 bool include_nondeduced_p
)
8354 struct pair_fn_data pfd
;
8360 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8362 /* Walk the tree. (Conceptually, we would like to walk without
8363 duplicates, but for_each_template_parm_r recursively calls
8364 for_each_template_parm, so we would need to reorganize a fair
8365 bit to use walk_tree_without_duplicates, so we keep our own
8368 pfd
.visited
= visited
;
8370 pfd
.visited
= new hash_set
<tree
>;
8371 result
= cp_walk_tree (&t
,
8372 for_each_template_parm_r
,
8374 pfd
.visited
) != NULL_TREE
;
8386 /* Returns true if T depends on any template parameter. */
8389 uses_template_parms (tree t
)
8395 int saved_processing_template_decl
;
8397 saved_processing_template_decl
= processing_template_decl
;
8398 if (!saved_processing_template_decl
)
8399 processing_template_decl
= 1;
8401 dependent_p
= dependent_type_p (t
);
8402 else if (TREE_CODE (t
) == TREE_VEC
)
8403 dependent_p
= any_dependent_template_arguments_p (t
);
8404 else if (TREE_CODE (t
) == TREE_LIST
)
8405 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8406 || uses_template_parms (TREE_CHAIN (t
)));
8407 else if (TREE_CODE (t
) == TYPE_DECL
)
8408 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8411 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8412 || TREE_CODE (t
) == OVERLOAD
8415 || TREE_CODE (t
) == TRAIT_EXPR
8416 || TREE_CODE (t
) == CONSTRUCTOR
8417 || CONSTANT_CLASS_P (t
))
8418 dependent_p
= (type_dependent_expression_p (t
)
8419 || value_dependent_expression_p (t
));
8422 gcc_assert (t
== error_mark_node
);
8423 dependent_p
= false;
8426 processing_template_decl
= saved_processing_template_decl
;
8431 /* Returns true iff current_function_decl is an incompletely instantiated
8432 template. Useful instead of processing_template_decl because the latter
8433 is set to 0 during instantiate_non_dependent_expr. */
8436 in_template_function (void)
8438 tree fn
= current_function_decl
;
8440 ++processing_template_decl
;
8441 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8442 && DECL_TEMPLATE_INFO (fn
)
8443 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8444 --processing_template_decl
;
8448 /* Returns true if T depends on any template parameter with level LEVEL. */
8451 uses_template_parms_level (tree t
, int level
)
8453 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8454 /*include_nondeduced_p=*/true);
8457 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8458 ill-formed translation unit, i.e. a variable or function that isn't
8459 usable in a constant expression. */
8462 neglectable_inst_p (tree d
)
8465 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8466 : decl_maybe_constant_var_p (d
)));
8469 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8470 neglectable and instantiated from within an erroneous instantiation. */
8473 limit_bad_template_recursion (tree decl
)
8475 struct tinst_level
*lev
= current_tinst_level
;
8476 int errs
= errorcount
+ sorrycount
;
8477 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8480 for (; lev
; lev
= lev
->next
)
8481 if (neglectable_inst_p (lev
->decl
))
8484 return (lev
&& errs
> lev
->errors
);
8487 static int tinst_depth
;
8488 extern int max_tinst_depth
;
8491 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8493 /* We're starting to instantiate D; record the template instantiation context
8494 for diagnostics and to restore it later. */
8497 push_tinst_level (tree d
)
8499 return push_tinst_level_loc (d
, input_location
);
8502 /* We're starting to instantiate D; record the template instantiation context
8503 at LOC for diagnostics and to restore it later. */
8506 push_tinst_level_loc (tree d
, location_t loc
)
8508 struct tinst_level
*new_level
;
8510 if (tinst_depth
>= max_tinst_depth
)
8512 fatal_error (input_location
,
8513 "template instantiation depth exceeds maximum of %d"
8514 " (use -ftemplate-depth= to increase the maximum)",
8519 /* If the current instantiation caused problems, don't let it instantiate
8520 anything else. Do allow deduction substitution and decls usable in
8521 constant expressions. */
8522 if (limit_bad_template_recursion (d
))
8525 new_level
= ggc_alloc
<tinst_level
> ();
8526 new_level
->decl
= d
;
8527 new_level
->locus
= loc
;
8528 new_level
->errors
= errorcount
+sorrycount
;
8529 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8530 new_level
->next
= current_tinst_level
;
8531 current_tinst_level
= new_level
;
8534 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8535 depth_reached
= tinst_depth
;
8540 /* We're done instantiating this template; return to the instantiation
8544 pop_tinst_level (void)
8546 /* Restore the filename and line number stashed away when we started
8547 this instantiation. */
8548 input_location
= current_tinst_level
->locus
;
8549 current_tinst_level
= current_tinst_level
->next
;
8553 /* We're instantiating a deferred template; restore the template
8554 instantiation context in which the instantiation was requested, which
8555 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8558 reopen_tinst_level (struct tinst_level
*level
)
8560 struct tinst_level
*t
;
8563 for (t
= level
; t
; t
= t
->next
)
8566 current_tinst_level
= level
;
8568 if (current_tinst_level
)
8569 current_tinst_level
->errors
= errorcount
+sorrycount
;
8573 /* Returns the TINST_LEVEL which gives the original instantiation
8576 struct tinst_level
*
8577 outermost_tinst_level (void)
8579 struct tinst_level
*level
= current_tinst_level
;
8582 level
= level
->next
;
8586 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8587 vector of template arguments, as for tsubst.
8589 Returns an appropriate tsubst'd friend declaration. */
8592 tsubst_friend_function (tree decl
, tree args
)
8596 if (TREE_CODE (decl
) == FUNCTION_DECL
8597 && DECL_TEMPLATE_INSTANTIATION (decl
)
8598 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8599 /* This was a friend declared with an explicit template
8600 argument list, e.g.:
8604 to indicate that f was a template instantiation, not a new
8605 function declaration. Now, we have to figure out what
8606 instantiation of what template. */
8608 tree template_id
, arglist
, fns
;
8611 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8613 /* Friend functions are looked up in the containing namespace scope.
8614 We must enter that scope, to avoid finding member functions of the
8615 current class with same name. */
8616 push_nested_namespace (ns
);
8617 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8618 tf_warning_or_error
, NULL_TREE
,
8619 /*integral_constant_expression_p=*/false);
8620 pop_nested_namespace (ns
);
8621 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8622 tf_warning_or_error
, NULL_TREE
);
8623 template_id
= lookup_template_function (fns
, arglist
);
8625 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8626 tmpl
= determine_specialization (template_id
, new_friend
,
8628 /*need_member_template=*/0,
8629 TREE_VEC_LENGTH (args
),
8631 return instantiate_template (tmpl
, new_args
, tf_error
);
8634 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8636 /* The NEW_FRIEND will look like an instantiation, to the
8637 compiler, but is not an instantiation from the point of view of
8638 the language. For example, we might have had:
8640 template <class T> struct S {
8641 template <class U> friend void f(T, U);
8644 Then, in S<int>, template <class U> void f(int, U) is not an
8645 instantiation of anything. */
8646 if (new_friend
== error_mark_node
)
8647 return error_mark_node
;
8649 DECL_USE_TEMPLATE (new_friend
) = 0;
8650 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8652 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8653 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8654 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8657 /* The mangled name for the NEW_FRIEND is incorrect. The function
8658 is not a template instantiation and should not be mangled like
8659 one. Therefore, we forget the mangling here; we'll recompute it
8660 later if we need it. */
8661 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8663 SET_DECL_RTL (new_friend
, NULL
);
8664 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8667 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8670 tree new_friend_template_info
;
8671 tree new_friend_result_template_info
;
8673 int new_friend_is_defn
;
8675 /* We must save some information from NEW_FRIEND before calling
8676 duplicate decls since that function will free NEW_FRIEND if
8678 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8679 new_friend_is_defn
=
8680 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8681 (template_for_substitution (new_friend
)))
8683 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8685 /* This declaration is a `primary' template. */
8686 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8688 new_friend_result_template_info
8689 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8692 new_friend_result_template_info
= NULL_TREE
;
8694 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8695 if (new_friend_is_defn
)
8696 DECL_INITIAL (new_friend
) = error_mark_node
;
8698 /* Inside pushdecl_namespace_level, we will push into the
8699 current namespace. However, the friend function should go
8700 into the namespace of the template. */
8701 ns
= decl_namespace_context (new_friend
);
8702 push_nested_namespace (ns
);
8703 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8704 pop_nested_namespace (ns
);
8706 if (old_decl
== error_mark_node
)
8707 return error_mark_node
;
8709 if (old_decl
!= new_friend
)
8711 /* This new friend declaration matched an existing
8712 declaration. For example, given:
8714 template <class T> void f(T);
8715 template <class U> class C {
8716 template <class T> friend void f(T) {}
8719 the friend declaration actually provides the definition
8720 of `f', once C has been instantiated for some type. So,
8721 old_decl will be the out-of-class template declaration,
8722 while new_friend is the in-class definition.
8724 But, if `f' was called before this point, the
8725 instantiation of `f' will have DECL_TI_ARGS corresponding
8726 to `T' but not to `U', references to which might appear
8727 in the definition of `f'. Previously, the most general
8728 template for an instantiation of `f' was the out-of-class
8729 version; now it is the in-class version. Therefore, we
8730 run through all specialization of `f', adding to their
8731 DECL_TI_ARGS appropriately. In particular, they need a
8732 new set of outer arguments, corresponding to the
8733 arguments for this class instantiation.
8735 The same situation can arise with something like this:
8738 template <class T> class C {
8742 when `C<int>' is instantiated. Now, `f(int)' is defined
8745 if (!new_friend_is_defn
)
8746 /* On the other hand, if the in-class declaration does
8747 *not* provide a definition, then we don't want to alter
8748 existing definitions. We can just leave everything
8753 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8754 tree new_args
= TI_ARGS (new_friend_template_info
);
8756 /* Overwrite whatever template info was there before, if
8757 any, with the new template information pertaining to
8759 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8761 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8763 /* We should have called reregister_specialization in
8765 gcc_assert (retrieve_specialization (new_template
,
8769 /* Instantiate it if the global has already been used. */
8770 if (DECL_ODR_USED (old_decl
))
8771 instantiate_decl (old_decl
, /*defer_ok=*/true,
8772 /*expl_inst_class_mem_p=*/false);
8778 /* Indicate that the old function template is a partial
8780 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8781 = new_friend_result_template_info
;
8783 gcc_assert (new_template
8784 == most_general_template (new_template
));
8785 gcc_assert (new_template
!= old_decl
);
8787 /* Reassign any specializations already in the hash table
8788 to the new more general template, and add the
8789 additional template args. */
8790 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8794 tree spec
= TREE_VALUE (t
);
8797 elt
.tmpl
= old_decl
;
8798 elt
.args
= DECL_TI_ARGS (spec
);
8799 elt
.spec
= NULL_TREE
;
8801 decl_specializations
->remove_elt (&elt
);
8804 = add_outermost_template_args (new_args
,
8805 DECL_TI_ARGS (spec
));
8807 register_specialization
8808 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8811 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8815 /* The information from NEW_FRIEND has been merged into OLD_DECL
8816 by duplicate_decls. */
8817 new_friend
= old_decl
;
8822 tree context
= DECL_CONTEXT (new_friend
);
8826 template <class T> class C {
8827 template <class U> friend void C1<U>::f (); // case 1
8828 friend void C2<T>::f (); // case 2
8830 we only need to make sure CONTEXT is a complete type for
8831 case 2. To distinguish between the two cases, we note that
8832 CONTEXT of case 1 remains dependent type after tsubst while
8833 this isn't true for case 2. */
8834 ++processing_template_decl
;
8835 dependent_p
= dependent_type_p (context
);
8836 --processing_template_decl
;
8839 && !complete_type_or_else (context
, NULL_TREE
))
8840 return error_mark_node
;
8842 if (COMPLETE_TYPE_P (context
))
8844 tree fn
= new_friend
;
8845 /* do_friend adds the TEMPLATE_DECL for any member friend
8846 template even if it isn't a member template, i.e.
8847 template <class T> friend A<T>::f();
8848 Look through it in that case. */
8849 if (TREE_CODE (fn
) == TEMPLATE_DECL
8850 && !PRIMARY_TEMPLATE_P (fn
))
8851 fn
= DECL_TEMPLATE_RESULT (fn
);
8852 /* Check to see that the declaration is really present, and,
8853 possibly obtain an improved declaration. */
8854 fn
= check_classfn (context
, fn
, NULL_TREE
);
8864 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8865 template arguments, as for tsubst.
8867 Returns an appropriate tsubst'd friend type or error_mark_node on
8871 tsubst_friend_class (tree friend_tmpl
, tree args
)
8877 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8879 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8880 return TREE_TYPE (t
);
8883 context
= CP_DECL_CONTEXT (friend_tmpl
);
8885 if (context
!= global_namespace
)
8887 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8888 push_nested_namespace (context
);
8890 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8893 /* Look for a class template declaration. We look for hidden names
8894 because two friend declarations of the same template are the
8895 same. For example, in:
8898 template <typename> friend class F;
8900 template <typename> struct B {
8901 template <typename> friend class F;
8904 both F templates are the same. */
8905 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8906 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8908 /* But, if we don't find one, it might be because we're in a
8909 situation like this:
8917 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8918 for `S<int>', not the TEMPLATE_DECL. */
8919 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8921 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8922 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8925 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8927 /* The friend template has already been declared. Just
8928 check to see that the declarations match, and install any new
8929 default parameters. We must tsubst the default parameters,
8930 of course. We only need the innermost template parameters
8931 because that is all that redeclare_class_template will look
8933 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8934 > TMPL_ARGS_DEPTH (args
))
8937 location_t saved_input_location
;
8938 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8939 args
, tf_warning_or_error
);
8941 saved_input_location
= input_location
;
8942 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8943 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8944 input_location
= saved_input_location
;
8948 friend_type
= TREE_TYPE (tmpl
);
8952 /* The friend template has not already been declared. In this
8953 case, the instantiation of the template class will cause the
8954 injection of this template into the global scope. */
8955 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8956 if (tmpl
== error_mark_node
)
8957 return error_mark_node
;
8959 /* The new TMPL is not an instantiation of anything, so we
8960 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8961 the new type because that is supposed to be the corresponding
8962 template decl, i.e., TMPL. */
8963 DECL_USE_TEMPLATE (tmpl
) = 0;
8964 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8965 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8966 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8967 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8969 /* Inject this template into the global scope. */
8970 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8973 if (context
!= global_namespace
)
8975 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8976 pop_nested_namespace (context
);
8978 pop_nested_class ();
8984 /* Returns zero if TYPE cannot be completed later due to circularity.
8985 Otherwise returns one. */
8988 can_complete_type_without_circularity (tree type
)
8990 if (type
== NULL_TREE
|| type
== error_mark_node
)
8992 else if (COMPLETE_TYPE_P (type
))
8994 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8995 return can_complete_type_without_circularity (TREE_TYPE (type
));
8996 else if (CLASS_TYPE_P (type
)
8997 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
9003 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
9005 /* Apply any attributes which had to be deferred until instantiation
9006 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
9007 ARGS, COMPLAIN, IN_DECL are as tsubst. */
9010 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
9011 tree args
, tsubst_flags_t complain
, tree in_decl
)
9013 tree last_dep
= NULL_TREE
;
9017 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
9018 if (ATTR_IS_DEPENDENT (t
))
9021 attributes
= copy_list (attributes
);
9025 if (DECL_P (*decl_p
))
9027 if (TREE_TYPE (*decl_p
) == error_mark_node
)
9029 p
= &DECL_ATTRIBUTES (*decl_p
);
9032 p
= &TYPE_ATTRIBUTES (*decl_p
);
9036 tree late_attrs
= NULL_TREE
;
9037 tree
*q
= &late_attrs
;
9039 for (*p
= attributes
; *p
; )
9042 if (ATTR_IS_DEPENDENT (t
))
9044 *p
= TREE_CHAIN (t
);
9045 TREE_CHAIN (t
) = NULL_TREE
;
9046 if ((flag_openmp
|| flag_cilkplus
)
9047 && is_attribute_p ("omp declare simd",
9048 get_attribute_name (t
))
9051 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
9052 clauses
= tsubst_omp_clauses (clauses
, true, args
,
9054 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
9055 clauses
= finish_omp_clauses (clauses
);
9056 tree parms
= DECL_ARGUMENTS (*decl_p
);
9058 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
9060 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
9062 TREE_VALUE (t
) = NULL_TREE
;
9064 /* If the first attribute argument is an identifier, don't
9065 pass it through tsubst. Attributes like mode, format,
9066 cleanup and several target specific attributes expect it
9068 else if (attribute_takes_identifier_p (get_attribute_name (t
))
9072 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
9074 /*integral_constant_expression_p=*/false);
9075 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
9077 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
9080 else if (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
)))
9082 /* An attribute pack expansion. */
9083 tree purp
= TREE_PURPOSE (t
);
9084 tree pack
= (tsubst_pack_expansion
9085 (TREE_VALUE (t
), args
, complain
, in_decl
));
9086 int len
= TREE_VEC_LENGTH (pack
);
9087 for (int i
= 0; i
< len
; ++i
)
9089 tree elt
= TREE_VEC_ELT (pack
, i
);
9090 *q
= build_tree_list (purp
, elt
);
9091 q
= &TREE_CHAIN (*q
);
9097 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
9098 /*integral_constant_expression_p=*/false);
9100 q
= &TREE_CHAIN (t
);
9103 p
= &TREE_CHAIN (t
);
9106 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
9110 /* Perform (or defer) access check for typedefs that were referenced
9111 from within the template TMPL code.
9112 This is a subroutine of instantiate_decl and instantiate_class_template.
9113 TMPL is the template to consider and TARGS is the list of arguments of
9117 perform_typedefs_access_check (tree tmpl
, tree targs
)
9119 location_t saved_location
;
9121 qualified_typedef_usage_t
*iter
;
9124 || (!CLASS_TYPE_P (tmpl
)
9125 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
9128 saved_location
= input_location
;
9129 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
9131 tree type_decl
= iter
->typedef_decl
;
9132 tree type_scope
= iter
->context
;
9134 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
9137 if (uses_template_parms (type_decl
))
9138 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
9139 if (uses_template_parms (type_scope
))
9140 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
9142 /* Make access check error messages point to the location
9143 of the use of the typedef. */
9144 input_location
= iter
->locus
;
9145 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
9146 type_decl
, type_decl
,
9147 tf_warning_or_error
);
9149 input_location
= saved_location
;
9153 instantiate_class_template_1 (tree type
)
9155 tree templ
, args
, pattern
, t
, member
;
9159 unsigned int saved_maximum_field_alignment
;
9162 if (type
== error_mark_node
)
9163 return error_mark_node
;
9165 if (COMPLETE_OR_OPEN_TYPE_P (type
)
9166 || uses_template_parms (type
))
9169 /* Figure out which template is being instantiated. */
9170 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
9171 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
9173 /* Determine what specialization of the original template to
9175 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
9176 if (t
== error_mark_node
)
9178 TYPE_BEING_DEFINED (type
) = 1;
9179 return error_mark_node
;
9183 /* This TYPE is actually an instantiation of a partial
9184 specialization. We replace the innermost set of ARGS with
9185 the arguments appropriate for substitution. For example,
9188 template <class T> struct S {};
9189 template <class T> struct S<T*> {};
9191 and supposing that we are instantiating S<int*>, ARGS will
9192 presently be {int*} -- but we need {int}. */
9193 pattern
= TREE_TYPE (t
);
9194 args
= TREE_PURPOSE (t
);
9198 pattern
= TREE_TYPE (templ
);
9199 args
= CLASSTYPE_TI_ARGS (type
);
9202 /* If the template we're instantiating is incomplete, then clearly
9203 there's nothing we can do. */
9204 if (!COMPLETE_TYPE_P (pattern
))
9207 /* If we've recursively instantiated too many templates, stop. */
9208 if (! push_tinst_level (type
))
9211 /* Now we're really doing the instantiation. Mark the type as in
9212 the process of being defined. */
9213 TYPE_BEING_DEFINED (type
) = 1;
9215 /* We may be in the middle of deferred access check. Disable
9217 push_deferring_access_checks (dk_no_deferred
);
9219 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
9220 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9221 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
9222 fn_context
= error_mark_node
;
9224 push_to_top_level ();
9225 /* Use #pragma pack from the template context. */
9226 saved_maximum_field_alignment
= maximum_field_alignment
;
9227 maximum_field_alignment
= TYPE_PRECISION (pattern
);
9229 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
9231 /* Set the input location to the most specialized template definition.
9232 This is needed if tsubsting causes an error. */
9233 typedecl
= TYPE_MAIN_DECL (pattern
);
9234 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
9235 DECL_SOURCE_LOCATION (typedecl
);
9237 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
9238 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
9239 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
9240 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
9241 if (ANON_AGGR_TYPE_P (pattern
))
9242 SET_ANON_AGGR_TYPE_P (type
);
9243 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
9245 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
9246 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
9247 /* Adjust visibility for template arguments. */
9248 determine_visibility (TYPE_MAIN_DECL (type
));
9250 if (CLASS_TYPE_P (type
))
9251 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
9253 pbinfo
= TYPE_BINFO (pattern
);
9255 /* We should never instantiate a nested class before its enclosing
9256 class; we need to look up the nested class by name before we can
9257 instantiate it, and that lookup should instantiate the enclosing
9259 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
9260 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
9262 base_list
= NULL_TREE
;
9263 if (BINFO_N_BASE_BINFOS (pbinfo
))
9269 /* We must enter the scope containing the type, as that is where
9270 the accessibility of types named in dependent bases are
9272 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9274 /* Substitute into each of the bases to determine the actual
9276 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9279 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9280 tree expanded_bases
= NULL_TREE
;
9283 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9286 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9287 args
, tf_error
, NULL_TREE
);
9288 if (expanded_bases
== error_mark_node
)
9291 len
= TREE_VEC_LENGTH (expanded_bases
);
9294 for (idx
= 0; idx
< len
; idx
++)
9297 /* Extract the already-expanded base class. */
9298 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9300 /* Substitute to figure out the base class. */
9301 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9304 if (base
== error_mark_node
)
9307 base_list
= tree_cons (access
, base
, base_list
);
9308 if (BINFO_VIRTUAL_P (pbase_binfo
))
9309 TREE_TYPE (base_list
) = integer_type_node
;
9313 /* The list is now in reverse order; correct that. */
9314 base_list
= nreverse (base_list
);
9317 pop_scope (pushed_scope
);
9319 /* Now call xref_basetypes to set up all the base-class
9321 xref_basetypes (type
, base_list
);
9323 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9324 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9325 args
, tf_error
, NULL_TREE
);
9326 fixup_attribute_variants (type
);
9328 /* Now that our base classes are set up, enter the scope of the
9329 class, so that name lookups into base classes, etc. will work
9330 correctly. This is precisely analogous to what we do in
9331 begin_class_definition when defining an ordinary non-template
9332 class, except we also need to push the enclosing classes. */
9333 push_nested_class (type
);
9335 /* Now members are processed in the order of declaration. */
9336 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9337 member
; member
= TREE_CHAIN (member
))
9339 tree t
= TREE_VALUE (member
);
9341 if (TREE_PURPOSE (member
))
9345 /* Build new CLASSTYPE_NESTED_UTDS. */
9348 bool class_template_p
;
9350 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9351 && TYPE_LANG_SPECIFIC (t
)
9352 && CLASSTYPE_IS_TEMPLATE (t
));
9353 /* If the member is a class template, then -- even after
9354 substitution -- there may be dependent types in the
9355 template argument list for the class. We increment
9356 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9357 that function will assume that no types are dependent
9358 when outside of a template. */
9359 if (class_template_p
)
9360 ++processing_template_decl
;
9361 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9362 if (class_template_p
)
9363 --processing_template_decl
;
9364 if (newtag
== error_mark_node
)
9367 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9369 tree name
= TYPE_IDENTIFIER (t
);
9371 if (class_template_p
)
9372 /* Unfortunately, lookup_template_class sets
9373 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9374 instantiation (i.e., for the type of a member
9375 template class nested within a template class.)
9376 This behavior is required for
9377 maybe_process_partial_specialization to work
9378 correctly, but is not accurate in this case;
9379 the TAG is not an instantiation of anything.
9380 (The corresponding TEMPLATE_DECL is an
9381 instantiation, but the TYPE is not.) */
9382 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9384 /* Now, we call pushtag to put this NEWTAG into the scope of
9385 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9386 pushtag calling push_template_decl. We don't have to do
9387 this for enums because it will already have been done in
9390 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9391 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9394 else if (DECL_DECLARES_FUNCTION_P (t
))
9396 /* Build new TYPE_METHODS. */
9399 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9400 ++processing_template_decl
;
9401 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9402 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9403 --processing_template_decl
;
9404 set_current_access_from_decl (r
);
9405 finish_member_declaration (r
);
9406 /* Instantiate members marked with attribute used. */
9407 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9409 if (TREE_CODE (r
) == FUNCTION_DECL
9410 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9411 cp_check_omp_declare_reduction (r
);
9413 else if (DECL_CLASS_TEMPLATE_P (t
)
9414 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
9415 /* A closure type for a lambda in a default argument for a
9416 member template. Ignore it; it will be instantiated with
9417 the default argument. */;
9420 /* Build new TYPE_FIELDS. */
9421 if (TREE_CODE (t
) == STATIC_ASSERT
)
9425 ++c_inhibit_evaluation_warnings
;
9427 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9428 tf_warning_or_error
, NULL_TREE
,
9429 /*integral_constant_expression_p=*/true);
9430 --c_inhibit_evaluation_warnings
;
9432 finish_static_assert (condition
,
9433 STATIC_ASSERT_MESSAGE (t
),
9434 STATIC_ASSERT_SOURCE_LOCATION (t
),
9437 else if (TREE_CODE (t
) != CONST_DECL
)
9440 tree vec
= NULL_TREE
;
9443 /* The file and line for this declaration, to
9444 assist in error message reporting. Since we
9445 called push_tinst_level above, we don't need to
9447 input_location
= DECL_SOURCE_LOCATION (t
);
9449 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9450 ++processing_template_decl
;
9451 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9452 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9453 --processing_template_decl
;
9455 if (TREE_CODE (r
) == TREE_VEC
)
9457 /* A capture pack became multiple fields. */
9459 len
= TREE_VEC_LENGTH (vec
);
9462 for (int i
= 0; i
< len
; ++i
)
9465 r
= TREE_VEC_ELT (vec
, i
);
9470 [t]he initialization (and any associated
9471 side-effects) of a static data member does
9472 not occur unless the static data member is
9473 itself used in a way that requires the
9474 definition of the static data member to
9477 Therefore, we do not substitute into the
9478 initialized for the static data member here. */
9479 finish_static_data_member_decl
9482 /*init_const_expr_p=*/false,
9483 /*asmspec_tree=*/NULL_TREE
,
9485 /* Instantiate members marked with attribute used. */
9486 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9489 else if (TREE_CODE (r
) == FIELD_DECL
)
9491 /* Determine whether R has a valid type and can be
9492 completed later. If R is invalid, then its type
9493 is replaced by error_mark_node. */
9494 tree rtype
= TREE_TYPE (r
);
9495 if (can_complete_type_without_circularity (rtype
))
9496 complete_type (rtype
);
9498 if (!COMPLETE_TYPE_P (rtype
))
9500 cxx_incomplete_type_error (r
, rtype
);
9501 TREE_TYPE (r
) = error_mark_node
;
9505 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9506 such a thing will already have been added to the field
9507 list by tsubst_enum in finish_member_declaration in the
9508 CLASSTYPE_NESTED_UTDS case above. */
9509 if (!(TREE_CODE (r
) == TYPE_DECL
9510 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9511 && DECL_ARTIFICIAL (r
)))
9513 set_current_access_from_decl (r
);
9514 finish_member_declaration (r
);
9522 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9523 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9525 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9527 tree friend_type
= t
;
9528 bool adjust_processing_template_decl
= false;
9530 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9532 /* template <class T> friend class C; */
9533 friend_type
= tsubst_friend_class (friend_type
, args
);
9534 adjust_processing_template_decl
= true;
9536 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9538 /* template <class T> friend class C::D; */
9539 friend_type
= tsubst (friend_type
, args
,
9540 tf_warning_or_error
, NULL_TREE
);
9541 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9542 friend_type
= TREE_TYPE (friend_type
);
9543 adjust_processing_template_decl
= true;
9545 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9546 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9548 /* This could be either
9552 when dependent_type_p is false or
9554 template <class U> friend class T::C;
9557 friend_type
= tsubst (friend_type
, args
,
9558 tf_warning_or_error
, NULL_TREE
);
9559 /* Bump processing_template_decl for correct
9560 dependent_type_p calculation. */
9561 ++processing_template_decl
;
9562 if (dependent_type_p (friend_type
))
9563 adjust_processing_template_decl
= true;
9564 --processing_template_decl
;
9566 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9567 && hidden_name_p (TYPE_NAME (friend_type
)))
9571 where C hasn't been declared yet. Let's lookup name
9572 from namespace scope directly, bypassing any name that
9573 come from dependent base class. */
9574 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9576 /* The call to xref_tag_from_type does injection for friend
9578 push_nested_namespace (ns
);
9580 xref_tag_from_type (friend_type
, NULL_TREE
,
9581 /*tag_scope=*/ts_current
);
9582 pop_nested_namespace (ns
);
9584 else if (uses_template_parms (friend_type
))
9585 /* friend class C<T>; */
9586 friend_type
= tsubst (friend_type
, args
,
9587 tf_warning_or_error
, NULL_TREE
);
9592 where C is already declared or
9594 friend class C<int>;
9596 We don't have to do anything in these cases. */
9598 if (adjust_processing_template_decl
)
9599 /* Trick make_friend_class into realizing that the friend
9600 we're adding is a template, not an ordinary class. It's
9601 important that we use make_friend_class since it will
9602 perform some error-checking and output cross-reference
9604 ++processing_template_decl
;
9606 if (friend_type
!= error_mark_node
)
9607 make_friend_class (type
, friend_type
, /*complain=*/false);
9609 if (adjust_processing_template_decl
)
9610 --processing_template_decl
;
9614 /* Build new DECL_FRIENDLIST. */
9617 /* The file and line for this declaration, to
9618 assist in error message reporting. Since we
9619 called push_tinst_level above, we don't need to
9621 input_location
= DECL_SOURCE_LOCATION (t
);
9623 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9625 ++processing_template_decl
;
9626 push_deferring_access_checks (dk_no_check
);
9629 r
= tsubst_friend_function (t
, args
);
9630 add_friend (type
, r
, /*complain=*/false);
9631 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9633 pop_deferring_access_checks ();
9634 --processing_template_decl
;
9640 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9642 tree decl
= lambda_function (type
);
9645 if (!DECL_TEMPLATE_INFO (decl
)
9646 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9647 instantiate_decl (decl
, false, false);
9649 /* We need to instantiate the capture list from the template
9650 after we've instantiated the closure members, but before we
9651 consider adding the conversion op. Also keep any captures
9652 that may have been added during instantiation of the op(). */
9653 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9655 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9656 args
, tf_warning_or_error
, NULL_TREE
,
9659 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9660 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9662 maybe_add_lambda_conv_op (type
);
9665 gcc_assert (errorcount
);
9668 /* Set the file and line number information to whatever is given for
9669 the class itself. This puts error messages involving generated
9670 implicit functions at a predictable point, and the same point
9671 that would be used for non-template classes. */
9672 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9674 unreverse_member_declarations (type
);
9675 finish_struct_1 (type
);
9676 TYPE_BEING_DEFINED (type
) = 0;
9678 /* We don't instantiate default arguments for member functions. 14.7.1:
9680 The implicit instantiation of a class template specialization causes
9681 the implicit instantiation of the declarations, but not of the
9682 definitions or default arguments, of the class member functions,
9683 member classes, static data members and member templates.... */
9685 /* Some typedefs referenced from within the template code need to be access
9686 checked at template instantiation time, i.e now. These types were
9687 added to the template at parsing time. Let's get those and perform
9688 the access checks then. */
9689 perform_typedefs_access_check (pattern
, args
);
9690 perform_deferred_access_checks (tf_warning_or_error
);
9691 pop_nested_class ();
9692 maximum_field_alignment
= saved_maximum_field_alignment
;
9694 pop_from_top_level ();
9695 pop_deferring_access_checks ();
9698 /* The vtable for a template class can be emitted in any translation
9699 unit in which the class is instantiated. When there is no key
9700 method, however, finish_struct_1 will already have added TYPE to
9701 the keyed_classes list. */
9702 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9703 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9708 /* Wrapper for instantiate_class_template_1. */
9711 instantiate_class_template (tree type
)
9714 timevar_push (TV_TEMPLATE_INST
);
9715 ret
= instantiate_class_template_1 (type
);
9716 timevar_pop (TV_TEMPLATE_INST
);
9721 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9727 else if (TYPE_P (t
))
9728 r
= tsubst (t
, args
, complain
, in_decl
);
9731 if (!(complain
& tf_warning
))
9732 ++c_inhibit_evaluation_warnings
;
9733 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9734 /*integral_constant_expression_p=*/true);
9735 if (!(complain
& tf_warning
))
9736 --c_inhibit_evaluation_warnings
;
9741 /* Given a function parameter pack TMPL_PARM and some function parameters
9742 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9743 and set *SPEC_P to point at the next point in the list. */
9746 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9748 /* Collect all of the extra "packed" parameters into an
9752 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9753 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9754 tree spec_parm
= *spec_p
;
9757 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9759 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9762 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9763 parmvec
= make_tree_vec (len
);
9764 parmtypevec
= make_tree_vec (len
);
9765 spec_parm
= *spec_p
;
9766 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9768 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9769 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9772 /* Build the argument packs. */
9773 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9774 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9775 TREE_TYPE (argpack
) = argtypepack
;
9776 *spec_p
= spec_parm
;
9781 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9782 NONTYPE_ARGUMENT_PACK. */
9785 make_fnparm_pack (tree spec_parm
)
9787 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9790 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
9791 pack expansion with no extra args, 2 if it has extra args, or 0
9792 if it is not a pack expansion. */
9795 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9797 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9798 if (i
>= TREE_VEC_LENGTH (vec
))
9800 tree elt
= TREE_VEC_ELT (vec
, i
);
9801 if (!PACK_EXPANSION_P (elt
))
9803 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
9809 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9812 make_argument_pack_select (tree arg_pack
, unsigned index
)
9814 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9816 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9817 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9822 /* This is a subroutine of tsubst_pack_expansion.
9824 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9825 mechanism to store the (non complete list of) arguments of the
9826 substitution and return a non substituted pack expansion, in order
9827 to wait for when we have enough arguments to really perform the
9831 use_pack_expansion_extra_args_p (tree parm_packs
,
9835 /* If one pack has an expansion and another pack has a normal
9836 argument or if one pack has an empty argument and an another
9837 one hasn't then tsubst_pack_expansion cannot perform the
9838 substitution and need to fall back on the
9839 PACK_EXPANSION_EXTRA mechanism. */
9840 if (parm_packs
== NULL_TREE
)
9842 else if (has_empty_arg
)
9845 bool has_expansion_arg
= false;
9846 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9848 bool has_non_expansion_arg
= false;
9849 for (tree parm_pack
= parm_packs
;
9851 parm_pack
= TREE_CHAIN (parm_pack
))
9853 tree arg
= TREE_VALUE (parm_pack
);
9855 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
9857 /* We can't substitute a pack expansion with extra args into
9861 has_expansion_arg
= true;
9863 has_non_expansion_arg
= true;
9866 if (has_expansion_arg
&& has_non_expansion_arg
)
9872 /* [temp.variadic]/6 says that:
9874 The instantiation of a pack expansion [...]
9875 produces a list E1,E2, ..., En, where N is the number of elements
9876 in the pack expansion parameters.
9878 This subroutine of tsubst_pack_expansion produces one of these Ei.
9880 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9881 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9882 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9883 INDEX is the index 'i' of the element Ei to produce. ARGS,
9884 COMPLAIN, and IN_DECL are the same parameters as for the
9885 tsubst_pack_expansion function.
9887 The function returns the resulting Ei upon successful completion,
9890 Note that this function possibly modifies the ARGS parameter, so
9891 it's the responsibility of the caller to restore it. */
9894 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9897 tree args
/* This parm gets
9899 tsubst_flags_t complain
,
9903 bool ith_elem_is_expansion
= false;
9905 /* For each parameter pack, change the substitution of the parameter
9906 pack to the ith argument in its argument pack, then expand the
9908 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9910 tree parm
= TREE_PURPOSE (pack
);
9911 tree arg_pack
= TREE_VALUE (pack
);
9912 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9914 ith_elem_is_expansion
|=
9915 argument_pack_element_is_expansion_p (arg_pack
, index
);
9917 /* Select the Ith argument from the pack. */
9918 if (TREE_CODE (parm
) == PARM_DECL
9919 || TREE_CODE (parm
) == FIELD_DECL
)
9923 aps
= make_argument_pack_select (arg_pack
, index
);
9924 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
9925 return error_mark_node
;
9926 register_local_specialization (aps
, parm
);
9929 aps
= retrieve_local_specialization (parm
);
9934 template_parm_level_and_index (parm
, &level
, &idx
);
9938 aps
= make_argument_pack_select (arg_pack
, index
);
9939 /* Update the corresponding argument. */
9940 TMPL_ARG (args
, level
, idx
) = aps
;
9943 /* Re-use the ARGUMENT_PACK_SELECT. */
9944 aps
= TMPL_ARG (args
, level
, idx
);
9946 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9949 /* Substitute into the PATTERN with the (possibly altered)
9951 if (pattern
== in_decl
)
9952 /* Expanding a fixed parameter pack from
9953 coerce_template_parameter_pack. */
9954 t
= tsubst_decl (pattern
, args
, complain
);
9955 else if (!TYPE_P (pattern
))
9956 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9957 /*integral_constant_expression_p=*/false);
9959 t
= tsubst (pattern
, args
, complain
, in_decl
);
9961 /* If the Ith argument pack element is a pack expansion, then
9962 the Ith element resulting from the substituting is going to
9963 be a pack expansion as well. */
9964 if (ith_elem_is_expansion
)
9965 t
= make_pack_expansion (t
);
9970 /* Substitute ARGS into T, which is an pack expansion
9971 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9972 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9973 (if only a partial substitution could be performed) or
9974 ERROR_MARK_NODE if there was an error. */
9976 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9980 tree pack
, packs
= NULL_TREE
;
9981 bool unsubstituted_packs
= false;
9984 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
9985 bool need_local_specializations
= false;
9988 gcc_assert (PACK_EXPANSION_P (t
));
9989 pattern
= PACK_EXPANSION_PATTERN (t
);
9991 /* Add in any args remembered from an earlier partial instantiation. */
9992 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9994 levels
= TMPL_ARGS_DEPTH (args
);
9996 /* Determine the argument packs that will instantiate the parameter
9997 packs used in the expansion expression. While we're at it,
9998 compute the number of arguments to be expanded and make sure it
10000 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
10001 pack
= TREE_CHAIN (pack
))
10003 tree parm_pack
= TREE_VALUE (pack
);
10004 tree arg_pack
= NULL_TREE
;
10005 tree orig_arg
= NULL_TREE
;
10008 if (TREE_CODE (parm_pack
) == BASES
)
10010 if (BASES_DIRECT (parm_pack
))
10011 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
10012 args
, complain
, in_decl
, false));
10014 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
10015 args
, complain
, in_decl
, false));
10017 if (TREE_CODE (parm_pack
) == PARM_DECL
)
10019 if (PACK_EXPANSION_LOCAL_P (t
))
10020 arg_pack
= retrieve_local_specialization (parm_pack
);
10023 /* We can't rely on local_specializations for a parameter
10024 name used later in a function declaration (such as in a
10025 late-specified return type). Even if it exists, it might
10026 have the wrong value for a recursive call. Just make a
10027 dummy decl, since it's only used for its type. */
10028 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
10029 if (arg_pack
&& DECL_PACK_P (arg_pack
))
10030 /* Partial instantiation of the parm_pack, we can't build
10031 up an argument pack yet. */
10032 arg_pack
= NULL_TREE
;
10034 arg_pack
= make_fnparm_pack (arg_pack
);
10035 need_local_specializations
= true;
10038 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
10039 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
10043 template_parm_level_and_index (parm_pack
, &level
, &idx
);
10045 if (level
<= levels
)
10046 arg_pack
= TMPL_ARG (args
, level
, idx
);
10049 orig_arg
= arg_pack
;
10050 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
10051 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
10053 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
10054 /* This can only happen if we forget to expand an argument
10055 pack somewhere else. Just return an error, silently. */
10057 result
= make_tree_vec (1);
10058 TREE_VEC_ELT (result
, 0) = error_mark_node
;
10065 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
10067 /* Don't bother trying to do a partial substitution with
10068 incomplete packs; we'll try again after deduction. */
10069 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
10074 else if (len
!= my_len
)
10076 if (!(complain
& tf_error
))
10077 /* Fail quietly. */;
10078 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
10079 error ("mismatched argument pack lengths while expanding "
10083 error ("mismatched argument pack lengths while expanding "
10086 return error_mark_node
;
10089 /* Keep track of the parameter packs and their corresponding
10091 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
10092 TREE_TYPE (packs
) = orig_arg
;
10096 /* We can't substitute for this parameter pack. We use a flag as
10097 well as the missing_level counter because function parameter
10098 packs don't have a level. */
10099 unsubstituted_packs
= true;
10103 /* If the expansion is just T..., return the matching argument pack. */
10104 if (!unsubstituted_packs
10105 && TREE_PURPOSE (packs
) == pattern
)
10107 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
10108 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
10109 || pack_expansion_args_count (args
))
10111 /* Otherwise use the normal path so we get convert_from_reference. */
10114 /* We cannot expand this expansion expression, because we don't have
10115 all of the argument packs we need. */
10116 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
10118 /* We got some full packs, but we can't substitute them in until we
10119 have values for all the packs. So remember these until then. */
10121 t
= make_pack_expansion (pattern
);
10122 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
10125 else if (unsubstituted_packs
)
10127 /* There were no real arguments, we're just replacing a parameter
10128 pack with another version of itself. Substitute into the
10129 pattern and return a PACK_EXPANSION_*. The caller will need to
10131 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
10132 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
10133 /*integral_constant_expression_p=*/false);
10135 t
= tsubst (pattern
, args
, complain
, in_decl
);
10136 t
= make_pack_expansion (t
);
10140 gcc_assert (len
>= 0);
10142 if (need_local_specializations
)
10144 /* We're in a late-specified return type, so create our own local
10145 specializations map; the current map is either NULL or (in the
10146 case of recursive unification) might have bindings that we don't
10147 want to use or alter. */
10148 saved_local_specializations
= local_specializations
;
10149 local_specializations
= new hash_map
<tree
, tree
>;
10152 /* For each argument in each argument pack, substitute into the
10154 result
= make_tree_vec (len
);
10155 for (i
= 0; i
< len
; ++i
)
10157 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
10161 TREE_VEC_ELT (result
, i
) = t
;
10162 if (t
== error_mark_node
)
10164 result
= error_mark_node
;
10169 /* Update ARGS to restore the substitution from parameter packs to
10170 their argument packs. */
10171 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
10173 tree parm
= TREE_PURPOSE (pack
);
10175 if (TREE_CODE (parm
) == PARM_DECL
10176 || TREE_CODE (parm
) == FIELD_DECL
)
10177 register_local_specialization (TREE_TYPE (pack
), parm
);
10182 if (TREE_VALUE (pack
) == NULL_TREE
)
10185 template_parm_level_and_index (parm
, &level
, &idx
);
10187 /* Update the corresponding argument. */
10188 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
10189 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
10192 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
10196 if (need_local_specializations
)
10198 delete local_specializations
;
10199 local_specializations
= saved_local_specializations
;
10205 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10206 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10207 parameter packs; all parms generated from a function parameter pack will
10208 have the same DECL_PARM_INDEX. */
10211 get_pattern_parm (tree parm
, tree tmpl
)
10213 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
10216 if (DECL_ARTIFICIAL (parm
))
10218 for (patparm
= DECL_ARGUMENTS (pattern
);
10219 patparm
; patparm
= DECL_CHAIN (patparm
))
10220 if (DECL_ARTIFICIAL (patparm
)
10221 && DECL_NAME (parm
) == DECL_NAME (patparm
))
10226 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
10227 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
10228 gcc_assert (DECL_PARM_INDEX (patparm
)
10229 == DECL_PARM_INDEX (parm
));
10235 /* Substitute ARGS into the vector or list of template arguments T. */
10238 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10241 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
10244 if (t
== error_mark_node
)
10245 return error_mark_node
;
10247 len
= TREE_VEC_LENGTH (t
);
10248 elts
= XALLOCAVEC (tree
, len
);
10250 for (i
= 0; i
< len
; i
++)
10252 tree orig_arg
= TREE_VEC_ELT (t
, i
);
10255 if (TREE_CODE (orig_arg
) == TREE_VEC
)
10256 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
10257 else if (PACK_EXPANSION_P (orig_arg
))
10259 /* Substitute into an expansion expression. */
10260 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
10262 if (TREE_CODE (new_arg
) == TREE_VEC
)
10263 /* Add to the expanded length adjustment the number of
10264 expanded arguments. We subtract one from this
10265 measurement, because the argument pack expression
10266 itself is already counted as 1 in
10267 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10268 the argument pack is empty. */
10269 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
10271 else if (ARGUMENT_PACK_P (orig_arg
))
10273 /* Substitute into each of the arguments. */
10274 new_arg
= TYPE_P (orig_arg
)
10275 ? cxx_make_type (TREE_CODE (orig_arg
))
10276 : make_node (TREE_CODE (orig_arg
));
10278 SET_ARGUMENT_PACK_ARGS (
10280 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
10281 args
, complain
, in_decl
));
10283 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
10284 new_arg
= error_mark_node
;
10286 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
10287 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
10288 complain
, in_decl
);
10289 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
10291 if (TREE_TYPE (new_arg
) == error_mark_node
)
10292 new_arg
= error_mark_node
;
10296 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
10298 if (new_arg
== error_mark_node
)
10299 return error_mark_node
;
10302 if (new_arg
!= orig_arg
)
10309 /* Make space for the expanded arguments coming from template
10311 t
= make_tree_vec (len
+ expanded_len_adjust
);
10312 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10313 arguments for a member template.
10314 In that case each TREE_VEC in ORIG_T represents a level of template
10315 arguments, and ORIG_T won't carry any non defaulted argument count.
10316 It will rather be the nested TREE_VECs that will carry one.
10317 In other words, ORIG_T carries a non defaulted argument count only
10318 if it doesn't contain any nested TREE_VEC. */
10319 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
10321 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
10322 count
+= expanded_len_adjust
;
10323 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
10325 for (i
= 0, out
= 0; i
< len
; i
++)
10327 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
10328 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
10329 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10333 /* Now expand the template argument pack "in place". */
10334 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10335 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10339 TREE_VEC_ELT (t
, out
) = elts
[i
];
10347 /* Return the result of substituting ARGS into the template parameters
10348 given by PARMS. If there are m levels of ARGS and m + n levels of
10349 PARMS, then the result will contain n levels of PARMS. For
10350 example, if PARMS is `template <class T> template <class U>
10351 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10352 result will be `template <int*, double, class V>'. */
10355 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10357 tree r
= NULL_TREE
;
10360 /* When substituting into a template, we must set
10361 PROCESSING_TEMPLATE_DECL as the template parameters may be
10362 dependent if they are based on one-another, and the dependency
10363 predicates are short-circuit outside of templates. */
10364 ++processing_template_decl
;
10366 for (new_parms
= &r
;
10367 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10368 new_parms
= &(TREE_CHAIN (*new_parms
)),
10369 parms
= TREE_CHAIN (parms
))
10372 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10375 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10379 if (parms
== error_mark_node
)
10382 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10384 if (tuple
== error_mark_node
)
10387 TREE_VEC_ELT (new_vec
, i
) =
10388 tsubst_template_parm (tuple
, args
, complain
);
10392 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10393 - TMPL_ARGS_DEPTH (args
)),
10394 new_vec
, NULL_TREE
);
10397 --processing_template_decl
;
10402 /* Return the result of substituting ARGS into one template parameter
10403 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10404 parameter and which TREE_PURPOSE is the default argument of the
10405 template parameter. */
10408 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10410 tree default_value
, parm_decl
;
10412 if (args
== NULL_TREE
10414 || t
== error_mark_node
)
10417 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10419 default_value
= TREE_PURPOSE (t
);
10420 parm_decl
= TREE_VALUE (t
);
10422 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10423 if (TREE_CODE (parm_decl
) == PARM_DECL
10424 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10425 parm_decl
= error_mark_node
;
10426 default_value
= tsubst_template_arg (default_value
, args
,
10427 complain
, NULL_TREE
);
10429 return build_tree_list (default_value
, parm_decl
);
10432 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10433 type T. If T is not an aggregate or enumeration type, it is
10434 handled as if by tsubst. IN_DECL is as for tsubst. If
10435 ENTERING_SCOPE is nonzero, T is the context for a template which
10436 we are presently tsubst'ing. Return the substituted value. */
10439 tsubst_aggr_type (tree t
,
10441 tsubst_flags_t complain
,
10443 int entering_scope
)
10445 if (t
== NULL_TREE
)
10448 switch (TREE_CODE (t
))
10451 if (TYPE_PTRMEMFUNC_P (t
))
10452 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10454 /* Else fall through. */
10455 case ENUMERAL_TYPE
:
10457 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10462 int saved_unevaluated_operand
;
10463 int saved_inhibit_evaluation_warnings
;
10465 /* In "sizeof(X<I>)" we need to evaluate "I". */
10466 saved_unevaluated_operand
= cp_unevaluated_operand
;
10467 cp_unevaluated_operand
= 0;
10468 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10469 c_inhibit_evaluation_warnings
= 0;
10471 /* First, determine the context for the type we are looking
10473 context
= TYPE_CONTEXT (t
);
10474 if (context
&& TYPE_P (context
))
10476 context
= tsubst_aggr_type (context
, args
, complain
,
10477 in_decl
, /*entering_scope=*/1);
10478 /* If context is a nested class inside a class template,
10479 it may still need to be instantiated (c++/33959). */
10480 context
= complete_type (context
);
10483 /* Then, figure out what arguments are appropriate for the
10484 type we are trying to find. For example, given:
10486 template <class T> struct S;
10487 template <class T, class U> void f(T, U) { S<U> su; }
10489 and supposing that we are instantiating f<int, double>,
10490 then our ARGS will be {int, double}, but, when looking up
10491 S we only want {double}. */
10492 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10493 complain
, in_decl
);
10494 if (argvec
== error_mark_node
)
10495 r
= error_mark_node
;
10498 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10499 entering_scope
, complain
);
10500 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10503 cp_unevaluated_operand
= saved_unevaluated_operand
;
10504 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10509 /* This is not a template type, so there's nothing to do. */
10513 return tsubst (t
, args
, complain
, in_decl
);
10517 /* Substitute into the default argument ARG (a default argument for
10518 FN), which has the indicated TYPE. */
10521 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10523 tree saved_class_ptr
= NULL_TREE
;
10524 tree saved_class_ref
= NULL_TREE
;
10525 int errs
= errorcount
+ sorrycount
;
10527 /* This can happen in invalid code. */
10528 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10531 /* This default argument came from a template. Instantiate the
10532 default argument here, not in tsubst. In the case of
10541 we must be careful to do name lookup in the scope of S<T>,
10542 rather than in the current class. */
10543 push_access_scope (fn
);
10544 /* The "this" pointer is not valid in a default argument. */
10547 saved_class_ptr
= current_class_ptr
;
10548 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10549 saved_class_ref
= current_class_ref
;
10550 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10553 push_deferring_access_checks(dk_no_deferred
);
10554 /* The default argument expression may cause implicitly defined
10555 member functions to be synthesized, which will result in garbage
10556 collection. We must treat this situation as if we were within
10557 the body of function so as to avoid collecting live data on the
10560 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10561 complain
, NULL_TREE
,
10562 /*integral_constant_expression_p=*/false);
10564 pop_deferring_access_checks();
10566 /* Restore the "this" pointer. */
10569 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10570 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10573 if (errorcount
+sorrycount
> errs
10574 && (complain
& tf_warning_or_error
))
10575 inform (input_location
,
10576 " when instantiating default argument for call to %D", fn
);
10578 /* Make sure the default argument is reasonable. */
10579 arg
= check_default_argument (type
, arg
, complain
);
10581 pop_access_scope (fn
);
10586 /* Substitute into all the default arguments for FN. */
10589 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10594 tmpl_args
= DECL_TI_ARGS (fn
);
10596 /* If this function is not yet instantiated, we certainly don't need
10597 its default arguments. */
10598 if (uses_template_parms (tmpl_args
))
10600 /* Don't do this again for clones. */
10601 if (DECL_CLONED_FUNCTION_P (fn
))
10604 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10606 arg
= TREE_CHAIN (arg
))
10607 if (TREE_PURPOSE (arg
))
10608 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10610 TREE_PURPOSE (arg
),
10614 /* Substitute the ARGS into the T, which is a _DECL. Return the
10615 result of the substitution. Issue error and warning messages under
10616 control of COMPLAIN. */
10619 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10621 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10622 location_t saved_loc
;
10623 tree r
= NULL_TREE
;
10625 hashval_t hash
= 0;
10627 /* Set the filename and linenumber to improve error-reporting. */
10628 saved_loc
= input_location
;
10629 input_location
= DECL_SOURCE_LOCATION (t
);
10631 switch (TREE_CODE (t
))
10633 case TEMPLATE_DECL
:
10635 /* We can get here when processing a member function template,
10636 member class template, or template template parameter. */
10637 tree decl
= DECL_TEMPLATE_RESULT (t
);
10642 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10644 /* Template template parameter is treated here. */
10645 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10646 if (new_type
== error_mark_node
)
10647 RETURN (error_mark_node
);
10648 /* If we get a real template back, return it. This can happen in
10649 the context of most_specialized_partial_spec. */
10650 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10654 DECL_CHAIN (r
) = NULL_TREE
;
10655 TREE_TYPE (r
) = new_type
;
10656 DECL_TEMPLATE_RESULT (r
)
10657 = build_decl (DECL_SOURCE_LOCATION (decl
),
10658 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10659 DECL_TEMPLATE_PARMS (r
)
10660 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10662 TYPE_NAME (new_type
) = r
;
10666 /* We might already have an instance of this template.
10667 The ARGS are for the surrounding class type, so the
10668 full args contain the tsubst'd args for the context,
10669 plus the innermost args from the template decl. */
10670 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10671 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10672 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10673 /* Because this is a template, the arguments will still be
10674 dependent, even after substitution. If
10675 PROCESSING_TEMPLATE_DECL is not set, the dependency
10676 predicates will short-circuit. */
10677 ++processing_template_decl
;
10678 full_args
= tsubst_template_args (tmpl_args
, args
,
10679 complain
, in_decl
);
10680 --processing_template_decl
;
10681 if (full_args
== error_mark_node
)
10682 RETURN (error_mark_node
);
10684 /* If this is a default template template argument,
10685 tsubst might not have changed anything. */
10686 if (full_args
== tmpl_args
)
10689 hash
= hash_tmpl_and_args (t
, full_args
);
10690 spec
= retrieve_specialization (t
, full_args
, hash
);
10691 if (spec
!= NULL_TREE
)
10697 /* Make a new template decl. It will be similar to the
10698 original, but will record the current template arguments.
10699 We also create a new function declaration, which is just
10700 like the old one, but points to this new template, rather
10701 than the old one. */
10703 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10704 DECL_CHAIN (r
) = NULL_TREE
;
10706 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10708 if (TREE_CODE (decl
) == TYPE_DECL
10709 && !TYPE_DECL_ALIAS_P (decl
))
10712 ++processing_template_decl
;
10713 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10714 --processing_template_decl
;
10715 if (new_type
== error_mark_node
)
10716 RETURN (error_mark_node
);
10718 TREE_TYPE (r
) = new_type
;
10719 /* For a partial specialization, we need to keep pointing to
10720 the primary template. */
10721 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10722 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10723 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10724 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10725 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10730 ++processing_template_decl
;
10731 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10732 --processing_template_decl
;
10733 if (new_decl
== error_mark_node
)
10734 RETURN (error_mark_node
);
10736 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10737 DECL_TI_TEMPLATE (new_decl
) = r
;
10738 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10739 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10740 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10743 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10744 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10745 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10747 /* The template parameters for this new template are all the
10748 template parameters for the old template, except the
10749 outermost level of parameters. */
10750 DECL_TEMPLATE_PARMS (r
)
10751 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10754 if (PRIMARY_TEMPLATE_P (t
))
10755 DECL_PRIMARY_TEMPLATE (r
) = r
;
10757 if (TREE_CODE (decl
) != TYPE_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
10758 /* Record this non-type partial instantiation. */
10759 register_specialization (r
, t
,
10760 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10765 case FUNCTION_DECL
:
10768 tree argvec
= NULL_TREE
;
10776 /* Nobody should be tsubst'ing into non-template functions. */
10777 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10779 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10784 /* If T is not dependent, just return it. We have to
10785 increment PROCESSING_TEMPLATE_DECL because
10786 value_dependent_expression_p assumes that nothing is
10787 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10788 ++processing_template_decl
;
10789 dependent_p
= value_dependent_expression_p (t
);
10790 --processing_template_decl
;
10794 /* Calculate the most general template of which R is a
10795 specialization, and the complete set of arguments used to
10797 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10798 argvec
= tsubst_template_args (DECL_TI_ARGS
10799 (DECL_TEMPLATE_RESULT
10800 (DECL_TI_TEMPLATE (t
))),
10801 args
, complain
, in_decl
);
10802 if (argvec
== error_mark_node
)
10803 RETURN (error_mark_node
);
10805 /* Check to see if we already have this specialization. */
10806 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10807 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10815 /* We can see more levels of arguments than parameters if
10816 there was a specialization of a member template, like
10819 template <class T> struct S { template <class U> void f(); }
10820 template <> template <class U> void S<int>::f(U);
10822 Here, we'll be substituting into the specialization,
10823 because that's where we can find the code we actually
10824 want to generate, but we'll have enough arguments for
10825 the most general template.
10827 We also deal with the peculiar case:
10829 template <class T> struct S {
10830 template <class U> friend void f();
10832 template <class U> void f() {}
10834 template void f<double>();
10836 Here, the ARGS for the instantiation of will be {int,
10837 double}. But, we only need as many ARGS as there are
10838 levels of template parameters in CODE_PATTERN. We are
10839 careful not to get fooled into reducing the ARGS in
10842 template <class T> struct S { template <class U> void f(U); }
10843 template <class T> template <> void S<T>::f(int) {}
10845 which we can spot because the pattern will be a
10846 specialization in this case. */
10847 args_depth
= TMPL_ARGS_DEPTH (args
);
10849 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10850 if (args_depth
> parms_depth
10851 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10852 args
= get_innermost_template_args (args
, parms_depth
);
10856 /* This special case arises when we have something like this:
10858 template <class T> struct S {
10859 friend void f<int>(int, double);
10862 Here, the DECL_TI_TEMPLATE for the friend declaration
10863 will be an IDENTIFIER_NODE. We are being called from
10864 tsubst_friend_function, and we want only to create a
10865 new decl (R) with appropriate types so that we can call
10866 determine_specialization. */
10867 gen_tmpl
= NULL_TREE
;
10870 if (DECL_CLASS_SCOPE_P (t
))
10872 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10876 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10877 complain
, t
, /*entering_scope=*/1);
10882 ctx
= DECL_CONTEXT (t
);
10884 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10885 if (type
== error_mark_node
)
10886 RETURN (error_mark_node
);
10888 /* If we hit excessive deduction depth, the type is bogus even if
10889 it isn't error_mark_node, so don't build a decl. */
10890 if (excessive_deduction_depth
)
10891 RETURN (error_mark_node
);
10893 /* We do NOT check for matching decls pushed separately at this
10894 point, as they may not represent instantiations of this
10895 template, and in any case are considered separate under the
10898 DECL_USE_TEMPLATE (r
) = 0;
10899 TREE_TYPE (r
) = type
;
10900 /* Clear out the mangled name and RTL for the instantiation. */
10901 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10902 SET_DECL_RTL (r
, NULL
);
10903 /* Leave DECL_INITIAL set on deleted instantiations. */
10904 if (!DECL_DELETED_FN (r
))
10905 DECL_INITIAL (r
) = NULL_TREE
;
10906 DECL_CONTEXT (r
) = ctx
;
10908 /* OpenMP UDRs have the only argument a reference to the declared
10909 type. We want to diagnose if the declared type is a reference,
10910 which is invalid, but as references to references are usually
10911 quietly merged, diagnose it here. */
10912 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10915 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10916 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10917 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10918 error_at (DECL_SOURCE_LOCATION (t
),
10919 "reference type %qT in "
10920 "%<#pragma omp declare reduction%>", argtype
);
10921 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10922 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10926 if (member
&& DECL_CONV_FN_P (r
))
10927 /* Type-conversion operator. Reconstruct the name, in
10928 case it's the name of one of the template's parameters. */
10929 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10931 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10933 DECL_RESULT (r
) = NULL_TREE
;
10935 TREE_STATIC (r
) = 0;
10936 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10937 DECL_EXTERNAL (r
) = 1;
10938 /* If this is an instantiation of a function with internal
10939 linkage, we already know what object file linkage will be
10940 assigned to the instantiation. */
10941 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10942 DECL_DEFER_OUTPUT (r
) = 0;
10943 DECL_CHAIN (r
) = NULL_TREE
;
10944 DECL_PENDING_INLINE_INFO (r
) = 0;
10945 DECL_PENDING_INLINE_P (r
) = 0;
10946 DECL_SAVED_TREE (r
) = NULL_TREE
;
10947 DECL_STRUCT_FUNCTION (r
) = NULL
;
10949 /* We'll re-clone as appropriate in instantiate_template. */
10950 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10952 /* If we aren't complaining now, return on error before we register
10953 the specialization so that we'll complain eventually. */
10954 if ((complain
& tf_error
) == 0
10955 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10956 && !grok_op_properties (r
, /*complain=*/false))
10957 RETURN (error_mark_node
);
10959 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10960 this in the special friend case mentioned above where
10961 GEN_TMPL is NULL. */
10964 DECL_TEMPLATE_INFO (r
)
10965 = build_template_info (gen_tmpl
, argvec
);
10966 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10969 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10971 /* We instantiated this while substituting into
10972 the type earlier (template/friend54.C). */
10975 /* We're not supposed to instantiate default arguments
10976 until they are called, for a template. But, for a
10979 template <class T> void f ()
10980 { extern void g(int i = T()); }
10982 we should do the substitution when the template is
10983 instantiated. We handle the member function case in
10984 instantiate_class_template since the default arguments
10985 might refer to other members of the class. */
10987 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10988 && !uses_template_parms (argvec
))
10989 tsubst_default_arguments (r
, complain
);
10992 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10994 /* Copy the list of befriending classes. */
10995 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10997 friends
= &TREE_CHAIN (*friends
))
10999 *friends
= copy_node (*friends
);
11000 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
11005 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
11007 maybe_retrofit_in_chrg (r
);
11008 if (DECL_CONSTRUCTOR_P (r
))
11009 grok_ctor_properties (ctx
, r
);
11010 if (DECL_INHERITED_CTOR_BASE (r
))
11011 deduce_inheriting_ctor (r
);
11012 /* If this is an instantiation of a member template, clone it.
11013 If it isn't, that'll be handled by
11014 clone_constructors_and_destructors. */
11015 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
11016 clone_function_decl (r
, /*update_method_vec_p=*/0);
11018 else if ((complain
& tf_error
) != 0
11019 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
11020 && !grok_op_properties (r
, /*complain=*/true))
11021 RETURN (error_mark_node
);
11023 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
11024 SET_DECL_FRIEND_CONTEXT (r
,
11025 tsubst (DECL_FRIEND_CONTEXT (t
),
11026 args
, complain
, in_decl
));
11028 /* Possibly limit visibility based on template args. */
11029 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11030 if (DECL_VISIBILITY_SPECIFIED (t
))
11032 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11033 DECL_ATTRIBUTES (r
)
11034 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11036 determine_visibility (r
);
11037 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
11038 && !processing_template_decl
)
11039 defaulted_late_check (r
);
11041 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11042 args
, complain
, in_decl
);
11048 tree type
= NULL_TREE
;
11050 tree expanded_types
= NULL_TREE
;
11051 tree prev_r
= NULL_TREE
;
11052 tree first_r
= NULL_TREE
;
11054 if (DECL_PACK_P (t
))
11056 /* If there is a local specialization that isn't a
11057 parameter pack, it means that we're doing a "simple"
11058 substitution from inside tsubst_pack_expansion. Just
11059 return the local specialization (which will be a single
11061 tree spec
= retrieve_local_specialization (t
);
11063 && TREE_CODE (spec
) == PARM_DECL
11064 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
11067 /* Expand the TYPE_PACK_EXPANSION that provides the types for
11068 the parameters in this function parameter pack. */
11069 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11070 complain
, in_decl
);
11071 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11073 len
= TREE_VEC_LENGTH (expanded_types
);
11075 /* Zero-length parameter packs are boring. Just substitute
11078 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
11083 /* All we did was update the type. Make a note of that. */
11084 type
= expanded_types
;
11085 expanded_types
= NULL_TREE
;
11089 /* Loop through all of the parameters we'll build. When T is
11090 a function parameter pack, LEN is the number of expanded
11091 types in EXPANDED_TYPES; otherwise, LEN is 1. */
11093 for (i
= 0; i
< len
; ++i
)
11097 if (DECL_TEMPLATE_PARM_P (t
))
11098 SET_DECL_TEMPLATE_PARM_P (r
);
11100 if (expanded_types
)
11101 /* We're on the Ith parameter of the function parameter
11104 /* Get the Ith type. */
11105 type
= TREE_VEC_ELT (expanded_types
, i
);
11107 /* Rename the parameter to include the index. */
11109 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11112 /* We're dealing with a normal parameter. */
11113 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11115 type
= type_decays_to (type
);
11116 TREE_TYPE (r
) = type
;
11117 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11119 if (DECL_INITIAL (r
))
11121 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
11122 DECL_INITIAL (r
) = TREE_TYPE (r
);
11124 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
11125 complain
, in_decl
);
11128 DECL_CONTEXT (r
) = NULL_TREE
;
11130 if (!DECL_TEMPLATE_PARM_P (r
))
11131 DECL_ARG_TYPE (r
) = type_passed_as (type
);
11133 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11134 args
, complain
, in_decl
);
11136 /* Keep track of the first new parameter we
11137 generate. That's what will be returned to the
11142 /* Build a proper chain of parameters when substituting
11143 into a function parameter pack. */
11145 DECL_CHAIN (prev_r
) = r
;
11148 /* If cp_unevaluated_operand is set, we're just looking for a
11149 single dummy parameter, so don't keep going. */
11150 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
11151 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
11152 complain
, DECL_CHAIN (t
));
11154 /* FIRST_R contains the start of the chain we've built. */
11161 tree type
= NULL_TREE
;
11162 tree vec
= NULL_TREE
;
11163 tree expanded_types
= NULL_TREE
;
11166 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
11168 /* This field is a lambda capture pack. Return a TREE_VEC of
11169 the expanded fields to instantiate_class_template_1 and
11170 store them in the specializations hash table as a
11171 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11172 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11173 complain
, in_decl
);
11174 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11176 len
= TREE_VEC_LENGTH (expanded_types
);
11177 vec
= make_tree_vec (len
);
11181 /* All we did was update the type. Make a note of that. */
11182 type
= expanded_types
;
11183 expanded_types
= NULL_TREE
;
11187 for (int i
= 0; i
< len
; ++i
)
11190 if (expanded_types
)
11192 type
= TREE_VEC_ELT (expanded_types
, i
);
11194 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11197 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11199 if (type
== error_mark_node
)
11200 RETURN (error_mark_node
);
11201 TREE_TYPE (r
) = type
;
11202 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11204 if (DECL_C_BIT_FIELD (r
))
11205 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11206 non-bit-fields DECL_INITIAL is a non-static data member
11207 initializer, which gets deferred instantiation. */
11209 = tsubst_expr (DECL_INITIAL (t
), args
,
11211 /*integral_constant_expression_p=*/true);
11212 else if (DECL_INITIAL (t
))
11214 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11215 NSDMI in perform_member_init. Still set DECL_INITIAL
11216 so that we know there is one. */
11217 DECL_INITIAL (r
) = void_node
;
11218 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
11219 retrofit_lang_decl (r
);
11220 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
11222 /* We don't have to set DECL_CONTEXT here; it is set by
11223 finish_member_declaration. */
11224 DECL_CHAIN (r
) = NULL_TREE
;
11226 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11227 args
, complain
, in_decl
);
11230 TREE_VEC_ELT (vec
, i
) = r
;
11236 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
11237 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
11238 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
11239 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
11240 TREE_TYPE (pack
) = tpack
;
11241 register_specialization (pack
, t
, args
, false, 0);
11247 /* We reach here only for member using decls. We also need to check
11248 uses_template_parms because DECL_DEPENDENT_P is not set for a
11249 using-declaration that designates a member of the current
11250 instantiation (c++/53549). */
11251 if (DECL_DEPENDENT_P (t
)
11252 || uses_template_parms (USING_DECL_SCOPE (t
)))
11254 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
11255 complain
, in_decl
);
11256 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
11257 r
= do_class_using_decl (inst_scope
, name
);
11259 r
= error_mark_node
;
11262 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
11263 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
11269 DECL_CHAIN (r
) = NULL_TREE
;
11276 tree argvec
= NULL_TREE
;
11277 tree gen_tmpl
= NULL_TREE
;
11279 tree tmpl
= NULL_TREE
;
11281 tree type
= NULL_TREE
;
11284 if (TREE_TYPE (t
) == error_mark_node
)
11285 RETURN (error_mark_node
);
11287 if (TREE_CODE (t
) == TYPE_DECL
11288 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
11290 /* If this is the canonical decl, we don't have to
11291 mess with instantiations, and often we can't (for
11292 typename, template type parms and such). Note that
11293 TYPE_NAME is not correct for the above test if
11294 we've copied the type for a typedef. */
11295 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11296 if (type
== error_mark_node
)
11297 RETURN (error_mark_node
);
11298 r
= TYPE_NAME (type
);
11302 /* Check to see if we already have the specialization we
11305 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
11307 /* T is a static data member or namespace-scope entity.
11308 We have to substitute into namespace-scope variables
11309 (even though such entities are never templates) because
11312 template <class T> void f() { extern T t; }
11314 where the entity referenced is not known until
11315 instantiation time. */
11317 ctx
= DECL_CONTEXT (t
);
11318 if (DECL_CLASS_SCOPE_P (t
))
11320 ctx
= tsubst_aggr_type (ctx
, args
,
11322 in_decl
, /*entering_scope=*/1);
11323 /* If CTX is unchanged, then T is in fact the
11324 specialization we want. That situation occurs when
11325 referencing a static data member within in its own
11326 class. We can use pointer equality, rather than
11327 same_type_p, because DECL_CONTEXT is always
11329 if (ctx
== DECL_CONTEXT (t
)
11330 /* ... unless T is a member template; in which
11331 case our caller can be willing to create a
11332 specialization of that template represented
11334 && !(DECL_TI_TEMPLATE (t
)
11335 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
11341 tmpl
= DECL_TI_TEMPLATE (t
);
11342 gen_tmpl
= most_general_template (tmpl
);
11343 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11344 if (argvec
!= error_mark_node
)
11345 argvec
= (coerce_innermost_template_parms
11346 (DECL_TEMPLATE_PARMS (gen_tmpl
),
11347 argvec
, t
, complain
,
11348 /*all*/true, /*defarg*/true));
11349 if (argvec
== error_mark_node
)
11350 RETURN (error_mark_node
);
11351 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11352 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11357 /* A local variable. */
11359 /* Subsequent calls to pushdecl will fill this in. */
11361 spec
= retrieve_local_specialization (t
);
11363 /* If we already have the specialization we need, there is
11364 nothing more to do. */
11371 /* Create a new node for the specialization we need. */
11373 if (type
== NULL_TREE
)
11375 if (is_typedef_decl (t
))
11376 type
= DECL_ORIGINAL_TYPE (t
);
11378 type
= TREE_TYPE (t
);
11380 && VAR_HAD_UNKNOWN_BOUND (t
)
11381 && type
!= error_mark_node
)
11382 type
= strip_array_domain (type
);
11383 type
= tsubst (type
, args
, complain
, in_decl
);
11387 /* Even if the original location is out of scope, the
11388 newly substituted one is not. */
11389 DECL_DEAD_FOR_LOCAL (r
) = 0;
11390 DECL_INITIALIZED_P (r
) = 0;
11391 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11392 if (type
== error_mark_node
)
11393 RETURN (error_mark_node
);
11394 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11396 /* It may seem that this case cannot occur, since:
11401 declares a function, not a variable. However:
11404 template <typename T> void g() { T t; }
11405 template void g<f>();
11407 is an attempt to declare a variable with function
11409 error ("variable %qD has function type",
11410 /* R is not yet sufficiently initialized, so we
11411 just use its name. */
11413 RETURN (error_mark_node
);
11415 type
= complete_type (type
);
11416 /* Wait until cp_finish_decl to set this again, to handle
11417 circular dependency (template/instantiate6.C). */
11418 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11419 type
= check_var_type (DECL_NAME (r
), type
);
11421 if (DECL_HAS_VALUE_EXPR_P (t
))
11423 tree ve
= DECL_VALUE_EXPR (t
);
11424 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11425 /*constant_expression_p=*/false);
11426 if (REFERENCE_REF_P (ve
))
11428 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11429 ve
= TREE_OPERAND (ve
, 0);
11431 SET_DECL_VALUE_EXPR (r
, ve
);
11433 if (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
11434 set_decl_tls_model (r
, decl_tls_model (t
));
11436 else if (DECL_SELF_REFERENCE_P (t
))
11437 SET_DECL_SELF_REFERENCE_P (r
);
11438 TREE_TYPE (r
) = type
;
11439 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11440 DECL_CONTEXT (r
) = ctx
;
11441 /* Clear out the mangled name and RTL for the instantiation. */
11442 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11443 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11444 SET_DECL_RTL (r
, NULL
);
11445 /* The initializer must not be expanded until it is required;
11446 see [temp.inst]. */
11447 DECL_INITIAL (r
) = NULL_TREE
;
11448 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11449 SET_DECL_RTL (r
, NULL
);
11450 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11453 /* Possibly limit visibility based on template args. */
11454 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11455 if (DECL_VISIBILITY_SPECIFIED (t
))
11457 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11458 DECL_ATTRIBUTES (r
)
11459 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11461 determine_visibility (r
);
11466 /* A static data member declaration is always marked
11467 external when it is declared in-class, even if an
11468 initializer is present. We mimic the non-template
11469 processing here. */
11470 DECL_EXTERNAL (r
) = 1;
11472 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11473 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11474 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11476 else if (!cp_unevaluated_operand
)
11477 register_local_specialization (r
, t
);
11479 DECL_CHAIN (r
) = NULL_TREE
;
11481 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11483 args
, complain
, in_decl
);
11485 /* Preserve a typedef that names a type. */
11486 if (is_typedef_decl (r
))
11488 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11489 set_underlying_type (r
);
11492 layout_decl (r
, 0);
11497 gcc_unreachable ();
11502 /* Restore the file and line information. */
11503 input_location
= saved_loc
;
11508 /* Substitute into the ARG_TYPES of a function type.
11509 If END is a TREE_CHAIN, leave it and any following types
11513 tsubst_arg_types (tree arg_types
,
11516 tsubst_flags_t complain
,
11519 tree remaining_arg_types
;
11520 tree type
= NULL_TREE
;
11522 tree expanded_args
= NULL_TREE
;
11525 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11528 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11529 args
, end
, complain
, in_decl
);
11530 if (remaining_arg_types
== error_mark_node
)
11531 return error_mark_node
;
11533 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11535 /* For a pack expansion, perform substitution on the
11536 entire expression. Later on, we'll handle the arguments
11538 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11539 args
, complain
, in_decl
);
11541 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11542 /* So that we'll spin through the parameters, one by one. */
11543 i
= TREE_VEC_LENGTH (expanded_args
);
11546 /* We only partially substituted into the parameter
11547 pack. Our type is TYPE_PACK_EXPANSION. */
11548 type
= expanded_args
;
11549 expanded_args
= NULL_TREE
;
11557 type
= TREE_VEC_ELT (expanded_args
, i
);
11559 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11561 if (type
== error_mark_node
)
11562 return error_mark_node
;
11563 if (VOID_TYPE_P (type
))
11565 if (complain
& tf_error
)
11567 error ("invalid parameter type %qT", type
);
11569 error ("in declaration %q+D", in_decl
);
11571 return error_mark_node
;
11574 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11575 return error_mark_node
;
11577 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11578 top-level qualifiers as required. */
11579 type
= cv_unqualified (type_decays_to (type
));
11581 /* We do not substitute into default arguments here. The standard
11582 mandates that they be instantiated only when needed, which is
11583 done in build_over_call. */
11584 default_arg
= TREE_PURPOSE (arg_types
);
11586 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11588 /* We've instantiated a template before its default arguments
11589 have been parsed. This can happen for a nested template
11590 class, and is not an error unless we require the default
11591 argument in a call of this function. */
11592 remaining_arg_types
=
11593 tree_cons (default_arg
, type
, remaining_arg_types
);
11594 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11597 remaining_arg_types
=
11598 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11601 return remaining_arg_types
;
11604 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11605 *not* handle the exception-specification for FNTYPE, because the
11606 initial substitution of explicitly provided template parameters
11607 during argument deduction forbids substitution into the
11608 exception-specification:
11612 All references in the function type of the function template to the
11613 corresponding template parameters are replaced by the specified tem-
11614 plate argument values. If a substitution in a template parameter or
11615 in the function type of the function template results in an invalid
11616 type, type deduction fails. [Note: The equivalent substitution in
11617 exception specifications is done only when the function is instanti-
11618 ated, at which point a program is ill-formed if the substitution
11619 results in an invalid type.] */
11622 tsubst_function_type (tree t
,
11624 tsubst_flags_t complain
,
11628 tree arg_types
= NULL_TREE
;
11631 /* The TYPE_CONTEXT is not used for function/method types. */
11632 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11634 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11636 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11638 if (late_return_type_p
)
11640 /* Substitute the argument types. */
11641 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11642 complain
, in_decl
);
11643 if (arg_types
== error_mark_node
)
11644 return error_mark_node
;
11646 tree save_ccp
= current_class_ptr
;
11647 tree save_ccr
= current_class_ref
;
11648 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11649 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11650 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11653 /* DR 1207: 'this' is in scope in the trailing return type. */
11654 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11657 /* Substitute the return type. */
11658 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11662 current_class_ptr
= save_ccp
;
11663 current_class_ref
= save_ccr
;
11667 /* Substitute the return type. */
11668 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11670 if (return_type
== error_mark_node
)
11671 return error_mark_node
;
11672 /* DR 486 clarifies that creation of a function type with an
11673 invalid return type is a deduction failure. */
11674 if (TREE_CODE (return_type
) == ARRAY_TYPE
11675 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11677 if (complain
& tf_error
)
11679 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11680 error ("function returning an array");
11682 error ("function returning a function");
11684 return error_mark_node
;
11687 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11688 return error_mark_node
;
11690 if (!late_return_type_p
)
11692 /* Substitute the argument types. */
11693 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11694 complain
, in_decl
);
11695 if (arg_types
== error_mark_node
)
11696 return error_mark_node
;
11699 /* Construct a new type node and return it. */
11700 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11702 fntype
= build_function_type (return_type
, arg_types
);
11703 fntype
= apply_memfn_quals (fntype
,
11704 type_memfn_quals (t
),
11705 type_memfn_rqual (t
));
11709 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11710 /* Don't pick up extra function qualifiers from the basetype. */
11711 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11712 if (! MAYBE_CLASS_TYPE_P (r
))
11716 Type deduction may fail for any of the following
11719 -- Attempting to create "pointer to member of T" when T
11720 is not a class type. */
11721 if (complain
& tf_error
)
11722 error ("creating pointer to member function of non-class type %qT",
11724 return error_mark_node
;
11727 fntype
= build_method_type_directly (r
, return_type
,
11728 TREE_CHAIN (arg_types
));
11729 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11731 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11733 if (late_return_type_p
)
11734 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11739 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11740 ARGS into that specification, and return the substituted
11741 specification. If there is no specification, return NULL_TREE. */
11744 tsubst_exception_specification (tree fntype
,
11746 tsubst_flags_t complain
,
11753 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11754 new_specs
= NULL_TREE
;
11755 if (specs
&& TREE_PURPOSE (specs
))
11757 /* A noexcept-specifier. */
11758 tree expr
= TREE_PURPOSE (specs
);
11759 if (TREE_CODE (expr
) == INTEGER_CST
)
11763 /* Defer instantiation of noexcept-specifiers to avoid
11764 excessive instantiations (c++/49107). */
11765 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11766 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11768 /* We already partially instantiated this member template,
11769 so combine the new args with the old. */
11770 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11771 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11772 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11773 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11777 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11778 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11782 new_specs
= tsubst_copy_and_build
11783 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11784 /*integral_constant_expression_p=*/true);
11785 new_specs
= build_noexcept_spec (new_specs
, complain
);
11789 if (! TREE_VALUE (specs
))
11796 tree expanded_specs
= NULL_TREE
;
11798 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11800 /* Expand the pack expansion type. */
11801 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11805 if (expanded_specs
== error_mark_node
)
11806 return error_mark_node
;
11807 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11808 len
= TREE_VEC_LENGTH (expanded_specs
);
11811 /* We're substituting into a member template, so
11812 we got a TYPE_PACK_EXPANSION back. Add that
11813 expansion and move on. */
11814 gcc_assert (TREE_CODE (expanded_specs
)
11815 == TYPE_PACK_EXPANSION
);
11816 new_specs
= add_exception_specifier (new_specs
,
11819 specs
= TREE_CHAIN (specs
);
11824 for (i
= 0; i
< len
; ++i
)
11826 if (expanded_specs
)
11827 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11829 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11830 if (spec
== error_mark_node
)
11832 new_specs
= add_exception_specifier (new_specs
, spec
,
11836 specs
= TREE_CHAIN (specs
);
11842 /* Take the tree structure T and replace template parameters used
11843 therein with the argument vector ARGS. IN_DECL is an associated
11844 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11845 Issue error and warning messages under control of COMPLAIN. Note
11846 that we must be relatively non-tolerant of extensions here, in
11847 order to preserve conformance; if we allow substitutions that
11848 should not be allowed, we may allow argument deductions that should
11849 not succeed, and therefore report ambiguous overload situations
11850 where there are none. In theory, we could allow the substitution,
11851 but indicate that it should have failed, and allow our caller to
11852 make sure that the right thing happens, but we don't try to do this
11855 This function is used for dealing with types, decls and the like;
11856 for expressions, use tsubst_expr or tsubst_copy. */
11859 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11861 enum tree_code code
;
11862 tree type
, r
= NULL_TREE
;
11864 if (t
== NULL_TREE
|| t
== error_mark_node
11865 || t
== integer_type_node
11866 || t
== void_type_node
11867 || t
== char_type_node
11868 || t
== unknown_type_node
11869 || TREE_CODE (t
) == NAMESPACE_DECL
11870 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11874 return tsubst_decl (t
, args
, complain
);
11876 if (args
== NULL_TREE
)
11879 code
= TREE_CODE (t
);
11881 if (code
== IDENTIFIER_NODE
)
11882 type
= IDENTIFIER_TYPE_VALUE (t
);
11884 type
= TREE_TYPE (t
);
11886 gcc_assert (type
!= unknown_type_node
);
11888 /* Reuse typedefs. We need to do this to handle dependent attributes,
11889 such as attribute aligned. */
11891 && typedef_variant_p (t
))
11893 tree decl
= TYPE_NAME (t
);
11895 if (alias_template_specialization_p (t
))
11897 /* DECL represents an alias template and we want to
11899 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11900 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11901 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11903 else if (DECL_CLASS_SCOPE_P (decl
)
11904 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11905 && uses_template_parms (DECL_CONTEXT (decl
)))
11907 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11908 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11909 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11911 else if (DECL_FUNCTION_SCOPE_P (decl
)
11912 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11913 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11914 r
= retrieve_local_specialization (decl
);
11916 /* The typedef is from a non-template context. */
11922 r
= cp_build_qualified_type_real
11923 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11924 complain
| tf_ignore_bad_quals
);
11929 /* We don't have an instantiation yet, so drop the typedef. */
11930 int quals
= cp_type_quals (t
);
11931 t
= DECL_ORIGINAL_TYPE (decl
);
11932 t
= cp_build_qualified_type_real (t
, quals
,
11933 complain
| tf_ignore_bad_quals
);
11938 && code
!= TYPENAME_TYPE
11939 && code
!= TEMPLATE_TYPE_PARM
11940 && code
!= IDENTIFIER_NODE
11941 && code
!= FUNCTION_TYPE
11942 && code
!= METHOD_TYPE
)
11943 type
= tsubst (type
, args
, complain
, in_decl
);
11944 if (type
== error_mark_node
)
11945 return error_mark_node
;
11951 case ENUMERAL_TYPE
:
11952 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11953 /*entering_scope=*/0);
11956 case IDENTIFIER_NODE
:
11967 if (t
== integer_type_node
)
11970 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11971 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11975 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11977 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11978 /*integral_constant_expression_p=*/false);
11980 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11982 if (TREE_CODE (max
) == NOP_EXPR
11983 && TREE_SIDE_EFFECTS (omax
)
11984 && !TREE_TYPE (max
))
11985 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11987 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11988 with TREE_SIDE_EFFECTS that indicates this is not an integral
11989 constant expression. */
11990 if (processing_template_decl
11991 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11993 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11994 TREE_SIDE_EFFECTS (max
) = 1;
11997 return compute_array_index_type (NULL_TREE
, max
, complain
);
12000 case TEMPLATE_TYPE_PARM
:
12001 case TEMPLATE_TEMPLATE_PARM
:
12002 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12003 case TEMPLATE_PARM_INDEX
:
12008 tree arg
= NULL_TREE
;
12012 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
12013 template_parm_level_and_index (t
, &level
, &idx
);
12015 levels
= TMPL_ARGS_DEPTH (args
);
12016 if (level
<= levels
)
12018 arg
= TMPL_ARG (args
, level
, idx
);
12020 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
12022 /* See through ARGUMENT_PACK_SELECT arguments. */
12023 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
12024 /* If the selected argument is an expansion E, that most
12025 likely means we were called from
12026 gen_elem_of_pack_expansion_instantiation during the
12027 substituting of pack an argument pack (which Ith
12028 element is a pack expansion, where I is
12029 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
12030 In this case, the Ith element resulting from this
12031 substituting is going to be a pack expansion, which
12032 pattern is the pattern of E. Let's return the
12034 gen_elem_of_pack_expansion_instantiation will
12035 build the resulting pack expansion from it. */
12036 if (PACK_EXPANSION_P (arg
))
12038 /* Make sure we aren't throwing away arg info. */
12039 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
12040 arg
= PACK_EXPANSION_PATTERN (arg
);
12045 if (arg
== error_mark_node
)
12046 return error_mark_node
;
12047 else if (arg
!= NULL_TREE
)
12049 if (ARGUMENT_PACK_P (arg
))
12050 /* If ARG is an argument pack, we don't actually want to
12051 perform a substitution here, because substitutions
12052 for argument packs are only done
12053 element-by-element. We can get to this point when
12054 substituting the type of a non-type template
12055 parameter pack, when that type actually contains
12056 template parameter packs from an outer template, e.g.,
12058 template<typename... Types> struct A {
12059 template<Types... Values> struct B { };
12063 if (code
== TEMPLATE_TYPE_PARM
)
12066 gcc_assert (TYPE_P (arg
));
12068 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
12070 return cp_build_qualified_type_real
12071 (arg
, quals
, complain
| tf_ignore_bad_quals
);
12073 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12075 /* We are processing a type constructed from a
12076 template template parameter. */
12077 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
12078 args
, complain
, in_decl
);
12079 if (argvec
== error_mark_node
)
12080 return error_mark_node
;
12082 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
12083 || TREE_CODE (arg
) == TEMPLATE_DECL
12084 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
12086 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
12087 /* Consider this code:
12089 template <template <class> class Template>
12091 template <class Arg> using Bind = Template<Arg>;
12094 template <template <class> class Template, class Arg>
12095 using Instantiate = Template<Arg>; //#0
12097 template <template <class> class Template,
12100 Instantiate<Internal<Template>::template Bind,
12103 When #1 is parsed, the
12104 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12105 parameter `Template' in #0 matches the
12106 UNBOUND_CLASS_TEMPLATE representing the argument
12107 `Internal<Template>::template Bind'; We then want
12108 to assemble the type `Bind<Argument>' that can't
12109 be fully created right now, because
12110 `Internal<Template>' not being complete, the Bind
12111 template cannot be looked up in that context. So
12112 we need to "store" `Bind<Argument>' for later
12113 when the context of Bind becomes complete. Let's
12114 store that in a TYPENAME_TYPE. */
12115 return make_typename_type (TYPE_CONTEXT (arg
),
12116 build_nt (TEMPLATE_ID_EXPR
,
12117 TYPE_IDENTIFIER (arg
),
12122 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12123 are resolving nested-types in the signature of a
12124 member function templates. Otherwise ARG is a
12125 TEMPLATE_DECL and is the real template to be
12127 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
12128 arg
= TYPE_NAME (arg
);
12130 r
= lookup_template_class (arg
,
12132 DECL_CONTEXT (arg
),
12133 /*entering_scope=*/0,
12135 return cp_build_qualified_type_real
12136 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
12139 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12140 return convert_from_reference (unshare_expr (arg
));
12144 /* This can happen during the attempted tsubst'ing in
12145 unify. This means that we don't yet have any information
12146 about the template parameter in question. */
12149 /* Early in template argument deduction substitution, we don't
12150 want to reduce the level of 'auto', or it will be confused
12151 with a normal template parm in subsequent deduction. */
12152 if (is_auto (t
) && (complain
& tf_partial
))
12155 /* If we get here, we must have been looking at a parm for a
12156 more deeply nested template. Make a new version of this
12157 template parameter, but with a lower level. */
12160 case TEMPLATE_TYPE_PARM
:
12161 case TEMPLATE_TEMPLATE_PARM
:
12162 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12163 if (cp_type_quals (t
))
12165 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
12166 r
= cp_build_qualified_type_real
12167 (r
, cp_type_quals (t
),
12168 complain
| (code
== TEMPLATE_TYPE_PARM
12169 ? tf_ignore_bad_quals
: 0));
12174 TEMPLATE_TYPE_PARM_INDEX (r
)
12175 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
12176 r
, levels
, args
, complain
);
12177 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
12178 TYPE_MAIN_VARIANT (r
) = r
;
12179 TYPE_POINTER_TO (r
) = NULL_TREE
;
12180 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
12182 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
12183 /* We have reduced the level of the template
12184 template parameter, but not the levels of its
12185 template parameters, so canonical_type_parameter
12186 will not be able to find the canonical template
12187 template parameter for this level. Thus, we
12188 require structural equality checking to compare
12189 TEMPLATE_TEMPLATE_PARMs. */
12190 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12191 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
12192 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12194 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
12196 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12198 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
12199 complain
, in_decl
);
12200 if (argvec
== error_mark_node
)
12201 return error_mark_node
;
12203 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
12204 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
12209 case TEMPLATE_PARM_INDEX
:
12210 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
12214 gcc_unreachable ();
12222 tree purpose
, value
, chain
;
12224 if (t
== void_list_node
)
12227 purpose
= TREE_PURPOSE (t
);
12230 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
12231 if (purpose
== error_mark_node
)
12232 return error_mark_node
;
12234 value
= TREE_VALUE (t
);
12237 value
= tsubst (value
, args
, complain
, in_decl
);
12238 if (value
== error_mark_node
)
12239 return error_mark_node
;
12241 chain
= TREE_CHAIN (t
);
12242 if (chain
&& chain
!= void_type_node
)
12244 chain
= tsubst (chain
, args
, complain
, in_decl
);
12245 if (chain
== error_mark_node
)
12246 return error_mark_node
;
12248 if (purpose
== TREE_PURPOSE (t
)
12249 && value
== TREE_VALUE (t
)
12250 && chain
== TREE_CHAIN (t
))
12252 return hash_tree_cons (purpose
, value
, chain
);
12256 /* We should never be tsubsting a binfo. */
12257 gcc_unreachable ();
12260 /* A vector of template arguments. */
12261 gcc_assert (!type
);
12262 return tsubst_template_args (t
, args
, complain
, in_decl
);
12265 case REFERENCE_TYPE
:
12267 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
12272 Type deduction may fail for any of the following
12275 -- Attempting to create a pointer to reference type.
12276 -- Attempting to create a reference to a reference type or
12277 a reference to void.
12279 Core issue 106 says that creating a reference to a reference
12280 during instantiation is no longer a cause for failure. We
12281 only enforce this check in strict C++98 mode. */
12282 if ((TREE_CODE (type
) == REFERENCE_TYPE
12283 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
12284 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
12286 static location_t last_loc
;
12288 /* We keep track of the last time we issued this error
12289 message to avoid spewing a ton of messages during a
12290 single bad template instantiation. */
12291 if (complain
& tf_error
12292 && last_loc
!= input_location
)
12294 if (VOID_TYPE_P (type
))
12295 error ("forming reference to void");
12296 else if (code
== POINTER_TYPE
)
12297 error ("forming pointer to reference type %qT", type
);
12299 error ("forming reference to reference type %qT", type
);
12300 last_loc
= input_location
;
12303 return error_mark_node
;
12305 else if (TREE_CODE (type
) == FUNCTION_TYPE
12306 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
12307 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12309 if (complain
& tf_error
)
12311 if (code
== POINTER_TYPE
)
12312 error ("forming pointer to qualified function type %qT",
12315 error ("forming reference to qualified function type %qT",
12318 return error_mark_node
;
12320 else if (code
== POINTER_TYPE
)
12322 r
= build_pointer_type (type
);
12323 if (TREE_CODE (type
) == METHOD_TYPE
)
12324 r
= build_ptrmemfunc_type (r
);
12326 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12327 /* In C++0x, during template argument substitution, when there is an
12328 attempt to create a reference to a reference type, reference
12329 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12331 "If a template-argument for a template-parameter T names a type
12332 that is a reference to a type A, an attempt to create the type
12333 'lvalue reference to cv T' creates the type 'lvalue reference to
12334 A,' while an attempt to create the type type rvalue reference to
12335 cv T' creates the type T"
12337 r
= cp_build_reference_type
12339 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12341 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12342 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12344 if (r
!= error_mark_node
)
12345 /* Will this ever be needed for TYPE_..._TO values? */
12352 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12353 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12357 Type deduction may fail for any of the following
12360 -- Attempting to create "pointer to member of T" when T
12361 is not a class type. */
12362 if (complain
& tf_error
)
12363 error ("creating pointer to member of non-class type %qT", r
);
12364 return error_mark_node
;
12366 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12368 if (complain
& tf_error
)
12369 error ("creating pointer to member reference type %qT", type
);
12370 return error_mark_node
;
12372 if (VOID_TYPE_P (type
))
12374 if (complain
& tf_error
)
12375 error ("creating pointer to member of type void");
12376 return error_mark_node
;
12378 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12379 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12381 /* The type of the implicit object parameter gets its
12382 cv-qualifiers from the FUNCTION_TYPE. */
12385 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12386 type_memfn_rqual (type
));
12387 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12388 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12392 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12396 case FUNCTION_TYPE
:
12401 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12402 if (fntype
== error_mark_node
)
12403 return error_mark_node
;
12405 /* Substitute the exception specification. */
12406 specs
= tsubst_exception_specification (t
, args
, complain
,
12407 in_decl
, /*defer_ok*/true);
12408 if (specs
== error_mark_node
)
12409 return error_mark_node
;
12411 fntype
= build_exception_variant (fntype
, specs
);
12416 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12417 if (domain
== error_mark_node
)
12418 return error_mark_node
;
12420 /* As an optimization, we avoid regenerating the array type if
12421 it will obviously be the same as T. */
12422 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12425 /* These checks should match the ones in create_array_type_for_decl.
12429 The deduction may fail for any of the following reasons:
12431 -- Attempting to create an array with an element type that
12432 is void, a function type, or a reference type, or [DR337]
12433 an abstract class type. */
12434 if (VOID_TYPE_P (type
)
12435 || TREE_CODE (type
) == FUNCTION_TYPE
12436 || (TREE_CODE (type
) == ARRAY_TYPE
12437 && TYPE_DOMAIN (type
) == NULL_TREE
)
12438 || TREE_CODE (type
) == REFERENCE_TYPE
)
12440 if (complain
& tf_error
)
12441 error ("creating array of %qT", type
);
12442 return error_mark_node
;
12445 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12446 return error_mark_node
;
12448 r
= build_cplus_array_type (type
, domain
);
12450 if (TYPE_USER_ALIGN (t
))
12452 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12453 TYPE_USER_ALIGN (r
) = 1;
12459 case TYPENAME_TYPE
:
12461 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12462 in_decl
, /*entering_scope=*/1);
12463 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12464 complain
, in_decl
);
12466 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12467 return error_mark_node
;
12469 if (!MAYBE_CLASS_TYPE_P (ctx
))
12471 if (complain
& tf_error
)
12472 error ("%qT is not a class, struct, or union type", ctx
);
12473 return error_mark_node
;
12475 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12477 /* Normally, make_typename_type does not require that the CTX
12478 have complete type in order to allow things like:
12480 template <class T> struct S { typename S<T>::X Y; };
12482 But, such constructs have already been resolved by this
12483 point, so here CTX really should have complete type, unless
12484 it's a partial instantiation. */
12485 ctx
= complete_type (ctx
);
12486 if (!COMPLETE_TYPE_P (ctx
))
12488 if (complain
& tf_error
)
12489 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12490 return error_mark_node
;
12494 f
= make_typename_type (ctx
, f
, typename_type
,
12495 complain
| tf_keep_type_decl
);
12496 if (f
== error_mark_node
)
12498 if (TREE_CODE (f
) == TYPE_DECL
)
12500 complain
|= tf_ignore_bad_quals
;
12504 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12506 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12508 if (complain
& tf_error
)
12509 error ("%qT resolves to %qT, which is not an enumeration type",
12512 return error_mark_node
;
12514 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12516 if (complain
& tf_error
)
12517 error ("%qT resolves to %qT, which is is not a class type",
12520 return error_mark_node
;
12524 return cp_build_qualified_type_real
12525 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12528 case UNBOUND_CLASS_TEMPLATE
:
12530 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12531 in_decl
, /*entering_scope=*/1);
12532 tree name
= TYPE_IDENTIFIER (t
);
12533 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12535 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12536 return error_mark_node
;
12539 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12540 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12547 ++cp_unevaluated_operand
;
12548 ++c_inhibit_evaluation_warnings
;
12550 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12552 /*integral_constant_expression_p=*/false);
12554 --cp_unevaluated_operand
;
12555 --c_inhibit_evaluation_warnings
;
12557 type
= finish_typeof (type
);
12558 return cp_build_qualified_type_real (type
,
12560 | cp_type_quals (type
),
12564 case DECLTYPE_TYPE
:
12568 ++cp_unevaluated_operand
;
12569 ++c_inhibit_evaluation_warnings
;
12571 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12572 complain
|tf_decltype
, in_decl
,
12573 /*function_p*/false,
12574 /*integral_constant_expression*/false);
12576 --cp_unevaluated_operand
;
12577 --c_inhibit_evaluation_warnings
;
12579 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12580 type
= lambda_capture_field_type (type
,
12581 DECLTYPE_FOR_INIT_CAPTURE (t
));
12582 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12583 type
= lambda_proxy_type (type
);
12586 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12587 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12589 /* In a template ~id could be either a complement expression
12590 or an unqualified-id naming a destructor; if instantiating
12591 it produces an expression, it's not an id-expression or
12594 type
= finish_decltype_type (type
, id
, complain
);
12596 return cp_build_qualified_type_real (type
,
12598 | cp_type_quals (type
),
12599 complain
| tf_ignore_bad_quals
);
12602 case UNDERLYING_TYPE
:
12604 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12605 complain
, in_decl
);
12606 return finish_underlying_type (type
);
12609 case TYPE_ARGUMENT_PACK
:
12610 case NONTYPE_ARGUMENT_PACK
:
12612 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12614 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12618 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12620 /* For template nontype argument packs, also substitute into
12622 if (code
== NONTYPE_ARGUMENT_PACK
)
12623 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12642 /* We should use one of the expression tsubsts for these codes. */
12643 gcc_unreachable ();
12646 sorry ("use of %qs in template", get_tree_code_name (code
));
12647 return error_mark_node
;
12651 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12652 type of the expression on the left-hand side of the "." or "->"
12656 tsubst_baselink (tree baselink
, tree object_type
,
12657 tree args
, tsubst_flags_t complain
, tree in_decl
)
12660 tree qualifying_scope
;
12663 tree template_args
= 0;
12664 bool template_id_p
= false;
12665 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12667 /* A baselink indicates a function from a base class. Both the
12668 BASELINK_ACCESS_BINFO and the base class referenced may
12669 indicate bases of the template class, rather than the
12670 instantiated class. In addition, lookups that were not
12671 ambiguous before may be ambiguous now. Therefore, we perform
12672 the lookup again. */
12673 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12674 qualifying_scope
= tsubst (qualifying_scope
, args
,
12675 complain
, in_decl
);
12676 fns
= BASELINK_FUNCTIONS (baselink
);
12677 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12678 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12680 template_id_p
= true;
12681 template_args
= TREE_OPERAND (fns
, 1);
12682 fns
= TREE_OPERAND (fns
, 0);
12684 template_args
= tsubst_template_args (template_args
, args
,
12685 complain
, in_decl
);
12687 name
= DECL_NAME (get_first_fn (fns
));
12688 if (IDENTIFIER_TYPENAME_P (name
))
12689 name
= mangle_conv_op_name_for_type (optype
);
12690 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12692 return error_mark_node
;
12694 /* If lookup found a single function, mark it as used at this
12695 point. (If it lookup found multiple functions the one selected
12696 later by overload resolution will be marked as used at that
12698 if (BASELINK_P (baselink
))
12699 fns
= BASELINK_FUNCTIONS (baselink
);
12700 if (!template_id_p
&& !really_overloaded_fn (fns
)
12701 && !mark_used (OVL_CURRENT (fns
), complain
) && !(complain
& tf_error
))
12702 return error_mark_node
;
12704 /* Add back the template arguments, if present. */
12705 if (BASELINK_P (baselink
) && template_id_p
)
12706 BASELINK_FUNCTIONS (baselink
)
12707 = build_nt (TEMPLATE_ID_EXPR
,
12708 BASELINK_FUNCTIONS (baselink
),
12710 /* Update the conversion operator type. */
12711 BASELINK_OPTYPE (baselink
) = optype
;
12714 object_type
= current_class_type
;
12717 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12723 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12724 true if the qualified-id will be a postfix-expression in-and-of
12725 itself; false if more of the postfix-expression follows the
12726 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12730 tsubst_qualified_id (tree qualified_id
, tree args
,
12731 tsubst_flags_t complain
, tree in_decl
,
12732 bool done
, bool address_p
)
12738 tree template_args
;
12739 location_t loc
= UNKNOWN_LOCATION
;
12741 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12743 /* Figure out what name to look up. */
12744 name
= TREE_OPERAND (qualified_id
, 1);
12745 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12747 is_template
= true;
12748 loc
= EXPR_LOCATION (name
);
12749 template_args
= TREE_OPERAND (name
, 1);
12751 template_args
= tsubst_template_args (template_args
, args
,
12752 complain
, in_decl
);
12753 name
= TREE_OPERAND (name
, 0);
12757 is_template
= false;
12758 template_args
= NULL_TREE
;
12761 /* Substitute into the qualifying scope. When there are no ARGS, we
12762 are just trying to simplify a non-dependent expression. In that
12763 case the qualifying scope may be dependent, and, in any case,
12764 substituting will not help. */
12765 scope
= TREE_OPERAND (qualified_id
, 0);
12768 scope
= tsubst (scope
, args
, complain
, in_decl
);
12769 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12774 if (dependent_scope_p (scope
))
12777 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12778 return build_qualified_name (NULL_TREE
, scope
, expr
,
12779 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12782 if (!BASELINK_P (name
) && !DECL_P (expr
))
12784 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12786 /* A BIT_NOT_EXPR is used to represent a destructor. */
12787 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12789 error ("qualifying type %qT does not match destructor name ~%qT",
12790 scope
, TREE_OPERAND (expr
, 0));
12791 expr
= error_mark_node
;
12794 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12795 /*is_type_p=*/0, false);
12798 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12799 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12800 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12802 if (complain
& tf_error
)
12804 error ("dependent-name %qE is parsed as a non-type, but "
12805 "instantiation yields a type", qualified_id
);
12806 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12808 return error_mark_node
;
12814 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12816 /* Remember that there was a reference to this entity. */
12817 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
12818 return error_mark_node
;
12821 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12823 if (complain
& tf_error
)
12824 qualified_name_lookup_error (scope
,
12825 TREE_OPERAND (qualified_id
, 1),
12826 expr
, input_location
);
12827 return error_mark_node
;
12831 expr
= lookup_template_function (expr
, template_args
);
12833 if (expr
== error_mark_node
&& complain
& tf_error
)
12834 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12835 expr
, input_location
);
12836 else if (TYPE_P (scope
))
12838 expr
= (adjust_result_of_qualified_name_lookup
12839 (expr
, scope
, current_nonlambda_class_type ()));
12840 expr
= (finish_qualified_id_expr
12841 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12842 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12843 /*template_arg_p=*/false, complain
));
12846 /* Expressions do not generally have reference type. */
12847 if (TREE_CODE (expr
) != SCOPE_REF
12848 /* However, if we're about to form a pointer-to-member, we just
12849 want the referenced member referenced. */
12850 && TREE_CODE (expr
) != OFFSET_REF
)
12851 expr
= convert_from_reference (expr
);
12856 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12857 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12861 tsubst_init (tree init
, tree decl
, tree args
,
12862 tsubst_flags_t complain
, tree in_decl
)
12867 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12871 /* If we had an initializer but it
12872 instantiated to nothing,
12873 value-initialize the object. This will
12874 only occur when the initializer was a
12875 pack expansion where the parameter packs
12876 used in that expansion were of length
12878 init
= build_value_init (TREE_TYPE (decl
),
12880 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12881 init
= get_target_expr_sfinae (init
, complain
);
12887 /* Like tsubst, but deals with expressions. This function just replaces
12888 template parms; to finish processing the resultant expression, use
12889 tsubst_copy_and_build or tsubst_expr. */
12892 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12894 enum tree_code code
;
12897 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12900 code
= TREE_CODE (t
);
12905 r
= retrieve_local_specialization (t
);
12907 if (r
== NULL_TREE
)
12909 /* We get here for a use of 'this' in an NSDMI. */
12910 if (DECL_NAME (t
) == this_identifier
12911 && current_function_decl
12912 && DECL_CONSTRUCTOR_P (current_function_decl
))
12913 return current_class_ptr
;
12915 /* This can happen for a parameter name used later in a function
12916 declaration (such as in a late-specified return type). Just
12917 make a dummy decl, since it's only used for its type. */
12918 gcc_assert (cp_unevaluated_operand
!= 0);
12919 r
= tsubst_decl (t
, args
, complain
);
12920 /* Give it the template pattern as its context; its true context
12921 hasn't been instantiated yet and this is good enough for
12923 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12926 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12927 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12928 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
12929 return error_mark_node
;
12937 if (DECL_TEMPLATE_PARM_P (t
))
12938 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12939 /* There is no need to substitute into namespace-scope
12941 if (DECL_NAMESPACE_SCOPE_P (t
))
12943 /* If ARGS is NULL, then T is known to be non-dependent. */
12944 if (args
== NULL_TREE
)
12945 return scalar_constant_value (t
);
12947 /* Unfortunately, we cannot just call lookup_name here.
12950 template <int I> int f() {
12952 struct S { void g() { E e = a; } };
12955 When we instantiate f<7>::S::g(), say, lookup_name is not
12956 clever enough to find f<7>::a. */
12958 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12959 /*entering_scope=*/0);
12961 for (v
= TYPE_VALUES (enum_type
);
12963 v
= TREE_CHAIN (v
))
12964 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12965 return TREE_VALUE (v
);
12967 /* We didn't find the name. That should never happen; if
12968 name-lookup found it during preliminary parsing, we
12969 should find it again here during instantiation. */
12970 gcc_unreachable ();
12975 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12977 /* Check for a local specialization set up by
12978 tsubst_pack_expansion. */
12979 if (tree r
= retrieve_local_specialization (t
))
12981 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12982 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12986 /* When retrieving a capture pack from a generic lambda, remove the
12987 lambda call op's own template argument list from ARGS. Only the
12988 template arguments active for the closure type should be used to
12989 retrieve the pack specialization. */
12990 if (LAMBDA_FUNCTION_P (current_function_decl
)
12991 && (template_class_depth (DECL_CONTEXT (t
))
12992 != TMPL_ARGS_DEPTH (args
)))
12993 args
= strip_innermost_template_args (args
, 1);
12995 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12996 tsubst_decl put in the hash table. */
12997 return retrieve_specialization (t
, args
, 0);
13000 if (DECL_CONTEXT (t
))
13004 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
13005 /*entering_scope=*/1);
13006 if (ctx
!= DECL_CONTEXT (t
))
13008 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
13011 if (complain
& tf_error
)
13012 error ("using invalid field %qD", t
);
13013 return error_mark_node
;
13022 case FUNCTION_DECL
:
13023 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
13024 r
= tsubst (t
, args
, complain
, in_decl
);
13025 else if (local_variable_p (t
))
13027 r
= retrieve_local_specialization (t
);
13028 if (r
== NULL_TREE
)
13030 /* First try name lookup to find the instantiation. */
13031 r
= lookup_name (DECL_NAME (t
));
13034 /* Make sure that the one we found is the one we want. */
13035 tree ctx
= tsubst (DECL_CONTEXT (t
), args
,
13036 complain
, in_decl
);
13037 if (ctx
!= DECL_CONTEXT (r
))
13045 /* This can happen for a variable used in a
13046 late-specified return type of a local lambda, or for a
13047 local static or constant. Building a new VAR_DECL
13048 should be OK in all those cases. */
13049 r
= tsubst_decl (t
, args
, complain
);
13050 if (decl_maybe_constant_var_p (r
))
13052 /* We can't call cp_finish_decl, so handle the
13053 initializer by hand. */
13054 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
13055 complain
, in_decl
);
13056 if (!processing_template_decl
)
13057 init
= maybe_constant_init (init
);
13058 if (processing_template_decl
13059 ? potential_constant_expression (init
)
13060 : reduced_constant_expression_p (init
))
13061 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
13062 = TREE_CONSTANT (r
) = true;
13063 DECL_INITIAL (r
) = init
;
13065 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
13066 || decl_constant_var_p (r
)
13067 || errorcount
|| sorrycount
);
13068 if (!processing_template_decl
)
13070 if (TREE_STATIC (r
))
13071 rest_of_decl_compilation (r
, toplevel_bindings_p (),
13073 else if (decl_constant_var_p (r
))
13074 /* A use of a local constant decays to its value.
13075 FIXME update for core DR 696. */
13076 r
= scalar_constant_value (r
);
13079 /* Remember this for subsequent uses. */
13080 if (local_specializations
)
13081 register_local_specialization (r
, t
);
13086 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
13087 return error_mark_node
;
13090 case NAMESPACE_DECL
:
13094 /* An OVERLOAD will always be a non-dependent overload set; an
13095 overload set from function scope will just be represented with an
13096 IDENTIFIER_NODE, and from class scope with a BASELINK. */
13097 gcc_assert (!uses_template_parms (t
));
13101 return tsubst_baselink (t
, current_nonlambda_class_type (),
13102 args
, complain
, in_decl
);
13104 case TEMPLATE_DECL
:
13105 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13106 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
13107 args
, complain
, in_decl
);
13108 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
13109 return tsubst (t
, args
, complain
, in_decl
);
13110 else if (DECL_CLASS_SCOPE_P (t
)
13111 && uses_template_parms (DECL_CONTEXT (t
)))
13113 /* Template template argument like the following example need
13116 template <template <class> class TT> struct C {};
13117 template <class T> struct D {
13118 template <class U> struct E {};
13123 We are processing the template argument `E' in #1 for
13124 the template instantiation #2. Originally, `E' is a
13125 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13126 have to substitute this with one having context `D<int>'. */
13128 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
13129 return lookup_field (context
, DECL_NAME(t
), 0, false);
13132 /* Ordinary template template argument. */
13136 case REINTERPRET_CAST_EXPR
:
13137 case CONST_CAST_EXPR
:
13138 case STATIC_CAST_EXPR
:
13139 case DYNAMIC_CAST_EXPR
:
13140 case IMPLICIT_CONV_EXPR
:
13144 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13145 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13146 return build1 (code
, type
, op0
);
13150 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
13153 tree expanded
, op
= TREE_OPERAND (t
, 0);
13156 if (SIZEOF_EXPR_TYPE_P (t
))
13157 op
= TREE_TYPE (op
);
13159 ++cp_unevaluated_operand
;
13160 ++c_inhibit_evaluation_warnings
;
13161 /* We only want to compute the number of arguments. */
13162 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
13163 --cp_unevaluated_operand
;
13164 --c_inhibit_evaluation_warnings
;
13166 if (TREE_CODE (expanded
) == TREE_VEC
)
13167 len
= TREE_VEC_LENGTH (expanded
);
13169 if (expanded
== error_mark_node
)
13170 return error_mark_node
;
13171 else if (PACK_EXPANSION_P (expanded
)
13172 || (TREE_CODE (expanded
) == TREE_VEC
13174 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
13176 if (TREE_CODE (expanded
) == TREE_VEC
)
13177 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
13179 if (TYPE_P (expanded
))
13180 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
13181 complain
& tf_error
);
13183 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
13184 complain
& tf_error
);
13187 return build_int_cst (size_type_node
, len
);
13189 if (SIZEOF_EXPR_TYPE_P (t
))
13191 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
13192 args
, complain
, in_decl
);
13193 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
13194 r
= build1 (SIZEOF_EXPR
,
13195 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
13196 SIZEOF_EXPR_TYPE_P (r
) = 1;
13203 case TRUTH_NOT_EXPR
:
13206 case UNARY_PLUS_EXPR
: /* Unary + */
13208 case AT_ENCODE_EXPR
:
13212 case REALPART_EXPR
:
13213 case IMAGPART_EXPR
:
13216 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13217 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13218 return build1 (code
, type
, op0
);
13221 case COMPONENT_REF
:
13226 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13227 name
= TREE_OPERAND (t
, 1);
13228 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
13230 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13231 complain
, in_decl
);
13232 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13234 else if (TREE_CODE (name
) == SCOPE_REF
13235 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
13237 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13238 complain
, in_decl
);
13239 name
= TREE_OPERAND (name
, 1);
13240 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13241 complain
, in_decl
);
13242 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13243 name
= build_qualified_name (/*type=*/NULL_TREE
,
13245 /*template_p=*/false);
13247 else if (BASELINK_P (name
))
13248 name
= tsubst_baselink (name
,
13249 non_reference (TREE_TYPE (object
)),
13253 name
= tsubst_copy (name
, args
, complain
, in_decl
);
13254 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
13260 case TRUNC_DIV_EXPR
:
13261 case CEIL_DIV_EXPR
:
13262 case FLOOR_DIV_EXPR
:
13263 case ROUND_DIV_EXPR
:
13264 case EXACT_DIV_EXPR
:
13268 case TRUNC_MOD_EXPR
:
13269 case FLOOR_MOD_EXPR
:
13270 case TRUTH_ANDIF_EXPR
:
13271 case TRUTH_ORIF_EXPR
:
13272 case TRUTH_AND_EXPR
:
13273 case TRUTH_OR_EXPR
:
13286 case COMPOUND_EXPR
:
13289 case PREDECREMENT_EXPR
:
13290 case PREINCREMENT_EXPR
:
13291 case POSTDECREMENT_EXPR
:
13292 case POSTINCREMENT_EXPR
:
13294 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13295 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13296 return build_nt (code
, op0
, op1
);
13301 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13302 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13303 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
13304 QUALIFIED_NAME_IS_TEMPLATE (t
));
13309 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13310 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13311 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13316 int n
= VL_EXP_OPERAND_LENGTH (t
);
13317 tree result
= build_vl_exp (CALL_EXPR
, n
);
13319 for (i
= 0; i
< n
; i
++)
13320 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13321 complain
, in_decl
);
13327 case PSEUDO_DTOR_EXPR
:
13328 case VEC_PERM_EXPR
:
13330 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13331 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13332 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13333 r
= build_nt (code
, op0
, op1
, op2
);
13334 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13340 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13341 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13342 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13343 r
= build_nt (code
, op0
, op1
, op2
);
13344 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13350 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13351 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13352 r
= build_nt (code
, op0
, op1
);
13353 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13354 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13358 case TEMPLATE_ID_EXPR
:
13360 /* Substituted template arguments */
13361 tree fn
= TREE_OPERAND (t
, 0);
13362 tree targs
= TREE_OPERAND (t
, 1);
13364 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13366 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13368 return lookup_template_function (fn
, targs
);
13373 tree purpose
, value
, chain
;
13375 if (t
== void_list_node
)
13378 purpose
= TREE_PURPOSE (t
);
13380 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13381 value
= TREE_VALUE (t
);
13383 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13384 chain
= TREE_CHAIN (t
);
13385 if (chain
&& chain
!= void_type_node
)
13386 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13387 if (purpose
== TREE_PURPOSE (t
)
13388 && value
== TREE_VALUE (t
)
13389 && chain
== TREE_CHAIN (t
))
13391 return tree_cons (purpose
, value
, chain
);
13396 case ENUMERAL_TYPE
:
13398 case TEMPLATE_TYPE_PARM
:
13399 case TEMPLATE_TEMPLATE_PARM
:
13400 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13401 case TEMPLATE_PARM_INDEX
:
13403 case REFERENCE_TYPE
:
13405 case FUNCTION_TYPE
:
13408 case TYPENAME_TYPE
:
13409 case UNBOUND_CLASS_TEMPLATE
:
13411 case DECLTYPE_TYPE
:
13413 return tsubst (t
, args
, complain
, in_decl
);
13417 /* Fall through. */
13418 case IDENTIFIER_NODE
:
13419 if (IDENTIFIER_TYPENAME_P (t
))
13421 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13422 return mangle_conv_op_name_for_type (new_type
);
13428 /* This is handled by tsubst_copy_and_build. */
13429 gcc_unreachable ();
13433 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13434 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13435 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13438 case CLEANUP_POINT_EXPR
:
13439 /* We shouldn't have built any of these during initial template
13440 generation. Instead, they should be built during instantiation
13441 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13442 gcc_unreachable ();
13446 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13447 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13448 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13449 r
= build2 (code
, type
, op0
, op1
);
13450 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13451 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
13452 && !(complain
& tf_error
))
13453 return error_mark_node
;
13457 case EXPR_PACK_EXPANSION
:
13458 error ("invalid use of pack expansion expression");
13459 return error_mark_node
;
13461 case NONTYPE_ARGUMENT_PACK
:
13462 error ("use %<...%> to expand argument pack");
13463 return error_mark_node
;
13466 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13474 /* Instantiate any typedefs in the type. */
13475 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13476 r
= fold_convert (type
, t
);
13477 gcc_assert (TREE_CODE (r
) == code
);
13482 /* These can sometimes show up in a partial instantiation, but never
13483 involve template parms. */
13484 gcc_assert (!uses_template_parms (t
));
13488 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13489 gcc_checking_assert (false);
13494 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13497 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13498 tree args
, tsubst_flags_t complain
, tree in_decl
)
13500 tree new_clauses
= NULL
, nc
, oc
;
13502 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13504 nc
= copy_node (oc
);
13505 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13508 switch (OMP_CLAUSE_CODE (nc
))
13510 case OMP_CLAUSE_LASTPRIVATE
:
13511 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13513 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13514 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13515 in_decl
, /*integral_constant_expression_p=*/false);
13516 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13517 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13520 case OMP_CLAUSE_PRIVATE
:
13521 case OMP_CLAUSE_SHARED
:
13522 case OMP_CLAUSE_FIRSTPRIVATE
:
13523 case OMP_CLAUSE_COPYIN
:
13524 case OMP_CLAUSE_COPYPRIVATE
:
13525 case OMP_CLAUSE_IF
:
13526 case OMP_CLAUSE_NUM_THREADS
:
13527 case OMP_CLAUSE_SCHEDULE
:
13528 case OMP_CLAUSE_COLLAPSE
:
13529 case OMP_CLAUSE_FINAL
:
13530 case OMP_CLAUSE_DEPEND
:
13531 case OMP_CLAUSE_FROM
:
13532 case OMP_CLAUSE_TO
:
13533 case OMP_CLAUSE_UNIFORM
:
13534 case OMP_CLAUSE_MAP
:
13535 case OMP_CLAUSE_DEVICE
:
13536 case OMP_CLAUSE_DIST_SCHEDULE
:
13537 case OMP_CLAUSE_NUM_TEAMS
:
13538 case OMP_CLAUSE_THREAD_LIMIT
:
13539 case OMP_CLAUSE_SAFELEN
:
13540 case OMP_CLAUSE_SIMDLEN
:
13541 OMP_CLAUSE_OPERAND (nc
, 0)
13542 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13543 in_decl
, /*integral_constant_expression_p=*/false);
13545 case OMP_CLAUSE_REDUCTION
:
13546 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13548 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13549 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13551 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13552 complain
, in_decl
);
13553 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13554 = build_qualified_name (NULL_TREE
, scope
,
13555 TREE_OPERAND (placeholder
, 1),
13559 gcc_assert (identifier_p (placeholder
));
13561 OMP_CLAUSE_OPERAND (nc
, 0)
13562 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13563 in_decl
, /*integral_constant_expression_p=*/false);
13565 case OMP_CLAUSE_LINEAR
:
13566 case OMP_CLAUSE_ALIGNED
:
13567 OMP_CLAUSE_OPERAND (nc
, 0)
13568 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13569 in_decl
, /*integral_constant_expression_p=*/false);
13570 OMP_CLAUSE_OPERAND (nc
, 1)
13571 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13572 in_decl
, /*integral_constant_expression_p=*/false);
13575 case OMP_CLAUSE_NOWAIT
:
13576 case OMP_CLAUSE_ORDERED
:
13577 case OMP_CLAUSE_DEFAULT
:
13578 case OMP_CLAUSE_UNTIED
:
13579 case OMP_CLAUSE_MERGEABLE
:
13580 case OMP_CLAUSE_INBRANCH
:
13581 case OMP_CLAUSE_NOTINBRANCH
:
13582 case OMP_CLAUSE_PROC_BIND
:
13583 case OMP_CLAUSE_FOR
:
13584 case OMP_CLAUSE_PARALLEL
:
13585 case OMP_CLAUSE_SECTIONS
:
13586 case OMP_CLAUSE_TASKGROUP
:
13589 gcc_unreachable ();
13593 new_clauses
= nreverse (new_clauses
);
13595 new_clauses
= finish_omp_clauses (new_clauses
);
13596 return new_clauses
;
13599 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13602 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13605 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13607 tree purpose
, value
, chain
;
13612 if (TREE_CODE (t
) != TREE_LIST
)
13613 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13614 /*function_p=*/false,
13615 /*integral_constant_expression_p=*/false);
13617 if (t
== void_list_node
)
13620 purpose
= TREE_PURPOSE (t
);
13622 purpose
= RECUR (purpose
);
13623 value
= TREE_VALUE (t
);
13626 if (TREE_CODE (value
) != LABEL_DECL
)
13627 value
= RECUR (value
);
13630 value
= lookup_label (DECL_NAME (value
));
13631 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13632 TREE_USED (value
) = 1;
13635 chain
= TREE_CHAIN (t
);
13636 if (chain
&& chain
!= void_type_node
)
13637 chain
= RECUR (chain
);
13638 return tree_cons (purpose
, value
, chain
);
13642 /* Substitute one OMP_FOR iterator. */
13645 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13646 tree condv
, tree incrv
, tree
*clauses
,
13647 tree args
, tsubst_flags_t complain
, tree in_decl
,
13648 bool integral_constant_expression_p
)
13650 #define RECUR(NODE) \
13651 tsubst_expr ((NODE), args, complain, in_decl, \
13652 integral_constant_expression_p)
13653 tree decl
, init
, cond
, incr
;
13655 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13656 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13657 decl
= TREE_OPERAND (init
, 0);
13658 init
= TREE_OPERAND (init
, 1);
13659 tree decl_expr
= NULL_TREE
;
13660 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13662 /* We need to jump through some hoops to handle declarations in the
13663 for-init-statement, since we might need to handle auto deduction,
13664 but we need to keep control of initialization. */
13666 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13667 decl
= tsubst_decl (decl
, args
, complain
);
13670 decl
= RECUR (decl
);
13671 init
= RECUR (init
);
13673 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13674 if (auto_node
&& init
)
13676 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13678 gcc_assert (!type_dependent_expression_p (decl
));
13680 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13684 /* Declare the variable, but don't let that initialize it. */
13685 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13686 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13688 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13691 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13692 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13693 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13695 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13696 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13697 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13698 NOP_EXPR
, rhs
, complain
);
13701 incr
= RECUR (incr
);
13702 TREE_VEC_ELT (declv
, i
) = decl
;
13703 TREE_VEC_ELT (initv
, i
) = init
;
13704 TREE_VEC_ELT (condv
, i
) = cond
;
13705 TREE_VEC_ELT (incrv
, i
) = incr
;
13711 /* Declare and initialize the variable. */
13718 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13720 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13721 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13722 && OMP_CLAUSE_DECL (c
) == decl
)
13724 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13725 && OMP_CLAUSE_DECL (c
) == decl
)
13726 error ("iteration variable %qD should not be firstprivate", decl
);
13727 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13728 && OMP_CLAUSE_DECL (c
) == decl
)
13729 error ("iteration variable %qD should not be reduction", decl
);
13733 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13734 OMP_CLAUSE_DECL (c
) = decl
;
13735 c
= finish_omp_clauses (c
);
13738 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13743 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13744 if (COMPARISON_CLASS_P (cond
))
13746 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13747 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13748 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13751 cond
= RECUR (cond
);
13752 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13753 switch (TREE_CODE (incr
))
13755 case PREINCREMENT_EXPR
:
13756 case PREDECREMENT_EXPR
:
13757 case POSTINCREMENT_EXPR
:
13758 case POSTDECREMENT_EXPR
:
13759 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13760 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13763 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13764 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13766 tree rhs
= TREE_OPERAND (incr
, 1);
13767 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13768 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13769 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13770 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13771 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13775 incr
= RECUR (incr
);
13778 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13779 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13781 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13782 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13783 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13784 TREE_TYPE (decl
), lhs
,
13785 RECUR (TREE_OPERAND (incr
, 2))));
13787 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13788 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13789 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13791 tree rhs
= TREE_OPERAND (incr
, 2);
13792 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13793 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13794 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13795 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13796 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13800 incr
= RECUR (incr
);
13803 incr
= RECUR (incr
);
13807 TREE_VEC_ELT (declv
, i
) = decl
;
13808 TREE_VEC_ELT (initv
, i
) = init
;
13809 TREE_VEC_ELT (condv
, i
) = cond
;
13810 TREE_VEC_ELT (incrv
, i
) = incr
;
13814 /* Like tsubst_copy for expressions, etc. but also does semantic
13818 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13819 bool integral_constant_expression_p
)
13821 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13822 #define RECUR(NODE) \
13823 tsubst_expr ((NODE), args, complain, in_decl, \
13824 integral_constant_expression_p)
13830 if (t
== NULL_TREE
|| t
== error_mark_node
)
13833 loc
= input_location
;
13834 if (EXPR_HAS_LOCATION (t
))
13835 input_location
= EXPR_LOCATION (t
);
13836 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13837 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13839 switch (TREE_CODE (t
))
13841 case STATEMENT_LIST
:
13843 tree_stmt_iterator i
;
13844 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13845 RECUR (tsi_stmt (i
));
13849 case CTOR_INITIALIZER
:
13850 finish_mem_initializers (tsubst_initializer_list
13851 (TREE_OPERAND (t
, 0), args
));
13855 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13859 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13860 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13861 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13863 finish_expr_stmt (tmp
);
13867 do_using_directive (USING_STMT_NAMESPACE (t
));
13872 tree decl
, pattern_decl
;
13875 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13876 if (TREE_CODE (decl
) == LABEL_DECL
)
13877 finish_label_decl (DECL_NAME (decl
));
13878 else if (TREE_CODE (decl
) == USING_DECL
)
13880 tree scope
= USING_DECL_SCOPE (decl
);
13881 tree name
= DECL_NAME (decl
);
13884 scope
= tsubst (scope
, args
, complain
, in_decl
);
13885 decl
= lookup_qualified_name (scope
, name
,
13886 /*is_type_p=*/false,
13887 /*complain=*/false);
13888 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13889 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13891 do_local_using_decl (decl
, scope
, name
);
13893 else if (DECL_PACK_P (decl
))
13895 /* Don't build up decls for a variadic capture proxy, we'll
13896 instantiate the elements directly as needed. */
13901 init
= DECL_INITIAL (decl
);
13902 decl
= tsubst (decl
, args
, complain
, in_decl
);
13903 if (decl
!= error_mark_node
)
13905 /* By marking the declaration as instantiated, we avoid
13906 trying to instantiate it. Since instantiate_decl can't
13907 handle local variables, and since we've already done
13908 all that needs to be done, that's the right thing to
13911 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13913 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13914 /* Anonymous aggregates are a special case. */
13915 finish_anon_union (decl
);
13916 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13918 DECL_CONTEXT (decl
) = current_function_decl
;
13919 if (DECL_NAME (decl
) == this_identifier
)
13921 tree lam
= DECL_CONTEXT (current_function_decl
);
13922 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13923 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13925 insert_capture_proxy (decl
);
13927 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13928 /* We already did a pushtag. */;
13929 else if (TREE_CODE (decl
) == FUNCTION_DECL
13930 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13931 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13933 DECL_CONTEXT (decl
) = NULL_TREE
;
13935 DECL_CONTEXT (decl
) = current_function_decl
;
13936 cp_check_omp_declare_reduction (decl
);
13940 int const_init
= false;
13941 maybe_push_decl (decl
);
13943 && DECL_PRETTY_FUNCTION_P (decl
))
13945 /* For __PRETTY_FUNCTION__ we have to adjust the
13947 const char *const name
13948 = cxx_printable_name (current_function_decl
, 2);
13949 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13952 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
13955 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13957 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13966 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13967 RECUR (FOR_INIT_STMT (t
));
13968 finish_for_init_stmt (stmt
);
13969 tmp
= RECUR (FOR_COND (t
));
13970 finish_for_cond (tmp
, stmt
, false);
13971 tmp
= RECUR (FOR_EXPR (t
));
13972 finish_for_expr (tmp
, stmt
);
13973 RECUR (FOR_BODY (t
));
13974 finish_for_stmt (stmt
);
13977 case RANGE_FOR_STMT
:
13980 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13981 decl
= RANGE_FOR_DECL (t
);
13982 decl
= tsubst (decl
, args
, complain
, in_decl
);
13983 maybe_push_decl (decl
);
13984 expr
= RECUR (RANGE_FOR_EXPR (t
));
13985 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13986 RECUR (RANGE_FOR_BODY (t
));
13987 finish_for_stmt (stmt
);
13992 stmt
= begin_while_stmt ();
13993 tmp
= RECUR (WHILE_COND (t
));
13994 finish_while_stmt_cond (tmp
, stmt
, false);
13995 RECUR (WHILE_BODY (t
));
13996 finish_while_stmt (stmt
);
14000 stmt
= begin_do_stmt ();
14001 RECUR (DO_BODY (t
));
14002 finish_do_body (stmt
);
14003 tmp
= RECUR (DO_COND (t
));
14004 finish_do_stmt (tmp
, stmt
, false);
14008 stmt
= begin_if_stmt ();
14009 tmp
= RECUR (IF_COND (t
));
14010 finish_if_stmt_cond (tmp
, stmt
);
14011 RECUR (THEN_CLAUSE (t
));
14012 finish_then_clause (stmt
);
14014 if (ELSE_CLAUSE (t
))
14016 begin_else_clause (stmt
);
14017 RECUR (ELSE_CLAUSE (t
));
14018 finish_else_clause (stmt
);
14021 finish_if_stmt (stmt
);
14025 if (BIND_EXPR_BODY_BLOCK (t
))
14026 stmt
= begin_function_body ();
14028 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
14029 ? BCS_TRY_BLOCK
: 0);
14031 RECUR (BIND_EXPR_BODY (t
));
14033 if (BIND_EXPR_BODY_BLOCK (t
))
14034 finish_function_body (stmt
);
14036 finish_compound_stmt (stmt
);
14040 finish_break_stmt ();
14043 case CONTINUE_STMT
:
14044 finish_continue_stmt ();
14048 stmt
= begin_switch_stmt ();
14049 tmp
= RECUR (SWITCH_STMT_COND (t
));
14050 finish_switch_cond (tmp
, stmt
);
14051 RECUR (SWITCH_STMT_BODY (t
));
14052 finish_switch_stmt (stmt
);
14055 case CASE_LABEL_EXPR
:
14057 tree low
= RECUR (CASE_LOW (t
));
14058 tree high
= RECUR (CASE_HIGH (t
));
14059 finish_case_label (EXPR_LOCATION (t
), low
, high
);
14065 tree decl
= LABEL_EXPR_LABEL (t
);
14068 label
= finish_label_stmt (DECL_NAME (decl
));
14069 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
14070 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
14075 tmp
= GOTO_DESTINATION (t
);
14076 if (TREE_CODE (tmp
) != LABEL_DECL
)
14077 /* Computed goto's must be tsubst'd into. On the other hand,
14078 non-computed gotos must not be; the identifier in question
14079 will have no binding. */
14082 tmp
= DECL_NAME (tmp
);
14083 finish_goto_stmt (tmp
);
14088 tree string
= RECUR (ASM_STRING (t
));
14089 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
14090 complain
, in_decl
);
14091 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
14092 complain
, in_decl
);
14093 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
14094 complain
, in_decl
);
14095 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
14096 complain
, in_decl
);
14097 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
14099 tree asm_expr
= tmp
;
14100 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
14101 asm_expr
= TREE_OPERAND (asm_expr
, 0);
14102 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
14109 stmt
= begin_try_block ();
14110 RECUR (TRY_STMTS (t
));
14111 finish_cleanup_try_block (stmt
);
14112 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
14116 tree compound_stmt
= NULL_TREE
;
14118 if (FN_TRY_BLOCK_P (t
))
14119 stmt
= begin_function_try_block (&compound_stmt
);
14121 stmt
= begin_try_block ();
14123 RECUR (TRY_STMTS (t
));
14125 if (FN_TRY_BLOCK_P (t
))
14126 finish_function_try_block (stmt
);
14128 finish_try_block (stmt
);
14130 RECUR (TRY_HANDLERS (t
));
14131 if (FN_TRY_BLOCK_P (t
))
14132 finish_function_handler_sequence (stmt
, compound_stmt
);
14134 finish_handler_sequence (stmt
);
14140 tree decl
= HANDLER_PARMS (t
);
14144 decl
= tsubst (decl
, args
, complain
, in_decl
);
14145 /* Prevent instantiate_decl from trying to instantiate
14146 this variable. We've already done all that needs to be
14148 if (decl
!= error_mark_node
)
14149 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
14151 stmt
= begin_handler ();
14152 finish_handler_parms (decl
, stmt
);
14153 RECUR (HANDLER_BODY (t
));
14154 finish_handler (stmt
);
14159 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
14160 if (CLASS_TYPE_P (tmp
))
14162 /* Local classes are not independent templates; they are
14163 instantiated along with their containing function. And this
14164 way we don't have to deal with pushing out of one local class
14165 to instantiate a member of another local class. */
14167 /* Closures are handled by the LAMBDA_EXPR. */
14168 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
14169 complete_type (tmp
);
14170 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
14171 if (!DECL_ARTIFICIAL (fn
))
14172 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
14176 case STATIC_ASSERT
:
14180 ++c_inhibit_evaluation_warnings
;
14182 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
14185 /*integral_constant_expression_p=*/true);
14186 --c_inhibit_evaluation_warnings
;
14188 finish_static_assert (condition
,
14189 STATIC_ASSERT_MESSAGE (t
),
14190 STATIC_ASSERT_SOURCE_LOCATION (t
),
14191 /*member_p=*/false);
14196 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
14197 args
, complain
, in_decl
);
14198 stmt
= begin_omp_parallel ();
14199 RECUR (OMP_PARALLEL_BODY (t
));
14200 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
14201 = OMP_PARALLEL_COMBINED (t
);
14205 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
14206 args
, complain
, in_decl
);
14207 stmt
= begin_omp_task ();
14208 RECUR (OMP_TASK_BODY (t
));
14209 finish_omp_task (tmp
, stmt
);
14216 case OMP_DISTRIBUTE
:
14218 tree clauses
, body
, pre_body
;
14219 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
14220 tree incrv
= NULL_TREE
;
14223 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
14224 args
, complain
, in_decl
);
14225 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14227 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14228 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14229 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14230 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14233 stmt
= begin_omp_structured_block ();
14235 pre_body
= push_stmt_list ();
14236 RECUR (OMP_FOR_PRE_BODY (t
));
14237 pre_body
= pop_stmt_list (pre_body
);
14239 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14240 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
14241 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
14242 &clauses
, args
, complain
, in_decl
,
14243 integral_constant_expression_p
);
14245 body
= push_stmt_list ();
14246 RECUR (OMP_FOR_BODY (t
));
14247 body
= pop_stmt_list (body
);
14249 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14250 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
14251 condv
, incrv
, body
, pre_body
, clauses
);
14254 t
= make_node (TREE_CODE (t
));
14255 TREE_TYPE (t
) = void_type_node
;
14256 OMP_FOR_BODY (t
) = body
;
14257 OMP_FOR_PRE_BODY (t
) = pre_body
;
14258 OMP_FOR_CLAUSES (t
) = clauses
;
14259 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
14263 add_stmt (finish_omp_structured_block (stmt
));
14270 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14271 args
, complain
, in_decl
);
14272 stmt
= push_stmt_list ();
14273 RECUR (OMP_BODY (t
));
14274 stmt
= pop_stmt_list (stmt
);
14277 OMP_BODY (t
) = stmt
;
14278 OMP_CLAUSES (t
) = tmp
;
14282 case OMP_TARGET_DATA
:
14284 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14285 args
, complain
, in_decl
);
14286 keep_next_level (true);
14287 stmt
= begin_omp_structured_block ();
14289 RECUR (OMP_BODY (t
));
14290 stmt
= finish_omp_structured_block (stmt
);
14293 OMP_BODY (t
) = stmt
;
14294 OMP_CLAUSES (t
) = tmp
;
14298 case OMP_TARGET_UPDATE
:
14299 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
14300 args
, complain
, in_decl
);
14302 OMP_TARGET_UPDATE_CLAUSES (t
) = tmp
;
14309 case OMP_TASKGROUP
:
14311 stmt
= push_stmt_list ();
14312 RECUR (OMP_BODY (t
));
14313 stmt
= pop_stmt_list (stmt
);
14316 OMP_BODY (t
) = stmt
;
14321 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14322 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14324 tree op1
= TREE_OPERAND (t
, 1);
14325 tree rhs1
= NULL_TREE
;
14327 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14329 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14330 op1
= TREE_OPERAND (op1
, 1);
14332 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14333 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14334 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14335 NULL_TREE
, NULL_TREE
, rhs1
,
14336 OMP_ATOMIC_SEQ_CST (t
));
14340 tree op1
= TREE_OPERAND (t
, 1);
14341 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14342 tree rhs1
= NULL_TREE
;
14343 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14344 enum tree_code opcode
= NOP_EXPR
;
14345 if (code
== OMP_ATOMIC_READ
)
14347 v
= RECUR (TREE_OPERAND (op1
, 0));
14348 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14350 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14351 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14353 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14354 v
= RECUR (TREE_OPERAND (op1
, 0));
14355 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14356 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14358 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14359 op11
= TREE_OPERAND (op11
, 1);
14361 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14362 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14363 opcode
= TREE_CODE (op11
);
14364 if (opcode
== MODIFY_EXPR
)
14370 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14371 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14373 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14374 OMP_ATOMIC_SEQ_CST (t
));
14378 case TRANSACTION_EXPR
:
14381 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14382 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14384 if (TRANSACTION_EXPR_IS_STMT (t
))
14386 tree body
= TRANSACTION_EXPR_BODY (t
);
14387 tree noex
= NULL_TREE
;
14388 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14390 noex
= MUST_NOT_THROW_COND (body
);
14391 if (noex
== NULL_TREE
)
14392 noex
= boolean_true_node
;
14393 body
= TREE_OPERAND (body
, 0);
14395 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14397 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14401 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14402 RECUR (TRANSACTION_EXPR_BODY (t
)),
14409 case MUST_NOT_THROW_EXPR
:
14411 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14412 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14413 RETURN (build_must_not_throw_expr (op0
, cond
));
14416 case EXPR_PACK_EXPANSION
:
14417 error ("invalid use of pack expansion expression");
14418 RETURN (error_mark_node
);
14420 case NONTYPE_ARGUMENT_PACK
:
14421 error ("use %<...%> to expand argument pack");
14422 RETURN (error_mark_node
);
14424 case CILK_SPAWN_STMT
:
14425 cfun
->calls_cilk_spawn
= 1;
14426 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14428 case CILK_SYNC_STMT
:
14429 RETURN (build_cilk_sync ());
14431 case COMPOUND_EXPR
:
14432 tmp
= RECUR (TREE_OPERAND (t
, 0));
14433 if (tmp
== NULL_TREE
)
14434 /* If the first operand was a statement, we're done with it. */
14435 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14436 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14437 RECUR (TREE_OPERAND (t
, 1)),
14440 case ANNOTATE_EXPR
:
14441 tmp
= RECUR (TREE_OPERAND (t
, 0));
14442 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14443 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14446 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14448 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14449 /*function_p=*/false,
14450 integral_constant_expression_p
));
14453 RETURN (NULL_TREE
);
14455 input_location
= loc
;
14461 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14462 function. For description of the body see comment above
14463 cp_parser_omp_declare_reduction_exprs. */
14466 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14468 if (t
== NULL_TREE
|| t
== error_mark_node
)
14471 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14473 tree_stmt_iterator tsi
;
14476 memset (stmts
, 0, sizeof stmts
);
14477 for (i
= 0, tsi
= tsi_start (t
);
14478 i
< 7 && !tsi_end_p (tsi
);
14479 i
++, tsi_next (&tsi
))
14480 stmts
[i
] = tsi_stmt (tsi
);
14481 gcc_assert (tsi_end_p (tsi
));
14485 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14486 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14487 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14488 args
, complain
, in_decl
);
14489 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14490 args
, complain
, in_decl
);
14491 DECL_CONTEXT (omp_out
) = current_function_decl
;
14492 DECL_CONTEXT (omp_in
) = current_function_decl
;
14493 keep_next_level (true);
14494 tree block
= begin_omp_structured_block ();
14495 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14496 block
= finish_omp_structured_block (block
);
14497 block
= maybe_cleanup_point_expr_void (block
);
14498 add_decl_expr (omp_out
);
14499 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14500 TREE_NO_WARNING (omp_out
) = 1;
14501 add_decl_expr (omp_in
);
14502 finish_expr_stmt (block
);
14506 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14507 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14508 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14509 args
, complain
, in_decl
);
14510 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14511 args
, complain
, in_decl
);
14512 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14513 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14514 keep_next_level (true);
14515 tree block
= begin_omp_structured_block ();
14516 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14517 block
= finish_omp_structured_block (block
);
14518 block
= maybe_cleanup_point_expr_void (block
);
14519 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14520 add_decl_expr (omp_priv
);
14521 add_decl_expr (omp_orig
);
14522 finish_expr_stmt (block
);
14524 add_decl_expr (omp_orig
);
14528 /* T is a postfix-expression that is not being used in a function
14529 call. Return the substituted version of T. */
14532 tsubst_non_call_postfix_expression (tree t
, tree args
,
14533 tsubst_flags_t complain
,
14536 if (TREE_CODE (t
) == SCOPE_REF
)
14537 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14538 /*done=*/false, /*address_p=*/false);
14540 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14541 /*function_p=*/false,
14542 /*integral_constant_expression_p=*/false);
14547 /* Like tsubst but deals with expressions and performs semantic
14548 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14551 tsubst_copy_and_build (tree t
,
14553 tsubst_flags_t complain
,
14556 bool integral_constant_expression_p
)
14558 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14559 #define RECUR(NODE) \
14560 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14561 /*function_p=*/false, \
14562 integral_constant_expression_p)
14567 if (t
== NULL_TREE
|| t
== error_mark_node
)
14570 loc
= input_location
;
14571 if (EXPR_HAS_LOCATION (t
))
14572 input_location
= EXPR_LOCATION (t
);
14574 /* N3276 decltype magic only applies to calls at the top level or on the
14575 right side of a comma. */
14576 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14577 complain
&= ~tf_decltype
;
14579 switch (TREE_CODE (t
))
14583 /* Fall through. */
14584 case IDENTIFIER_NODE
:
14588 bool non_integral_constant_expression_p
;
14589 const char *error_msg
;
14591 if (IDENTIFIER_TYPENAME_P (t
))
14593 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14594 t
= mangle_conv_op_name_for_type (new_type
);
14597 /* Look up the name. */
14598 decl
= lookup_name (t
);
14600 /* By convention, expressions use ERROR_MARK_NODE to indicate
14601 failure, not NULL_TREE. */
14602 if (decl
== NULL_TREE
)
14603 decl
= error_mark_node
;
14605 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14607 integral_constant_expression_p
,
14608 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14609 &non_integral_constant_expression_p
,
14610 /*template_p=*/false,
14612 /*address_p=*/false,
14613 /*template_arg_p=*/false,
14618 if (!function_p
&& identifier_p (decl
))
14620 if (complain
& tf_error
)
14621 unqualified_name_lookup_error (decl
);
14622 decl
= error_mark_node
;
14627 case TEMPLATE_ID_EXPR
:
14630 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14631 tree targs
= TREE_OPERAND (t
, 1);
14634 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14636 if (TREE_CODE (templ
) == COMPONENT_REF
)
14638 object
= TREE_OPERAND (templ
, 0);
14639 templ
= TREE_OPERAND (templ
, 1);
14642 object
= NULL_TREE
;
14643 templ
= lookup_template_function (templ
, targs
);
14646 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14647 object
, templ
, NULL_TREE
));
14649 RETURN (baselink_for_fns (templ
));
14654 tree r
= RECUR (TREE_OPERAND (t
, 0));
14656 if (REFERENCE_REF_P (t
))
14658 /* A type conversion to reference type will be enclosed in
14659 such an indirect ref, but the substitution of the cast
14660 will have also added such an indirect ref. */
14661 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14662 r
= convert_from_reference (r
);
14665 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14666 complain
|decltype_flag
);
14672 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14673 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14674 RETURN (build_nop (type
, op0
));
14677 case IMPLICIT_CONV_EXPR
:
14679 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14680 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14681 int flags
= LOOKUP_IMPLICIT
;
14682 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14683 flags
= LOOKUP_NORMAL
;
14684 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14690 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14691 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14692 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14696 case REINTERPRET_CAST_EXPR
:
14697 case CONST_CAST_EXPR
:
14698 case DYNAMIC_CAST_EXPR
:
14699 case STATIC_CAST_EXPR
:
14702 tree op
, r
= NULL_TREE
;
14704 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14705 if (integral_constant_expression_p
14706 && !cast_valid_in_integral_constant_expression_p (type
))
14708 if (complain
& tf_error
)
14709 error ("a cast to a type other than an integral or "
14710 "enumeration type cannot appear in a constant-expression");
14711 RETURN (error_mark_node
);
14714 op
= RECUR (TREE_OPERAND (t
, 0));
14716 warning_sentinel
s(warn_useless_cast
);
14717 switch (TREE_CODE (t
))
14720 r
= build_functional_cast (type
, op
, complain
);
14722 case REINTERPRET_CAST_EXPR
:
14723 r
= build_reinterpret_cast (type
, op
, complain
);
14725 case CONST_CAST_EXPR
:
14726 r
= build_const_cast (type
, op
, complain
);
14728 case DYNAMIC_CAST_EXPR
:
14729 r
= build_dynamic_cast (type
, op
, complain
);
14731 case STATIC_CAST_EXPR
:
14732 r
= build_static_cast (type
, op
, complain
);
14735 gcc_unreachable ();
14741 case POSTDECREMENT_EXPR
:
14742 case POSTINCREMENT_EXPR
:
14743 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14744 args
, complain
, in_decl
);
14745 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14746 complain
|decltype_flag
));
14748 case PREDECREMENT_EXPR
:
14749 case PREINCREMENT_EXPR
:
14753 case TRUTH_NOT_EXPR
:
14754 case UNARY_PLUS_EXPR
: /* Unary + */
14755 case REALPART_EXPR
:
14756 case IMAGPART_EXPR
:
14757 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14758 RECUR (TREE_OPERAND (t
, 0)),
14759 complain
|decltype_flag
));
14761 case FIX_TRUNC_EXPR
:
14762 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14766 op1
= TREE_OPERAND (t
, 0);
14767 if (TREE_CODE (op1
) == LABEL_DECL
)
14768 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14769 EXPR_LOCATION (op1
)));
14770 if (TREE_CODE (op1
) == SCOPE_REF
)
14771 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14772 /*done=*/true, /*address_p=*/true);
14774 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14776 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14777 complain
|decltype_flag
));
14782 case TRUNC_DIV_EXPR
:
14783 case CEIL_DIV_EXPR
:
14784 case FLOOR_DIV_EXPR
:
14785 case ROUND_DIV_EXPR
:
14786 case EXACT_DIV_EXPR
:
14790 case TRUNC_MOD_EXPR
:
14791 case FLOOR_MOD_EXPR
:
14792 case TRUTH_ANDIF_EXPR
:
14793 case TRUTH_ORIF_EXPR
:
14794 case TRUTH_AND_EXPR
:
14795 case TRUTH_OR_EXPR
:
14811 warning_sentinel
s1(warn_type_limits
);
14812 warning_sentinel
s2(warn_div_by_zero
);
14813 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14814 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14815 tree r
= build_x_binary_op
14816 (input_location
, TREE_CODE (t
),
14818 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14820 : TREE_CODE (TREE_OPERAND (t
, 0))),
14822 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14824 : TREE_CODE (TREE_OPERAND (t
, 1))),
14826 complain
|decltype_flag
);
14827 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14828 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14833 case POINTER_PLUS_EXPR
:
14835 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14836 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14837 return fold_build_pointer_plus (op0
, op1
);
14841 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14842 /*address_p=*/false));
14844 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14845 args
, complain
, in_decl
);
14846 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14847 RECUR (TREE_OPERAND (t
, 1)),
14848 complain
|decltype_flag
));
14850 case ARRAY_NOTATION_REF
:
14852 tree start_index
, length
, stride
;
14853 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14854 args
, complain
, in_decl
);
14855 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14856 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14857 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14858 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14859 length
, stride
, TREE_TYPE (op1
)));
14862 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14863 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14870 op1
= TREE_OPERAND (t
, 0);
14871 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14872 op1
= TREE_TYPE (op1
);
14875 /* When there are no ARGS, we are trying to evaluate a
14876 non-dependent expression from the parser. Trying to do
14877 the substitutions may not work. */
14879 op1
= TREE_TYPE (op1
);
14883 ++cp_unevaluated_operand
;
14884 ++c_inhibit_evaluation_warnings
;
14886 op1
= tsubst (op1
, args
, complain
, in_decl
);
14888 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14889 /*function_p=*/false,
14890 /*integral_constant_expression_p=*/
14892 --cp_unevaluated_operand
;
14893 --c_inhibit_evaluation_warnings
;
14896 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14897 complain
& tf_error
);
14899 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14900 complain
& tf_error
);
14901 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14903 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14905 if (!processing_template_decl
&& TYPE_P (op1
))
14907 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14908 build1 (NOP_EXPR
, op1
, error_mark_node
));
14909 SIZEOF_EXPR_TYPE_P (r
) = 1;
14912 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14913 TREE_SIDE_EFFECTS (r
) = 0;
14914 TREE_READONLY (r
) = 1;
14916 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14921 case AT_ENCODE_EXPR
:
14923 op1
= TREE_OPERAND (t
, 0);
14924 ++cp_unevaluated_operand
;
14925 ++c_inhibit_evaluation_warnings
;
14926 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14927 /*function_p=*/false,
14928 /*integral_constant_expression_p=*/false);
14929 --cp_unevaluated_operand
;
14930 --c_inhibit_evaluation_warnings
;
14931 RETURN (objc_build_encode_expr (op1
));
14934 case NOEXCEPT_EXPR
:
14935 op1
= TREE_OPERAND (t
, 0);
14936 ++cp_unevaluated_operand
;
14937 ++c_inhibit_evaluation_warnings
;
14938 ++cp_noexcept_operand
;
14939 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14940 /*function_p=*/false,
14941 /*integral_constant_expression_p=*/false);
14942 --cp_unevaluated_operand
;
14943 --c_inhibit_evaluation_warnings
;
14944 --cp_noexcept_operand
;
14945 RETURN (finish_noexcept_expr (op1
, complain
));
14949 warning_sentinel
s(warn_div_by_zero
);
14950 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
14951 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
14952 tree r
= build_x_modify_expr
14953 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
14954 complain
|decltype_flag
);
14955 /* TREE_NO_WARNING must be set if either the expression was
14956 parenthesized or it uses an operator such as >>= rather
14957 than plain assignment. In the former case, it was already
14958 set and must be copied. In the latter case,
14959 build_x_modify_expr sets it and it must not be reset
14961 if (TREE_NO_WARNING (t
))
14962 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14968 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14969 args
, complain
, in_decl
);
14970 /* Remember that there was a reference to this entity. */
14972 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
14973 RETURN (error_mark_node
);
14974 RETURN (build_x_arrow (input_location
, op1
, complain
));
14978 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14979 tree init
= RECUR (TREE_OPERAND (t
, 3));
14980 vec
<tree
, va_gc
> *placement_vec
;
14981 vec
<tree
, va_gc
> *init_vec
;
14984 if (placement
== NULL_TREE
)
14985 placement_vec
= NULL
;
14988 placement_vec
= make_tree_vector ();
14989 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14990 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14993 /* If there was an initializer in the original tree, but it
14994 instantiated to an empty list, then we should pass a
14995 non-NULL empty vector to tell build_new that it was an
14996 empty initializer() rather than no initializer. This can
14997 only happen when the initializer is a pack expansion whose
14998 parameter packs are of length zero. */
14999 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
15003 init_vec
= make_tree_vector ();
15004 if (init
== void_node
)
15005 gcc_assert (init_vec
!= NULL
);
15008 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
15009 vec_safe_push (init_vec
, TREE_VALUE (init
));
15013 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15014 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15015 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
15016 NEW_EXPR_USE_GLOBAL (t
),
15019 if (placement_vec
!= NULL
)
15020 release_tree_vector (placement_vec
);
15021 if (init_vec
!= NULL
)
15022 release_tree_vector (init_vec
);
15029 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15030 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15031 RETURN (delete_sanity (op0
, op1
,
15032 DELETE_EXPR_USE_VEC (t
),
15033 DELETE_EXPR_USE_GLOBAL (t
),
15037 case COMPOUND_EXPR
:
15039 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
15040 complain
& ~tf_decltype
, in_decl
,
15041 /*function_p=*/false,
15042 integral_constant_expression_p
);
15043 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
15045 RECUR (TREE_OPERAND (t
, 1)),
15046 complain
|decltype_flag
));
15052 vec
<tree
, va_gc
> *call_args
;
15053 unsigned int nargs
, i
;
15058 function
= CALL_EXPR_FN (t
);
15059 /* When we parsed the expression, we determined whether or
15060 not Koenig lookup should be performed. */
15061 koenig_p
= KOENIG_LOOKUP_P (t
);
15062 if (TREE_CODE (function
) == SCOPE_REF
)
15064 qualified_p
= true;
15065 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
15067 /*address_p=*/false);
15069 else if (koenig_p
&& identifier_p (function
))
15071 /* Do nothing; calling tsubst_copy_and_build on an identifier
15072 would incorrectly perform unqualified lookup again.
15074 Note that we can also have an IDENTIFIER_NODE if the earlier
15075 unqualified lookup found a member function; in that case
15076 koenig_p will be false and we do want to do the lookup
15077 again to find the instantiated member function.
15079 FIXME but doing that causes c++/15272, so we need to stop
15080 using IDENTIFIER_NODE in that situation. */
15081 qualified_p
= false;
15085 if (TREE_CODE (function
) == COMPONENT_REF
)
15087 tree op
= TREE_OPERAND (function
, 1);
15089 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
15090 || (BASELINK_P (op
)
15091 && BASELINK_QUALIFIED_P (op
)));
15094 qualified_p
= false;
15096 if (TREE_CODE (function
) == ADDR_EXPR
15097 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
15098 /* Avoid error about taking the address of a constructor. */
15099 function
= TREE_OPERAND (function
, 0);
15101 function
= tsubst_copy_and_build (function
, args
, complain
,
15104 integral_constant_expression_p
);
15106 if (BASELINK_P (function
))
15107 qualified_p
= true;
15110 nargs
= call_expr_nargs (t
);
15111 call_args
= make_tree_vector ();
15112 for (i
= 0; i
< nargs
; ++i
)
15114 tree arg
= CALL_EXPR_ARG (t
, i
);
15116 if (!PACK_EXPANSION_P (arg
))
15117 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
15120 /* Expand the pack expansion and push each entry onto
15122 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
15123 if (TREE_CODE (arg
) == TREE_VEC
)
15125 unsigned int len
, j
;
15127 len
= TREE_VEC_LENGTH (arg
);
15128 for (j
= 0; j
< len
; ++j
)
15130 tree value
= TREE_VEC_ELT (arg
, j
);
15131 if (value
!= NULL_TREE
)
15132 value
= convert_from_reference (value
);
15133 vec_safe_push (call_args
, value
);
15138 /* A partial substitution. Add one entry. */
15139 vec_safe_push (call_args
, arg
);
15144 /* We do not perform argument-dependent lookup if normal
15145 lookup finds a non-function, in accordance with the
15146 expected resolution of DR 218. */
15148 && ((is_overloaded_fn (function
)
15149 /* If lookup found a member function, the Koenig lookup is
15150 not appropriate, even if an unqualified-name was used
15151 to denote the function. */
15152 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
15153 || identifier_p (function
))
15154 /* Only do this when substitution turns a dependent call
15155 into a non-dependent call. */
15156 && type_dependent_expression_p_push (t
)
15157 && !any_type_dependent_arguments_p (call_args
))
15158 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
15160 if (identifier_p (function
)
15161 && !any_type_dependent_arguments_p (call_args
))
15163 if (koenig_p
&& (complain
& tf_warning_or_error
))
15165 /* For backwards compatibility and good diagnostics, try
15166 the unqualified lookup again if we aren't in SFINAE
15168 tree unq
= (tsubst_copy_and_build
15169 (function
, args
, complain
, in_decl
, true,
15170 integral_constant_expression_p
));
15171 if (unq
== error_mark_node
)
15172 RETURN (error_mark_node
);
15174 if (unq
!= function
)
15177 if (INDIRECT_REF_P (fn
))
15178 fn
= TREE_OPERAND (fn
, 0);
15179 if (TREE_CODE (fn
) == COMPONENT_REF
)
15180 fn
= TREE_OPERAND (fn
, 1);
15181 if (is_overloaded_fn (fn
))
15182 fn
= get_first_fn (fn
);
15183 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
15184 "%qD was not declared in this scope, "
15185 "and no declarations were found by "
15186 "argument-dependent lookup at the point "
15187 "of instantiation", function
))
15190 /* Can't say anything more. */;
15191 else if (DECL_CLASS_SCOPE_P (fn
))
15193 location_t loc
= EXPR_LOC_OR_LOC (t
,
15196 "declarations in dependent base %qT are "
15197 "not found by unqualified lookup",
15198 DECL_CLASS_CONTEXT (fn
));
15199 if (current_class_ptr
)
15201 "use %<this->%D%> instead", function
);
15204 "use %<%T::%D%> instead",
15205 current_class_name
, function
);
15208 inform (0, "%q+D declared here, later in the "
15209 "translation unit", fn
);
15214 if (identifier_p (function
))
15216 if (complain
& tf_error
)
15217 unqualified_name_lookup_error (function
);
15218 release_tree_vector (call_args
);
15219 RETURN (error_mark_node
);
15223 /* Remember that there was a reference to this entity. */
15224 if (DECL_P (function
)
15225 && !mark_used (function
, complain
) && !(complain
& tf_error
))
15226 RETURN (error_mark_node
);
15228 /* Put back tf_decltype for the actual call. */
15229 complain
|= decltype_flag
;
15231 if (TREE_CODE (function
) == OFFSET_REF
)
15232 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
15234 else if (TREE_CODE (function
) == COMPONENT_REF
)
15236 tree instance
= TREE_OPERAND (function
, 0);
15237 tree fn
= TREE_OPERAND (function
, 1);
15239 if (processing_template_decl
15240 && (type_dependent_expression_p (instance
)
15241 || (!BASELINK_P (fn
)
15242 && TREE_CODE (fn
) != FIELD_DECL
)
15243 || type_dependent_expression_p (fn
)
15244 || any_type_dependent_arguments_p (call_args
)))
15245 ret
= build_nt_call_vec (function
, call_args
);
15246 else if (!BASELINK_P (fn
))
15247 ret
= finish_call_expr (function
, &call_args
,
15248 /*disallow_virtual=*/false,
15249 /*koenig_p=*/false,
15252 ret
= (build_new_method_call
15254 &call_args
, NULL_TREE
,
15255 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
15260 ret
= finish_call_expr (function
, &call_args
,
15261 /*disallow_virtual=*/qualified_p
,
15265 release_tree_vector (call_args
);
15272 tree cond
= RECUR (TREE_OPERAND (t
, 0));
15273 tree folded_cond
= fold_non_dependent_expr (cond
);
15276 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
15278 if (integer_zerop (folded_cond
))
15280 ++c_inhibit_evaluation_warnings
;
15281 exp1
= RECUR (TREE_OPERAND (t
, 1));
15282 --c_inhibit_evaluation_warnings
;
15283 exp2
= RECUR (TREE_OPERAND (t
, 2));
15287 exp1
= RECUR (TREE_OPERAND (t
, 1));
15288 ++c_inhibit_evaluation_warnings
;
15289 exp2
= RECUR (TREE_OPERAND (t
, 2));
15290 --c_inhibit_evaluation_warnings
;
15292 cond
= folded_cond
;
15296 exp1
= RECUR (TREE_OPERAND (t
, 1));
15297 exp2
= RECUR (TREE_OPERAND (t
, 2));
15300 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
15301 cond
, exp1
, exp2
, complain
));
15304 case PSEUDO_DTOR_EXPR
:
15306 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15307 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15308 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15309 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
15315 tree purpose
, value
, chain
;
15317 if (t
== void_list_node
)
15320 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15321 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15323 /* We have pack expansions, so expand those and
15324 create a new list out of it. */
15325 tree purposevec
= NULL_TREE
;
15326 tree valuevec
= NULL_TREE
;
15330 /* Expand the argument expressions. */
15331 if (TREE_PURPOSE (t
))
15332 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15333 complain
, in_decl
);
15334 if (TREE_VALUE (t
))
15335 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15336 complain
, in_decl
);
15338 /* Build the rest of the list. */
15339 chain
= TREE_CHAIN (t
);
15340 if (chain
&& chain
!= void_type_node
)
15341 chain
= RECUR (chain
);
15343 /* Determine the number of arguments. */
15344 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15346 len
= TREE_VEC_LENGTH (purposevec
);
15347 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15349 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15350 len
= TREE_VEC_LENGTH (valuevec
);
15353 /* Since we only performed a partial substitution into
15354 the argument pack, we only RETURN (a single list
15356 if (purposevec
== TREE_PURPOSE (t
)
15357 && valuevec
== TREE_VALUE (t
)
15358 && chain
== TREE_CHAIN (t
))
15361 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15364 /* Convert the argument vectors into a TREE_LIST */
15368 /* Grab the Ith values. */
15370 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15373 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15376 /* Build the list (backwards). */
15377 chain
= tree_cons (purpose
, value
, chain
);
15383 purpose
= TREE_PURPOSE (t
);
15385 purpose
= RECUR (purpose
);
15386 value
= TREE_VALUE (t
);
15388 value
= RECUR (value
);
15389 chain
= TREE_CHAIN (t
);
15390 if (chain
&& chain
!= void_type_node
)
15391 chain
= RECUR (chain
);
15392 if (purpose
== TREE_PURPOSE (t
)
15393 && value
== TREE_VALUE (t
)
15394 && chain
== TREE_CHAIN (t
))
15396 RETURN (tree_cons (purpose
, value
, chain
));
15399 case COMPONENT_REF
:
15406 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15407 args
, complain
, in_decl
);
15408 /* Remember that there was a reference to this entity. */
15409 if (DECL_P (object
)
15410 && !mark_used (object
, complain
) && !(complain
& tf_error
))
15411 RETURN (error_mark_node
);
15412 object_type
= TREE_TYPE (object
);
15414 member
= TREE_OPERAND (t
, 1);
15415 if (BASELINK_P (member
))
15416 member
= tsubst_baselink (member
,
15417 non_reference (TREE_TYPE (object
)),
15418 args
, complain
, in_decl
);
15420 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15421 if (member
== error_mark_node
)
15422 RETURN (error_mark_node
);
15424 if (type_dependent_expression_p (object
))
15425 /* We can't do much here. */;
15426 else if (!CLASS_TYPE_P (object_type
))
15428 if (scalarish_type_p (object_type
))
15430 tree s
= NULL_TREE
;
15431 tree dtor
= member
;
15433 if (TREE_CODE (dtor
) == SCOPE_REF
)
15435 s
= TREE_OPERAND (dtor
, 0);
15436 dtor
= TREE_OPERAND (dtor
, 1);
15438 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15440 dtor
= TREE_OPERAND (dtor
, 0);
15442 RETURN (finish_pseudo_destructor_expr
15443 (object
, s
, dtor
, input_location
));
15447 else if (TREE_CODE (member
) == SCOPE_REF
15448 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15450 /* Lookup the template functions now that we know what the
15452 tree scope
= TREE_OPERAND (member
, 0);
15453 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15454 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15455 member
= lookup_qualified_name (scope
, tmpl
,
15456 /*is_type_p=*/false,
15457 /*complain=*/false);
15458 if (BASELINK_P (member
))
15460 BASELINK_FUNCTIONS (member
)
15461 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15463 member
= (adjust_result_of_qualified_name_lookup
15464 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15469 qualified_name_lookup_error (scope
, tmpl
, member
,
15471 RETURN (error_mark_node
);
15474 else if (TREE_CODE (member
) == SCOPE_REF
15475 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15476 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15478 if (complain
& tf_error
)
15480 if (TYPE_P (TREE_OPERAND (member
, 0)))
15481 error ("%qT is not a class or namespace",
15482 TREE_OPERAND (member
, 0));
15484 error ("%qD is not a class or namespace",
15485 TREE_OPERAND (member
, 0));
15487 RETURN (error_mark_node
);
15489 else if (TREE_CODE (member
) == FIELD_DECL
)
15491 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15492 if (TREE_CODE (r
) == COMPONENT_REF
)
15493 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15497 r
= finish_class_member_access_expr (object
, member
,
15498 /*template_p=*/false,
15500 if (TREE_CODE (r
) == COMPONENT_REF
)
15501 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15506 RETURN (build_throw
15507 (RECUR (TREE_OPERAND (t
, 0))));
15511 vec
<constructor_elt
, va_gc
> *n
;
15512 constructor_elt
*ce
;
15513 unsigned HOST_WIDE_INT idx
;
15514 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15515 bool process_index_p
;
15517 bool need_copy_p
= false;
15520 if (type
== error_mark_node
)
15521 RETURN (error_mark_node
);
15523 /* digest_init will do the wrong thing if we let it. */
15524 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15527 /* We do not want to process the index of aggregate
15528 initializers as they are identifier nodes which will be
15529 looked up by digest_init. */
15530 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15532 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15533 newlen
= vec_safe_length (n
);
15534 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15536 if (ce
->index
&& process_index_p
15537 /* An identifier index is looked up in the type
15538 being initialized, not the current scope. */
15539 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15540 ce
->index
= RECUR (ce
->index
);
15542 if (PACK_EXPANSION_P (ce
->value
))
15544 /* Substitute into the pack expansion. */
15545 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15548 if (ce
->value
== error_mark_node
15549 || PACK_EXPANSION_P (ce
->value
))
15551 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15552 /* Just move the argument into place. */
15553 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15556 /* Update the length of the final CONSTRUCTOR
15557 arguments vector, and note that we will need to
15559 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15560 need_copy_p
= true;
15564 ce
->value
= RECUR (ce
->value
);
15569 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15571 vec_alloc (n
, newlen
);
15572 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15574 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15576 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15577 for (i
= 0; i
< len
; ++i
)
15578 CONSTRUCTOR_APPEND_ELT (n
, 0,
15579 TREE_VEC_ELT (ce
->value
, i
));
15582 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15586 r
= build_constructor (init_list_type_node
, n
);
15587 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15589 if (TREE_HAS_CONSTRUCTOR (t
))
15590 RETURN (finish_compound_literal (type
, r
, complain
));
15592 TREE_TYPE (r
) = type
;
15598 tree operand_0
= TREE_OPERAND (t
, 0);
15599 if (TYPE_P (operand_0
))
15601 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15602 RETURN (get_typeid (operand_0
, complain
));
15606 operand_0
= RECUR (operand_0
);
15607 RETURN (build_typeid (operand_0
, complain
));
15614 else if (DECL_PACK_P (t
))
15616 /* We don't build decls for an instantiation of a
15617 variadic capture proxy, we instantiate the elements
15619 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15620 return RECUR (DECL_VALUE_EXPR (t
));
15626 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15627 /* ??? We're doing a subset of finish_id_expression here. */
15629 && !processing_template_decl
15630 && !cp_unevaluated_operand
15631 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
15632 && DECL_THREAD_LOCAL_P (r
))
15634 if (tree wrap
= get_tls_wrapper_fn (r
))
15635 /* Replace an evaluated use of the thread_local variable with
15636 a call to its wrapper. */
15637 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
15639 else if (outer_automatic_var_p (r
))
15640 r
= process_outer_var_ref (r
, complain
);
15642 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15643 /* If the original type was a reference, we'll be wrapped in
15644 the appropriate INDIRECT_REF. */
15645 r
= convert_from_reference (r
);
15651 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15652 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15653 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15656 case OFFSETOF_EXPR
:
15657 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0)),
15658 EXPR_LOCATION (t
)));
15662 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15663 complain
, in_decl
);
15665 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15666 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
15667 type2
= RECUR (type2
);
15669 type2
= tsubst (type2
, args
, complain
, in_decl
);
15671 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15676 tree old_stmt_expr
= cur_stmt_expr
;
15677 tree stmt_expr
= begin_stmt_expr ();
15679 cur_stmt_expr
= stmt_expr
;
15680 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15681 integral_constant_expression_p
);
15682 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15683 cur_stmt_expr
= old_stmt_expr
;
15685 /* If the resulting list of expression statement is empty,
15686 fold it further into void_node. */
15687 if (empty_expr_stmt_p (stmt_expr
))
15688 stmt_expr
= void_node
;
15690 RETURN (stmt_expr
);
15695 tree r
= build_lambda_expr ();
15697 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15698 LAMBDA_EXPR_CLOSURE (r
) = type
;
15699 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15701 LAMBDA_EXPR_LOCATION (r
)
15702 = LAMBDA_EXPR_LOCATION (t
);
15703 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15704 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15705 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15706 LAMBDA_EXPR_DISCRIMINATOR (r
)
15707 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15708 /* For a function scope, we want to use tsubst so that we don't
15709 complain about referring to an auto function before its return
15710 type has been deduced. Otherwise, we want to use tsubst_copy so
15711 that we look up the existing field/parameter/variable rather
15712 than build a new one. */
15713 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15714 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15715 scope
= tsubst (scope
, args
, complain
, in_decl
);
15716 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15718 /* Look up the parameter we want directly, as tsubst_copy
15719 doesn't do what we need. */
15720 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15721 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15722 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15723 parm
= DECL_CHAIN (parm
);
15725 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15726 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15727 DECL_CONTEXT (scope
) = fn
;
15730 scope
= RECUR (scope
);
15731 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15732 LAMBDA_EXPR_RETURN_TYPE (r
)
15733 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15735 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15736 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15738 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15739 determine_visibility (TYPE_NAME (type
));
15740 /* Now that we know visibility, instantiate the type so we have a
15741 declaration of the op() for later calls to lambda_function. */
15742 complete_type (type
);
15744 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15746 RETURN (build_lambda_object (r
));
15750 /* We can get here for a constant initializer of non-dependent type.
15751 FIXME stop folding in cp_parser_initializer_clause. */
15753 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15758 case TRANSACTION_EXPR
:
15759 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15760 integral_constant_expression_p
));
15763 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15765 case VEC_PERM_EXPR
:
15767 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15768 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15769 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15770 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15775 /* Handle Objective-C++ constructs, if appropriate. */
15778 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15779 in_decl
, /*function_p=*/false);
15783 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15789 input_location
= loc
;
15793 /* Verify that the instantiated ARGS are valid. For type arguments,
15794 make sure that the type's linkage is ok. For non-type arguments,
15795 make sure they are constants if they are integral or enumerations.
15796 Emit an error under control of COMPLAIN, and return TRUE on error. */
15799 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15801 if (dependent_template_arg_p (t
))
15803 if (ARGUMENT_PACK_P (t
))
15805 tree vec
= ARGUMENT_PACK_ARGS (t
);
15806 int len
= TREE_VEC_LENGTH (vec
);
15807 bool result
= false;
15810 for (i
= 0; i
< len
; ++i
)
15811 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15815 else if (TYPE_P (t
))
15817 /* [basic.link]: A name with no linkage (notably, the name
15818 of a class or enumeration declared in a local scope)
15819 shall not be used to declare an entity with linkage.
15820 This implies that names with no linkage cannot be used as
15823 DR 757 relaxes this restriction for C++0x. */
15824 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15825 : no_linkage_check (t
, /*relaxed_p=*/false));
15829 /* DR 488 makes use of a type with no linkage cause
15830 type deduction to fail. */
15831 if (complain
& tf_error
)
15833 if (TYPE_ANONYMOUS_P (nt
))
15834 error ("%qT is/uses anonymous type", t
);
15836 error ("template argument for %qD uses local type %qT",
15841 /* In order to avoid all sorts of complications, we do not
15842 allow variably-modified types as template arguments. */
15843 else if (variably_modified_type_p (t
, NULL_TREE
))
15845 if (complain
& tf_error
)
15846 error ("%qT is a variably modified type", t
);
15850 /* Class template and alias template arguments should be OK. */
15851 else if (DECL_TYPE_TEMPLATE_P (t
))
15853 /* A non-type argument of integral or enumerated type must be a
15855 else if (TREE_TYPE (t
)
15856 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15857 && !REFERENCE_REF_P (t
)
15858 && !TREE_CONSTANT (t
))
15860 if (complain
& tf_error
)
15861 error ("integral expression %qE is not constant", t
);
15868 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15870 int ix
, len
= DECL_NTPARMS (tmpl
);
15871 bool result
= false;
15873 for (ix
= 0; ix
!= len
; ix
++)
15875 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15878 if (result
&& (complain
& tf_error
))
15879 error (" trying to instantiate %qD", tmpl
);
15883 /* We're out of SFINAE context now, so generate diagnostics for the access
15884 errors we saw earlier when instantiating D from TMPL and ARGS. */
15887 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15889 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15890 tree type
= TREE_TYPE (pattern
);
15891 location_t loc
= input_location
;
15893 push_access_scope (d
);
15894 push_deferring_access_checks (dk_no_deferred
);
15895 input_location
= DECL_SOURCE_LOCATION (pattern
);
15896 tsubst (type
, args
, tf_warning_or_error
, d
);
15897 input_location
= loc
;
15898 pop_deferring_access_checks ();
15899 pop_access_scope (d
);
15902 /* Instantiate the indicated variable, function, or alias template TMPL with
15903 the template arguments in TARG_PTR. */
15906 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15908 tree targ_ptr
= orig_args
;
15912 bool access_ok
= true;
15914 if (tmpl
== error_mark_node
)
15915 return error_mark_node
;
15917 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15919 /* If this function is a clone, handle it specially. */
15920 if (DECL_CLONED_FUNCTION_P (tmpl
))
15925 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15926 DECL_CLONED_FUNCTION. */
15927 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15928 targ_ptr
, complain
);
15929 if (spec
== error_mark_node
)
15930 return error_mark_node
;
15932 /* Look for the clone. */
15933 FOR_EACH_CLONE (clone
, spec
)
15934 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15936 /* We should always have found the clone by now. */
15937 gcc_unreachable ();
15941 if (targ_ptr
== error_mark_node
)
15942 return error_mark_node
;
15944 /* Check to see if we already have this specialization. */
15945 gen_tmpl
= most_general_template (tmpl
);
15946 if (tmpl
!= gen_tmpl
)
15947 /* The TMPL is a partial instantiation. To get a full set of
15948 arguments we must add the arguments used to perform the
15949 partial instantiation. */
15950 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15953 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15954 but it doesn't seem to be on the hot path. */
15955 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15957 gcc_assert (tmpl
== gen_tmpl
15958 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15960 || fndecl
== NULL_TREE
);
15962 if (spec
!= NULL_TREE
)
15964 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15966 if (complain
& tf_error
)
15967 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15968 return error_mark_node
;
15973 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15975 return error_mark_node
;
15977 /* We are building a FUNCTION_DECL, during which the access of its
15978 parameters and return types have to be checked. However this
15979 FUNCTION_DECL which is the desired context for access checking
15980 is not built yet. We solve this chicken-and-egg problem by
15981 deferring all checks until we have the FUNCTION_DECL. */
15982 push_deferring_access_checks (dk_deferred
);
15984 /* Instantiation of the function happens in the context of the function
15985 template, not the context of the overload resolution we're doing. */
15986 push_to_top_level ();
15987 /* If there are dependent arguments, e.g. because we're doing partial
15988 ordering, make sure processing_template_decl stays set. */
15989 if (uses_template_parms (targ_ptr
))
15990 ++processing_template_decl
;
15991 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15993 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15994 complain
, gen_tmpl
, true);
15995 push_nested_class (ctx
);
15998 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
16000 if (VAR_P (pattern
))
16002 /* We need to determine if we're using a partial or explicit
16003 specialization now, because the type of the variable could be
16005 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
16006 tree elt
= most_specialized_partial_spec (tid
, complain
);
16007 if (elt
== error_mark_node
)
16008 pattern
= error_mark_node
;
16011 tmpl
= TREE_VALUE (elt
);
16012 pattern
= DECL_TEMPLATE_RESULT (tmpl
);
16013 targ_ptr
= TREE_PURPOSE (elt
);
16017 /* Substitute template parameters to obtain the specialization. */
16018 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
16019 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
16020 pop_nested_class ();
16021 pop_from_top_level ();
16023 if (fndecl
== error_mark_node
)
16025 pop_deferring_access_checks ();
16026 return error_mark_node
;
16029 /* The DECL_TI_TEMPLATE should always be the immediate parent
16030 template, not the most general template. */
16031 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
16033 /* Now we know the specialization, compute access previously
16035 push_access_scope (fndecl
);
16036 if (!perform_deferred_access_checks (complain
))
16038 pop_access_scope (fndecl
);
16039 pop_deferring_access_checks ();
16041 /* If we've just instantiated the main entry point for a function,
16042 instantiate all the alternate entry points as well. We do this
16043 by cloning the instantiation of the main entry point, not by
16044 instantiating the template clones. */
16045 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
16046 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
16050 if (!(complain
& tf_error
))
16052 /* Remember to reinstantiate when we're out of SFINAE so the user
16053 can see the errors. */
16054 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
16056 return error_mark_node
;
16061 /* Wrapper for instantiate_template_1. */
16064 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
16067 timevar_push (TV_TEMPLATE_INST
);
16068 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
16069 timevar_pop (TV_TEMPLATE_INST
);
16073 /* Instantiate the alias template TMPL with ARGS. Also push a template
16074 instantiation level, which instantiate_template doesn't do because
16075 functions and variables have sufficient context established by the
16079 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
16081 struct pending_template
*old_last_pend
= last_pending_template
;
16082 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16083 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
16084 return error_mark_node
;
16085 tree tinst
= build_tree_list (tmpl
, args
);
16086 if (!push_tinst_level (tinst
))
16089 return error_mark_node
;
16093 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
16094 args
, tmpl
, complain
,
16095 /*require_all_args=*/true,
16096 /*use_default_args=*/true);
16098 tree r
= instantiate_template (tmpl
, args
, complain
);
16099 pop_tinst_level ();
16100 /* We can't free this if a pending_template entry or last_error_tinst_level
16101 is pointing at it. */
16102 if (last_pending_template
== old_last_pend
16103 && last_error_tinst_level
== old_error_tinst
)
16109 /* PARM is a template parameter pack for FN. Returns true iff
16110 PARM is used in a deducible way in the argument list of FN. */
16113 pack_deducible_p (tree parm
, tree fn
)
16115 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
16116 for (; t
; t
= TREE_CHAIN (t
))
16118 tree type
= TREE_VALUE (t
);
16120 if (!PACK_EXPANSION_P (type
))
16122 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
16123 packs
; packs
= TREE_CHAIN (packs
))
16124 if (template_args_equal (TREE_VALUE (packs
), parm
))
16126 /* The template parameter pack is used in a function parameter
16127 pack. If this is the end of the parameter list, the
16128 template parameter pack is deducible. */
16129 if (TREE_CHAIN (t
) == void_list_node
)
16132 /* Otherwise, not. Well, it could be deduced from
16133 a non-pack parameter, but doing so would end up with
16134 a deduction mismatch, so don't bother. */
16138 /* The template parameter pack isn't used in any function parameter
16139 packs, but it might be used deeper, e.g. tuple<Args...>. */
16143 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
16144 NARGS elements of the arguments that are being used when calling
16145 it. TARGS is a vector into which the deduced template arguments
16148 Returns either a FUNCTION_DECL for the matching specialization of FN or
16149 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
16150 true, diagnostics will be printed to explain why it failed.
16152 If FN is a conversion operator, or we are trying to produce a specific
16153 specialization, RETURN_TYPE is the return type desired.
16155 The EXPLICIT_TARGS are explicit template arguments provided via a
16158 The parameter STRICT is one of:
16161 We are deducing arguments for a function call, as in
16162 [temp.deduct.call].
16165 We are deducing arguments for a conversion function, as in
16166 [temp.deduct.conv].
16169 We are deducing arguments when doing an explicit instantiation
16170 as in [temp.explicit], when determining an explicit specialization
16171 as in [temp.expl.spec], or when taking the address of a function
16172 template, as in [temp.deduct.funcaddr]. */
16175 fn_type_unification (tree fn
,
16176 tree explicit_targs
,
16179 unsigned int nargs
,
16181 unification_kind_t strict
,
16188 tree decl
= NULL_TREE
;
16189 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
16191 static int deduction_depth
;
16192 struct pending_template
*old_last_pend
= last_pending_template
;
16193 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16194 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
16196 tree r
= error_mark_node
;
16199 complain
|= tf_decltype
;
16201 /* In C++0x, it's possible to have a function template whose type depends
16202 on itself recursively. This is most obvious with decltype, but can also
16203 occur with enumeration scope (c++/48969). So we need to catch infinite
16204 recursion and reject the substitution at deduction time; this function
16205 will return error_mark_node for any repeated substitution.
16207 This also catches excessive recursion such as when f<N> depends on
16208 f<N-1> across all integers, and returns error_mark_node for all the
16209 substitutions back up to the initial one.
16211 This is, of course, not reentrant. */
16212 if (excessive_deduction_depth
)
16213 return error_mark_node
;
16214 tinst
= build_tree_list (fn
, NULL_TREE
);
16217 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
16219 fntype
= TREE_TYPE (fn
);
16220 if (explicit_targs
)
16224 The specified template arguments must match the template
16225 parameters in kind (i.e., type, nontype, template), and there
16226 must not be more arguments than there are parameters;
16227 otherwise type deduction fails.
16229 Nontype arguments must match the types of the corresponding
16230 nontype template parameters, or must be convertible to the
16231 types of the corresponding nontype parameters as specified in
16232 _temp.arg.nontype_, otherwise type deduction fails.
16234 All references in the function type of the function template
16235 to the corresponding template parameters are replaced by the
16236 specified template argument values. If a substitution in a
16237 template parameter or in the function type of the function
16238 template results in an invalid type, type deduction fails. */
16239 int i
, len
= TREE_VEC_LENGTH (tparms
);
16240 location_t loc
= input_location
;
16241 bool incomplete
= false;
16243 /* Adjust any explicit template arguments before entering the
16244 substitution context. */
16246 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
16248 /*require_all_args=*/false,
16249 /*use_default_args=*/false));
16250 if (explicit_targs
== error_mark_node
)
16253 /* Substitute the explicit args into the function type. This is
16254 necessary so that, for instance, explicitly declared function
16255 arguments can match null pointed constants. If we were given
16256 an incomplete set of explicit args, we must not do semantic
16257 processing during substitution as we could create partial
16259 for (i
= 0; i
< len
; i
++)
16261 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16262 bool parameter_pack
= false;
16263 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
16265 /* Dig out the actual parm. */
16266 if (TREE_CODE (parm
) == TYPE_DECL
16267 || TREE_CODE (parm
) == TEMPLATE_DECL
)
16269 parm
= TREE_TYPE (parm
);
16270 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
16272 else if (TREE_CODE (parm
) == PARM_DECL
)
16274 parm
= DECL_INITIAL (parm
);
16275 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
16278 if (!parameter_pack
&& targ
== NULL_TREE
)
16279 /* No explicit argument for this template parameter. */
16282 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
16284 /* Mark the argument pack as "incomplete". We could
16285 still deduce more arguments during unification.
16286 We remove this mark in type_unification_real. */
16289 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
16290 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
16291 = ARGUMENT_PACK_ARGS (targ
);
16294 /* We have some incomplete argument packs. */
16299 TREE_VALUE (tinst
) = explicit_targs
;
16300 if (!push_tinst_level (tinst
))
16302 excessive_deduction_depth
= true;
16305 processing_template_decl
+= incomplete
;
16306 input_location
= DECL_SOURCE_LOCATION (fn
);
16307 /* Ignore any access checks; we'll see them again in
16308 instantiate_template and they might have the wrong
16309 access path at this point. */
16310 push_deferring_access_checks (dk_deferred
);
16311 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
16312 complain
| tf_partial
, NULL_TREE
);
16313 pop_deferring_access_checks ();
16314 input_location
= loc
;
16315 processing_template_decl
-= incomplete
;
16316 pop_tinst_level ();
16318 if (fntype
== error_mark_node
)
16321 /* Place the explicitly specified arguments in TARGS. */
16322 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
16323 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
16326 /* Never do unification on the 'this' parameter. */
16327 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
16333 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
16334 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
16335 new_args
[0] = return_type
;
16336 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
16341 /* We allow incomplete unification without an error message here
16342 because the standard doesn't seem to explicitly prohibit it. Our
16343 callers must be ready to deal with unification failures in any
16346 TREE_VALUE (tinst
) = targs
;
16347 /* If we aren't explaining yet, push tinst context so we can see where
16348 any errors (e.g. from class instantiations triggered by instantiation
16349 of default template arguments) come from. If we are explaining, this
16350 context is redundant. */
16351 if (!explain_p
&& !push_tinst_level (tinst
))
16353 excessive_deduction_depth
= true;
16357 /* type_unification_real will pass back any access checks from default
16358 template argument substitution. */
16359 vec
<deferred_access_check
, va_gc
> *checks
;
16362 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16363 targs
, parms
, args
, nargs
, /*subr=*/0,
16364 strict
, flags
, &checks
, explain_p
);
16366 pop_tinst_level ();
16370 /* Now that we have bindings for all of the template arguments,
16371 ensure that the arguments deduced for the template template
16372 parameters have compatible template parameter lists. We cannot
16373 check this property before we have deduced all template
16374 arguments, because the template parameter types of a template
16375 template parameter might depend on prior template parameters
16376 deduced after the template template parameter. The following
16377 ill-formed example illustrates this issue:
16379 template<typename T, template<T> class C> void f(C<5>, T);
16381 template<int N> struct X {};
16384 f(X<5>(), 5l); // error: template argument deduction fails
16387 The template parameter list of 'C' depends on the template type
16388 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16389 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16390 time that we deduce 'C'. */
16391 if (!template_template_parm_bindings_ok_p
16392 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16394 unify_inconsistent_template_template_parameters (explain_p
);
16398 /* All is well so far. Now, check:
16402 When all template arguments have been deduced, all uses of
16403 template parameters in nondeduced contexts are replaced with
16404 the corresponding deduced argument values. If the
16405 substitution results in an invalid type, as described above,
16406 type deduction fails. */
16407 TREE_VALUE (tinst
) = targs
;
16408 if (!push_tinst_level (tinst
))
16410 excessive_deduction_depth
= true;
16414 /* Also collect access checks from the instantiation. */
16415 reopen_deferring_access_checks (checks
);
16417 decl
= instantiate_template (fn
, targs
, complain
);
16419 checks
= get_deferred_access_checks ();
16420 pop_deferring_access_checks ();
16422 pop_tinst_level ();
16424 if (decl
== error_mark_node
)
16427 /* Now perform any access checks encountered during substitution. */
16428 push_access_scope (decl
);
16429 ok
= perform_access_checks (checks
, complain
);
16430 pop_access_scope (decl
);
16434 /* If we're looking for an exact match, check that what we got
16435 is indeed an exact match. It might not be if some template
16436 parameters are used in non-deduced contexts. But don't check
16437 for an exact match if we have dependent template arguments;
16438 in that case we're doing partial ordering, and we already know
16439 that we have two candidates that will provide the actual type. */
16440 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16442 tree substed
= TREE_TYPE (decl
);
16446 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16448 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16449 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16450 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16452 unify_type_mismatch (explain_p
, args
[i
],
16453 TREE_VALUE (sarg
));
16462 if (excessive_deduction_depth
)
16464 if (deduction_depth
== 0)
16465 /* Reset once we're all the way out. */
16466 excessive_deduction_depth
= false;
16469 /* We can't free this if a pending_template entry or last_error_tinst_level
16470 is pointing at it. */
16471 if (last_pending_template
== old_last_pend
16472 && last_error_tinst_level
== old_error_tinst
)
16478 /* Adjust types before performing type deduction, as described in
16479 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16480 sections are symmetric. PARM is the type of a function parameter
16481 or the return type of the conversion function. ARG is the type of
16482 the argument passed to the call, or the type of the value
16483 initialized with the result of the conversion function.
16484 ARG_EXPR is the original argument expression, which may be null. */
16487 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16501 /* Swap PARM and ARG throughout the remainder of this
16502 function; the handling is precisely symmetric since PARM
16503 will initialize ARG rather than vice versa. */
16511 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16512 too, but here handle it by stripping the reference from PARM
16513 rather than by adding it to ARG. */
16514 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16515 && TYPE_REF_IS_RVALUE (*parm
)
16516 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16517 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16518 && TREE_CODE (*arg
) == REFERENCE_TYPE
16519 && !TYPE_REF_IS_RVALUE (*arg
))
16520 *parm
= TREE_TYPE (*parm
);
16521 /* Nothing else to do in this case. */
16525 gcc_unreachable ();
16528 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16530 /* [temp.deduct.call]
16532 If P is not a reference type:
16534 --If A is an array type, the pointer type produced by the
16535 array-to-pointer standard conversion (_conv.array_) is
16536 used in place of A for type deduction; otherwise,
16538 --If A is a function type, the pointer type produced by
16539 the function-to-pointer standard conversion
16540 (_conv.func_) is used in place of A for type deduction;
16543 --If A is a cv-qualified type, the top level
16544 cv-qualifiers of A's type are ignored for type
16546 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16547 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16548 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16549 *arg
= build_pointer_type (*arg
);
16551 *arg
= TYPE_MAIN_VARIANT (*arg
);
16554 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16555 of the form T&&, where T is a template parameter, and the argument
16556 is an lvalue, T is deduced as A& */
16557 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16558 && TYPE_REF_IS_RVALUE (*parm
)
16559 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16560 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16561 && (arg_expr
? real_lvalue_p (arg_expr
)
16562 /* try_one_overload doesn't provide an arg_expr, but
16563 functions are always lvalues. */
16564 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16565 *arg
= build_reference_type (*arg
);
16567 /* [temp.deduct.call]
16569 If P is a cv-qualified type, the top level cv-qualifiers
16570 of P's type are ignored for type deduction. If P is a
16571 reference type, the type referred to by P is used for
16573 *parm
= TYPE_MAIN_VARIANT (*parm
);
16574 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16576 *parm
= TREE_TYPE (*parm
);
16577 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16580 /* DR 322. For conversion deduction, remove a reference type on parm
16581 too (which has been swapped into ARG). */
16582 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16583 *arg
= TREE_TYPE (*arg
);
16588 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16589 template which does contain any deducible template parameters; check if
16590 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16591 unify_one_argument. */
16594 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16595 int flags
, bool explain_p
)
16600 type
= TREE_TYPE (arg
);
16604 if (same_type_p (parm
, type
))
16605 return unify_success (explain_p
);
16607 if (strict
== DEDUCE_CONV
)
16609 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16610 explain_p
? tf_warning_or_error
: tf_none
))
16611 return unify_success (explain_p
);
16613 else if (strict
!= DEDUCE_EXACT
)
16615 if (can_convert_arg (parm
, type
,
16616 TYPE_P (arg
) ? NULL_TREE
: arg
,
16617 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16618 return unify_success (explain_p
);
16621 if (strict
== DEDUCE_EXACT
)
16622 return unify_type_mismatch (explain_p
, parm
, arg
);
16624 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16627 static bool uses_deducible_template_parms (tree type
);
16629 /* Returns true iff the expression EXPR is one from which a template
16630 argument can be deduced. In other words, if it's an undecorated
16631 use of a template non-type parameter. */
16634 deducible_expression (tree expr
)
16636 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16639 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16640 deducible way; that is, if it has a max value of <PARM> - 1. */
16643 deducible_array_bound (tree domain
)
16645 if (domain
== NULL_TREE
)
16648 tree max
= TYPE_MAX_VALUE (domain
);
16649 if (TREE_CODE (max
) != MINUS_EXPR
)
16652 return deducible_expression (TREE_OPERAND (max
, 0));
16655 /* Returns true iff the template arguments ARGS use a template parameter
16656 in a deducible way. */
16659 deducible_template_args (tree args
)
16661 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16664 tree elt
= TREE_VEC_ELT (args
, i
);
16665 if (ARGUMENT_PACK_P (elt
))
16666 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16669 if (PACK_EXPANSION_P (elt
))
16670 elt
= PACK_EXPANSION_PATTERN (elt
);
16671 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16673 else if (TYPE_P (elt
))
16674 deducible
= uses_deducible_template_parms (elt
);
16676 deducible
= deducible_expression (elt
);
16684 /* Returns true iff TYPE contains any deducible references to template
16685 parameters, as per 14.8.2.5. */
16688 uses_deducible_template_parms (tree type
)
16690 if (PACK_EXPANSION_P (type
))
16691 type
= PACK_EXPANSION_PATTERN (type
);
16698 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16699 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16705 if (POINTER_TYPE_P (type
))
16706 return uses_deducible_template_parms (TREE_TYPE (type
));
16708 /* T[integer-constant ]
16710 if (TREE_CODE (type
) == ARRAY_TYPE
)
16711 return (uses_deducible_template_parms (TREE_TYPE (type
))
16712 || deducible_array_bound (TYPE_DOMAIN (type
)));
16724 if (TYPE_PTRMEM_P (type
))
16725 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16726 || (uses_deducible_template_parms
16727 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16729 /* template-name <T> (where template-name refers to a class template)
16730 template-name <i> (where template-name refers to a class template) */
16731 if (CLASS_TYPE_P (type
)
16732 && CLASSTYPE_TEMPLATE_INFO (type
)
16733 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16734 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16735 (CLASSTYPE_TI_ARGS (type
)));
16740 if (TREE_CODE (type
) == FUNCTION_TYPE
16741 || TREE_CODE (type
) == METHOD_TYPE
)
16743 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16745 tree parm
= TYPE_ARG_TYPES (type
);
16746 if (TREE_CODE (type
) == METHOD_TYPE
)
16747 parm
= TREE_CHAIN (parm
);
16748 for (; parm
; parm
= TREE_CHAIN (parm
))
16749 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16756 /* Subroutine of type_unification_real and unify_pack_expansion to
16757 handle unification of a single P/A pair. Parameters are as
16758 for those functions. */
16761 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16762 int subr
, unification_kind_t strict
,
16765 tree arg_expr
= NULL_TREE
;
16768 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16769 return unify_invalid (explain_p
);
16770 if (arg
== unknown_type_node
)
16771 /* We can't deduce anything from this, but we might get all the
16772 template args from other function args. */
16773 return unify_success (explain_p
);
16775 /* Implicit conversions (Clause 4) will be performed on a function
16776 argument to convert it to the type of the corresponding function
16777 parameter if the parameter type contains no template-parameters that
16778 participate in template argument deduction. */
16779 if (strict
!= DEDUCE_EXACT
16780 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16781 /* For function parameters with no deducible template parameters,
16782 just return. We'll check non-dependent conversions later. */
16783 return unify_success (explain_p
);
16788 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16789 | UNIFY_ALLOW_MORE_CV_QUAL
16790 | UNIFY_ALLOW_DERIVED
);
16794 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16798 arg_strict
= UNIFY_ALLOW_NONE
;
16802 gcc_unreachable ();
16805 /* We only do these transformations if this is the top-level
16806 parameter_type_list in a call or declaration matching; in other
16807 situations (nested function declarators, template argument lists) we
16808 won't be comparing a type to an expression, and we don't do any type
16814 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16815 if (type_unknown_p (arg
))
16817 /* [temp.deduct.type] A template-argument can be
16818 deduced from a pointer to function or pointer
16819 to member function argument if the set of
16820 overloaded functions does not contain function
16821 templates and at most one of a set of
16822 overloaded functions provides a unique
16825 if (resolve_overloaded_unification
16826 (tparms
, targs
, parm
, arg
, strict
,
16827 arg_strict
, explain_p
))
16828 return unify_success (explain_p
);
16829 return unify_overload_resolution_failure (explain_p
, arg
);
16833 arg
= unlowered_expr_type (arg
);
16834 if (arg
== error_mark_node
)
16835 return unify_invalid (explain_p
);
16839 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16842 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16843 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
16844 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16846 /* For deduction from an init-list we need the actual list. */
16847 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16849 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16852 /* Most parms like fn_type_unification.
16854 If SUBR is 1, we're being called recursively (to unify the
16855 arguments of a function or method parameter of a function
16858 CHECKS is a pointer to a vector of access checks encountered while
16859 substituting default template arguments. */
16862 type_unification_real (tree tparms
,
16866 unsigned int xnargs
,
16868 unification_kind_t strict
,
16870 vec
<deferred_access_check
, va_gc
> **checks
,
16875 int ntparms
= TREE_VEC_LENGTH (tparms
);
16876 int saw_undeduced
= 0;
16879 unsigned int nargs
;
16882 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16883 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16884 gcc_assert (ntparms
> 0);
16886 /* Reset the number of non-defaulted template arguments contained
16888 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16896 while (parms
&& parms
!= void_list_node
16899 parm
= TREE_VALUE (parms
);
16901 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16902 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16903 /* For a function parameter pack that occurs at the end of the
16904 parameter-declaration-list, the type A of each remaining
16905 argument of the call is compared with the type P of the
16906 declarator-id of the function parameter pack. */
16909 parms
= TREE_CHAIN (parms
);
16911 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16912 /* For a function parameter pack that does not occur at the
16913 end of the parameter-declaration-list, the type of the
16914 parameter pack is a non-deduced context. */
16920 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16926 && parms
!= void_list_node
16927 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16929 /* Unify the remaining arguments with the pack expansion type. */
16931 tree parmvec
= make_tree_vec (1);
16933 /* Allocate a TREE_VEC and copy in all of the arguments */
16934 argvec
= make_tree_vec (nargs
- ia
);
16935 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16936 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16938 /* Copy the parameter into parmvec. */
16939 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16940 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16941 /*subr=*/subr
, explain_p
))
16944 /* Advance to the end of the list of parameters. */
16945 parms
= TREE_CHAIN (parms
);
16948 /* Fail if we've reached the end of the parm list, and more args
16949 are present, and the parm list isn't variadic. */
16950 if (ia
< nargs
&& parms
== void_list_node
)
16951 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16952 /* Fail if parms are left and they don't have default values and
16953 they aren't all deduced as empty packs (c++/57397). This is
16954 consistent with sufficient_parms_p. */
16955 if (parms
&& parms
!= void_list_node
16956 && TREE_PURPOSE (parms
) == NULL_TREE
)
16958 unsigned int count
= nargs
;
16963 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
16966 p
= TREE_CHAIN (p
);
16968 while (p
&& p
!= void_list_node
);
16969 if (count
!= nargs
)
16970 return unify_too_few_arguments (explain_p
, ia
, count
,
16976 tsubst_flags_t complain
= (explain_p
16977 ? tf_warning_or_error
16980 for (i
= 0; i
< ntparms
; i
++)
16982 tree targ
= TREE_VEC_ELT (targs
, i
);
16983 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16985 /* Clear the "incomplete" flags on all argument packs now so that
16986 substituting them into later default arguments works. */
16987 if (targ
&& ARGUMENT_PACK_P (targ
))
16989 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16990 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16993 if (targ
|| tparm
== error_mark_node
)
16995 tparm
= TREE_VALUE (tparm
);
16997 /* If this is an undeduced nontype parameter that depends on
16998 a type parameter, try another pass; its type may have been
16999 deduced from a later argument than the one from which
17000 this parameter can be deduced. */
17001 if (TREE_CODE (tparm
) == PARM_DECL
17002 && uses_template_parms (TREE_TYPE (tparm
))
17003 && saw_undeduced
< 2)
17009 /* Core issue #226 (C++0x) [temp.deduct]:
17011 If a template argument has not been deduced, its
17012 default template argument, if any, is used.
17014 When we are in C++98 mode, TREE_PURPOSE will either
17015 be NULL_TREE or ERROR_MARK_NODE, so we do not need
17016 to explicitly check cxx_dialect here. */
17017 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
17018 /* OK, there is a default argument. Wait until after the
17019 conversion check to do substitution. */
17022 /* If the type parameter is a parameter pack, then it will
17023 be deduced to an empty parameter pack. */
17024 if (template_parameter_pack_p (tparm
))
17028 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
17030 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
17031 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
17032 TREE_CONSTANT (arg
) = 1;
17035 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17037 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
17039 TREE_VEC_ELT (targs
, i
) = arg
;
17043 return unify_parameter_deduction_failure (explain_p
, tparm
);
17046 /* DR 1391: All parameters have args, now check non-dependent parms for
17048 if (saw_undeduced
< 2)
17049 for (ia
= 0, parms
= xparms
, args
= xargs
, nargs
= xnargs
;
17050 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
17052 parm
= TREE_VALUE (parms
);
17054 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
17055 && (!TREE_CHAIN (parms
)
17056 || TREE_CHAIN (parms
) == void_list_node
))
17057 /* For a function parameter pack that occurs at the end of the
17058 parameter-declaration-list, the type A of each remaining
17059 argument of the call is compared with the type P of the
17060 declarator-id of the function parameter pack. */
17063 parms
= TREE_CHAIN (parms
);
17065 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
17066 /* For a function parameter pack that does not occur at the
17067 end of the parameter-declaration-list, the type of the
17068 parameter pack is a non-deduced context. */
17074 if (uses_template_parms (parm
))
17076 if (check_non_deducible_conversion (parm
, arg
, strict
, flags
,
17081 /* Now substitute into the default template arguments. */
17082 for (i
= 0; i
< ntparms
; i
++)
17084 tree targ
= TREE_VEC_ELT (targs
, i
);
17085 tree tparm
= TREE_VEC_ELT (tparms
, i
);
17087 if (targ
|| tparm
== error_mark_node
)
17089 tree parm
= TREE_VALUE (tparm
);
17091 if (TREE_CODE (parm
) == PARM_DECL
17092 && uses_template_parms (TREE_TYPE (parm
))
17093 && saw_undeduced
< 2)
17096 tree arg
= TREE_PURPOSE (tparm
);
17097 reopen_deferring_access_checks (*checks
);
17098 location_t save_loc
= input_location
;
17100 input_location
= DECL_SOURCE_LOCATION (parm
);
17101 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
17102 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
17104 input_location
= save_loc
;
17105 *checks
= get_deferred_access_checks ();
17106 pop_deferring_access_checks ();
17107 if (arg
== error_mark_node
)
17111 TREE_VEC_ELT (targs
, i
) = arg
;
17112 /* The position of the first default template argument,
17113 is also the number of non-defaulted arguments in TARGS.
17115 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
17116 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
17121 if (saw_undeduced
++ == 1)
17124 #ifdef ENABLE_CHECKING
17125 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
17126 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
17129 return unify_success (explain_p
);
17132 /* Subroutine of type_unification_real. Args are like the variables
17133 at the call site. ARG is an overloaded function (or template-id);
17134 we try deducing template args from each of the overloads, and if
17135 only one succeeds, we go with that. Modifies TARGS and returns
17136 true on success. */
17139 resolve_overloaded_unification (tree tparms
,
17143 unification_kind_t strict
,
17147 tree tempargs
= copy_node (targs
);
17149 tree goodfn
= NULL_TREE
;
17152 if (TREE_CODE (arg
) == ADDR_EXPR
)
17154 arg
= TREE_OPERAND (arg
, 0);
17160 if (TREE_CODE (arg
) == COMPONENT_REF
)
17161 /* Handle `&x' where `x' is some static or non-static member
17163 arg
= TREE_OPERAND (arg
, 1);
17165 if (TREE_CODE (arg
) == OFFSET_REF
)
17166 arg
= TREE_OPERAND (arg
, 1);
17168 /* Strip baselink information. */
17169 if (BASELINK_P (arg
))
17170 arg
= BASELINK_FUNCTIONS (arg
);
17172 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
17174 /* If we got some explicit template args, we need to plug them into
17175 the affected templates before we try to unify, in case the
17176 explicit args will completely resolve the templates in question. */
17179 tree expl_subargs
= TREE_OPERAND (arg
, 1);
17180 arg
= TREE_OPERAND (arg
, 0);
17182 for (; arg
; arg
= OVL_NEXT (arg
))
17184 tree fn
= OVL_CURRENT (arg
);
17185 tree subargs
, elem
;
17187 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17190 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17191 expl_subargs
, NULL_TREE
, tf_none
,
17192 /*require_all_args=*/true,
17193 /*use_default_args=*/true);
17194 if (subargs
!= error_mark_node
17195 && !any_dependent_template_arguments_p (subargs
))
17197 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
17198 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17199 elem
, strict
, sub_strict
, addr_p
, explain_p
)
17200 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
17209 /* If no templates (or more than one) are fully resolved by the
17210 explicit arguments, this template-id is a non-deduced context; it
17211 could still be OK if we deduce all template arguments for the
17212 enclosing call through other arguments. */
17216 else if (TREE_CODE (arg
) != OVERLOAD
17217 && TREE_CODE (arg
) != FUNCTION_DECL
)
17218 /* If ARG is, for example, "(0, &f)" then its type will be unknown
17219 -- but the deduction does not succeed because the expression is
17220 not just the function on its own. */
17223 for (; arg
; arg
= OVL_NEXT (arg
))
17224 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17225 TREE_TYPE (OVL_CURRENT (arg
)),
17226 strict
, sub_strict
, addr_p
, explain_p
)
17227 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
17229 goodfn
= OVL_CURRENT (arg
);
17233 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17234 to function or pointer to member function argument if the set of
17235 overloaded functions does not contain function templates and at most
17236 one of a set of overloaded functions provides a unique match.
17238 So if we found multiple possibilities, we return success but don't
17239 deduce anything. */
17243 int i
= TREE_VEC_LENGTH (targs
);
17245 if (TREE_VEC_ELT (tempargs
, i
))
17247 tree old
= TREE_VEC_ELT (targs
, i
);
17248 tree new_
= TREE_VEC_ELT (tempargs
, i
);
17249 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
17250 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
17251 /* Don't forget explicit template arguments in a pack. */
17252 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
17253 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
17254 TREE_VEC_ELT (targs
, i
) = new_
;
17263 /* Core DR 115: In contexts where deduction is done and fails, or in
17264 contexts where deduction is not done, if a template argument list is
17265 specified and it, along with any default template arguments, identifies
17266 a single function template specialization, then the template-id is an
17267 lvalue for the function template specialization. */
17270 resolve_nondeduced_context (tree orig_expr
)
17272 tree expr
, offset
, baselink
;
17275 if (!type_unknown_p (orig_expr
))
17280 offset
= NULL_TREE
;
17281 baselink
= NULL_TREE
;
17283 if (TREE_CODE (expr
) == ADDR_EXPR
)
17285 expr
= TREE_OPERAND (expr
, 0);
17288 if (TREE_CODE (expr
) == OFFSET_REF
)
17291 expr
= TREE_OPERAND (expr
, 1);
17293 if (BASELINK_P (expr
))
17296 expr
= BASELINK_FUNCTIONS (expr
);
17299 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
17302 tree goodfn
= NULL_TREE
;
17304 /* If we got some explicit template args, we need to plug them into
17305 the affected templates before we try to unify, in case the
17306 explicit args will completely resolve the templates in question. */
17308 tree expl_subargs
= TREE_OPERAND (expr
, 1);
17309 tree arg
= TREE_OPERAND (expr
, 0);
17310 tree badfn
= NULL_TREE
;
17311 tree badargs
= NULL_TREE
;
17313 for (; arg
; arg
= OVL_NEXT (arg
))
17315 tree fn
= OVL_CURRENT (arg
);
17316 tree subargs
, elem
;
17318 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17321 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17322 expl_subargs
, NULL_TREE
, tf_none
,
17323 /*require_all_args=*/true,
17324 /*use_default_args=*/true);
17325 if (subargs
!= error_mark_node
17326 && !any_dependent_template_arguments_p (subargs
))
17328 elem
= instantiate_template (fn
, subargs
, tf_none
);
17329 if (elem
== error_mark_node
)
17334 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
17343 mark_used (goodfn
);
17346 expr
= build_baselink (BASELINK_BINFO (baselink
),
17347 BASELINK_ACCESS_BINFO (baselink
),
17348 expr
, BASELINK_OPTYPE (baselink
));
17352 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
17353 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
17356 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
17359 else if (good
== 0 && badargs
)
17360 /* There were no good options and at least one bad one, so let the
17361 user know what the problem is. */
17362 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
17367 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17368 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17369 different overloads deduce different arguments for a given parm.
17370 ADDR_P is true if the expression for which deduction is being
17371 performed was of the form "& fn" rather than simply "fn".
17373 Returns 1 on success. */
17376 try_one_overload (tree tparms
,
17381 unification_kind_t strict
,
17390 if (arg
== error_mark_node
)
17393 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17394 to function or pointer to member function argument if the set of
17395 overloaded functions does not contain function templates and at most
17396 one of a set of overloaded functions provides a unique match.
17398 So if this is a template, just return success. */
17400 if (uses_template_parms (arg
))
17403 if (TREE_CODE (arg
) == METHOD_TYPE
)
17404 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
17406 arg
= build_pointer_type (arg
);
17408 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
17410 /* We don't copy orig_targs for this because if we have already deduced
17411 some template args from previous args, unify would complain when we
17412 try to deduce a template parameter for the same argument, even though
17413 there isn't really a conflict. */
17414 nargs
= TREE_VEC_LENGTH (targs
);
17415 tempargs
= make_tree_vec (nargs
);
17417 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
17420 /* First make sure we didn't deduce anything that conflicts with
17421 explicitly specified args. */
17422 for (i
= nargs
; i
--; )
17424 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17425 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17429 else if (uses_template_parms (elt
))
17430 /* Since we're unifying against ourselves, we will fill in
17431 template args used in the function parm list with our own
17432 template parms. Discard them. */
17433 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17434 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17438 for (i
= nargs
; i
--; )
17440 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17443 TREE_VEC_ELT (targs
, i
) = elt
;
17449 /* PARM is a template class (perhaps with unbound template
17450 parameters). ARG is a fully instantiated type. If ARG can be
17451 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17452 TARGS are as for unify. */
17455 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17458 tree copy_of_targs
;
17460 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17461 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17462 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17465 /* We need to make a new template argument vector for the call to
17466 unify. If we used TARGS, we'd clutter it up with the result of
17467 the attempted unification, even if this class didn't work out.
17468 We also don't want to commit ourselves to all the unifications
17469 we've already done, since unification is supposed to be done on
17470 an argument-by-argument basis. In other words, consider the
17471 following pathological case:
17473 template <int I, int J, int K>
17476 template <int I, int J>
17477 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17479 template <int I, int J, int K>
17480 void f(S<I, J, K>, S<I, I, I>);
17489 Now, by the time we consider the unification involving `s2', we
17490 already know that we must have `f<0, 0, 0>'. But, even though
17491 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17492 because there are two ways to unify base classes of S<0, 1, 2>
17493 with S<I, I, I>. If we kept the already deduced knowledge, we
17494 would reject the possibility I=1. */
17495 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17497 /* If unification failed, we're done. */
17498 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17499 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17505 /* Given a template type PARM and a class type ARG, find the unique
17506 base type in ARG that is an instance of PARM. We do not examine
17507 ARG itself; only its base-classes. If there is not exactly one
17508 appropriate base class, return NULL_TREE. PARM may be the type of
17509 a partial specialization, as well as a plain template type. Used
17512 static enum template_base_result
17513 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17514 bool explain_p
, tree
*result
)
17516 tree rval
= NULL_TREE
;
17519 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17521 binfo
= TYPE_BINFO (complete_type (arg
));
17524 /* The type could not be completed. */
17525 *result
= NULL_TREE
;
17526 return tbr_incomplete_type
;
17529 /* Walk in inheritance graph order. The search order is not
17530 important, and this avoids multiple walks of virtual bases. */
17531 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17533 tree r
= try_class_unification (tparms
, targs
, parm
,
17534 BINFO_TYPE (binfo
), explain_p
);
17538 /* If there is more than one satisfactory baseclass, then:
17542 If they yield more than one possible deduced A, the type
17546 if (rval
&& !same_type_p (r
, rval
))
17548 *result
= NULL_TREE
;
17549 return tbr_ambiguous_baseclass
;
17557 return tbr_success
;
17560 /* Returns the level of DECL, which declares a template parameter. */
17563 template_decl_level (tree decl
)
17565 switch (TREE_CODE (decl
))
17568 case TEMPLATE_DECL
:
17569 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17572 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17575 gcc_unreachable ();
17580 /* Decide whether ARG can be unified with PARM, considering only the
17581 cv-qualifiers of each type, given STRICT as documented for unify.
17582 Returns nonzero iff the unification is OK on that basis. */
17585 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17587 int arg_quals
= cp_type_quals (arg
);
17588 int parm_quals
= cp_type_quals (parm
);
17590 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17591 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17593 /* Although a CVR qualifier is ignored when being applied to a
17594 substituted template parameter ([8.3.2]/1 for example), that
17595 does not allow us to unify "const T" with "int&" because both
17596 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17597 It is ok when we're allowing additional CV qualifiers
17598 at the outer level [14.8.2.1]/3,1st bullet. */
17599 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17600 || TREE_CODE (arg
) == FUNCTION_TYPE
17601 || TREE_CODE (arg
) == METHOD_TYPE
)
17602 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17605 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17606 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17610 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17611 && (arg_quals
& parm_quals
) != parm_quals
)
17614 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17615 && (parm_quals
& arg_quals
) != arg_quals
)
17621 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17623 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17625 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17626 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17627 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17629 *index
= TEMPLATE_TYPE_IDX (parm
);
17630 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17634 *index
= TEMPLATE_PARM_IDX (parm
);
17635 *level
= TEMPLATE_PARM_LEVEL (parm
);
17639 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17641 if (unify (TP, TA, P, A, S, EP)) \
17645 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17646 expansion at the end of PACKED_PARMS. Returns 0 if the type
17647 deduction succeeds, 1 otherwise. STRICT is the same as in
17648 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17649 call argument list. We'll need to adjust the arguments to make them
17650 types. SUBR tells us if this is from a recursive call to
17651 type_unification_real, or for comparing two template argument
17655 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17656 tree packed_args
, unification_kind_t strict
,
17657 bool subr
, bool explain_p
)
17660 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17661 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17662 tree pack
, packs
= NULL_TREE
;
17663 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17665 packed_args
= expand_template_argument_pack (packed_args
);
17667 int len
= TREE_VEC_LENGTH (packed_args
);
17669 /* Determine the parameter packs we will be deducing from the
17670 pattern, and record their current deductions. */
17671 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17672 pack
; pack
= TREE_CHAIN (pack
))
17674 tree parm_pack
= TREE_VALUE (pack
);
17677 /* Determine the index and level of this parameter pack. */
17678 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17680 /* Keep track of the parameter packs and their corresponding
17682 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17683 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17686 /* Loop through all of the arguments that have not yet been
17687 unified and unify each with the pattern. */
17688 for (i
= start
; i
< len
; i
++)
17691 bool any_explicit
= false;
17692 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17694 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17695 or the element of its argument pack at the current index if
17696 this argument was explicitly specified. */
17697 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17701 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17704 if (TREE_VALUE (pack
)
17705 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17706 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17708 any_explicit
= true;
17709 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17711 TMPL_ARG (targs
, level
, idx
) = arg
;
17714 /* If we had explicit template arguments, substitute them into the
17715 pattern before deduction. */
17718 /* Some arguments might still be unspecified or dependent. */
17720 ++processing_template_decl
;
17721 dependent
= any_dependent_template_arguments_p (targs
);
17723 --processing_template_decl
;
17724 parm
= tsubst (pattern
, targs
,
17725 explain_p
? tf_warning_or_error
: tf_none
,
17728 --processing_template_decl
;
17729 if (parm
== error_mark_node
)
17735 /* Unify the pattern with the current argument. */
17736 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17740 /* For each parameter pack, collect the deduced value. */
17741 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17744 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17746 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17747 TMPL_ARG (targs
, level
, idx
);
17751 /* Verify that the results of unification with the parameter packs
17752 produce results consistent with what we've seen before, and make
17753 the deduced argument packs available. */
17754 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17756 tree old_pack
= TREE_VALUE (pack
);
17757 tree new_args
= TREE_TYPE (pack
);
17758 int i
, len
= TREE_VEC_LENGTH (new_args
);
17760 bool nondeduced_p
= false;
17762 /* By default keep the original deduced argument pack.
17763 If necessary, more specific code is going to update the
17764 resulting deduced argument later down in this function. */
17765 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17766 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17768 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17769 actually deduce anything. */
17770 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17771 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17772 nondeduced_p
= true;
17776 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17778 /* If we had fewer function args than explicit template args,
17779 just use the explicits. */
17780 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17781 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17782 if (len
< explicit_len
)
17783 new_args
= explicit_args
;
17789 /* Build the deduced *_ARGUMENT_PACK. */
17790 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17792 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17793 TREE_TYPE (result
) =
17794 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17795 TREE_CONSTANT (result
) = 1;
17798 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17800 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17802 /* Note the deduced argument packs for this parameter
17804 TMPL_ARG (targs
, level
, idx
) = result
;
17806 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17807 && (ARGUMENT_PACK_ARGS (old_pack
)
17808 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17810 /* We only had the explicitly-provided arguments before, but
17811 now we have a complete set of arguments. */
17812 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17814 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17815 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17816 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17820 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17821 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17823 if (!comp_template_args_with_info (old_args
, new_args
,
17824 &bad_old_arg
, &bad_new_arg
))
17825 /* Inconsistent unification of this parameter pack. */
17826 return unify_parameter_pack_inconsistent (explain_p
,
17832 return unify_success (explain_p
);
17835 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17836 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17837 parameters and return value are as for unify. */
17840 unify_array_domain (tree tparms
, tree targs
,
17841 tree parm_dom
, tree arg_dom
,
17849 /* Our representation of array types uses "N - 1" as the
17850 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17851 not an integer constant. We cannot unify arbitrarily
17852 complex expressions, so we eliminate the MINUS_EXPRs
17854 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17855 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17858 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17859 parm_max
= TREE_OPERAND (parm_max
, 0);
17861 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17862 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17865 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17866 trying to unify the type of a variable with the type
17867 of a template parameter. For example:
17869 template <unsigned int N>
17870 void f (char (&) [N]);
17877 Here, the type of the ARG will be "int [g(i)]", and
17878 may be a SAVE_EXPR, etc. */
17879 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17880 return unify_vla_arg (explain_p
, arg_dom
);
17881 arg_max
= TREE_OPERAND (arg_max
, 0);
17884 /* If only one of the bounds used a MINUS_EXPR, compensate
17885 by adding one to the other bound. */
17886 if (parm_cst
&& !arg_cst
)
17887 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17891 else if (arg_cst
&& !parm_cst
)
17892 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17897 return unify (tparms
, targs
, parm_max
, arg_max
,
17898 UNIFY_ALLOW_INTEGER
, explain_p
);
17901 /* Deduce the value of template parameters. TPARMS is the (innermost)
17902 set of template parameters to a template. TARGS is the bindings
17903 for those template parameters, as determined thus far; TARGS may
17904 include template arguments for outer levels of template parameters
17905 as well. PARM is a parameter to a template function, or a
17906 subcomponent of that parameter; ARG is the corresponding argument.
17907 This function attempts to match PARM with ARG in a manner
17908 consistent with the existing assignments in TARGS. If more values
17909 are deduced, then TARGS is updated.
17911 Returns 0 if the type deduction succeeds, 1 otherwise. The
17912 parameter STRICT is a bitwise or of the following flags:
17915 Require an exact match between PARM and ARG.
17916 UNIFY_ALLOW_MORE_CV_QUAL:
17917 Allow the deduced ARG to be more cv-qualified (by qualification
17918 conversion) than ARG.
17919 UNIFY_ALLOW_LESS_CV_QUAL:
17920 Allow the deduced ARG to be less cv-qualified than ARG.
17921 UNIFY_ALLOW_DERIVED:
17922 Allow the deduced ARG to be a template base class of ARG,
17923 or a pointer to a template base class of the type pointed to by
17925 UNIFY_ALLOW_INTEGER:
17926 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17927 case for more information.
17928 UNIFY_ALLOW_OUTER_LEVEL:
17929 This is the outermost level of a deduction. Used to determine validity
17930 of qualification conversions. A valid qualification conversion must
17931 have const qualified pointers leading up to the inner type which
17932 requires additional CV quals, except at the outer level, where const
17933 is not required [conv.qual]. It would be normal to set this flag in
17934 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17935 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17936 This is the outermost level of a deduction, and PARM can be more CV
17937 qualified at this point.
17938 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17939 This is the outermost level of a deduction, and PARM can be less CV
17940 qualified at this point. */
17943 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17949 int strict_in
= strict
;
17951 /* I don't think this will do the right thing with respect to types.
17952 But the only case I've seen it in so far has been array bounds, where
17953 signedness is the only information lost, and I think that will be
17955 while (TREE_CODE (parm
) == NOP_EXPR
)
17956 parm
= TREE_OPERAND (parm
, 0);
17958 if (arg
== error_mark_node
)
17959 return unify_invalid (explain_p
);
17960 if (arg
== unknown_type_node
17961 || arg
== init_list_type_node
)
17962 /* We can't deduce anything from this, but we might get all the
17963 template args from other function args. */
17964 return unify_success (explain_p
);
17966 /* If PARM uses template parameters, then we can't bail out here,
17967 even if ARG == PARM, since we won't record unifications for the
17968 template parameters. We might need them if we're trying to
17969 figure out which of two things is more specialized. */
17970 if (arg
== parm
&& !uses_template_parms (parm
))
17971 return unify_success (explain_p
);
17973 /* Handle init lists early, so the rest of the function can assume
17974 we're dealing with a type. */
17975 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17979 tree orig_parm
= parm
;
17981 /* Replace T with std::initializer_list<T> for deduction. */
17982 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17983 && flag_deduce_init_list
)
17984 parm
= listify (parm
);
17986 if (!is_std_init_list (parm
)
17987 && TREE_CODE (parm
) != ARRAY_TYPE
)
17988 /* We can only deduce from an initializer list argument if the
17989 parameter is std::initializer_list or an array; otherwise this
17990 is a non-deduced context. */
17991 return unify_success (explain_p
);
17993 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17994 elttype
= TREE_TYPE (parm
);
17997 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17998 /* Deduction is defined in terms of a single type, so just punt
17999 on the (bizarre) std::initializer_list<T...>. */
18000 if (PACK_EXPANSION_P (elttype
))
18001 return unify_success (explain_p
);
18004 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
18006 int elt_strict
= strict
;
18008 if (elt
== error_mark_node
)
18009 return unify_invalid (explain_p
);
18011 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
18013 tree type
= TREE_TYPE (elt
);
18014 if (type
== error_mark_node
)
18015 return unify_invalid (explain_p
);
18016 /* It should only be possible to get here for a call. */
18017 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
18018 elt_strict
|= maybe_adjust_types_for_deduction
18019 (DEDUCE_CALL
, &elttype
, &type
, elt
);
18023 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
18027 if (TREE_CODE (parm
) == ARRAY_TYPE
18028 && deducible_array_bound (TYPE_DOMAIN (parm
)))
18030 /* Also deduce from the length of the initializer list. */
18031 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
18032 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
18033 if (idx
== error_mark_node
)
18034 return unify_invalid (explain_p
);
18035 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18039 /* If the std::initializer_list<T> deduction worked, replace the
18040 deduced A with std::initializer_list<A>. */
18041 if (orig_parm
!= parm
)
18043 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
18044 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18045 targ
= listify (targ
);
18046 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
18048 return unify_success (explain_p
);
18051 /* Immediately reject some pairs that won't unify because of
18052 cv-qualification mismatches. */
18053 if (TREE_CODE (arg
) == TREE_CODE (parm
)
18055 /* It is the elements of the array which hold the cv quals of an array
18056 type, and the elements might be template type parms. We'll check
18057 when we recurse. */
18058 && TREE_CODE (arg
) != ARRAY_TYPE
18059 /* We check the cv-qualifiers when unifying with template type
18060 parameters below. We want to allow ARG `const T' to unify with
18061 PARM `T' for example, when computing which of two templates
18062 is more specialized, for example. */
18063 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
18064 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
18065 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18067 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
18068 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
18069 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
18070 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
18071 strict
&= ~UNIFY_ALLOW_DERIVED
;
18072 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
18073 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
18075 switch (TREE_CODE (parm
))
18077 case TYPENAME_TYPE
:
18079 case UNBOUND_CLASS_TEMPLATE
:
18080 /* In a type which contains a nested-name-specifier, template
18081 argument values cannot be deduced for template parameters used
18082 within the nested-name-specifier. */
18083 return unify_success (explain_p
);
18085 case TEMPLATE_TYPE_PARM
:
18086 case TEMPLATE_TEMPLATE_PARM
:
18087 case BOUND_TEMPLATE_TEMPLATE_PARM
:
18088 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18089 if (error_operand_p (tparm
))
18090 return unify_invalid (explain_p
);
18092 if (TEMPLATE_TYPE_LEVEL (parm
)
18093 != template_decl_level (tparm
))
18094 /* The PARM is not one we're trying to unify. Just check
18095 to see if it matches ARG. */
18097 if (TREE_CODE (arg
) == TREE_CODE (parm
)
18098 && (is_auto (parm
) ? is_auto (arg
)
18099 : same_type_p (parm
, arg
)))
18100 return unify_success (explain_p
);
18102 return unify_type_mismatch (explain_p
, parm
, arg
);
18104 idx
= TEMPLATE_TYPE_IDX (parm
);
18105 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18106 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
18107 if (error_operand_p (tparm
))
18108 return unify_invalid (explain_p
);
18110 /* Check for mixed types and values. */
18111 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
18112 && TREE_CODE (tparm
) != TYPE_DECL
)
18113 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18114 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
18115 gcc_unreachable ();
18117 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18119 /* ARG must be constructed from a template class or a template
18120 template parameter. */
18121 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
18122 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
18123 return unify_template_deduction_failure (explain_p
, parm
, arg
);
18125 tree parmvec
= TYPE_TI_ARGS (parm
);
18126 /* An alias template name is never deduced. */
18127 if (TYPE_ALIAS_P (arg
))
18128 arg
= strip_typedefs (arg
);
18129 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
18130 tree full_argvec
= add_to_template_args (targs
, argvec
);
18132 = DECL_INNERMOST_TEMPLATE_PARMS
18133 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
18135 int parm_variadic_p
= 0;
18137 /* The resolution to DR150 makes clear that default
18138 arguments for an N-argument may not be used to bind T
18139 to a template template parameter with fewer than N
18140 parameters. It is not safe to permit the binding of
18141 default arguments as an extension, as that may change
18142 the meaning of a conforming program. Consider:
18144 struct Dense { static const unsigned int dim = 1; };
18146 template <template <typename> class View,
18148 void operator+(float, View<Block> const&);
18150 template <typename Block,
18151 unsigned int Dim = Block::dim>
18152 struct Lvalue_proxy { operator float() const; };
18156 Lvalue_proxy<Dense> p;
18161 Here, if Lvalue_proxy is permitted to bind to View, then
18162 the global operator+ will be used; if they are not, the
18163 Lvalue_proxy will be converted to float. */
18164 if (coerce_template_parms (parm_parms
,
18166 TYPE_TI_TEMPLATE (parm
),
18168 ? tf_warning_or_error
18170 /*require_all_args=*/true,
18171 /*use_default_args=*/false)
18172 == error_mark_node
)
18175 /* Deduce arguments T, i from TT<T> or TT<i>.
18176 We check each element of PARMVEC and ARGVEC individually
18177 rather than the whole TREE_VEC since they can have
18178 different number of elements. */
18180 parmvec
= expand_template_argument_pack (parmvec
);
18181 argvec
= expand_template_argument_pack (argvec
);
18183 len
= TREE_VEC_LENGTH (parmvec
);
18185 /* Check if the parameters end in a pack, making them
18188 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
18189 parm_variadic_p
= 1;
18191 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18192 /* If the template argument list of P contains a pack
18193 expansion that is not the last template argument, the
18194 entire template argument list is a non-deduced
18196 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
18197 return unify_success (explain_p
);
18199 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
18200 return unify_too_few_arguments (explain_p
,
18201 TREE_VEC_LENGTH (argvec
), len
);
18203 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18205 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18206 TREE_VEC_ELT (parmvec
, i
),
18207 TREE_VEC_ELT (argvec
, i
),
18208 UNIFY_ALLOW_NONE
, explain_p
);
18211 if (parm_variadic_p
18212 && unify_pack_expansion (tparms
, targs
,
18215 /*subr=*/true, explain_p
))
18218 arg
= TYPE_TI_TEMPLATE (arg
);
18220 /* Fall through to deduce template name. */
18223 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18224 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18226 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
18228 /* Simple cases: Value already set, does match or doesn't. */
18229 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
18230 return unify_success (explain_p
);
18232 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18236 /* If PARM is `const T' and ARG is only `int', we don't have
18237 a match unless we are allowing additional qualification.
18238 If ARG is `const int' and PARM is just `T' that's OK;
18239 that binds `const int' to `T'. */
18240 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
18242 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18244 /* Consider the case where ARG is `const volatile int' and
18245 PARM is `const T'. Then, T should be `volatile int'. */
18246 arg
= cp_build_qualified_type_real
18247 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
18248 if (arg
== error_mark_node
)
18249 return unify_invalid (explain_p
);
18251 /* Simple cases: Value already set, does match or doesn't. */
18252 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
18253 return unify_success (explain_p
);
18255 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18257 /* Make sure that ARG is not a variable-sized array. (Note
18258 that were talking about variable-sized arrays (like
18259 `int[n]'), rather than arrays of unknown size (like
18260 `int[]').) We'll get very confused by such a type since
18261 the bound of the array is not constant, and therefore
18262 not mangleable. Besides, such types are not allowed in
18263 ISO C++, so we can do as we please here. We do allow
18264 them for 'auto' deduction, since that isn't ABI-exposed. */
18265 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
18266 return unify_vla_arg (explain_p
, arg
);
18268 /* Strip typedefs as in convert_template_argument. */
18269 arg
= canonicalize_type_argument (arg
, tf_none
);
18272 /* If ARG is a parameter pack or an expansion, we cannot unify
18273 against it unless PARM is also a parameter pack. */
18274 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18275 && !template_parameter_pack_p (parm
))
18276 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18278 /* If the argument deduction results is a METHOD_TYPE,
18279 then there is a problem.
18280 METHOD_TYPE doesn't map to any real C++ type the result of
18281 the deduction can not be of that type. */
18282 if (TREE_CODE (arg
) == METHOD_TYPE
)
18283 return unify_method_type_error (explain_p
, arg
);
18285 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18286 return unify_success (explain_p
);
18288 case TEMPLATE_PARM_INDEX
:
18289 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18290 if (error_operand_p (tparm
))
18291 return unify_invalid (explain_p
);
18293 if (TEMPLATE_PARM_LEVEL (parm
)
18294 != template_decl_level (tparm
))
18296 /* The PARM is not one we're trying to unify. Just check
18297 to see if it matches ARG. */
18298 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
18299 && cp_tree_equal (parm
, arg
));
18301 unify_expression_unequal (explain_p
, parm
, arg
);
18305 idx
= TEMPLATE_PARM_IDX (parm
);
18306 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18310 int x
= !cp_tree_equal (targ
, arg
);
18312 unify_inconsistency (explain_p
, parm
, targ
, arg
);
18316 /* [temp.deduct.type] If, in the declaration of a function template
18317 with a non-type template-parameter, the non-type
18318 template-parameter is used in an expression in the function
18319 parameter-list and, if the corresponding template-argument is
18320 deduced, the template-argument type shall match the type of the
18321 template-parameter exactly, except that a template-argument
18322 deduced from an array bound may be of any integral type.
18323 The non-type parameter might use already deduced type parameters. */
18324 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
18325 if (!TREE_TYPE (arg
))
18326 /* Template-parameter dependent expression. Just accept it for now.
18327 It will later be processed in convert_template_argument. */
18329 else if (same_type_p (TREE_TYPE (arg
), tparm
))
18331 else if ((strict
& UNIFY_ALLOW_INTEGER
)
18332 && CP_INTEGRAL_TYPE_P (tparm
))
18333 /* Convert the ARG to the type of PARM; the deduced non-type
18334 template argument must exactly match the types of the
18335 corresponding parameter. */
18336 arg
= fold (build_nop (tparm
, arg
));
18337 else if (uses_template_parms (tparm
))
18338 /* We haven't deduced the type of this parameter yet. Try again
18340 return unify_success (explain_p
);
18342 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
18344 /* If ARG is a parameter pack or an expansion, we cannot unify
18345 against it unless PARM is also a parameter pack. */
18346 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18347 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
18348 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18351 bool removed_attr
= false;
18352 arg
= strip_typedefs_expr (arg
, &removed_attr
);
18354 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18355 return unify_success (explain_p
);
18359 /* A pointer-to-member constant can be unified only with
18360 another constant. */
18361 if (TREE_CODE (arg
) != PTRMEM_CST
)
18362 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
18364 /* Just unify the class member. It would be useless (and possibly
18365 wrong, depending on the strict flags) to unify also
18366 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18367 arg refer to the same variable, even if through different
18368 classes. For instance:
18370 struct A { int x; };
18373 Unification of &A::x and &B::x must succeed. */
18374 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
18375 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
18380 if (!TYPE_PTR_P (arg
))
18381 return unify_type_mismatch (explain_p
, parm
, arg
);
18383 /* [temp.deduct.call]
18385 A can be another pointer or pointer to member type that can
18386 be converted to the deduced A via a qualification
18387 conversion (_conv.qual_).
18389 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18390 This will allow for additional cv-qualification of the
18391 pointed-to types if appropriate. */
18393 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
18394 /* The derived-to-base conversion only persists through one
18395 level of pointers. */
18396 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
18398 return unify (tparms
, targs
, TREE_TYPE (parm
),
18399 TREE_TYPE (arg
), strict
, explain_p
);
18402 case REFERENCE_TYPE
:
18403 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
18404 return unify_type_mismatch (explain_p
, parm
, arg
);
18405 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18406 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18409 if (TREE_CODE (arg
) != ARRAY_TYPE
)
18410 return unify_type_mismatch (explain_p
, parm
, arg
);
18411 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
18412 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
18413 return unify_type_mismatch (explain_p
, parm
, arg
);
18414 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18415 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18416 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
18417 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18418 TYPE_DOMAIN (arg
), explain_p
);
18419 return unify_success (explain_p
);
18426 case ENUMERAL_TYPE
:
18429 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18430 return unify_type_mismatch (explain_p
, parm
, arg
);
18432 /* We have already checked cv-qualification at the top of the
18434 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
18435 return unify_type_mismatch (explain_p
, parm
, arg
);
18437 /* As far as unification is concerned, this wins. Later checks
18438 will invalidate it if necessary. */
18439 return unify_success (explain_p
);
18441 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18442 /* Type INTEGER_CST can come from ordinary constant template args. */
18444 while (TREE_CODE (arg
) == NOP_EXPR
)
18445 arg
= TREE_OPERAND (arg
, 0);
18447 if (TREE_CODE (arg
) != INTEGER_CST
)
18448 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18449 return (tree_int_cst_equal (parm
, arg
)
18450 ? unify_success (explain_p
)
18451 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18455 int i
, len
, argslen
;
18456 int parm_variadic_p
= 0;
18458 if (TREE_CODE (arg
) != TREE_VEC
)
18459 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18461 len
= TREE_VEC_LENGTH (parm
);
18462 argslen
= TREE_VEC_LENGTH (arg
);
18464 /* Check for pack expansions in the parameters. */
18465 for (i
= 0; i
< len
; ++i
)
18467 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18470 /* We can unify against something with a trailing
18472 parm_variadic_p
= 1;
18474 /* [temp.deduct.type]/9: If the template argument list of
18475 P contains a pack expansion that is not the last
18476 template argument, the entire template argument list
18477 is a non-deduced context. */
18478 return unify_success (explain_p
);
18482 /* If we don't have enough arguments to satisfy the parameters
18483 (not counting the pack expression at the end), or we have
18484 too many arguments for a parameter list that doesn't end in
18485 a pack expression, we can't unify. */
18486 if (parm_variadic_p
18487 ? argslen
< len
- parm_variadic_p
18489 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18491 /* Unify all of the parameters that precede the (optional)
18492 pack expression. */
18493 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18495 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18496 TREE_VEC_ELT (parm
, i
),
18497 TREE_VEC_ELT (arg
, i
),
18498 UNIFY_ALLOW_NONE
, explain_p
);
18500 if (parm_variadic_p
)
18501 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18503 /*subr=*/true, explain_p
);
18504 return unify_success (explain_p
);
18509 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18510 return unify_type_mismatch (explain_p
, parm
, arg
);
18512 if (TYPE_PTRMEMFUNC_P (parm
))
18514 if (!TYPE_PTRMEMFUNC_P (arg
))
18515 return unify_type_mismatch (explain_p
, parm
, arg
);
18517 return unify (tparms
, targs
,
18518 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18519 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18520 strict
, explain_p
);
18522 else if (TYPE_PTRMEMFUNC_P (arg
))
18523 return unify_type_mismatch (explain_p
, parm
, arg
);
18525 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18527 tree t
= NULL_TREE
;
18529 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18531 /* First, we try to unify the PARM and ARG directly. */
18532 t
= try_class_unification (tparms
, targs
,
18533 parm
, arg
, explain_p
);
18537 /* Fallback to the special case allowed in
18538 [temp.deduct.call]:
18540 If P is a class, and P has the form
18541 template-id, then A can be a derived class of
18542 the deduced A. Likewise, if P is a pointer to
18543 a class of the form template-id, A can be a
18544 pointer to a derived class pointed to by the
18546 enum template_base_result r
;
18547 r
= get_template_base (tparms
, targs
, parm
, arg
,
18551 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18554 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18555 && (CLASSTYPE_TI_TEMPLATE (parm
)
18556 == CLASSTYPE_TI_TEMPLATE (arg
)))
18557 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18558 Then, we should unify `int' and `U'. */
18561 /* There's no chance of unification succeeding. */
18562 return unify_type_mismatch (explain_p
, parm
, arg
);
18564 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18565 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18567 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18568 return unify_type_mismatch (explain_p
, parm
, arg
);
18569 return unify_success (explain_p
);
18572 case FUNCTION_TYPE
:
18574 unsigned int nargs
;
18579 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18580 return unify_type_mismatch (explain_p
, parm
, arg
);
18582 /* CV qualifications for methods can never be deduced, they must
18583 match exactly. We need to check them explicitly here,
18584 because type_unification_real treats them as any other
18585 cv-qualified parameter. */
18586 if (TREE_CODE (parm
) == METHOD_TYPE
18587 && (!check_cv_quals_for_unify
18589 class_of_this_parm (arg
),
18590 class_of_this_parm (parm
))))
18591 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18593 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18594 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18596 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18597 args
= XALLOCAVEC (tree
, nargs
);
18598 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18599 a
!= NULL_TREE
&& a
!= void_list_node
;
18600 a
= TREE_CHAIN (a
), ++i
)
18601 args
[i
] = TREE_VALUE (a
);
18604 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18605 args
, nargs
, 1, DEDUCE_EXACT
,
18606 LOOKUP_NORMAL
, NULL
, explain_p
);
18610 /* Unify a pointer to member with a pointer to member function, which
18611 deduces the type of the member as a function type. */
18612 if (TYPE_PTRMEMFUNC_P (arg
))
18614 /* Check top-level cv qualifiers */
18615 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18616 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18618 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18619 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18620 UNIFY_ALLOW_NONE
, explain_p
);
18622 /* Determine the type of the function we are unifying against. */
18623 tree fntype
= static_fn_type (arg
);
18625 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18628 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18629 return unify_type_mismatch (explain_p
, parm
, arg
);
18630 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18631 TYPE_OFFSET_BASETYPE (arg
),
18632 UNIFY_ALLOW_NONE
, explain_p
);
18633 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18634 strict
, explain_p
);
18637 if (DECL_TEMPLATE_PARM_P (parm
))
18638 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18639 if (arg
!= scalar_constant_value (parm
))
18640 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18641 return unify_success (explain_p
);
18644 case TEMPLATE_DECL
:
18645 /* Matched cases are handled by the ARG == PARM test above. */
18646 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18649 /* A non-type template parameter that is a variable should be a
18650 an integral constant, in which case, it whould have been
18651 folded into its (constant) value. So we should not be getting
18652 a variable here. */
18653 gcc_unreachable ();
18655 case TYPE_ARGUMENT_PACK
:
18656 case NONTYPE_ARGUMENT_PACK
:
18657 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18658 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18661 case DECLTYPE_TYPE
:
18662 case UNDERLYING_TYPE
:
18663 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18664 or UNDERLYING_TYPE nodes. */
18665 return unify_success (explain_p
);
18668 /* Unification fails if we hit an error node. */
18669 return unify_invalid (explain_p
);
18672 if (REFERENCE_REF_P (parm
))
18674 if (REFERENCE_REF_P (arg
))
18675 arg
= TREE_OPERAND (arg
, 0);
18676 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18677 strict
, explain_p
);
18682 /* An unresolved overload is a nondeduced context. */
18683 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18684 return unify_success (explain_p
);
18685 gcc_assert (EXPR_P (parm
));
18687 /* We must be looking at an expression. This can happen with
18691 void foo(S<I>, S<I + 2>);
18693 This is a "nondeduced context":
18697 The nondeduced contexts are:
18699 --A type that is a template-id in which one or more of
18700 the template-arguments is an expression that references
18701 a template-parameter.
18703 In these cases, we assume deduction succeeded, but don't
18704 actually infer any unifications. */
18706 if (!uses_template_parms (parm
)
18707 && !template_args_equal (parm
, arg
))
18708 return unify_expression_unequal (explain_p
, parm
, arg
);
18710 return unify_success (explain_p
);
18713 #undef RECUR_AND_CHECK_FAILURE
18715 /* Note that DECL can be defined in this translation unit, if
18719 mark_definable (tree decl
)
18722 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18723 FOR_EACH_CLONE (clone
, decl
)
18724 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18727 /* Called if RESULT is explicitly instantiated, or is a member of an
18728 explicitly instantiated class. */
18731 mark_decl_instantiated (tree result
, int extern_p
)
18733 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18735 /* If this entity has already been written out, it's too late to
18736 make any modifications. */
18737 if (TREE_ASM_WRITTEN (result
))
18740 /* For anonymous namespace we don't need to do anything. */
18741 if (decl_anon_ns_mem_p (result
))
18743 gcc_assert (!TREE_PUBLIC (result
));
18747 if (TREE_CODE (result
) != FUNCTION_DECL
)
18748 /* The TREE_PUBLIC flag for function declarations will have been
18749 set correctly by tsubst. */
18750 TREE_PUBLIC (result
) = 1;
18752 /* This might have been set by an earlier implicit instantiation. */
18753 DECL_COMDAT (result
) = 0;
18756 DECL_NOT_REALLY_EXTERN (result
) = 0;
18759 mark_definable (result
);
18760 mark_needed (result
);
18761 /* Always make artificials weak. */
18762 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18763 comdat_linkage (result
);
18764 /* For WIN32 we also want to put explicit instantiations in
18765 linkonce sections. */
18766 else if (TREE_PUBLIC (result
))
18767 maybe_make_one_only (result
);
18770 /* If EXTERN_P, then this function will not be emitted -- unless
18771 followed by an explicit instantiation, at which point its linkage
18772 will be adjusted. If !EXTERN_P, then this function will be
18773 emitted here. In neither circumstance do we want
18774 import_export_decl to adjust the linkage. */
18775 DECL_INTERFACE_KNOWN (result
) = 1;
18778 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18779 important template arguments. If any are missing, we check whether
18780 they're important by using error_mark_node for substituting into any
18781 args that were used for partial ordering (the ones between ARGS and END)
18782 and seeing if it bubbles up. */
18785 check_undeduced_parms (tree targs
, tree args
, tree end
)
18787 bool found
= false;
18789 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18790 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18793 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18797 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18798 if (substed
== error_mark_node
)
18804 /* Given two function templates PAT1 and PAT2, return:
18806 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18807 -1 if PAT2 is more specialized than PAT1.
18808 0 if neither is more specialized.
18810 LEN indicates the number of parameters we should consider
18811 (defaulted parameters should not be considered).
18813 The 1998 std underspecified function template partial ordering, and
18814 DR214 addresses the issue. We take pairs of arguments, one from
18815 each of the templates, and deduce them against each other. One of
18816 the templates will be more specialized if all the *other*
18817 template's arguments deduce against its arguments and at least one
18818 of its arguments *does* *not* deduce against the other template's
18819 corresponding argument. Deduction is done as for class templates.
18820 The arguments used in deduction have reference and top level cv
18821 qualifiers removed. Iff both arguments were originally reference
18822 types *and* deduction succeeds in both directions, an lvalue reference
18823 wins against an rvalue reference and otherwise the template
18824 with the more cv-qualified argument wins for that pairing (if
18825 neither is more cv-qualified, they both are equal). Unlike regular
18826 deduction, after all the arguments have been deduced in this way,
18827 we do *not* verify the deduced template argument values can be
18828 substituted into non-deduced contexts.
18830 The logic can be a bit confusing here, because we look at deduce1 and
18831 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18832 can find template arguments for pat1 to make arg1 look like arg2, that
18833 means that arg2 is at least as specialized as arg1. */
18836 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18838 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18839 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18840 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18841 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18842 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18843 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18844 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18845 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18846 tree origs1
, origs2
;
18847 bool lose1
= false;
18848 bool lose2
= false;
18850 /* Remove the this parameter from non-static member functions. If
18851 one is a non-static member function and the other is not a static
18852 member function, remove the first parameter from that function
18853 also. This situation occurs for operator functions where we
18854 locate both a member function (with this pointer) and non-member
18855 operator (with explicit first operand). */
18856 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18858 len
--; /* LEN is the number of significant arguments for DECL1 */
18859 args1
= TREE_CHAIN (args1
);
18860 if (!DECL_STATIC_FUNCTION_P (decl2
))
18861 args2
= TREE_CHAIN (args2
);
18863 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18865 args2
= TREE_CHAIN (args2
);
18866 if (!DECL_STATIC_FUNCTION_P (decl1
))
18869 args1
= TREE_CHAIN (args1
);
18873 /* If only one is a conversion operator, they are unordered. */
18874 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18877 /* Consider the return type for a conversion function */
18878 if (DECL_CONV_FN_P (decl1
))
18880 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18881 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18885 processing_template_decl
++;
18891 /* Stop when an ellipsis is seen. */
18892 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18894 tree arg1
= TREE_VALUE (args1
);
18895 tree arg2
= TREE_VALUE (args2
);
18896 int deduce1
, deduce2
;
18902 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18903 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18905 /* When both arguments are pack expansions, we need only
18906 unify the patterns themselves. */
18907 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18908 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18910 /* This is the last comparison we need to do. */
18914 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18916 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18917 arg1
= TREE_TYPE (arg1
);
18918 quals1
= cp_type_quals (arg1
);
18921 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18923 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18924 arg2
= TREE_TYPE (arg2
);
18925 quals2
= cp_type_quals (arg2
);
18928 arg1
= TYPE_MAIN_VARIANT (arg1
);
18929 arg2
= TYPE_MAIN_VARIANT (arg2
);
18931 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18933 int i
, len2
= list_length (args2
);
18934 tree parmvec
= make_tree_vec (1);
18935 tree argvec
= make_tree_vec (len2
);
18938 /* Setup the parameter vector, which contains only ARG1. */
18939 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18941 /* Setup the argument vector, which contains the remaining
18943 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18944 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18946 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18947 argvec
, DEDUCE_EXACT
,
18948 /*subr=*/true, /*explain_p=*/false)
18951 /* We cannot deduce in the other direction, because ARG1 is
18952 a pack expansion but ARG2 is not. */
18955 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18957 int i
, len1
= list_length (args1
);
18958 tree parmvec
= make_tree_vec (1);
18959 tree argvec
= make_tree_vec (len1
);
18962 /* Setup the parameter vector, which contains only ARG1. */
18963 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18965 /* Setup the argument vector, which contains the remaining
18967 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18968 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18970 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18971 argvec
, DEDUCE_EXACT
,
18972 /*subr=*/true, /*explain_p=*/false)
18975 /* We cannot deduce in the other direction, because ARG2 is
18976 a pack expansion but ARG1 is not.*/
18982 /* The normal case, where neither argument is a pack
18984 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18985 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18987 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18988 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18992 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18993 arg2, then arg2 is not as specialized as arg1. */
18999 /* "If, for a given type, deduction succeeds in both directions
19000 (i.e., the types are identical after the transformations above)
19001 and both P and A were reference types (before being replaced with
19002 the type referred to above):
19003 - if the type from the argument template was an lvalue reference and
19004 the type from the parameter template was not, the argument type is
19005 considered to be more specialized than the other; otherwise,
19006 - if the type from the argument template is more cv-qualified
19007 than the type from the parameter template (as described above),
19008 the argument type is considered to be more specialized than the other;
19010 - neither type is more specialized than the other." */
19012 if (deduce1
&& deduce2
)
19014 if (ref1
&& ref2
&& ref1
!= ref2
)
19021 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
19023 if ((quals1
& quals2
) == quals2
)
19025 if ((quals1
& quals2
) == quals1
)
19030 if (lose1
&& lose2
)
19031 /* We've failed to deduce something in either direction.
19032 These must be unordered. */
19035 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
19036 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
19037 /* We have already processed all of the arguments in our
19038 handing of the pack expansion type. */
19041 args1
= TREE_CHAIN (args1
);
19042 args2
= TREE_CHAIN (args2
);
19045 /* "In most cases, all template parameters must have values in order for
19046 deduction to succeed, but for partial ordering purposes a template
19047 parameter may remain without a value provided it is not used in the
19048 types being used for partial ordering."
19050 Thus, if we are missing any of the targs1 we need to substitute into
19051 origs1, then pat2 is not as specialized as pat1. This can happen when
19052 there is a nondeduced context. */
19053 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
19055 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
19058 processing_template_decl
--;
19060 /* All things being equal, if the next argument is a pack expansion
19061 for one function but not for the other, prefer the
19062 non-variadic function. FIXME this is bogus; see c++/41958. */
19064 && args1
&& TREE_VALUE (args1
)
19065 && args2
&& TREE_VALUE (args2
))
19067 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
19068 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
19071 if (lose1
== lose2
)
19079 /* Determine which of two partial specializations of TMPL is more
19082 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
19083 to the first partial specialization. The TREE_PURPOSE is the
19084 innermost set of template parameters for the partial
19085 specialization. PAT2 is similar, but for the second template.
19087 Return 1 if the first partial specialization is more specialized;
19088 -1 if the second is more specialized; 0 if neither is more
19091 See [temp.class.order] for information about determining which of
19092 two templates is more specialized. */
19095 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
19099 bool any_deductions
= false;
19101 tree tmpl1
= TREE_VALUE (pat1
);
19102 tree tmpl2
= TREE_VALUE (pat2
);
19103 tree parms1
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl1
);
19104 tree parms2
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl2
);
19105 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
19106 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
19108 /* Just like what happens for functions, if we are ordering between
19109 different template specializations, we may encounter dependent
19110 types in the arguments, and we need our dependency check functions
19111 to behave correctly. */
19112 ++processing_template_decl
;
19113 targs
= get_partial_spec_bindings (tmpl
, parms1
, specargs1
, specargs2
);
19117 any_deductions
= true;
19120 targs
= get_partial_spec_bindings (tmpl
, parms2
, specargs2
, specargs1
);
19124 any_deductions
= true;
19126 --processing_template_decl
;
19128 /* In the case of a tie where at least one of the templates
19129 has a parameter pack at the end, the template with the most
19130 non-packed parameters wins. */
19133 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
19134 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
19136 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
19137 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
19138 int len1
= TREE_VEC_LENGTH (args1
);
19139 int len2
= TREE_VEC_LENGTH (args2
);
19141 /* We don't count the pack expansion at the end. */
19142 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
19144 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
19149 else if (len1
< len2
)
19156 /* Return the template arguments that will produce the function signature
19157 DECL from the function template FN, with the explicit template
19158 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
19159 also match. Return NULL_TREE if no satisfactory arguments could be
19163 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
19165 int ntparms
= DECL_NTPARMS (fn
);
19166 tree targs
= make_tree_vec (ntparms
);
19167 tree decl_type
= TREE_TYPE (decl
);
19168 tree decl_arg_types
;
19170 unsigned int nargs
, ix
;
19173 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
19175 /* Never do unification on the 'this' parameter. */
19176 decl_arg_types
= skip_artificial_parms_for (decl
,
19177 TYPE_ARG_TYPES (decl_type
));
19179 nargs
= list_length (decl_arg_types
);
19180 args
= XALLOCAVEC (tree
, nargs
);
19181 for (arg
= decl_arg_types
, ix
= 0;
19182 arg
!= NULL_TREE
&& arg
!= void_list_node
;
19183 arg
= TREE_CHAIN (arg
), ++ix
)
19184 args
[ix
] = TREE_VALUE (arg
);
19186 if (fn_type_unification (fn
, explicit_args
, targs
,
19188 (check_rettype
|| DECL_CONV_FN_P (fn
)
19189 ? TREE_TYPE (decl_type
) : NULL_TREE
),
19190 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
19192 == error_mark_node
)
19198 /* Return the innermost template arguments that, when applied to a partial
19199 specialization of TMPL whose innermost template parameters are
19200 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
19203 For example, suppose we have:
19205 template <class T, class U> struct S {};
19206 template <class T> struct S<T*, int> {};
19208 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
19209 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
19210 int}. The resulting vector will be {double}, indicating that `T'
19211 is bound to `double'. */
19214 get_partial_spec_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
19216 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
19218 tree innermost_deduced_args
;
19220 innermost_deduced_args
= make_tree_vec (ntparms
);
19221 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19223 deduced_args
= copy_node (args
);
19224 SET_TMPL_ARGS_LEVEL (deduced_args
,
19225 TMPL_ARGS_DEPTH (deduced_args
),
19226 innermost_deduced_args
);
19229 deduced_args
= innermost_deduced_args
;
19231 if (unify (tparms
, deduced_args
,
19232 INNERMOST_TEMPLATE_ARGS (spec_args
),
19233 INNERMOST_TEMPLATE_ARGS (args
),
19234 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
19237 for (i
= 0; i
< ntparms
; ++i
)
19238 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
19241 /* Verify that nondeduced template arguments agree with the type
19242 obtained from argument deduction.
19246 struct A { typedef int X; };
19247 template <class T, class U> struct C {};
19248 template <class T> struct C<T, typename T::X> {};
19250 Then with the instantiation `C<A, int>', we can deduce that
19251 `T' is `A' but unify () does not check whether `typename T::X'
19253 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
19254 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19256 tf_none
, false, false);
19257 if (spec_args
== error_mark_node
19258 /* We only need to check the innermost arguments; the other
19259 arguments will always agree. */
19260 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
19261 INNERMOST_TEMPLATE_ARGS (args
)))
19264 /* Now that we have bindings for all of the template arguments,
19265 ensure that the arguments deduced for the template template
19266 parameters have compatible template parameter lists. See the use
19267 of template_template_parm_bindings_ok_p in fn_type_unification
19268 for more information. */
19269 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
19272 return deduced_args
;
19275 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19276 Return the TREE_LIST node with the most specialized template, if
19277 any. If there is no most specialized template, the error_mark_node
19280 Note that this function does not look at, or modify, the
19281 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19282 returned is one of the elements of INSTANTIATIONS, callers may
19283 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19284 and retrieve it from the value returned. */
19287 most_specialized_instantiation (tree templates
)
19291 ++processing_template_decl
;
19294 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
19298 if (get_bindings (TREE_VALUE (champ
),
19299 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19300 NULL_TREE
, /*check_ret=*/true))
19303 if (get_bindings (TREE_VALUE (fn
),
19304 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19305 NULL_TREE
, /*check_ret=*/true))
19312 /* Equally specialized, move to next function. If there
19313 is no next function, nothing's most specialized. */
19314 fn
= TREE_CHAIN (fn
);
19322 /* Now verify that champ is better than everything earlier in the
19323 instantiation list. */
19324 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
19325 if (get_bindings (TREE_VALUE (champ
),
19326 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19327 NULL_TREE
, /*check_ret=*/true)
19328 || !get_bindings (TREE_VALUE (fn
),
19329 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19330 NULL_TREE
, /*check_ret=*/true))
19336 processing_template_decl
--;
19339 return error_mark_node
;
19344 /* If DECL is a specialization of some template, return the most
19345 general such template. Otherwise, returns NULL_TREE.
19347 For example, given:
19349 template <class T> struct S { template <class U> void f(U); };
19351 if TMPL is `template <class U> void S<int>::f(U)' this will return
19352 the full template. This function will not trace past partial
19353 specializations, however. For example, given in addition:
19355 template <class T> struct S<T*> { template <class U> void f(U); };
19357 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19358 `template <class T> template <class U> S<T*>::f(U)'. */
19361 most_general_template (tree decl
)
19363 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19365 if (tree tinfo
= get_template_info (decl
))
19366 decl
= TI_TEMPLATE (tinfo
);
19367 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19368 template friend, or a FIELD_DECL for a capture pack. */
19369 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19373 /* Look for more and more general templates. */
19374 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
19376 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19377 (See cp-tree.h for details.) */
19378 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
19381 if (CLASS_TYPE_P (TREE_TYPE (decl
))
19382 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
19383 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
19386 /* Stop if we run into an explicitly specialized class template. */
19387 if (!DECL_NAMESPACE_SCOPE_P (decl
)
19388 && DECL_CONTEXT (decl
)
19389 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
19392 decl
= DECL_TI_TEMPLATE (decl
);
19398 /* Return the most specialized of the template partial specializations
19399 which can produce TARGET, a specialization of some class or variable
19400 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
19401 a TEMPLATE_DECL node corresponding to the partial specialization, while
19402 the TREE_PURPOSE is the set of template arguments that must be
19403 substituted into the template pattern in order to generate TARGET.
19405 If the choice of partial specialization is ambiguous, a diagnostic
19406 is issued, and the error_mark_node is returned. If there are no
19407 partial specializations matching TARGET, then NULL_TREE is
19408 returned, indicating that the primary template should be used. */
19411 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
19413 tree list
= NULL_TREE
;
19418 tree outer_args
= NULL_TREE
;
19421 if (TYPE_P (target
))
19423 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
19424 tmpl
= TI_TEMPLATE (tinfo
);
19425 args
= TI_ARGS (tinfo
);
19427 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
19429 tmpl
= TREE_OPERAND (target
, 0);
19430 args
= TREE_OPERAND (target
, 1);
19432 else if (VAR_P (target
))
19434 tree tinfo
= DECL_TEMPLATE_INFO (target
);
19435 tmpl
= TI_TEMPLATE (tinfo
);
19436 args
= TI_ARGS (tinfo
);
19439 gcc_unreachable ();
19441 tree main_tmpl
= most_general_template (tmpl
);
19443 /* For determining which partial specialization to use, only the
19444 innermost args are interesting. */
19445 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19447 outer_args
= strip_innermost_template_args (args
, 1);
19448 args
= INNERMOST_TEMPLATE_ARGS (args
);
19451 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
19453 tree partial_spec_args
;
19455 tree spec_tmpl
= TREE_VALUE (t
);
19457 partial_spec_args
= TREE_PURPOSE (t
);
19459 ++processing_template_decl
;
19463 /* Discard the outer levels of args, and then substitute in the
19464 template args from the enclosing class. */
19465 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19466 partial_spec_args
= tsubst_template_args
19467 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19469 /* And the same for the partial specialization TEMPLATE_DECL. */
19470 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19473 partial_spec_args
=
19474 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19477 /*require_all_args=*/true,
19478 /*use_default_args=*/true);
19480 --processing_template_decl
;
19482 if (partial_spec_args
== error_mark_node
)
19483 return error_mark_node
;
19484 if (spec_tmpl
== error_mark_node
)
19485 return error_mark_node
;
19487 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19488 spec_args
= get_partial_spec_bindings (tmpl
, parms
,
19494 spec_args
= add_to_template_args (outer_args
, spec_args
);
19495 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
19496 TREE_TYPE (list
) = TREE_TYPE (t
);
19503 ambiguous_p
= false;
19506 t
= TREE_CHAIN (t
);
19507 for (; t
; t
= TREE_CHAIN (t
))
19509 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19516 t
= TREE_CHAIN (t
);
19519 ambiguous_p
= true;
19528 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19530 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19533 ambiguous_p
= true;
19541 char *spaces
= NULL
;
19542 if (!(complain
& tf_error
))
19543 return error_mark_node
;
19544 if (TYPE_P (target
))
19545 error ("ambiguous template instantiation for %q#T", target
);
19547 error ("ambiguous template instantiation for %q#D", target
);
19548 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19549 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19551 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
19552 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
19553 "%s %#S", spaces
? spaces
: str
, subst
);
19554 spaces
= spaces
? spaces
: get_spaces (str
);
19557 return error_mark_node
;
19563 /* Explicitly instantiate DECL. */
19566 do_decl_instantiation (tree decl
, tree storage
)
19568 tree result
= NULL_TREE
;
19571 if (!decl
|| decl
== error_mark_node
)
19572 /* An error occurred, for which grokdeclarator has already issued
19573 an appropriate message. */
19575 else if (! DECL_LANG_SPECIFIC (decl
))
19577 error ("explicit instantiation of non-template %q#D", decl
);
19581 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
19582 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
19584 if (VAR_P (decl
) && !var_templ
)
19586 /* There is an asymmetry here in the way VAR_DECLs and
19587 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19588 the latter, the DECL we get back will be marked as a
19589 template instantiation, and the appropriate
19590 DECL_TEMPLATE_INFO will be set up. This does not happen for
19591 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19592 should handle VAR_DECLs as it currently handles
19594 if (!DECL_CLASS_SCOPE_P (decl
))
19596 error ("%qD is not a static data member of a class template", decl
);
19599 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19600 if (!result
|| !VAR_P (result
))
19602 error ("no matching template for %qD found", decl
);
19605 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19607 error ("type %qT for explicit instantiation %qD does not match "
19608 "declared type %qT", TREE_TYPE (result
), decl
,
19613 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
19615 error ("explicit instantiation of %q#D", decl
);
19621 /* Check for various error cases. Note that if the explicit
19622 instantiation is valid the RESULT will currently be marked as an
19623 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19624 until we get here. */
19626 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19628 /* DR 259 [temp.spec].
19630 Both an explicit instantiation and a declaration of an explicit
19631 specialization shall not appear in a program unless the explicit
19632 instantiation follows a declaration of the explicit specialization.
19634 For a given set of template parameters, if an explicit
19635 instantiation of a template appears after a declaration of an
19636 explicit specialization for that template, the explicit
19637 instantiation has no effect. */
19640 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19644 No program shall explicitly instantiate any template more
19647 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19648 the first instantiation was `extern' and the second is not,
19649 and EXTERN_P for the opposite case. */
19650 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19651 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19652 /* If an "extern" explicit instantiation follows an ordinary
19653 explicit instantiation, the template is instantiated. */
19657 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19659 error ("no matching template for %qD found", result
);
19662 else if (!DECL_TEMPLATE_INFO (result
))
19664 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19668 if (storage
== NULL_TREE
)
19670 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19672 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19673 pedwarn (input_location
, OPT_Wpedantic
,
19674 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19679 error ("storage class %qD applied to template instantiation", storage
);
19681 check_explicit_instantiation_namespace (result
);
19682 mark_decl_instantiated (result
, extern_p
);
19684 instantiate_decl (result
, /*defer_ok=*/1,
19685 /*expl_inst_class_mem_p=*/false);
19689 mark_class_instantiated (tree t
, int extern_p
)
19691 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19692 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19693 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19694 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19697 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19698 rest_of_type_compilation (t
, 1);
19702 /* Called from do_type_instantiation through binding_table_foreach to
19703 do recursive instantiation for the type bound in ENTRY. */
19705 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19707 tree storage
= *(tree
*) data
;
19709 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19710 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19711 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19714 /* Called from do_type_instantiation to instantiate a member
19715 (a member function or a static member variable) of an
19716 explicitly instantiated class template. */
19718 instantiate_class_member (tree decl
, int extern_p
)
19720 mark_decl_instantiated (decl
, extern_p
);
19722 instantiate_decl (decl
, /*defer_ok=*/1,
19723 /*expl_inst_class_mem_p=*/true);
19726 /* Perform an explicit instantiation of template class T. STORAGE, if
19727 non-null, is the RID for extern, inline or static. COMPLAIN is
19728 nonzero if this is called from the parser, zero if called recursively,
19729 since the standard is unclear (as detailed below). */
19732 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19737 int previous_instantiation_extern_p
= 0;
19739 if (TREE_CODE (t
) == TYPE_DECL
)
19742 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19745 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19747 error ("explicit instantiation of non-class template %qD", tmpl
);
19749 error ("explicit instantiation of non-template type %qT", t
);
19755 if (!COMPLETE_TYPE_P (t
))
19757 if (complain
& tf_error
)
19758 error ("explicit instantiation of %q#T before definition of template",
19763 if (storage
!= NULL_TREE
)
19765 if (!in_system_header_at (input_location
))
19767 if (storage
== ridpointers
[(int) RID_EXTERN
])
19769 if (cxx_dialect
== cxx98
)
19770 pedwarn (input_location
, OPT_Wpedantic
,
19771 "ISO C++ 1998 forbids the use of %<extern%> on "
19772 "explicit instantiations");
19775 pedwarn (input_location
, OPT_Wpedantic
,
19776 "ISO C++ forbids the use of %qE"
19777 " on explicit instantiations", storage
);
19780 if (storage
== ridpointers
[(int) RID_INLINE
])
19782 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19784 else if (storage
== ridpointers
[(int) RID_STATIC
])
19788 error ("storage class %qD applied to template instantiation",
19794 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19796 /* DR 259 [temp.spec].
19798 Both an explicit instantiation and a declaration of an explicit
19799 specialization shall not appear in a program unless the explicit
19800 instantiation follows a declaration of the explicit specialization.
19802 For a given set of template parameters, if an explicit
19803 instantiation of a template appears after a declaration of an
19804 explicit specialization for that template, the explicit
19805 instantiation has no effect. */
19808 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19812 No program shall explicitly instantiate any template more
19815 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19816 instantiation was `extern'. If EXTERN_P then the second is.
19817 These cases are OK. */
19818 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19820 if (!previous_instantiation_extern_p
&& !extern_p
19821 && (complain
& tf_error
))
19822 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19824 /* If we've already instantiated the template, just return now. */
19825 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19829 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19830 mark_class_instantiated (t
, extern_p
);
19838 /* In contrast to implicit instantiation, where only the
19839 declarations, and not the definitions, of members are
19840 instantiated, we have here:
19844 The explicit instantiation of a class template specialization
19845 implies the instantiation of all of its members not
19846 previously explicitly specialized in the translation unit
19847 containing the explicit instantiation.
19849 Of course, we can't instantiate member template classes, since
19850 we don't have any arguments for them. Note that the standard
19851 is unclear on whether the instantiation of the members are
19852 *explicit* instantiations or not. However, the most natural
19853 interpretation is that it should be an explicit instantiation. */
19856 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19857 if (TREE_CODE (tmp
) == FUNCTION_DECL
19858 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19859 instantiate_class_member (tmp
, extern_p
);
19861 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19862 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19863 instantiate_class_member (tmp
, extern_p
);
19865 if (CLASSTYPE_NESTED_UTDS (t
))
19866 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19867 bt_instantiate_type_proc
, &storage
);
19871 /* Given a function DECL, which is a specialization of TMPL, modify
19872 DECL to be a re-instantiation of TMPL with the same template
19873 arguments. TMPL should be the template into which tsubst'ing
19874 should occur for DECL, not the most general template.
19876 One reason for doing this is a scenario like this:
19879 void f(const T&, int i);
19881 void g() { f(3, 7); }
19884 void f(const T& t, const int i) { }
19886 Note that when the template is first instantiated, with
19887 instantiate_template, the resulting DECL will have no name for the
19888 first parameter, and the wrong type for the second. So, when we go
19889 to instantiate the DECL, we regenerate it. */
19892 regenerate_decl_from_template (tree decl
, tree tmpl
)
19894 /* The arguments used to instantiate DECL, from the most general
19899 args
= DECL_TI_ARGS (decl
);
19900 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19902 /* Make sure that we can see identifiers, and compute access
19904 push_access_scope (decl
);
19906 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19914 args_depth
= TMPL_ARGS_DEPTH (args
);
19915 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19916 if (args_depth
> parms_depth
)
19917 args
= get_innermost_template_args (args
, parms_depth
);
19919 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19920 args
, tf_error
, NULL_TREE
,
19921 /*defer_ok*/false);
19922 if (specs
&& specs
!= error_mark_node
)
19923 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19926 /* Merge parameter declarations. */
19927 decl_parm
= skip_artificial_parms_for (decl
,
19928 DECL_ARGUMENTS (decl
));
19930 = skip_artificial_parms_for (code_pattern
,
19931 DECL_ARGUMENTS (code_pattern
));
19932 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19937 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19938 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19939 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19941 parm_type
= type_decays_to (parm_type
);
19942 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19943 TREE_TYPE (decl_parm
) = parm_type
;
19944 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19945 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19947 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19948 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19950 decl_parm
= DECL_CHAIN (decl_parm
);
19951 pattern_parm
= DECL_CHAIN (pattern_parm
);
19953 /* Merge any parameters that match with the function parameter
19955 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19958 tree expanded_types
;
19959 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19960 the parameters in this function parameter pack. */
19961 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19962 args
, tf_error
, NULL_TREE
);
19963 len
= TREE_VEC_LENGTH (expanded_types
);
19964 for (i
= 0; i
< len
; i
++)
19969 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19970 /* Rename the parameter to include the index. */
19971 DECL_NAME (decl_parm
) =
19972 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19973 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19974 parm_type
= type_decays_to (parm_type
);
19975 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19976 TREE_TYPE (decl_parm
) = parm_type
;
19977 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19978 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19980 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19981 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19983 decl_parm
= DECL_CHAIN (decl_parm
);
19986 /* Merge additional specifiers from the CODE_PATTERN. */
19987 if (DECL_DECLARED_INLINE_P (code_pattern
)
19988 && !DECL_DECLARED_INLINE_P (decl
))
19989 DECL_DECLARED_INLINE_P (decl
) = 1;
19991 else if (VAR_P (decl
))
19993 DECL_INITIAL (decl
) =
19994 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19995 tf_error
, DECL_TI_TEMPLATE (decl
),
19996 /*integral_constant_expression_p=*/false);
19997 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19998 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19999 tf_error
, DECL_TI_TEMPLATE (decl
));
20002 gcc_unreachable ();
20004 pop_access_scope (decl
);
20007 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
20008 substituted to get DECL. */
20011 template_for_substitution (tree decl
)
20013 tree tmpl
= DECL_TI_TEMPLATE (decl
);
20015 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
20016 for the instantiation. This is not always the most general
20017 template. Consider, for example:
20020 struct S { template <class U> void f();
20021 template <> void f<int>(); };
20023 and an instantiation of S<double>::f<int>. We want TD to be the
20024 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
20025 while (/* An instantiation cannot have a definition, so we need a
20026 more general template. */
20027 DECL_TEMPLATE_INSTANTIATION (tmpl
)
20028 /* We must also deal with friend templates. Given:
20030 template <class T> struct S {
20031 template <class U> friend void f() {};
20034 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
20035 so far as the language is concerned, but that's still
20036 where we get the pattern for the instantiation from. On
20037 other hand, if the definition comes outside the class, say:
20039 template <class T> struct S {
20040 template <class U> friend void f();
20042 template <class U> friend void f() {}
20044 we don't need to look any further. That's what the check for
20045 DECL_INITIAL is for. */
20046 || (TREE_CODE (decl
) == FUNCTION_DECL
20047 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
20048 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
20050 /* The present template, TD, should not be a definition. If it
20051 were a definition, we should be using it! Note that we
20052 cannot restructure the loop to just keep going until we find
20053 a template with a definition, since that might go too far if
20054 a specialization was declared, but not defined. */
20056 /* Fetch the more general template. */
20057 tmpl
= DECL_TI_TEMPLATE (tmpl
);
20063 /* Returns true if we need to instantiate this template instance even if we
20064 know we aren't going to emit it.. */
20067 always_instantiate_p (tree decl
)
20069 /* We always instantiate inline functions so that we can inline them. An
20070 explicit instantiation declaration prohibits implicit instantiation of
20071 non-inline functions. With high levels of optimization, we would
20072 normally inline non-inline functions -- but we're not allowed to do
20073 that for "extern template" functions. Therefore, we check
20074 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
20075 return ((TREE_CODE (decl
) == FUNCTION_DECL
20076 && (DECL_DECLARED_INLINE_P (decl
)
20077 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
20078 /* And we need to instantiate static data members so that
20079 their initializers are available in integral constant
20082 && decl_maybe_constant_var_p (decl
)));
20085 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
20086 instantiate it now, modifying TREE_TYPE (fn). */
20089 maybe_instantiate_noexcept (tree fn
)
20091 tree fntype
, spec
, noex
, clone
;
20093 /* Don't instantiate a noexcept-specification from template context. */
20094 if (processing_template_decl
)
20097 if (DECL_CLONED_FUNCTION_P (fn
))
20098 fn
= DECL_CLONED_FUNCTION (fn
);
20099 fntype
= TREE_TYPE (fn
);
20100 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
20102 if (!spec
|| !TREE_PURPOSE (spec
))
20105 noex
= TREE_PURPOSE (spec
);
20107 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
20109 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
20110 spec
= get_defaulted_eh_spec (fn
);
20111 else if (push_tinst_level (fn
))
20113 push_access_scope (fn
);
20114 push_deferring_access_checks (dk_no_deferred
);
20115 input_location
= DECL_SOURCE_LOCATION (fn
);
20116 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
20117 DEFERRED_NOEXCEPT_ARGS (noex
),
20118 tf_warning_or_error
, fn
,
20119 /*function_p=*/false,
20120 /*integral_constant_expression_p=*/true);
20121 pop_deferring_access_checks ();
20122 pop_access_scope (fn
);
20123 pop_tinst_level ();
20124 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
20125 if (spec
== error_mark_node
)
20126 spec
= noexcept_false_spec
;
20129 spec
= noexcept_false_spec
;
20131 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
20134 FOR_EACH_CLONE (clone
, fn
)
20136 if (TREE_TYPE (clone
) == fntype
)
20137 TREE_TYPE (clone
) = TREE_TYPE (fn
);
20139 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
20143 /* Produce the definition of D, a _DECL generated from a template. If
20144 DEFER_OK is nonzero, then we don't have to actually do the
20145 instantiation now; we just have to do it sometime. Normally it is
20146 an error if this is an explicit instantiation but D is undefined.
20147 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
20148 explicitly instantiated class template. */
20151 instantiate_decl (tree d
, int defer_ok
,
20152 bool expl_inst_class_mem_p
)
20154 tree tmpl
= DECL_TI_TEMPLATE (d
);
20161 bool pattern_defined
;
20162 location_t saved_loc
= input_location
;
20163 int saved_unevaluated_operand
= cp_unevaluated_operand
;
20164 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
20170 /* This function should only be used to instantiate templates for
20171 functions and static member variables. */
20172 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
20174 /* Variables are never deferred; if instantiation is required, they
20175 are instantiated right away. That allows for better code in the
20176 case that an expression refers to the value of the variable --
20177 if the variable has a constant value the referring expression can
20178 take advantage of that fact. */
20180 || DECL_DECLARED_CONSTEXPR_P (d
))
20183 /* Don't instantiate cloned functions. Instead, instantiate the
20184 functions they cloned. */
20185 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
20186 d
= DECL_CLONED_FUNCTION (d
);
20188 if (DECL_TEMPLATE_INSTANTIATED (d
)
20189 || (TREE_CODE (d
) == FUNCTION_DECL
20190 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
20191 || DECL_TEMPLATE_SPECIALIZATION (d
))
20192 /* D has already been instantiated or explicitly specialized, so
20193 there's nothing for us to do here.
20195 It might seem reasonable to check whether or not D is an explicit
20196 instantiation, and, if so, stop here. But when an explicit
20197 instantiation is deferred until the end of the compilation,
20198 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
20199 the instantiation. */
20202 /* Check to see whether we know that this template will be
20203 instantiated in some other file, as with "extern template"
20205 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
20207 /* In general, we do not instantiate such templates. */
20208 if (external_p
&& !always_instantiate_p (d
))
20211 gen_tmpl
= most_general_template (tmpl
);
20212 gen_args
= DECL_TI_ARGS (d
);
20214 if (tmpl
!= gen_tmpl
)
20215 /* We should already have the extra args. */
20216 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
20217 == TMPL_ARGS_DEPTH (gen_args
));
20218 /* And what's in the hash table should match D. */
20219 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
20220 || spec
== NULL_TREE
);
20222 /* This needs to happen before any tsubsting. */
20223 if (! push_tinst_level (d
))
20226 timevar_push (TV_TEMPLATE_INST
);
20228 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
20229 for the instantiation. */
20230 td
= template_for_substitution (d
);
20231 code_pattern
= DECL_TEMPLATE_RESULT (td
);
20233 /* We should never be trying to instantiate a member of a class
20234 template or partial specialization. */
20235 gcc_assert (d
!= code_pattern
);
20237 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
20238 || DECL_TEMPLATE_SPECIALIZATION (td
))
20239 /* In the case of a friend template whose definition is provided
20240 outside the class, we may have too many arguments. Drop the
20241 ones we don't need. The same is true for specializations. */
20242 args
= get_innermost_template_args
20243 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
20247 if (TREE_CODE (d
) == FUNCTION_DECL
)
20249 deleted_p
= DECL_DELETED_FN (code_pattern
);
20250 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
20251 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
20257 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
20260 /* We may be in the middle of deferred access check. Disable it now. */
20261 push_deferring_access_checks (dk_no_deferred
);
20263 /* Unless an explicit instantiation directive has already determined
20264 the linkage of D, remember that a definition is available for
20266 if (pattern_defined
20267 && !DECL_INTERFACE_KNOWN (d
)
20268 && !DECL_NOT_REALLY_EXTERN (d
))
20269 mark_definable (d
);
20271 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
20272 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
20273 input_location
= DECL_SOURCE_LOCATION (d
);
20275 /* If D is a member of an explicitly instantiated class template,
20276 and no definition is available, treat it like an implicit
20278 if (!pattern_defined
&& expl_inst_class_mem_p
20279 && DECL_EXPLICIT_INSTANTIATION (d
))
20281 /* Leave linkage flags alone on instantiations with anonymous
20283 if (TREE_PUBLIC (d
))
20285 DECL_NOT_REALLY_EXTERN (d
) = 0;
20286 DECL_INTERFACE_KNOWN (d
) = 0;
20288 SET_DECL_IMPLICIT_INSTANTIATION (d
);
20291 /* Defer all other templates, unless we have been explicitly
20292 forbidden from doing so. */
20293 if (/* If there is no definition, we cannot instantiate the
20296 /* If it's OK to postpone instantiation, do so. */
20298 /* If this is a static data member that will be defined
20299 elsewhere, we don't want to instantiate the entire data
20300 member, but we do want to instantiate the initializer so that
20301 we can substitute that elsewhere. */
20302 || (external_p
&& VAR_P (d
))
20303 /* Handle here a deleted function too, avoid generating
20304 its body (c++/61080). */
20307 /* The definition of the static data member is now required so
20308 we must substitute the initializer. */
20310 && !DECL_INITIAL (d
)
20311 && DECL_INITIAL (code_pattern
))
20315 bool const_init
= false;
20316 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20318 ns
= decl_namespace_context (d
);
20319 push_nested_namespace (ns
);
20321 push_nested_class (DECL_CONTEXT (d
));
20322 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
20324 tf_warning_or_error
, NULL_TREE
,
20325 /*integral_constant_expression_p=*/false);
20326 /* If instantiating the initializer involved instantiating this
20327 again, don't call cp_finish_decl twice. */
20328 if (!DECL_INITIAL (d
))
20330 /* Make sure the initializer is still constant, in case of
20331 circular dependency (template/instantiate6.C). */
20333 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20334 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
20335 /*asmspec_tree=*/NULL_TREE
,
20336 LOOKUP_ONLYCONVERTING
);
20339 pop_nested_class ();
20340 pop_nested_namespace (ns
);
20343 /* We restore the source position here because it's used by
20344 add_pending_template. */
20345 input_location
= saved_loc
;
20347 if (at_eof
&& !pattern_defined
20348 && DECL_EXPLICIT_INSTANTIATION (d
)
20349 && DECL_NOT_REALLY_EXTERN (d
))
20352 The definition of a non-exported function template, a
20353 non-exported member function template, or a non-exported
20354 member function or static data member of a class template
20355 shall be present in every translation unit in which it is
20356 explicitly instantiated. */
20357 permerror (input_location
, "explicit instantiation of %qD "
20358 "but no definition available", d
);
20360 /* If we're in unevaluated context, we just wanted to get the
20361 constant value; this isn't an odr use, so don't queue
20362 a full instantiation. */
20363 if (cp_unevaluated_operand
!= 0)
20365 /* ??? Historically, we have instantiated inline functions, even
20366 when marked as "extern template". */
20367 if (!(external_p
&& VAR_P (d
)))
20368 add_pending_template (d
);
20371 /* Tell the repository that D is available in this translation unit
20372 -- and see if it is supposed to be instantiated here. */
20373 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
20375 /* In a PCH file, despite the fact that the repository hasn't
20376 requested instantiation in the PCH it is still possible that
20377 an instantiation will be required in a file that includes the
20380 add_pending_template (d
);
20381 /* Instantiate inline functions so that the inliner can do its
20382 job, even though we'll not be emitting a copy of this
20384 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
20388 fn_context
= decl_function_context (d
);
20389 nested
= (current_function_decl
!= NULL_TREE
);
20391 push_to_top_level ();
20395 push_function_context ();
20396 cp_unevaluated_operand
= 0;
20397 c_inhibit_evaluation_warnings
= 0;
20400 /* Mark D as instantiated so that recursive calls to
20401 instantiate_decl do not try to instantiate it again. */
20402 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
20404 /* Regenerate the declaration in case the template has been modified
20405 by a subsequent redeclaration. */
20406 regenerate_decl_from_template (d
, td
);
20408 /* We already set the file and line above. Reset them now in case
20409 they changed as a result of calling regenerate_decl_from_template. */
20410 input_location
= DECL_SOURCE_LOCATION (d
);
20415 bool const_init
= false;
20417 /* Clear out DECL_RTL; whatever was there before may not be right
20418 since we've reset the type of the declaration. */
20419 SET_DECL_RTL (d
, NULL
);
20420 DECL_IN_AGGR_P (d
) = 0;
20422 /* The initializer is placed in DECL_INITIAL by
20423 regenerate_decl_from_template so we don't need to
20424 push/pop_access_scope again here. Pull it out so that
20425 cp_finish_decl can process it. */
20426 init
= DECL_INITIAL (d
);
20427 DECL_INITIAL (d
) = NULL_TREE
;
20428 DECL_INITIALIZED_P (d
) = 0;
20430 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20431 initializer. That function will defer actual emission until
20432 we have a chance to determine linkage. */
20433 DECL_EXTERNAL (d
) = 0;
20435 /* Enter the scope of D so that access-checking works correctly. */
20436 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20438 push_nested_class (DECL_CONTEXT (d
));
20440 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20441 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
20444 pop_nested_class ();
20446 if (variable_template_p (td
))
20447 note_variable_template_instantiation (d
);
20449 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
20450 synthesize_method (d
);
20451 else if (TREE_CODE (d
) == FUNCTION_DECL
)
20453 hash_map
<tree
, tree
> *saved_local_specializations
;
20457 tree block
= NULL_TREE
;
20459 /* Save away the current list, in case we are instantiating one
20460 template from within the body of another. */
20461 saved_local_specializations
= local_specializations
;
20463 /* Set up the list of local specializations. */
20464 local_specializations
= new hash_map
<tree
, tree
>;
20466 /* Set up context. */
20467 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20468 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20469 block
= push_stmt_list ();
20471 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
20473 /* Some typedefs referenced from within the template code need to be
20474 access checked at template instantiation time, i.e now. These
20475 types were added to the template at parsing time. Let's get those
20476 and perform the access checks then. */
20477 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20480 /* Create substitution entries for the parameters. */
20481 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20482 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20483 spec_parm
= DECL_ARGUMENTS (d
);
20484 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20486 register_local_specialization (spec_parm
, tmpl_parm
);
20487 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20488 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20490 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20492 if (!DECL_PACK_P (tmpl_parm
))
20494 register_local_specialization (spec_parm
, tmpl_parm
);
20495 spec_parm
= DECL_CHAIN (spec_parm
);
20499 /* Register the (value) argument pack as a specialization of
20500 TMPL_PARM, then move on. */
20501 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20502 register_local_specialization (argpack
, tmpl_parm
);
20505 gcc_assert (!spec_parm
);
20507 /* Substitute into the body of the function. */
20508 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20509 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20510 tf_warning_or_error
, tmpl
);
20513 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20514 tf_warning_or_error
, tmpl
,
20515 /*integral_constant_expression_p=*/false);
20517 /* Set the current input_location to the end of the function
20518 so that finish_function knows where we are. */
20520 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20522 /* Remember if we saw an infinite loop in the template. */
20523 current_function_infinite_loop
20524 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20527 /* We don't need the local specializations any more. */
20528 delete local_specializations
;
20529 local_specializations
= saved_local_specializations
;
20531 /* Finish the function. */
20532 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20533 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20534 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20537 d
= finish_function (0);
20538 expand_or_defer_fn (d
);
20541 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20542 cp_check_omp_declare_reduction (d
);
20545 /* We're not deferring instantiation any more. */
20546 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20549 pop_from_top_level ();
20551 pop_function_context ();
20554 input_location
= saved_loc
;
20555 cp_unevaluated_operand
= saved_unevaluated_operand
;
20556 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20557 pop_deferring_access_checks ();
20558 pop_tinst_level ();
20560 timevar_pop (TV_TEMPLATE_INST
);
20565 /* Run through the list of templates that we wish we could
20566 instantiate, and instantiate any we can. RETRIES is the
20567 number of times we retry pending template instantiation. */
20570 instantiate_pending_templates (int retries
)
20573 location_t saved_loc
= input_location
;
20575 /* Instantiating templates may trigger vtable generation. This in turn
20576 may require further template instantiations. We place a limit here
20577 to avoid infinite loop. */
20578 if (pending_templates
&& retries
>= max_tinst_depth
)
20580 tree decl
= pending_templates
->tinst
->decl
;
20582 fatal_error (input_location
,
20583 "template instantiation depth exceeds maximum of %d"
20584 " instantiating %q+D, possibly from virtual table generation"
20585 " (use -ftemplate-depth= to increase the maximum)",
20586 max_tinst_depth
, decl
);
20587 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20588 /* Pretend that we defined it. */
20589 DECL_INITIAL (decl
) = error_mark_node
;
20595 struct pending_template
**t
= &pending_templates
;
20596 struct pending_template
*last
= NULL
;
20600 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20601 bool complete
= false;
20603 if (TYPE_P (instantiation
))
20607 if (!COMPLETE_TYPE_P (instantiation
))
20609 instantiate_class_template (instantiation
);
20610 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20611 for (fn
= TYPE_METHODS (instantiation
);
20613 fn
= TREE_CHAIN (fn
))
20614 if (! DECL_ARTIFICIAL (fn
))
20615 instantiate_decl (fn
,
20617 /*expl_inst_class_mem_p=*/false);
20618 if (COMPLETE_TYPE_P (instantiation
))
20622 complete
= COMPLETE_TYPE_P (instantiation
);
20626 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20627 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20630 = instantiate_decl (instantiation
,
20632 /*expl_inst_class_mem_p=*/false);
20633 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20637 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20638 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20642 /* If INSTANTIATION has been instantiated, then we don't
20643 need to consider it again in the future. */
20651 current_tinst_level
= NULL
;
20653 last_pending_template
= last
;
20655 while (reconsider
);
20657 input_location
= saved_loc
;
20660 /* Substitute ARGVEC into T, which is a list of initializers for
20661 either base class or a non-static data member. The TREE_PURPOSEs
20662 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20663 instantiate_decl. */
20666 tsubst_initializer_list (tree t
, tree argvec
)
20668 tree inits
= NULL_TREE
;
20670 for (; t
; t
= TREE_CHAIN (t
))
20674 tree expanded_bases
= NULL_TREE
;
20675 tree expanded_arguments
= NULL_TREE
;
20678 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20683 /* Expand the base class expansion type into separate base
20685 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20686 tf_warning_or_error
,
20688 if (expanded_bases
== error_mark_node
)
20691 /* We'll be building separate TREE_LISTs of arguments for
20693 len
= TREE_VEC_LENGTH (expanded_bases
);
20694 expanded_arguments
= make_tree_vec (len
);
20695 for (i
= 0; i
< len
; i
++)
20696 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20698 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20699 expand each argument in the TREE_VALUE of t. */
20700 expr
= make_node (EXPR_PACK_EXPANSION
);
20701 PACK_EXPANSION_LOCAL_P (expr
) = true;
20702 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20703 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20705 if (TREE_VALUE (t
) == void_type_node
)
20706 /* VOID_TYPE_NODE is used to indicate
20707 value-initialization. */
20709 for (i
= 0; i
< len
; i
++)
20710 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20714 /* Substitute parameter packs into each argument in the
20716 in_base_initializer
= 1;
20717 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20719 tree expanded_exprs
;
20721 /* Expand the argument. */
20722 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20724 = tsubst_pack_expansion (expr
, argvec
,
20725 tf_warning_or_error
,
20727 if (expanded_exprs
== error_mark_node
)
20730 /* Prepend each of the expanded expressions to the
20731 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20732 for (i
= 0; i
< len
; i
++)
20734 TREE_VEC_ELT (expanded_arguments
, i
) =
20735 tree_cons (NULL_TREE
,
20736 TREE_VEC_ELT (expanded_exprs
, i
),
20737 TREE_VEC_ELT (expanded_arguments
, i
));
20740 in_base_initializer
= 0;
20742 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20743 since we built them backwards. */
20744 for (i
= 0; i
< len
; i
++)
20746 TREE_VEC_ELT (expanded_arguments
, i
) =
20747 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20752 for (i
= 0; i
< len
; ++i
)
20754 if (expanded_bases
)
20756 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20757 decl
= expand_member_init (decl
);
20758 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20763 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20764 tf_warning_or_error
, NULL_TREE
);
20766 decl
= expand_member_init (decl
);
20767 if (decl
&& !DECL_P (decl
))
20768 in_base_initializer
= 1;
20770 init
= TREE_VALUE (t
);
20772 if (init
!= void_type_node
)
20773 init
= tsubst_expr (init
, argvec
,
20774 tf_warning_or_error
, NULL_TREE
,
20775 /*integral_constant_expression_p=*/false);
20776 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20777 /* If we had an initializer but it instantiated to nothing,
20778 value-initialize the object. This will only occur when
20779 the initializer was a pack expansion where the parameter
20780 packs used in that expansion were of length zero. */
20781 init
= void_type_node
;
20782 in_base_initializer
= 0;
20787 init
= build_tree_list (decl
, init
);
20788 TREE_CHAIN (init
) = inits
;
20796 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20799 set_current_access_from_decl (tree decl
)
20801 if (TREE_PRIVATE (decl
))
20802 current_access_specifier
= access_private_node
;
20803 else if (TREE_PROTECTED (decl
))
20804 current_access_specifier
= access_protected_node
;
20806 current_access_specifier
= access_public_node
;
20809 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20810 is the instantiation (which should have been created with
20811 start_enum) and ARGS are the template arguments to use. */
20814 tsubst_enum (tree tag
, tree newtag
, tree args
)
20818 if (SCOPED_ENUM_P (newtag
))
20819 begin_scope (sk_scoped_enum
, newtag
);
20821 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20826 decl
= TREE_VALUE (e
);
20827 /* Note that in a template enum, the TREE_VALUE is the
20828 CONST_DECL, not the corresponding INTEGER_CST. */
20829 value
= tsubst_expr (DECL_INITIAL (decl
),
20830 args
, tf_warning_or_error
, NULL_TREE
,
20831 /*integral_constant_expression_p=*/true);
20833 /* Give this enumeration constant the correct access. */
20834 set_current_access_from_decl (decl
);
20836 /* Actually build the enumerator itself. Here we're assuming that
20837 enumerators can't have dependent attributes. */
20838 build_enumerator (DECL_NAME (decl
), value
, newtag
,
20839 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
20842 if (SCOPED_ENUM_P (newtag
))
20845 finish_enum_value_list (newtag
);
20846 finish_enum (newtag
);
20848 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20849 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20852 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20853 its type -- but without substituting the innermost set of template
20854 arguments. So, innermost set of template parameters will appear in
20858 get_mostly_instantiated_function_type (tree decl
)
20860 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
20861 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
20864 /* Return truthvalue if we're processing a template different from
20865 the last one involved in diagnostics. */
20867 problematic_instantiation_changed (void)
20869 return current_tinst_level
!= last_error_tinst_level
;
20872 /* Remember current template involved in diagnostics. */
20874 record_last_problematic_instantiation (void)
20876 last_error_tinst_level
= current_tinst_level
;
20879 struct tinst_level
*
20880 current_instantiation (void)
20882 return current_tinst_level
;
20885 /* Return TRUE if current_function_decl is being instantiated, false
20889 instantiating_current_function_p (void)
20891 return (current_instantiation ()
20892 && current_instantiation ()->decl
== current_function_decl
);
20895 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20896 type. Return zero for ok, nonzero for disallowed. Issue error and
20897 warning messages under control of COMPLAIN. */
20900 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20902 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20904 else if (POINTER_TYPE_P (type
))
20906 else if (TYPE_PTRMEM_P (type
))
20908 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20910 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20912 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20914 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20917 if (complain
& tf_error
)
20919 if (type
== error_mark_node
)
20920 inform (input_location
, "invalid template non-type parameter");
20922 error ("%q#T is not a valid type for a template non-type parameter",
20928 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20929 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20932 dependent_type_p_r (tree type
)
20938 A type is dependent if it is:
20940 -- a template parameter. Template template parameters are types
20941 for us (since TYPE_P holds true for them) so we handle
20943 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20944 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20946 /* -- a qualified-id with a nested-name-specifier which contains a
20947 class-name that names a dependent type or whose unqualified-id
20948 names a dependent type. */
20949 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20951 /* -- a cv-qualified type where the cv-unqualified type is
20953 No code is necessary for this bullet; the code below handles
20954 cv-qualified types, and we don't want to strip aliases with
20955 TYPE_MAIN_VARIANT because of DR 1558. */
20956 /* -- a compound type constructed from any dependent type. */
20957 if (TYPE_PTRMEM_P (type
))
20958 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20959 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20961 else if (TYPE_PTR_P (type
)
20962 || TREE_CODE (type
) == REFERENCE_TYPE
)
20963 return dependent_type_p (TREE_TYPE (type
));
20964 else if (TREE_CODE (type
) == FUNCTION_TYPE
20965 || TREE_CODE (type
) == METHOD_TYPE
)
20969 if (dependent_type_p (TREE_TYPE (type
)))
20971 for (arg_type
= TYPE_ARG_TYPES (type
);
20973 arg_type
= TREE_CHAIN (arg_type
))
20974 if (dependent_type_p (TREE_VALUE (arg_type
)))
20978 /* -- an array type constructed from any dependent type or whose
20979 size is specified by a constant expression that is
20982 We checked for type- and value-dependence of the bounds in
20983 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20984 if (TREE_CODE (type
) == ARRAY_TYPE
)
20986 if (TYPE_DOMAIN (type
)
20987 && dependent_type_p (TYPE_DOMAIN (type
)))
20989 return dependent_type_p (TREE_TYPE (type
));
20992 /* -- a template-id in which either the template name is a template
20994 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20996 /* ... or any of the template arguments is a dependent type or
20997 an expression that is type-dependent or value-dependent. */
20998 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
20999 && (any_dependent_template_arguments_p
21000 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
21002 /* For an alias template specialization, check the arguments both to the
21003 class template and the alias template. */
21004 else if (dependent_alias_template_spec_p (type
))
21007 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
21008 dependent; if the argument of the `typeof' expression is not
21009 type-dependent, then it should already been have resolved. */
21010 if (TREE_CODE (type
) == TYPEOF_TYPE
21011 || TREE_CODE (type
) == DECLTYPE_TYPE
21012 || TREE_CODE (type
) == UNDERLYING_TYPE
)
21015 /* A template argument pack is dependent if any of its packed
21017 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
21019 tree args
= ARGUMENT_PACK_ARGS (type
);
21020 int i
, len
= TREE_VEC_LENGTH (args
);
21021 for (i
= 0; i
< len
; ++i
)
21022 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21026 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
21027 be template parameters. */
21028 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
21031 /* The standard does not specifically mention types that are local
21032 to template functions or local classes, but they should be
21033 considered dependent too. For example:
21035 template <int I> void f() {
21040 The size of `E' cannot be known until the value of `I' has been
21041 determined. Therefore, `E' must be considered dependent. */
21042 scope
= TYPE_CONTEXT (type
);
21043 if (scope
&& TYPE_P (scope
))
21044 return dependent_type_p (scope
);
21045 /* Don't use type_dependent_expression_p here, as it can lead
21046 to infinite recursion trying to determine whether a lambda
21047 nested in a lambda is dependent (c++/47687). */
21048 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
21049 && DECL_LANG_SPECIFIC (scope
)
21050 && DECL_TEMPLATE_INFO (scope
)
21051 && (any_dependent_template_arguments_p
21052 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
21055 /* Other types are non-dependent. */
21059 /* Returns TRUE if TYPE is dependent, in the sense of
21060 [temp.dep.type]. Note that a NULL type is considered dependent. */
21063 dependent_type_p (tree type
)
21065 /* If there are no template parameters in scope, then there can't be
21066 any dependent types. */
21067 if (!processing_template_decl
)
21069 /* If we are not processing a template, then nobody should be
21070 providing us with a dependent type. */
21072 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
21076 /* If the type is NULL, we have not computed a type for the entity
21077 in question; in that case, the type is dependent. */
21081 /* Erroneous types can be considered non-dependent. */
21082 if (type
== error_mark_node
)
21085 /* If we have not already computed the appropriate value for TYPE,
21087 if (!TYPE_DEPENDENT_P_VALID (type
))
21089 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
21090 TYPE_DEPENDENT_P_VALID (type
) = 1;
21093 return TYPE_DEPENDENT_P (type
);
21096 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
21097 lookup. In other words, a dependent type that is not the current
21101 dependent_scope_p (tree scope
)
21103 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
21104 && !currently_open_class (scope
));
21107 /* T is a SCOPE_REF; return whether we need to consider it
21108 instantiation-dependent so that we can check access at instantiation
21109 time even though we know which member it resolves to. */
21112 instantiation_dependent_scope_ref_p (tree t
)
21114 if (DECL_P (TREE_OPERAND (t
, 1))
21115 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
21116 && accessible_in_template_p (TREE_OPERAND (t
, 0),
21117 TREE_OPERAND (t
, 1)))
21123 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
21124 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
21127 /* Note that this predicate is not appropriate for general expressions;
21128 only constant expressions (that satisfy potential_constant_expression)
21129 can be tested for value dependence. */
21132 value_dependent_expression_p (tree expression
)
21134 if (!processing_template_decl
)
21137 /* A name declared with a dependent type. */
21138 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
21141 switch (TREE_CODE (expression
))
21143 case IDENTIFIER_NODE
:
21144 /* A name that has not been looked up -- must be dependent. */
21147 case TEMPLATE_PARM_INDEX
:
21148 /* A non-type template parm. */
21152 /* A non-type template parm. */
21153 if (DECL_TEMPLATE_PARM_P (expression
))
21155 return value_dependent_expression_p (DECL_INITIAL (expression
));
21158 /* A constant with literal type and is initialized
21159 with an expression that is value-dependent.
21161 Note that a non-dependent parenthesized initializer will have
21162 already been replaced with its constant value, so if we see
21163 a TREE_LIST it must be dependent. */
21164 if (DECL_INITIAL (expression
)
21165 && decl_constant_var_p (expression
)
21166 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
21167 /* cp_finish_decl doesn't fold reference initializers. */
21168 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
21169 || value_dependent_expression_p (DECL_INITIAL (expression
))))
21173 case DYNAMIC_CAST_EXPR
:
21174 case STATIC_CAST_EXPR
:
21175 case CONST_CAST_EXPR
:
21176 case REINTERPRET_CAST_EXPR
:
21178 /* These expressions are value-dependent if the type to which
21179 the cast occurs is dependent or the expression being casted
21180 is value-dependent. */
21182 tree type
= TREE_TYPE (expression
);
21184 if (dependent_type_p (type
))
21187 /* A functional cast has a list of operands. */
21188 expression
= TREE_OPERAND (expression
, 0);
21191 /* If there are no operands, it must be an expression such
21192 as "int()". This should not happen for aggregate types
21193 because it would form non-constant expressions. */
21194 gcc_assert (cxx_dialect
>= cxx11
21195 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
21200 if (TREE_CODE (expression
) == TREE_LIST
)
21201 return any_value_dependent_elements_p (expression
);
21203 return value_dependent_expression_p (expression
);
21207 if (SIZEOF_EXPR_TYPE_P (expression
))
21208 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
21212 /* A `sizeof' expression is value-dependent if the operand is
21213 type-dependent or is a pack expansion. */
21214 expression
= TREE_OPERAND (expression
, 0);
21215 if (PACK_EXPANSION_P (expression
))
21217 else if (TYPE_P (expression
))
21218 return dependent_type_p (expression
);
21219 return instantiation_dependent_expression_p (expression
);
21221 case AT_ENCODE_EXPR
:
21222 /* An 'encode' expression is value-dependent if the operand is
21224 expression
= TREE_OPERAND (expression
, 0);
21225 return dependent_type_p (expression
);
21227 case NOEXCEPT_EXPR
:
21228 expression
= TREE_OPERAND (expression
, 0);
21229 return instantiation_dependent_expression_p (expression
);
21232 /* All instantiation-dependent expressions should also be considered
21233 value-dependent. */
21234 return instantiation_dependent_scope_ref_p (expression
);
21236 case COMPONENT_REF
:
21237 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
21238 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
21240 case NONTYPE_ARGUMENT_PACK
:
21241 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
21242 is value-dependent. */
21244 tree values
= ARGUMENT_PACK_ARGS (expression
);
21245 int i
, len
= TREE_VEC_LENGTH (values
);
21247 for (i
= 0; i
< len
; ++i
)
21248 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
21256 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
21257 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
21258 || (type2
? dependent_type_p (type2
) : false));
21262 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21263 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
21266 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21267 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
21271 tree op
= TREE_OPERAND (expression
, 0);
21272 return (value_dependent_expression_p (op
)
21273 || has_value_dependent_address (op
));
21278 tree fn
= get_callee_fndecl (expression
);
21280 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
21282 nargs
= call_expr_nargs (expression
);
21283 for (i
= 0; i
< nargs
; ++i
)
21285 tree op
= CALL_EXPR_ARG (expression
, i
);
21286 /* In a call to a constexpr member function, look through the
21287 implicit ADDR_EXPR on the object argument so that it doesn't
21288 cause the call to be considered value-dependent. We also
21289 look through it in potential_constant_expression. */
21290 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
21291 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
21292 && TREE_CODE (op
) == ADDR_EXPR
)
21293 op
= TREE_OPERAND (op
, 0);
21294 if (value_dependent_expression_p (op
))
21300 case TEMPLATE_ID_EXPR
:
21301 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21303 return type_dependent_expression_p (expression
);
21309 if (dependent_type_p (TREE_TYPE (expression
)))
21311 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
21312 if (value_dependent_expression_p (val
))
21318 /* Treat a GNU statement expression as dependent to avoid crashing
21319 under instantiate_non_dependent_expr; it can't be constant. */
21323 /* A constant expression is value-dependent if any subexpression is
21324 value-dependent. */
21325 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
21327 case tcc_reference
:
21329 case tcc_comparison
:
21331 case tcc_expression
:
21334 int i
, len
= cp_tree_operand_length (expression
);
21336 for (i
= 0; i
< len
; i
++)
21338 tree t
= TREE_OPERAND (expression
, i
);
21340 /* In some cases, some of the operands may be missing.l
21341 (For example, in the case of PREDECREMENT_EXPR, the
21342 amount to increment by may be missing.) That doesn't
21343 make the expression dependent. */
21344 if (t
&& value_dependent_expression_p (t
))
21355 /* The expression is not value-dependent. */
21359 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21360 [temp.dep.expr]. Note that an expression with no type is
21361 considered dependent. Other parts of the compiler arrange for an
21362 expression with type-dependent subexpressions to have no type, so
21363 this function doesn't have to be fully recursive. */
21366 type_dependent_expression_p (tree expression
)
21368 if (!processing_template_decl
)
21371 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
21374 /* An unresolved name is always dependent. */
21375 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
21378 /* Some expression forms are never type-dependent. */
21379 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
21380 || TREE_CODE (expression
) == SIZEOF_EXPR
21381 || TREE_CODE (expression
) == ALIGNOF_EXPR
21382 || TREE_CODE (expression
) == AT_ENCODE_EXPR
21383 || TREE_CODE (expression
) == NOEXCEPT_EXPR
21384 || TREE_CODE (expression
) == TRAIT_EXPR
21385 || TREE_CODE (expression
) == TYPEID_EXPR
21386 || TREE_CODE (expression
) == DELETE_EXPR
21387 || TREE_CODE (expression
) == VEC_DELETE_EXPR
21388 || TREE_CODE (expression
) == THROW_EXPR
)
21391 /* The types of these expressions depends only on the type to which
21392 the cast occurs. */
21393 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
21394 || TREE_CODE (expression
) == STATIC_CAST_EXPR
21395 || TREE_CODE (expression
) == CONST_CAST_EXPR
21396 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
21397 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
21398 || TREE_CODE (expression
) == CAST_EXPR
)
21399 return dependent_type_p (TREE_TYPE (expression
));
21401 /* The types of these expressions depends only on the type created
21402 by the expression. */
21403 if (TREE_CODE (expression
) == NEW_EXPR
21404 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
21406 /* For NEW_EXPR tree nodes created inside a template, either
21407 the object type itself or a TREE_LIST may appear as the
21409 tree type
= TREE_OPERAND (expression
, 1);
21410 if (TREE_CODE (type
) == TREE_LIST
)
21411 /* This is an array type. We need to check array dimensions
21413 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
21414 || value_dependent_expression_p
21415 (TREE_OPERAND (TREE_VALUE (type
), 1));
21417 return dependent_type_p (type
);
21420 if (TREE_CODE (expression
) == SCOPE_REF
)
21422 tree scope
= TREE_OPERAND (expression
, 0);
21423 tree name
= TREE_OPERAND (expression
, 1);
21425 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21426 contains an identifier associated by name lookup with one or more
21427 declarations declared with a dependent type, or...a
21428 nested-name-specifier or qualified-id that names a member of an
21429 unknown specialization. */
21430 return (type_dependent_expression_p (name
)
21431 || dependent_scope_p (scope
));
21434 if (TREE_CODE (expression
) == FUNCTION_DECL
21435 && DECL_LANG_SPECIFIC (expression
)
21436 && DECL_TEMPLATE_INFO (expression
)
21437 && (any_dependent_template_arguments_p
21438 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
21441 if (TREE_CODE (expression
) == TEMPLATE_DECL
21442 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
21445 if (TREE_CODE (expression
) == STMT_EXPR
)
21446 expression
= stmt_expr_value_expr (expression
);
21448 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21453 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21455 if (type_dependent_expression_p (elt
))
21461 /* A static data member of the current instantiation with incomplete
21462 array type is type-dependent, as the definition and specializations
21463 can have different bounds. */
21464 if (VAR_P (expression
)
21465 && DECL_CLASS_SCOPE_P (expression
)
21466 && dependent_type_p (DECL_CONTEXT (expression
))
21467 && VAR_HAD_UNKNOWN_BOUND (expression
))
21470 /* An array of unknown bound depending on a variadic parameter, eg:
21472 template<typename... Args>
21473 void foo (Args... args)
21475 int arr[] = { args... };
21478 template<int... vals>
21481 int arr[] = { vals... };
21484 If the array has no length and has an initializer, it must be that
21485 we couldn't determine its length in cp_complete_array_type because
21486 it is dependent. */
21487 if (VAR_P (expression
)
21488 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21489 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21490 && DECL_INITIAL (expression
))
21493 /* A variable template specialization is type-dependent if it has any
21494 dependent template arguments. */
21495 if (VAR_P (expression
)
21496 && DECL_LANG_SPECIFIC (expression
)
21497 && DECL_TEMPLATE_INFO (expression
)
21498 && variable_template_p (DECL_TI_TEMPLATE (expression
)))
21499 return any_dependent_template_arguments_p (DECL_TI_ARGS (expression
));
21501 /* Always dependent, on the number of arguments if nothing else. */
21502 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21505 if (TREE_TYPE (expression
) == unknown_type_node
)
21507 if (TREE_CODE (expression
) == ADDR_EXPR
)
21508 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21509 if (TREE_CODE (expression
) == COMPONENT_REF
21510 || TREE_CODE (expression
) == OFFSET_REF
)
21512 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21514 expression
= TREE_OPERAND (expression
, 1);
21515 if (identifier_p (expression
))
21518 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21519 if (TREE_CODE (expression
) == SCOPE_REF
)
21522 if (BASELINK_P (expression
))
21524 if (BASELINK_OPTYPE (expression
)
21525 && dependent_type_p (BASELINK_OPTYPE (expression
)))
21527 expression
= BASELINK_FUNCTIONS (expression
);
21530 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21532 if (any_dependent_template_arguments_p
21533 (TREE_OPERAND (expression
, 1)))
21535 expression
= TREE_OPERAND (expression
, 0);
21537 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21538 || TREE_CODE (expression
) == FUNCTION_DECL
);
21542 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21544 expression
= OVL_NEXT (expression
);
21549 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21551 return (dependent_type_p (TREE_TYPE (expression
)));
21554 /* walk_tree callback function for instantiation_dependent_expression_p,
21555 below. Returns non-zero if a dependent subexpression is found. */
21558 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21563 /* We don't have to worry about decltype currently because decltype
21564 of an instantiation-dependent expr is a dependent type. This
21565 might change depending on the resolution of DR 1172. */
21566 *walk_subtrees
= false;
21569 enum tree_code code
= TREE_CODE (*tp
);
21572 /* Don't treat an argument list as dependent just because it has no
21580 /* A constant with a dependent initializer is dependent. */
21581 if (value_dependent_expression_p (*tp
))
21585 case TEMPLATE_PARM_INDEX
:
21588 /* Handle expressions with type operands. */
21592 case AT_ENCODE_EXPR
:
21594 tree op
= TREE_OPERAND (*tp
, 0);
21595 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21596 op
= TREE_TYPE (op
);
21599 if (dependent_type_p (op
))
21603 *walk_subtrees
= false;
21611 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21612 || (TRAIT_EXPR_TYPE2 (*tp
)
21613 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21615 *walk_subtrees
= false;
21618 case COMPONENT_REF
:
21619 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21620 /* In a template, finish_class_member_access_expr creates a
21621 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21622 type-dependent, so that we can check access control at
21623 instantiation time (PR 42277). See also Core issue 1273. */
21628 if (instantiation_dependent_scope_ref_p (*tp
))
21633 /* Treat statement-expressions as dependent. */
21641 if (type_dependent_expression_p (*tp
))
21647 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21648 sense defined by the ABI:
21650 "An expression is instantiation-dependent if it is type-dependent
21651 or value-dependent, or it has a subexpression that is type-dependent
21652 or value-dependent." */
21655 instantiation_dependent_expression_p (tree expression
)
21659 if (!processing_template_decl
)
21662 if (expression
== error_mark_node
)
21665 result
= cp_walk_tree_without_duplicates (&expression
,
21666 instantiation_dependent_r
, NULL
);
21667 return result
!= NULL_TREE
;
21670 /* Like type_dependent_expression_p, but it also works while not processing
21671 a template definition, i.e. during substitution or mangling. */
21674 type_dependent_expression_p_push (tree expr
)
21677 ++processing_template_decl
;
21678 b
= type_dependent_expression_p (expr
);
21679 --processing_template_decl
;
21683 /* Returns TRUE if ARGS contains a type-dependent expression. */
21686 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21691 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21693 if (type_dependent_expression_p (arg
))
21699 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21700 expressions) contains any type-dependent expressions. */
21703 any_type_dependent_elements_p (const_tree list
)
21705 for (; list
; list
= TREE_CHAIN (list
))
21706 if (type_dependent_expression_p (TREE_VALUE (list
)))
21712 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21713 expressions) contains any value-dependent expressions. */
21716 any_value_dependent_elements_p (const_tree list
)
21718 for (; list
; list
= TREE_CHAIN (list
))
21719 if (value_dependent_expression_p (TREE_VALUE (list
)))
21725 /* Returns TRUE if the ARG (a template argument) is dependent. */
21728 dependent_template_arg_p (tree arg
)
21730 if (!processing_template_decl
)
21733 /* Assume a template argument that was wrongly written by the user
21734 is dependent. This is consistent with what
21735 any_dependent_template_arguments_p [that calls this function]
21737 if (!arg
|| arg
== error_mark_node
)
21740 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21741 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21743 if (TREE_CODE (arg
) == TEMPLATE_DECL
21744 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21745 return dependent_template_p (arg
);
21746 else if (ARGUMENT_PACK_P (arg
))
21748 tree args
= ARGUMENT_PACK_ARGS (arg
);
21749 int i
, len
= TREE_VEC_LENGTH (args
);
21750 for (i
= 0; i
< len
; ++i
)
21752 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21758 else if (TYPE_P (arg
))
21759 return dependent_type_p (arg
);
21761 return (type_dependent_expression_p (arg
)
21762 || value_dependent_expression_p (arg
));
21765 /* Returns true if ARGS (a collection of template arguments) contains
21766 any types that require structural equality testing. */
21769 any_template_arguments_need_structural_equality_p (tree args
)
21776 if (args
== error_mark_node
)
21779 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21781 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21782 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21784 tree arg
= TREE_VEC_ELT (level
, j
);
21785 tree packed_args
= NULL_TREE
;
21788 if (ARGUMENT_PACK_P (arg
))
21790 /* Look inside the argument pack. */
21791 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21792 len
= TREE_VEC_LENGTH (packed_args
);
21795 for (k
= 0; k
< len
; ++k
)
21798 arg
= TREE_VEC_ELT (packed_args
, k
);
21800 if (error_operand_p (arg
))
21802 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21804 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21806 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21807 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21816 /* Returns true if ARGS (a collection of template arguments) contains
21817 any dependent arguments. */
21820 any_dependent_template_arguments_p (const_tree args
)
21827 if (args
== error_mark_node
)
21830 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21832 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21833 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21834 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21841 /* Returns TRUE if the template TMPL is dependent. */
21844 dependent_template_p (tree tmpl
)
21846 if (TREE_CODE (tmpl
) == OVERLOAD
)
21850 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21852 tmpl
= OVL_NEXT (tmpl
);
21857 /* Template template parameters are dependent. */
21858 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21859 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21861 /* So are names that have not been looked up. */
21862 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21864 /* So are member templates of dependent classes. */
21865 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21866 return dependent_type_p (DECL_CONTEXT (tmpl
));
21870 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21873 dependent_template_id_p (tree tmpl
, tree args
)
21875 return (dependent_template_p (tmpl
)
21876 || any_dependent_template_arguments_p (args
));
21879 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21883 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21887 if (!processing_template_decl
)
21890 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21892 tree decl
= TREE_VEC_ELT (declv
, i
);
21893 tree init
= TREE_VEC_ELT (initv
, i
);
21894 tree cond
= TREE_VEC_ELT (condv
, i
);
21895 tree incr
= TREE_VEC_ELT (incrv
, i
);
21897 if (type_dependent_expression_p (decl
))
21900 if (init
&& type_dependent_expression_p (init
))
21903 if (type_dependent_expression_p (cond
))
21906 if (COMPARISON_CLASS_P (cond
)
21907 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21908 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21911 if (TREE_CODE (incr
) == MODOP_EXPR
)
21913 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21914 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21917 else if (type_dependent_expression_p (incr
))
21919 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21921 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21923 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21925 tree t
= TREE_OPERAND (incr
, 1);
21926 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21927 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21936 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21937 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21938 no such TYPE can be found. Note that this function peers inside
21939 uninstantiated templates and therefore should be used only in
21940 extremely limited situations. ONLY_CURRENT_P restricts this
21941 peering to the currently open classes hierarchy (which is required
21942 when comparing types). */
21945 resolve_typename_type (tree type
, bool only_current_p
)
21954 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21956 scope
= TYPE_CONTEXT (type
);
21957 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21958 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21959 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21960 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21961 identifier of the TYPENAME_TYPE anymore.
21962 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21963 TYPENAME_TYPE instead, we avoid messing up with a possible
21964 typedef variant case. */
21965 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21967 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21968 it first before we can figure out what NAME refers to. */
21969 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21971 if (TYPENAME_IS_RESOLVING_P (scope
))
21972 /* Given a class template A with a dependent base with nested type C,
21973 typedef typename A::C::C C will land us here, as trying to resolve
21974 the initial A::C leads to the local C typedef, which leads back to
21975 A::C::C. So we break the recursion now. */
21978 scope
= resolve_typename_type (scope
, only_current_p
);
21980 /* If we don't know what SCOPE refers to, then we cannot resolve the
21982 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21984 /* If the SCOPE is a template type parameter, we have no way of
21985 resolving the name. */
21986 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21988 /* If the SCOPE is not the current instantiation, there's no reason
21989 to look inside it. */
21990 if (only_current_p
&& !currently_open_class (scope
))
21992 /* If this is a typedef, we don't want to look inside (c++/11987). */
21993 if (typedef_variant_p (type
))
21995 /* If SCOPE isn't the template itself, it will not have a valid
21996 TYPE_FIELDS list. */
21997 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21998 /* scope is either the template itself or a compatible instantiation
21999 like X<T>, so look up the name in the original template. */
22000 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
22002 /* scope is a partial instantiation, so we can't do the lookup or we
22003 will lose the template arguments. */
22005 /* Enter the SCOPE so that name lookup will be resolved as if we
22006 were in the class definition. In particular, SCOPE will no
22007 longer be considered a dependent type. */
22008 pushed_scope
= push_scope (scope
);
22009 /* Look up the declaration. */
22010 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
22011 tf_warning_or_error
);
22013 result
= NULL_TREE
;
22015 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
22016 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
22019 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
22020 && TREE_CODE (decl
) == TYPE_DECL
)
22022 result
= TREE_TYPE (decl
);
22023 if (result
== error_mark_node
)
22024 result
= NULL_TREE
;
22026 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
22027 && DECL_CLASS_TEMPLATE_P (decl
))
22031 /* Obtain the template and the arguments. */
22032 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
22033 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
22034 /* Instantiate the template. */
22035 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
22036 /*entering_scope=*/0,
22037 tf_error
| tf_user
);
22038 if (result
== error_mark_node
)
22039 result
= NULL_TREE
;
22042 /* Leave the SCOPE. */
22044 pop_scope (pushed_scope
);
22046 /* If we failed to resolve it, return the original typename. */
22050 /* If lookup found a typename type, resolve that too. */
22051 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
22053 /* Ill-formed programs can cause infinite recursion here, so we
22054 must catch that. */
22055 TYPENAME_IS_RESOLVING_P (type
) = 1;
22056 result
= resolve_typename_type (result
, only_current_p
);
22057 TYPENAME_IS_RESOLVING_P (type
) = 0;
22060 /* Qualify the resulting type. */
22061 quals
= cp_type_quals (type
);
22063 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
22068 /* EXPR is an expression which is not type-dependent. Return a proxy
22069 for EXPR that can be used to compute the types of larger
22070 expressions containing EXPR. */
22073 build_non_dependent_expr (tree expr
)
22077 #ifdef ENABLE_CHECKING
22078 /* Try to get a constant value for all non-dependent expressions in
22079 order to expose bugs in *_dependent_expression_p and constexpr. */
22080 if (cxx_dialect
>= cxx11
)
22081 fold_non_dependent_expr (expr
);
22084 /* Preserve OVERLOADs; the functions must be available to resolve
22087 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
22088 inner_expr
= stmt_expr_value_expr (inner_expr
);
22089 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
22090 inner_expr
= TREE_OPERAND (inner_expr
, 0);
22091 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
22092 inner_expr
= TREE_OPERAND (inner_expr
, 1);
22093 if (is_overloaded_fn (inner_expr
)
22094 || TREE_CODE (inner_expr
) == OFFSET_REF
)
22096 /* There is no need to return a proxy for a variable. */
22099 /* Preserve string constants; conversions from string constants to
22100 "char *" are allowed, even though normally a "const char *"
22101 cannot be used to initialize a "char *". */
22102 if (TREE_CODE (expr
) == STRING_CST
)
22104 /* Preserve void and arithmetic constants, as an optimization -- there is no
22105 reason to create a new node. */
22106 if (TREE_CODE (expr
) == VOID_CST
22107 || TREE_CODE (expr
) == INTEGER_CST
22108 || TREE_CODE (expr
) == REAL_CST
)
22110 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
22111 There is at least one place where we want to know that a
22112 particular expression is a throw-expression: when checking a ?:
22113 expression, there are special rules if the second or third
22114 argument is a throw-expression. */
22115 if (TREE_CODE (expr
) == THROW_EXPR
)
22118 /* Don't wrap an initializer list, we need to be able to look inside. */
22119 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
22122 /* Don't wrap a dummy object, we need to be able to test for it. */
22123 if (is_dummy_object (expr
))
22126 if (TREE_CODE (expr
) == COND_EXPR
)
22127 return build3 (COND_EXPR
,
22129 TREE_OPERAND (expr
, 0),
22130 (TREE_OPERAND (expr
, 1)
22131 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
22132 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
22133 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
22134 if (TREE_CODE (expr
) == COMPOUND_EXPR
22135 && !COMPOUND_EXPR_OVERLOADED (expr
))
22136 return build2 (COMPOUND_EXPR
,
22138 TREE_OPERAND (expr
, 0),
22139 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
22141 /* If the type is unknown, it can't really be non-dependent */
22142 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
22144 /* Otherwise, build a NON_DEPENDENT_EXPR. */
22145 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
22148 /* ARGS is a vector of expressions as arguments to a function call.
22149 Replace the arguments with equivalent non-dependent expressions.
22150 This modifies ARGS in place. */
22153 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
22158 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
22160 tree newarg
= build_non_dependent_expr (arg
);
22162 (*args
)[ix
] = newarg
;
22166 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
22167 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
22171 make_auto_1 (tree name
)
22173 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
22174 TYPE_NAME (au
) = build_decl (input_location
,
22175 TYPE_DECL
, name
, au
);
22176 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
22177 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
22178 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
22179 TYPE_NAME (au
), NULL_TREE
);
22180 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
22181 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
22182 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
22188 make_decltype_auto (void)
22190 return make_auto_1 (get_identifier ("decltype(auto)"));
22196 return make_auto_1 (get_identifier ("auto"));
22199 /* Given type ARG, return std::initializer_list<ARG>. */
22204 tree std_init_list
= namespace_binding
22205 (get_identifier ("initializer_list"), std_node
);
22207 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
22209 error ("deducing from brace-enclosed initializer list requires "
22210 "#include <initializer_list>");
22211 return error_mark_node
;
22213 argvec
= make_tree_vec (1);
22214 TREE_VEC_ELT (argvec
, 0) = arg
;
22215 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
22216 NULL_TREE
, 0, tf_warning_or_error
);
22219 /* Replace auto in TYPE with std::initializer_list<auto>. */
22222 listify_autos (tree type
, tree auto_node
)
22224 tree init_auto
= listify (auto_node
);
22225 tree argvec
= make_tree_vec (1);
22226 TREE_VEC_ELT (argvec
, 0) = init_auto
;
22227 if (processing_template_decl
)
22228 argvec
= add_to_template_args (current_template_args (), argvec
);
22229 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22232 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
22233 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
22236 do_auto_deduction (tree type
, tree init
, tree auto_node
)
22240 if (init
== error_mark_node
)
22241 return error_mark_node
;
22243 if (type_dependent_expression_p (init
))
22244 /* Defining a subset of type-dependent expressions that we can deduce
22245 from ahead of time isn't worth the trouble. */
22248 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
22249 with either a new invented type template parameter U or, if the
22250 initializer is a braced-init-list (8.5.4), with
22251 std::initializer_list<U>. */
22252 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
22254 if (!DIRECT_LIST_INIT_P (init
))
22255 type
= listify_autos (type
, auto_node
);
22256 else if (CONSTRUCTOR_NELTS (init
) == 1)
22257 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
22260 if (permerror (input_location
, "direct-list-initialization of "
22261 "%<auto%> requires exactly one element"))
22262 inform (input_location
,
22263 "for deduction to %<std::initializer_list%>, use copy-"
22264 "list-initialization (i.e. add %<=%> before the %<{%>)");
22265 type
= listify_autos (type
, auto_node
);
22269 init
= resolve_nondeduced_context (init
);
22271 targs
= make_tree_vec (1);
22272 if (AUTO_IS_DECLTYPE (auto_node
))
22274 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
22275 && !REF_PARENTHESIZED_P (init
)));
22276 TREE_VEC_ELT (targs
, 0)
22277 = finish_decltype_type (init
, id
, tf_warning_or_error
);
22278 if (type
!= auto_node
)
22280 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
22281 return error_mark_node
;
22286 tree parms
= build_tree_list (NULL_TREE
, type
);
22287 tree tparms
= make_tree_vec (1);
22290 TREE_VEC_ELT (tparms
, 0)
22291 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
22292 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
22293 DEDUCE_CALL
, LOOKUP_NORMAL
,
22294 NULL
, /*explain_p=*/false);
22297 if (processing_template_decl
)
22298 /* Try again at instantiation time. */
22300 if (type
&& type
!= error_mark_node
)
22301 /* If type is error_mark_node a diagnostic must have been
22302 emitted by now. Also, having a mention to '<type error>'
22303 in the diagnostic is not really useful to the user. */
22305 if (cfun
&& auto_node
== current_function_auto_return_pattern
22306 && LAMBDA_FUNCTION_P (current_function_decl
))
22307 error ("unable to deduce lambda return type from %qE", init
);
22309 error ("unable to deduce %qT from %qE", type
, init
);
22311 return error_mark_node
;
22315 /* If the list of declarators contains more than one declarator, the type
22316 of each declared variable is determined as described above. If the
22317 type deduced for the template parameter U is not the same in each
22318 deduction, the program is ill-formed. */
22319 if (TREE_TYPE (auto_node
)
22320 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
22322 if (cfun
&& auto_node
== current_function_auto_return_pattern
22323 && LAMBDA_FUNCTION_P (current_function_decl
))
22324 error ("inconsistent types %qT and %qT deduced for "
22325 "lambda return type", TREE_TYPE (auto_node
),
22326 TREE_VEC_ELT (targs
, 0));
22328 error ("inconsistent deduction for %qT: %qT and then %qT",
22329 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
22330 return error_mark_node
;
22332 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
22334 if (processing_template_decl
)
22335 targs
= add_to_template_args (current_template_args (), targs
);
22336 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
22339 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22343 splice_late_return_type (tree type
, tree late_return_type
)
22347 if (late_return_type
== NULL_TREE
)
22349 argvec
= make_tree_vec (1);
22350 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
22351 if (processing_template_parmlist
)
22352 /* For a late-specified return type in a template type-parameter, we
22353 need to add a dummy argument level for its parmlist. */
22354 argvec
= add_to_template_args
22355 (make_tree_vec (processing_template_parmlist
), argvec
);
22356 if (current_template_parms
)
22357 argvec
= add_to_template_args (current_template_args (), argvec
);
22358 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22361 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22362 'decltype(auto)'. */
22365 is_auto (const_tree type
)
22367 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
22368 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
22369 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
22375 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22376 a use of `auto'. Returns NULL_TREE otherwise. */
22379 type_uses_auto (tree type
)
22381 return find_type_usage (type
, is_auto
);
22384 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22385 'decltype(auto)' or a concept. */
22388 is_auto_or_concept (const_tree type
)
22390 return is_auto (type
); // or concept
22393 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22394 a concept identifier) iff TYPE contains a use of a generic type. Returns
22395 NULL_TREE otherwise. */
22398 type_uses_auto_or_concept (tree type
)
22400 return find_type_usage (type
, is_auto_or_concept
);
22404 /* For a given template T, return the vector of typedefs referenced
22405 in T for which access check is needed at T instantiation time.
22406 T is either a FUNCTION_DECL or a RECORD_TYPE.
22407 Those typedefs were added to T by the function
22408 append_type_to_template_for_access_check. */
22410 vec
<qualified_typedef_usage_t
, va_gc
> *
22411 get_types_needing_access_check (tree t
)
22414 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
22416 if (!t
|| t
== error_mark_node
)
22419 if (!(ti
= get_template_info (t
)))
22422 if (CLASS_TYPE_P (t
)
22423 || TREE_CODE (t
) == FUNCTION_DECL
)
22425 if (!TI_TEMPLATE (ti
))
22428 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
22434 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22435 tied to T. That list of typedefs will be access checked at
22436 T instantiation time.
22437 T is either a FUNCTION_DECL or a RECORD_TYPE.
22438 TYPE_DECL is a TYPE_DECL node representing a typedef.
22439 SCOPE is the scope through which TYPE_DECL is accessed.
22440 LOCATION is the location of the usage point of TYPE_DECL.
22442 This function is a subroutine of
22443 append_type_to_template_for_access_check. */
22446 append_type_to_template_for_access_check_1 (tree t
,
22449 location_t location
)
22451 qualified_typedef_usage_t typedef_usage
;
22454 if (!t
|| t
== error_mark_node
)
22457 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
22458 || CLASS_TYPE_P (t
))
22460 && TREE_CODE (type_decl
) == TYPE_DECL
22463 if (!(ti
= get_template_info (t
)))
22466 gcc_assert (TI_TEMPLATE (ti
));
22468 typedef_usage
.typedef_decl
= type_decl
;
22469 typedef_usage
.context
= scope
;
22470 typedef_usage
.locus
= location
;
22472 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22475 /* Append TYPE_DECL to the template TEMPL.
22476 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22477 At TEMPL instanciation time, TYPE_DECL will be checked to see
22478 if it can be accessed through SCOPE.
22479 LOCATION is the location of the usage point of TYPE_DECL.
22481 e.g. consider the following code snippet:
22488 template<class U> struct S
22490 C::myint mi; // <-- usage point of the typedef C::myint
22495 At S<char> instantiation time, we need to check the access of C::myint
22496 In other words, we need to check the access of the myint typedef through
22497 the C scope. For that purpose, this function will add the myint typedef
22498 and the scope C through which its being accessed to a list of typedefs
22499 tied to the template S. That list will be walked at template instantiation
22500 time and access check performed on each typedefs it contains.
22501 Note that this particular code snippet should yield an error because
22502 myint is private to C. */
22505 append_type_to_template_for_access_check (tree templ
,
22508 location_t location
)
22510 qualified_typedef_usage_t
*iter
;
22513 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22515 /* Make sure we don't append the type to the template twice. */
22516 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22517 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22520 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22524 /* Convert the generic type parameters in PARM that match the types given in the
22525 range [START_IDX, END_IDX) from the current_template_parms into generic type
22529 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22531 tree current
= current_template_parms
;
22532 int depth
= TMPL_PARMS_DEPTH (current
);
22533 current
= INNERMOST_TEMPLATE_PARMS (current
);
22534 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22536 for (int i
= 0; i
< start_idx
; ++i
)
22537 TREE_VEC_ELT (replacement
, i
)
22538 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22540 for (int i
= start_idx
; i
< end_idx
; ++i
)
22542 /* Create a distinct parameter pack type from the current parm and add it
22543 to the replacement args to tsubst below into the generic function
22546 tree o
= TREE_TYPE (TREE_VALUE
22547 (TREE_VEC_ELT (current
, i
)));
22548 tree t
= copy_type (o
);
22549 TEMPLATE_TYPE_PARM_INDEX (t
)
22550 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22552 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22553 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22554 TYPE_MAIN_VARIANT (t
) = t
;
22555 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22556 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22557 TREE_VEC_ELT (replacement
, i
) = t
;
22558 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22561 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22562 TREE_VEC_ELT (replacement
, i
)
22563 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22565 /* If there are more levels then build up the replacement with the outer
22568 replacement
= add_to_template_args (template_parms_to_args
22569 (TREE_CHAIN (current_template_parms
)),
22572 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22576 /* Set up the hash tables for template instantiations. */
22579 init_template_processing (void)
22581 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22582 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22585 /* Print stats about the template hash tables for -fstats. */
22588 print_template_statistics (void)
22590 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22591 "%f collisions\n", (long) decl_specializations
->size (),
22592 (long) decl_specializations
->elements (),
22593 decl_specializations
->collisions ());
22594 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22595 "%f collisions\n", (long) type_specializations
->size (),
22596 (long) type_specializations
->elements (),
22597 type_specializations
->collisions ());
22600 #include "gt-cp-pt.h"