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 (not just variable templates) because of cases like:
11311 template <class T> void f() { extern T t; }
11313 where the entity referenced is not known until
11314 instantiation time. */
11316 ctx
= DECL_CONTEXT (t
);
11317 if (DECL_CLASS_SCOPE_P (t
))
11319 ctx
= tsubst_aggr_type (ctx
, args
,
11321 in_decl
, /*entering_scope=*/1);
11322 /* If CTX is unchanged, then T is in fact the
11323 specialization we want. That situation occurs when
11324 referencing a static data member within in its own
11325 class. We can use pointer equality, rather than
11326 same_type_p, because DECL_CONTEXT is always
11328 if (ctx
== DECL_CONTEXT (t
)
11329 /* ... unless T is a member template; in which
11330 case our caller can be willing to create a
11331 specialization of that template represented
11333 && !(DECL_TI_TEMPLATE (t
)
11334 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
11340 tmpl
= DECL_TI_TEMPLATE (t
);
11341 gen_tmpl
= most_general_template (tmpl
);
11342 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11343 if (argvec
!= error_mark_node
)
11344 argvec
= (coerce_innermost_template_parms
11345 (DECL_TEMPLATE_PARMS (gen_tmpl
),
11346 argvec
, t
, complain
,
11347 /*all*/true, /*defarg*/true));
11348 if (argvec
== error_mark_node
)
11349 RETURN (error_mark_node
);
11350 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11351 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11356 /* A local variable. */
11358 /* Subsequent calls to pushdecl will fill this in. */
11360 spec
= retrieve_local_specialization (t
);
11362 /* If we already have the specialization we need, there is
11363 nothing more to do. */
11370 /* Create a new node for the specialization we need. */
11372 if (type
== NULL_TREE
)
11374 if (is_typedef_decl (t
))
11375 type
= DECL_ORIGINAL_TYPE (t
);
11377 type
= TREE_TYPE (t
);
11379 && VAR_HAD_UNKNOWN_BOUND (t
)
11380 && type
!= error_mark_node
)
11381 type
= strip_array_domain (type
);
11382 type
= tsubst (type
, args
, complain
, in_decl
);
11386 /* Even if the original location is out of scope, the
11387 newly substituted one is not. */
11388 DECL_DEAD_FOR_LOCAL (r
) = 0;
11389 DECL_INITIALIZED_P (r
) = 0;
11390 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11391 if (type
== error_mark_node
)
11392 RETURN (error_mark_node
);
11393 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11395 /* It may seem that this case cannot occur, since:
11400 declares a function, not a variable. However:
11403 template <typename T> void g() { T t; }
11404 template void g<f>();
11406 is an attempt to declare a variable with function
11408 error ("variable %qD has function type",
11409 /* R is not yet sufficiently initialized, so we
11410 just use its name. */
11412 RETURN (error_mark_node
);
11414 type
= complete_type (type
);
11415 /* Wait until cp_finish_decl to set this again, to handle
11416 circular dependency (template/instantiate6.C). */
11417 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11418 type
= check_var_type (DECL_NAME (r
), type
);
11420 if (DECL_HAS_VALUE_EXPR_P (t
))
11422 tree ve
= DECL_VALUE_EXPR (t
);
11423 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11424 /*constant_expression_p=*/false);
11425 if (REFERENCE_REF_P (ve
))
11427 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11428 ve
= TREE_OPERAND (ve
, 0);
11430 SET_DECL_VALUE_EXPR (r
, ve
);
11432 if (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
11433 set_decl_tls_model (r
, decl_tls_model (t
));
11435 else if (DECL_SELF_REFERENCE_P (t
))
11436 SET_DECL_SELF_REFERENCE_P (r
);
11437 TREE_TYPE (r
) = type
;
11438 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11439 DECL_CONTEXT (r
) = ctx
;
11440 /* Clear out the mangled name and RTL for the instantiation. */
11441 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11442 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11443 SET_DECL_RTL (r
, NULL
);
11444 /* The initializer must not be expanded until it is required;
11445 see [temp.inst]. */
11446 DECL_INITIAL (r
) = NULL_TREE
;
11447 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11448 SET_DECL_RTL (r
, NULL
);
11449 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11452 /* Possibly limit visibility based on template args. */
11453 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11454 if (DECL_VISIBILITY_SPECIFIED (t
))
11456 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11457 DECL_ATTRIBUTES (r
)
11458 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11460 determine_visibility (r
);
11465 /* A static data member declaration is always marked
11466 external when it is declared in-class, even if an
11467 initializer is present. We mimic the non-template
11468 processing here. */
11469 DECL_EXTERNAL (r
) = 1;
11470 if (DECL_NAMESPACE_SCOPE_P (t
))
11471 DECL_NOT_REALLY_EXTERN (r
) = 1;
11473 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11474 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11475 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11477 else if (!cp_unevaluated_operand
)
11478 register_local_specialization (r
, t
);
11480 DECL_CHAIN (r
) = NULL_TREE
;
11482 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11484 args
, complain
, in_decl
);
11486 /* Preserve a typedef that names a type. */
11487 if (is_typedef_decl (r
))
11489 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11490 set_underlying_type (r
);
11493 layout_decl (r
, 0);
11498 gcc_unreachable ();
11503 /* Restore the file and line information. */
11504 input_location
= saved_loc
;
11509 /* Substitute into the ARG_TYPES of a function type.
11510 If END is a TREE_CHAIN, leave it and any following types
11514 tsubst_arg_types (tree arg_types
,
11517 tsubst_flags_t complain
,
11520 tree remaining_arg_types
;
11521 tree type
= NULL_TREE
;
11523 tree expanded_args
= NULL_TREE
;
11526 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11529 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11530 args
, end
, complain
, in_decl
);
11531 if (remaining_arg_types
== error_mark_node
)
11532 return error_mark_node
;
11534 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11536 /* For a pack expansion, perform substitution on the
11537 entire expression. Later on, we'll handle the arguments
11539 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11540 args
, complain
, in_decl
);
11542 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11543 /* So that we'll spin through the parameters, one by one. */
11544 i
= TREE_VEC_LENGTH (expanded_args
);
11547 /* We only partially substituted into the parameter
11548 pack. Our type is TYPE_PACK_EXPANSION. */
11549 type
= expanded_args
;
11550 expanded_args
= NULL_TREE
;
11558 type
= TREE_VEC_ELT (expanded_args
, i
);
11560 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11562 if (type
== error_mark_node
)
11563 return error_mark_node
;
11564 if (VOID_TYPE_P (type
))
11566 if (complain
& tf_error
)
11568 error ("invalid parameter type %qT", type
);
11570 error ("in declaration %q+D", in_decl
);
11572 return error_mark_node
;
11575 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11576 return error_mark_node
;
11578 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11579 top-level qualifiers as required. */
11580 type
= cv_unqualified (type_decays_to (type
));
11582 /* We do not substitute into default arguments here. The standard
11583 mandates that they be instantiated only when needed, which is
11584 done in build_over_call. */
11585 default_arg
= TREE_PURPOSE (arg_types
);
11587 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11589 /* We've instantiated a template before its default arguments
11590 have been parsed. This can happen for a nested template
11591 class, and is not an error unless we require the default
11592 argument in a call of this function. */
11593 remaining_arg_types
=
11594 tree_cons (default_arg
, type
, remaining_arg_types
);
11595 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11598 remaining_arg_types
=
11599 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11602 return remaining_arg_types
;
11605 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11606 *not* handle the exception-specification for FNTYPE, because the
11607 initial substitution of explicitly provided template parameters
11608 during argument deduction forbids substitution into the
11609 exception-specification:
11613 All references in the function type of the function template to the
11614 corresponding template parameters are replaced by the specified tem-
11615 plate argument values. If a substitution in a template parameter or
11616 in the function type of the function template results in an invalid
11617 type, type deduction fails. [Note: The equivalent substitution in
11618 exception specifications is done only when the function is instanti-
11619 ated, at which point a program is ill-formed if the substitution
11620 results in an invalid type.] */
11623 tsubst_function_type (tree t
,
11625 tsubst_flags_t complain
,
11629 tree arg_types
= NULL_TREE
;
11632 /* The TYPE_CONTEXT is not used for function/method types. */
11633 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11635 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11637 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11639 if (late_return_type_p
)
11641 /* Substitute the argument types. */
11642 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11643 complain
, in_decl
);
11644 if (arg_types
== error_mark_node
)
11645 return error_mark_node
;
11647 tree save_ccp
= current_class_ptr
;
11648 tree save_ccr
= current_class_ref
;
11649 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11650 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11651 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11654 /* DR 1207: 'this' is in scope in the trailing return type. */
11655 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11658 /* Substitute the return type. */
11659 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11663 current_class_ptr
= save_ccp
;
11664 current_class_ref
= save_ccr
;
11668 /* Substitute the return type. */
11669 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11671 if (return_type
== error_mark_node
)
11672 return error_mark_node
;
11673 /* DR 486 clarifies that creation of a function type with an
11674 invalid return type is a deduction failure. */
11675 if (TREE_CODE (return_type
) == ARRAY_TYPE
11676 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11678 if (complain
& tf_error
)
11680 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11681 error ("function returning an array");
11683 error ("function returning a function");
11685 return error_mark_node
;
11688 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11689 return error_mark_node
;
11691 if (!late_return_type_p
)
11693 /* Substitute the argument types. */
11694 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11695 complain
, in_decl
);
11696 if (arg_types
== error_mark_node
)
11697 return error_mark_node
;
11700 /* Construct a new type node and return it. */
11701 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11703 fntype
= build_function_type (return_type
, arg_types
);
11704 fntype
= apply_memfn_quals (fntype
,
11705 type_memfn_quals (t
),
11706 type_memfn_rqual (t
));
11710 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11711 /* Don't pick up extra function qualifiers from the basetype. */
11712 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11713 if (! MAYBE_CLASS_TYPE_P (r
))
11717 Type deduction may fail for any of the following
11720 -- Attempting to create "pointer to member of T" when T
11721 is not a class type. */
11722 if (complain
& tf_error
)
11723 error ("creating pointer to member function of non-class type %qT",
11725 return error_mark_node
;
11728 fntype
= build_method_type_directly (r
, return_type
,
11729 TREE_CHAIN (arg_types
));
11730 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11732 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11734 if (late_return_type_p
)
11735 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11740 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11741 ARGS into that specification, and return the substituted
11742 specification. If there is no specification, return NULL_TREE. */
11745 tsubst_exception_specification (tree fntype
,
11747 tsubst_flags_t complain
,
11754 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11755 new_specs
= NULL_TREE
;
11756 if (specs
&& TREE_PURPOSE (specs
))
11758 /* A noexcept-specifier. */
11759 tree expr
= TREE_PURPOSE (specs
);
11760 if (TREE_CODE (expr
) == INTEGER_CST
)
11764 /* Defer instantiation of noexcept-specifiers to avoid
11765 excessive instantiations (c++/49107). */
11766 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11767 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11769 /* We already partially instantiated this member template,
11770 so combine the new args with the old. */
11771 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11772 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11773 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11774 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11778 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11779 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11783 new_specs
= tsubst_copy_and_build
11784 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11785 /*integral_constant_expression_p=*/true);
11786 new_specs
= build_noexcept_spec (new_specs
, complain
);
11790 if (! TREE_VALUE (specs
))
11797 tree expanded_specs
= NULL_TREE
;
11799 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11801 /* Expand the pack expansion type. */
11802 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11806 if (expanded_specs
== error_mark_node
)
11807 return error_mark_node
;
11808 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11809 len
= TREE_VEC_LENGTH (expanded_specs
);
11812 /* We're substituting into a member template, so
11813 we got a TYPE_PACK_EXPANSION back. Add that
11814 expansion and move on. */
11815 gcc_assert (TREE_CODE (expanded_specs
)
11816 == TYPE_PACK_EXPANSION
);
11817 new_specs
= add_exception_specifier (new_specs
,
11820 specs
= TREE_CHAIN (specs
);
11825 for (i
= 0; i
< len
; ++i
)
11827 if (expanded_specs
)
11828 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11830 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11831 if (spec
== error_mark_node
)
11833 new_specs
= add_exception_specifier (new_specs
, spec
,
11837 specs
= TREE_CHAIN (specs
);
11843 /* Take the tree structure T and replace template parameters used
11844 therein with the argument vector ARGS. IN_DECL is an associated
11845 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11846 Issue error and warning messages under control of COMPLAIN. Note
11847 that we must be relatively non-tolerant of extensions here, in
11848 order to preserve conformance; if we allow substitutions that
11849 should not be allowed, we may allow argument deductions that should
11850 not succeed, and therefore report ambiguous overload situations
11851 where there are none. In theory, we could allow the substitution,
11852 but indicate that it should have failed, and allow our caller to
11853 make sure that the right thing happens, but we don't try to do this
11856 This function is used for dealing with types, decls and the like;
11857 for expressions, use tsubst_expr or tsubst_copy. */
11860 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11862 enum tree_code code
;
11863 tree type
, r
= NULL_TREE
;
11865 if (t
== NULL_TREE
|| t
== error_mark_node
11866 || t
== integer_type_node
11867 || t
== void_type_node
11868 || t
== char_type_node
11869 || t
== unknown_type_node
11870 || TREE_CODE (t
) == NAMESPACE_DECL
11871 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11875 return tsubst_decl (t
, args
, complain
);
11877 if (args
== NULL_TREE
)
11880 code
= TREE_CODE (t
);
11882 if (code
== IDENTIFIER_NODE
)
11883 type
= IDENTIFIER_TYPE_VALUE (t
);
11885 type
= TREE_TYPE (t
);
11887 gcc_assert (type
!= unknown_type_node
);
11889 /* Reuse typedefs. We need to do this to handle dependent attributes,
11890 such as attribute aligned. */
11892 && typedef_variant_p (t
))
11894 tree decl
= TYPE_NAME (t
);
11896 if (alias_template_specialization_p (t
))
11898 /* DECL represents an alias template and we want to
11900 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11901 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11902 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11904 else if (DECL_CLASS_SCOPE_P (decl
)
11905 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11906 && uses_template_parms (DECL_CONTEXT (decl
)))
11908 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11909 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11910 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11912 else if (DECL_FUNCTION_SCOPE_P (decl
)
11913 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11914 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11915 r
= retrieve_local_specialization (decl
);
11917 /* The typedef is from a non-template context. */
11923 r
= cp_build_qualified_type_real
11924 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11925 complain
| tf_ignore_bad_quals
);
11930 /* We don't have an instantiation yet, so drop the typedef. */
11931 int quals
= cp_type_quals (t
);
11932 t
= DECL_ORIGINAL_TYPE (decl
);
11933 t
= cp_build_qualified_type_real (t
, quals
,
11934 complain
| tf_ignore_bad_quals
);
11939 && code
!= TYPENAME_TYPE
11940 && code
!= TEMPLATE_TYPE_PARM
11941 && code
!= IDENTIFIER_NODE
11942 && code
!= FUNCTION_TYPE
11943 && code
!= METHOD_TYPE
)
11944 type
= tsubst (type
, args
, complain
, in_decl
);
11945 if (type
== error_mark_node
)
11946 return error_mark_node
;
11952 case ENUMERAL_TYPE
:
11953 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11954 /*entering_scope=*/0);
11957 case IDENTIFIER_NODE
:
11968 if (t
== integer_type_node
)
11971 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11972 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11976 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11978 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11979 /*integral_constant_expression_p=*/false);
11981 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11983 if (TREE_CODE (max
) == NOP_EXPR
11984 && TREE_SIDE_EFFECTS (omax
)
11985 && !TREE_TYPE (max
))
11986 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11988 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11989 with TREE_SIDE_EFFECTS that indicates this is not an integral
11990 constant expression. */
11991 if (processing_template_decl
11992 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11994 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11995 TREE_SIDE_EFFECTS (max
) = 1;
11998 return compute_array_index_type (NULL_TREE
, max
, complain
);
12001 case TEMPLATE_TYPE_PARM
:
12002 case TEMPLATE_TEMPLATE_PARM
:
12003 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12004 case TEMPLATE_PARM_INDEX
:
12009 tree arg
= NULL_TREE
;
12013 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
12014 template_parm_level_and_index (t
, &level
, &idx
);
12016 levels
= TMPL_ARGS_DEPTH (args
);
12017 if (level
<= levels
)
12019 arg
= TMPL_ARG (args
, level
, idx
);
12021 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
12023 /* See through ARGUMENT_PACK_SELECT arguments. */
12024 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
12025 /* If the selected argument is an expansion E, that most
12026 likely means we were called from
12027 gen_elem_of_pack_expansion_instantiation during the
12028 substituting of pack an argument pack (which Ith
12029 element is a pack expansion, where I is
12030 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
12031 In this case, the Ith element resulting from this
12032 substituting is going to be a pack expansion, which
12033 pattern is the pattern of E. Let's return the
12035 gen_elem_of_pack_expansion_instantiation will
12036 build the resulting pack expansion from it. */
12037 if (PACK_EXPANSION_P (arg
))
12039 /* Make sure we aren't throwing away arg info. */
12040 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
12041 arg
= PACK_EXPANSION_PATTERN (arg
);
12046 if (arg
== error_mark_node
)
12047 return error_mark_node
;
12048 else if (arg
!= NULL_TREE
)
12050 if (ARGUMENT_PACK_P (arg
))
12051 /* If ARG is an argument pack, we don't actually want to
12052 perform a substitution here, because substitutions
12053 for argument packs are only done
12054 element-by-element. We can get to this point when
12055 substituting the type of a non-type template
12056 parameter pack, when that type actually contains
12057 template parameter packs from an outer template, e.g.,
12059 template<typename... Types> struct A {
12060 template<Types... Values> struct B { };
12064 if (code
== TEMPLATE_TYPE_PARM
)
12067 gcc_assert (TYPE_P (arg
));
12069 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
12071 return cp_build_qualified_type_real
12072 (arg
, quals
, complain
| tf_ignore_bad_quals
);
12074 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12076 /* We are processing a type constructed from a
12077 template template parameter. */
12078 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
12079 args
, complain
, in_decl
);
12080 if (argvec
== error_mark_node
)
12081 return error_mark_node
;
12083 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
12084 || TREE_CODE (arg
) == TEMPLATE_DECL
12085 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
12087 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
12088 /* Consider this code:
12090 template <template <class> class Template>
12092 template <class Arg> using Bind = Template<Arg>;
12095 template <template <class> class Template, class Arg>
12096 using Instantiate = Template<Arg>; //#0
12098 template <template <class> class Template,
12101 Instantiate<Internal<Template>::template Bind,
12104 When #1 is parsed, the
12105 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12106 parameter `Template' in #0 matches the
12107 UNBOUND_CLASS_TEMPLATE representing the argument
12108 `Internal<Template>::template Bind'; We then want
12109 to assemble the type `Bind<Argument>' that can't
12110 be fully created right now, because
12111 `Internal<Template>' not being complete, the Bind
12112 template cannot be looked up in that context. So
12113 we need to "store" `Bind<Argument>' for later
12114 when the context of Bind becomes complete. Let's
12115 store that in a TYPENAME_TYPE. */
12116 return make_typename_type (TYPE_CONTEXT (arg
),
12117 build_nt (TEMPLATE_ID_EXPR
,
12118 TYPE_IDENTIFIER (arg
),
12123 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12124 are resolving nested-types in the signature of a
12125 member function templates. Otherwise ARG is a
12126 TEMPLATE_DECL and is the real template to be
12128 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
12129 arg
= TYPE_NAME (arg
);
12131 r
= lookup_template_class (arg
,
12133 DECL_CONTEXT (arg
),
12134 /*entering_scope=*/0,
12136 return cp_build_qualified_type_real
12137 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
12140 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12141 return convert_from_reference (unshare_expr (arg
));
12145 /* This can happen during the attempted tsubst'ing in
12146 unify. This means that we don't yet have any information
12147 about the template parameter in question. */
12150 /* Early in template argument deduction substitution, we don't
12151 want to reduce the level of 'auto', or it will be confused
12152 with a normal template parm in subsequent deduction. */
12153 if (is_auto (t
) && (complain
& tf_partial
))
12156 /* If we get here, we must have been looking at a parm for a
12157 more deeply nested template. Make a new version of this
12158 template parameter, but with a lower level. */
12161 case TEMPLATE_TYPE_PARM
:
12162 case TEMPLATE_TEMPLATE_PARM
:
12163 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12164 if (cp_type_quals (t
))
12166 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
12167 r
= cp_build_qualified_type_real
12168 (r
, cp_type_quals (t
),
12169 complain
| (code
== TEMPLATE_TYPE_PARM
12170 ? tf_ignore_bad_quals
: 0));
12175 TEMPLATE_TYPE_PARM_INDEX (r
)
12176 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
12177 r
, levels
, args
, complain
);
12178 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
12179 TYPE_MAIN_VARIANT (r
) = r
;
12180 TYPE_POINTER_TO (r
) = NULL_TREE
;
12181 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
12183 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
12184 /* We have reduced the level of the template
12185 template parameter, but not the levels of its
12186 template parameters, so canonical_type_parameter
12187 will not be able to find the canonical template
12188 template parameter for this level. Thus, we
12189 require structural equality checking to compare
12190 TEMPLATE_TEMPLATE_PARMs. */
12191 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12192 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
12193 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12195 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
12197 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12199 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
12200 complain
, in_decl
);
12201 if (argvec
== error_mark_node
)
12202 return error_mark_node
;
12204 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
12205 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
12210 case TEMPLATE_PARM_INDEX
:
12211 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
12215 gcc_unreachable ();
12223 tree purpose
, value
, chain
;
12225 if (t
== void_list_node
)
12228 purpose
= TREE_PURPOSE (t
);
12231 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
12232 if (purpose
== error_mark_node
)
12233 return error_mark_node
;
12235 value
= TREE_VALUE (t
);
12238 value
= tsubst (value
, args
, complain
, in_decl
);
12239 if (value
== error_mark_node
)
12240 return error_mark_node
;
12242 chain
= TREE_CHAIN (t
);
12243 if (chain
&& chain
!= void_type_node
)
12245 chain
= tsubst (chain
, args
, complain
, in_decl
);
12246 if (chain
== error_mark_node
)
12247 return error_mark_node
;
12249 if (purpose
== TREE_PURPOSE (t
)
12250 && value
== TREE_VALUE (t
)
12251 && chain
== TREE_CHAIN (t
))
12253 return hash_tree_cons (purpose
, value
, chain
);
12257 /* We should never be tsubsting a binfo. */
12258 gcc_unreachable ();
12261 /* A vector of template arguments. */
12262 gcc_assert (!type
);
12263 return tsubst_template_args (t
, args
, complain
, in_decl
);
12266 case REFERENCE_TYPE
:
12268 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
12273 Type deduction may fail for any of the following
12276 -- Attempting to create a pointer to reference type.
12277 -- Attempting to create a reference to a reference type or
12278 a reference to void.
12280 Core issue 106 says that creating a reference to a reference
12281 during instantiation is no longer a cause for failure. We
12282 only enforce this check in strict C++98 mode. */
12283 if ((TREE_CODE (type
) == REFERENCE_TYPE
12284 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
12285 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
12287 static location_t last_loc
;
12289 /* We keep track of the last time we issued this error
12290 message to avoid spewing a ton of messages during a
12291 single bad template instantiation. */
12292 if (complain
& tf_error
12293 && last_loc
!= input_location
)
12295 if (VOID_TYPE_P (type
))
12296 error ("forming reference to void");
12297 else if (code
== POINTER_TYPE
)
12298 error ("forming pointer to reference type %qT", type
);
12300 error ("forming reference to reference type %qT", type
);
12301 last_loc
= input_location
;
12304 return error_mark_node
;
12306 else if (TREE_CODE (type
) == FUNCTION_TYPE
12307 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
12308 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12310 if (complain
& tf_error
)
12312 if (code
== POINTER_TYPE
)
12313 error ("forming pointer to qualified function type %qT",
12316 error ("forming reference to qualified function type %qT",
12319 return error_mark_node
;
12321 else if (code
== POINTER_TYPE
)
12323 r
= build_pointer_type (type
);
12324 if (TREE_CODE (type
) == METHOD_TYPE
)
12325 r
= build_ptrmemfunc_type (r
);
12327 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12328 /* In C++0x, during template argument substitution, when there is an
12329 attempt to create a reference to a reference type, reference
12330 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12332 "If a template-argument for a template-parameter T names a type
12333 that is a reference to a type A, an attempt to create the type
12334 'lvalue reference to cv T' creates the type 'lvalue reference to
12335 A,' while an attempt to create the type type rvalue reference to
12336 cv T' creates the type T"
12338 r
= cp_build_reference_type
12340 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12342 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12343 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12345 if (r
!= error_mark_node
)
12346 /* Will this ever be needed for TYPE_..._TO values? */
12353 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12354 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12358 Type deduction may fail for any of the following
12361 -- Attempting to create "pointer to member of T" when T
12362 is not a class type. */
12363 if (complain
& tf_error
)
12364 error ("creating pointer to member of non-class type %qT", r
);
12365 return error_mark_node
;
12367 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12369 if (complain
& tf_error
)
12370 error ("creating pointer to member reference type %qT", type
);
12371 return error_mark_node
;
12373 if (VOID_TYPE_P (type
))
12375 if (complain
& tf_error
)
12376 error ("creating pointer to member of type void");
12377 return error_mark_node
;
12379 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12380 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12382 /* The type of the implicit object parameter gets its
12383 cv-qualifiers from the FUNCTION_TYPE. */
12386 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12387 type_memfn_rqual (type
));
12388 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12389 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12393 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12397 case FUNCTION_TYPE
:
12402 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12403 if (fntype
== error_mark_node
)
12404 return error_mark_node
;
12406 /* Substitute the exception specification. */
12407 specs
= tsubst_exception_specification (t
, args
, complain
,
12408 in_decl
, /*defer_ok*/true);
12409 if (specs
== error_mark_node
)
12410 return error_mark_node
;
12412 fntype
= build_exception_variant (fntype
, specs
);
12417 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12418 if (domain
== error_mark_node
)
12419 return error_mark_node
;
12421 /* As an optimization, we avoid regenerating the array type if
12422 it will obviously be the same as T. */
12423 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12426 /* These checks should match the ones in create_array_type_for_decl.
12430 The deduction may fail for any of the following reasons:
12432 -- Attempting to create an array with an element type that
12433 is void, a function type, or a reference type, or [DR337]
12434 an abstract class type. */
12435 if (VOID_TYPE_P (type
)
12436 || TREE_CODE (type
) == FUNCTION_TYPE
12437 || (TREE_CODE (type
) == ARRAY_TYPE
12438 && TYPE_DOMAIN (type
) == NULL_TREE
)
12439 || TREE_CODE (type
) == REFERENCE_TYPE
)
12441 if (complain
& tf_error
)
12442 error ("creating array of %qT", type
);
12443 return error_mark_node
;
12446 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12447 return error_mark_node
;
12449 r
= build_cplus_array_type (type
, domain
);
12451 if (TYPE_USER_ALIGN (t
))
12453 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12454 TYPE_USER_ALIGN (r
) = 1;
12460 case TYPENAME_TYPE
:
12462 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12463 in_decl
, /*entering_scope=*/1);
12464 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12465 complain
, in_decl
);
12467 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12468 return error_mark_node
;
12470 if (!MAYBE_CLASS_TYPE_P (ctx
))
12472 if (complain
& tf_error
)
12473 error ("%qT is not a class, struct, or union type", ctx
);
12474 return error_mark_node
;
12476 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12478 /* Normally, make_typename_type does not require that the CTX
12479 have complete type in order to allow things like:
12481 template <class T> struct S { typename S<T>::X Y; };
12483 But, such constructs have already been resolved by this
12484 point, so here CTX really should have complete type, unless
12485 it's a partial instantiation. */
12486 ctx
= complete_type (ctx
);
12487 if (!COMPLETE_TYPE_P (ctx
))
12489 if (complain
& tf_error
)
12490 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12491 return error_mark_node
;
12495 f
= make_typename_type (ctx
, f
, typename_type
,
12496 complain
| tf_keep_type_decl
);
12497 if (f
== error_mark_node
)
12499 if (TREE_CODE (f
) == TYPE_DECL
)
12501 complain
|= tf_ignore_bad_quals
;
12505 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12507 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12509 if (complain
& tf_error
)
12510 error ("%qT resolves to %qT, which is not an enumeration type",
12513 return error_mark_node
;
12515 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12517 if (complain
& tf_error
)
12518 error ("%qT resolves to %qT, which is is not a class type",
12521 return error_mark_node
;
12525 return cp_build_qualified_type_real
12526 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12529 case UNBOUND_CLASS_TEMPLATE
:
12531 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12532 in_decl
, /*entering_scope=*/1);
12533 tree name
= TYPE_IDENTIFIER (t
);
12534 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12536 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12537 return error_mark_node
;
12540 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12541 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12548 ++cp_unevaluated_operand
;
12549 ++c_inhibit_evaluation_warnings
;
12551 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12553 /*integral_constant_expression_p=*/false);
12555 --cp_unevaluated_operand
;
12556 --c_inhibit_evaluation_warnings
;
12558 type
= finish_typeof (type
);
12559 return cp_build_qualified_type_real (type
,
12561 | cp_type_quals (type
),
12565 case DECLTYPE_TYPE
:
12569 ++cp_unevaluated_operand
;
12570 ++c_inhibit_evaluation_warnings
;
12572 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12573 complain
|tf_decltype
, in_decl
,
12574 /*function_p*/false,
12575 /*integral_constant_expression*/false);
12577 --cp_unevaluated_operand
;
12578 --c_inhibit_evaluation_warnings
;
12580 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12581 type
= lambda_capture_field_type (type
,
12582 DECLTYPE_FOR_INIT_CAPTURE (t
));
12583 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12584 type
= lambda_proxy_type (type
);
12587 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12588 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12590 /* In a template ~id could be either a complement expression
12591 or an unqualified-id naming a destructor; if instantiating
12592 it produces an expression, it's not an id-expression or
12595 type
= finish_decltype_type (type
, id
, complain
);
12597 return cp_build_qualified_type_real (type
,
12599 | cp_type_quals (type
),
12600 complain
| tf_ignore_bad_quals
);
12603 case UNDERLYING_TYPE
:
12605 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12606 complain
, in_decl
);
12607 return finish_underlying_type (type
);
12610 case TYPE_ARGUMENT_PACK
:
12611 case NONTYPE_ARGUMENT_PACK
:
12613 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12615 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12619 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12621 /* For template nontype argument packs, also substitute into
12623 if (code
== NONTYPE_ARGUMENT_PACK
)
12624 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12643 /* We should use one of the expression tsubsts for these codes. */
12644 gcc_unreachable ();
12647 sorry ("use of %qs in template", get_tree_code_name (code
));
12648 return error_mark_node
;
12652 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12653 type of the expression on the left-hand side of the "." or "->"
12657 tsubst_baselink (tree baselink
, tree object_type
,
12658 tree args
, tsubst_flags_t complain
, tree in_decl
)
12661 tree qualifying_scope
;
12664 tree template_args
= 0;
12665 bool template_id_p
= false;
12666 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12668 /* A baselink indicates a function from a base class. Both the
12669 BASELINK_ACCESS_BINFO and the base class referenced may
12670 indicate bases of the template class, rather than the
12671 instantiated class. In addition, lookups that were not
12672 ambiguous before may be ambiguous now. Therefore, we perform
12673 the lookup again. */
12674 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12675 qualifying_scope
= tsubst (qualifying_scope
, args
,
12676 complain
, in_decl
);
12677 fns
= BASELINK_FUNCTIONS (baselink
);
12678 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12679 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12681 template_id_p
= true;
12682 template_args
= TREE_OPERAND (fns
, 1);
12683 fns
= TREE_OPERAND (fns
, 0);
12685 template_args
= tsubst_template_args (template_args
, args
,
12686 complain
, in_decl
);
12688 name
= DECL_NAME (get_first_fn (fns
));
12689 if (IDENTIFIER_TYPENAME_P (name
))
12690 name
= mangle_conv_op_name_for_type (optype
);
12691 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12693 return error_mark_node
;
12695 /* If lookup found a single function, mark it as used at this
12696 point. (If it lookup found multiple functions the one selected
12697 later by overload resolution will be marked as used at that
12699 if (BASELINK_P (baselink
))
12700 fns
= BASELINK_FUNCTIONS (baselink
);
12701 if (!template_id_p
&& !really_overloaded_fn (fns
)
12702 && !mark_used (OVL_CURRENT (fns
), complain
) && !(complain
& tf_error
))
12703 return error_mark_node
;
12705 /* Add back the template arguments, if present. */
12706 if (BASELINK_P (baselink
) && template_id_p
)
12707 BASELINK_FUNCTIONS (baselink
)
12708 = build_nt (TEMPLATE_ID_EXPR
,
12709 BASELINK_FUNCTIONS (baselink
),
12711 /* Update the conversion operator type. */
12712 BASELINK_OPTYPE (baselink
) = optype
;
12715 object_type
= current_class_type
;
12718 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12724 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12725 true if the qualified-id will be a postfix-expression in-and-of
12726 itself; false if more of the postfix-expression follows the
12727 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12731 tsubst_qualified_id (tree qualified_id
, tree args
,
12732 tsubst_flags_t complain
, tree in_decl
,
12733 bool done
, bool address_p
)
12739 tree template_args
;
12740 location_t loc
= UNKNOWN_LOCATION
;
12742 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12744 /* Figure out what name to look up. */
12745 name
= TREE_OPERAND (qualified_id
, 1);
12746 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12748 is_template
= true;
12749 loc
= EXPR_LOCATION (name
);
12750 template_args
= TREE_OPERAND (name
, 1);
12752 template_args
= tsubst_template_args (template_args
, args
,
12753 complain
, in_decl
);
12754 name
= TREE_OPERAND (name
, 0);
12758 is_template
= false;
12759 template_args
= NULL_TREE
;
12762 /* Substitute into the qualifying scope. When there are no ARGS, we
12763 are just trying to simplify a non-dependent expression. In that
12764 case the qualifying scope may be dependent, and, in any case,
12765 substituting will not help. */
12766 scope
= TREE_OPERAND (qualified_id
, 0);
12769 scope
= tsubst (scope
, args
, complain
, in_decl
);
12770 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12775 if (dependent_scope_p (scope
))
12778 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12779 return build_qualified_name (NULL_TREE
, scope
, expr
,
12780 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12783 if (!BASELINK_P (name
) && !DECL_P (expr
))
12785 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12787 /* A BIT_NOT_EXPR is used to represent a destructor. */
12788 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12790 error ("qualifying type %qT does not match destructor name ~%qT",
12791 scope
, TREE_OPERAND (expr
, 0));
12792 expr
= error_mark_node
;
12795 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12796 /*is_type_p=*/0, false);
12799 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12800 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12801 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12803 if (complain
& tf_error
)
12805 error ("dependent-name %qE is parsed as a non-type, but "
12806 "instantiation yields a type", qualified_id
);
12807 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12809 return error_mark_node
;
12815 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12817 /* Remember that there was a reference to this entity. */
12818 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
12819 return error_mark_node
;
12822 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12824 if (complain
& tf_error
)
12825 qualified_name_lookup_error (scope
,
12826 TREE_OPERAND (qualified_id
, 1),
12827 expr
, input_location
);
12828 return error_mark_node
;
12832 expr
= lookup_template_function (expr
, template_args
);
12834 if (expr
== error_mark_node
&& complain
& tf_error
)
12835 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12836 expr
, input_location
);
12837 else if (TYPE_P (scope
))
12839 expr
= (adjust_result_of_qualified_name_lookup
12840 (expr
, scope
, current_nonlambda_class_type ()));
12841 expr
= (finish_qualified_id_expr
12842 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12843 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12844 /*template_arg_p=*/false, complain
));
12847 /* Expressions do not generally have reference type. */
12848 if (TREE_CODE (expr
) != SCOPE_REF
12849 /* However, if we're about to form a pointer-to-member, we just
12850 want the referenced member referenced. */
12851 && TREE_CODE (expr
) != OFFSET_REF
)
12852 expr
= convert_from_reference (expr
);
12857 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12858 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12862 tsubst_init (tree init
, tree decl
, tree args
,
12863 tsubst_flags_t complain
, tree in_decl
)
12868 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12872 /* If we had an initializer but it
12873 instantiated to nothing,
12874 value-initialize the object. This will
12875 only occur when the initializer was a
12876 pack expansion where the parameter packs
12877 used in that expansion were of length
12879 init
= build_value_init (TREE_TYPE (decl
),
12881 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12882 init
= get_target_expr_sfinae (init
, complain
);
12888 /* Like tsubst, but deals with expressions. This function just replaces
12889 template parms; to finish processing the resultant expression, use
12890 tsubst_copy_and_build or tsubst_expr. */
12893 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12895 enum tree_code code
;
12898 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12901 code
= TREE_CODE (t
);
12906 r
= retrieve_local_specialization (t
);
12908 if (r
== NULL_TREE
)
12910 /* We get here for a use of 'this' in an NSDMI. */
12911 if (DECL_NAME (t
) == this_identifier
12912 && current_function_decl
12913 && DECL_CONSTRUCTOR_P (current_function_decl
))
12914 return current_class_ptr
;
12916 /* This can happen for a parameter name used later in a function
12917 declaration (such as in a late-specified return type). Just
12918 make a dummy decl, since it's only used for its type. */
12919 gcc_assert (cp_unevaluated_operand
!= 0);
12920 r
= tsubst_decl (t
, args
, complain
);
12921 /* Give it the template pattern as its context; its true context
12922 hasn't been instantiated yet and this is good enough for
12924 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12927 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12928 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12929 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
12930 return error_mark_node
;
12938 if (DECL_TEMPLATE_PARM_P (t
))
12939 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12940 /* There is no need to substitute into namespace-scope
12942 if (DECL_NAMESPACE_SCOPE_P (t
))
12944 /* If ARGS is NULL, then T is known to be non-dependent. */
12945 if (args
== NULL_TREE
)
12946 return scalar_constant_value (t
);
12948 /* Unfortunately, we cannot just call lookup_name here.
12951 template <int I> int f() {
12953 struct S { void g() { E e = a; } };
12956 When we instantiate f<7>::S::g(), say, lookup_name is not
12957 clever enough to find f<7>::a. */
12959 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12960 /*entering_scope=*/0);
12962 for (v
= TYPE_VALUES (enum_type
);
12964 v
= TREE_CHAIN (v
))
12965 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12966 return TREE_VALUE (v
);
12968 /* We didn't find the name. That should never happen; if
12969 name-lookup found it during preliminary parsing, we
12970 should find it again here during instantiation. */
12971 gcc_unreachable ();
12976 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12978 /* Check for a local specialization set up by
12979 tsubst_pack_expansion. */
12980 if (tree r
= retrieve_local_specialization (t
))
12982 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12983 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12987 /* When retrieving a capture pack from a generic lambda, remove the
12988 lambda call op's own template argument list from ARGS. Only the
12989 template arguments active for the closure type should be used to
12990 retrieve the pack specialization. */
12991 if (LAMBDA_FUNCTION_P (current_function_decl
)
12992 && (template_class_depth (DECL_CONTEXT (t
))
12993 != TMPL_ARGS_DEPTH (args
)))
12994 args
= strip_innermost_template_args (args
, 1);
12996 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12997 tsubst_decl put in the hash table. */
12998 return retrieve_specialization (t
, args
, 0);
13001 if (DECL_CONTEXT (t
))
13005 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
13006 /*entering_scope=*/1);
13007 if (ctx
!= DECL_CONTEXT (t
))
13009 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
13012 if (complain
& tf_error
)
13013 error ("using invalid field %qD", t
);
13014 return error_mark_node
;
13023 case FUNCTION_DECL
:
13024 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
13025 r
= tsubst (t
, args
, complain
, in_decl
);
13026 else if (local_variable_p (t
))
13028 r
= retrieve_local_specialization (t
);
13029 if (r
== NULL_TREE
)
13031 /* First try name lookup to find the instantiation. */
13032 r
= lookup_name (DECL_NAME (t
));
13035 /* Make sure that the one we found is the one we want. */
13036 tree ctx
= tsubst (DECL_CONTEXT (t
), args
,
13037 complain
, in_decl
);
13038 if (ctx
!= DECL_CONTEXT (r
))
13046 /* This can happen for a variable used in a
13047 late-specified return type of a local lambda, or for a
13048 local static or constant. Building a new VAR_DECL
13049 should be OK in all those cases. */
13050 r
= tsubst_decl (t
, args
, complain
);
13051 if (decl_maybe_constant_var_p (r
))
13053 /* We can't call cp_finish_decl, so handle the
13054 initializer by hand. */
13055 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
13056 complain
, in_decl
);
13057 if (!processing_template_decl
)
13058 init
= maybe_constant_init (init
);
13059 if (processing_template_decl
13060 ? potential_constant_expression (init
)
13061 : reduced_constant_expression_p (init
))
13062 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
13063 = TREE_CONSTANT (r
) = true;
13064 DECL_INITIAL (r
) = init
;
13066 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
13067 || decl_constant_var_p (r
)
13068 || errorcount
|| sorrycount
);
13069 if (!processing_template_decl
)
13071 if (TREE_STATIC (r
))
13072 rest_of_decl_compilation (r
, toplevel_bindings_p (),
13074 else if (decl_constant_var_p (r
))
13075 /* A use of a local constant decays to its value.
13076 FIXME update for core DR 696. */
13077 r
= scalar_constant_value (r
);
13080 /* Remember this for subsequent uses. */
13081 if (local_specializations
)
13082 register_local_specialization (r
, t
);
13087 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
13088 return error_mark_node
;
13091 case NAMESPACE_DECL
:
13095 /* An OVERLOAD will always be a non-dependent overload set; an
13096 overload set from function scope will just be represented with an
13097 IDENTIFIER_NODE, and from class scope with a BASELINK. */
13098 gcc_assert (!uses_template_parms (t
));
13102 return tsubst_baselink (t
, current_nonlambda_class_type (),
13103 args
, complain
, in_decl
);
13105 case TEMPLATE_DECL
:
13106 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13107 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
13108 args
, complain
, in_decl
);
13109 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
13110 return tsubst (t
, args
, complain
, in_decl
);
13111 else if (DECL_CLASS_SCOPE_P (t
)
13112 && uses_template_parms (DECL_CONTEXT (t
)))
13114 /* Template template argument like the following example need
13117 template <template <class> class TT> struct C {};
13118 template <class T> struct D {
13119 template <class U> struct E {};
13124 We are processing the template argument `E' in #1 for
13125 the template instantiation #2. Originally, `E' is a
13126 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13127 have to substitute this with one having context `D<int>'. */
13129 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
13130 return lookup_field (context
, DECL_NAME(t
), 0, false);
13133 /* Ordinary template template argument. */
13137 case REINTERPRET_CAST_EXPR
:
13138 case CONST_CAST_EXPR
:
13139 case STATIC_CAST_EXPR
:
13140 case DYNAMIC_CAST_EXPR
:
13141 case IMPLICIT_CONV_EXPR
:
13145 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13146 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13147 return build1 (code
, type
, op0
);
13151 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
13154 tree expanded
, op
= TREE_OPERAND (t
, 0);
13157 if (SIZEOF_EXPR_TYPE_P (t
))
13158 op
= TREE_TYPE (op
);
13160 ++cp_unevaluated_operand
;
13161 ++c_inhibit_evaluation_warnings
;
13162 /* We only want to compute the number of arguments. */
13163 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
13164 --cp_unevaluated_operand
;
13165 --c_inhibit_evaluation_warnings
;
13167 if (TREE_CODE (expanded
) == TREE_VEC
)
13168 len
= TREE_VEC_LENGTH (expanded
);
13170 if (expanded
== error_mark_node
)
13171 return error_mark_node
;
13172 else if (PACK_EXPANSION_P (expanded
)
13173 || (TREE_CODE (expanded
) == TREE_VEC
13175 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
13177 if (TREE_CODE (expanded
) == TREE_VEC
)
13178 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
13180 if (TYPE_P (expanded
))
13181 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
13182 complain
& tf_error
);
13184 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
13185 complain
& tf_error
);
13188 return build_int_cst (size_type_node
, len
);
13190 if (SIZEOF_EXPR_TYPE_P (t
))
13192 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
13193 args
, complain
, in_decl
);
13194 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
13195 r
= build1 (SIZEOF_EXPR
,
13196 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
13197 SIZEOF_EXPR_TYPE_P (r
) = 1;
13204 case TRUTH_NOT_EXPR
:
13207 case UNARY_PLUS_EXPR
: /* Unary + */
13209 case AT_ENCODE_EXPR
:
13213 case REALPART_EXPR
:
13214 case IMAGPART_EXPR
:
13217 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13218 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13219 return build1 (code
, type
, op0
);
13222 case COMPONENT_REF
:
13227 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13228 name
= TREE_OPERAND (t
, 1);
13229 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
13231 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13232 complain
, in_decl
);
13233 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13235 else if (TREE_CODE (name
) == SCOPE_REF
13236 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
13238 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13239 complain
, in_decl
);
13240 name
= TREE_OPERAND (name
, 1);
13241 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13242 complain
, in_decl
);
13243 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13244 name
= build_qualified_name (/*type=*/NULL_TREE
,
13246 /*template_p=*/false);
13248 else if (BASELINK_P (name
))
13249 name
= tsubst_baselink (name
,
13250 non_reference (TREE_TYPE (object
)),
13254 name
= tsubst_copy (name
, args
, complain
, in_decl
);
13255 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
13261 case TRUNC_DIV_EXPR
:
13262 case CEIL_DIV_EXPR
:
13263 case FLOOR_DIV_EXPR
:
13264 case ROUND_DIV_EXPR
:
13265 case EXACT_DIV_EXPR
:
13269 case TRUNC_MOD_EXPR
:
13270 case FLOOR_MOD_EXPR
:
13271 case TRUTH_ANDIF_EXPR
:
13272 case TRUTH_ORIF_EXPR
:
13273 case TRUTH_AND_EXPR
:
13274 case TRUTH_OR_EXPR
:
13287 case COMPOUND_EXPR
:
13290 case PREDECREMENT_EXPR
:
13291 case PREINCREMENT_EXPR
:
13292 case POSTDECREMENT_EXPR
:
13293 case POSTINCREMENT_EXPR
:
13295 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13296 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13297 return build_nt (code
, op0
, op1
);
13302 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13303 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13304 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
13305 QUALIFIED_NAME_IS_TEMPLATE (t
));
13310 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13311 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13312 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13317 int n
= VL_EXP_OPERAND_LENGTH (t
);
13318 tree result
= build_vl_exp (CALL_EXPR
, n
);
13320 for (i
= 0; i
< n
; i
++)
13321 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13322 complain
, in_decl
);
13328 case PSEUDO_DTOR_EXPR
:
13329 case VEC_PERM_EXPR
:
13331 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13332 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13333 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13334 r
= build_nt (code
, op0
, op1
, op2
);
13335 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13341 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13342 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13343 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13344 r
= build_nt (code
, op0
, op1
, op2
);
13345 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13351 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13352 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13353 r
= build_nt (code
, op0
, op1
);
13354 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13355 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13359 case TEMPLATE_ID_EXPR
:
13361 /* Substituted template arguments */
13362 tree fn
= TREE_OPERAND (t
, 0);
13363 tree targs
= TREE_OPERAND (t
, 1);
13365 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13367 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13369 return lookup_template_function (fn
, targs
);
13374 tree purpose
, value
, chain
;
13376 if (t
== void_list_node
)
13379 purpose
= TREE_PURPOSE (t
);
13381 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13382 value
= TREE_VALUE (t
);
13384 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13385 chain
= TREE_CHAIN (t
);
13386 if (chain
&& chain
!= void_type_node
)
13387 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13388 if (purpose
== TREE_PURPOSE (t
)
13389 && value
== TREE_VALUE (t
)
13390 && chain
== TREE_CHAIN (t
))
13392 return tree_cons (purpose
, value
, chain
);
13397 case ENUMERAL_TYPE
:
13399 case TEMPLATE_TYPE_PARM
:
13400 case TEMPLATE_TEMPLATE_PARM
:
13401 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13402 case TEMPLATE_PARM_INDEX
:
13404 case REFERENCE_TYPE
:
13406 case FUNCTION_TYPE
:
13409 case TYPENAME_TYPE
:
13410 case UNBOUND_CLASS_TEMPLATE
:
13412 case DECLTYPE_TYPE
:
13414 return tsubst (t
, args
, complain
, in_decl
);
13418 /* Fall through. */
13419 case IDENTIFIER_NODE
:
13420 if (IDENTIFIER_TYPENAME_P (t
))
13422 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13423 return mangle_conv_op_name_for_type (new_type
);
13429 /* This is handled by tsubst_copy_and_build. */
13430 gcc_unreachable ();
13434 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13435 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13436 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13439 case CLEANUP_POINT_EXPR
:
13440 /* We shouldn't have built any of these during initial template
13441 generation. Instead, they should be built during instantiation
13442 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13443 gcc_unreachable ();
13447 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13448 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13449 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13450 r
= build2 (code
, type
, op0
, op1
);
13451 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13452 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
13453 && !(complain
& tf_error
))
13454 return error_mark_node
;
13458 case EXPR_PACK_EXPANSION
:
13459 error ("invalid use of pack expansion expression");
13460 return error_mark_node
;
13462 case NONTYPE_ARGUMENT_PACK
:
13463 error ("use %<...%> to expand argument pack");
13464 return error_mark_node
;
13467 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13475 /* Instantiate any typedefs in the type. */
13476 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13477 r
= fold_convert (type
, t
);
13478 gcc_assert (TREE_CODE (r
) == code
);
13483 /* These can sometimes show up in a partial instantiation, but never
13484 involve template parms. */
13485 gcc_assert (!uses_template_parms (t
));
13489 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13490 gcc_checking_assert (false);
13495 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13498 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13499 tree args
, tsubst_flags_t complain
, tree in_decl
)
13501 tree new_clauses
= NULL
, nc
, oc
;
13503 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13505 nc
= copy_node (oc
);
13506 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13509 switch (OMP_CLAUSE_CODE (nc
))
13511 case OMP_CLAUSE_LASTPRIVATE
:
13512 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13514 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13515 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13516 in_decl
, /*integral_constant_expression_p=*/false);
13517 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13518 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13521 case OMP_CLAUSE_PRIVATE
:
13522 case OMP_CLAUSE_SHARED
:
13523 case OMP_CLAUSE_FIRSTPRIVATE
:
13524 case OMP_CLAUSE_COPYIN
:
13525 case OMP_CLAUSE_COPYPRIVATE
:
13526 case OMP_CLAUSE_IF
:
13527 case OMP_CLAUSE_NUM_THREADS
:
13528 case OMP_CLAUSE_SCHEDULE
:
13529 case OMP_CLAUSE_COLLAPSE
:
13530 case OMP_CLAUSE_FINAL
:
13531 case OMP_CLAUSE_DEPEND
:
13532 case OMP_CLAUSE_FROM
:
13533 case OMP_CLAUSE_TO
:
13534 case OMP_CLAUSE_UNIFORM
:
13535 case OMP_CLAUSE_MAP
:
13536 case OMP_CLAUSE_DEVICE
:
13537 case OMP_CLAUSE_DIST_SCHEDULE
:
13538 case OMP_CLAUSE_NUM_TEAMS
:
13539 case OMP_CLAUSE_THREAD_LIMIT
:
13540 case OMP_CLAUSE_SAFELEN
:
13541 case OMP_CLAUSE_SIMDLEN
:
13542 OMP_CLAUSE_OPERAND (nc
, 0)
13543 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13544 in_decl
, /*integral_constant_expression_p=*/false);
13546 case OMP_CLAUSE_REDUCTION
:
13547 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13549 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13550 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13552 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13553 complain
, in_decl
);
13554 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13555 = build_qualified_name (NULL_TREE
, scope
,
13556 TREE_OPERAND (placeholder
, 1),
13560 gcc_assert (identifier_p (placeholder
));
13562 OMP_CLAUSE_OPERAND (nc
, 0)
13563 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13564 in_decl
, /*integral_constant_expression_p=*/false);
13566 case OMP_CLAUSE_LINEAR
:
13567 case OMP_CLAUSE_ALIGNED
:
13568 OMP_CLAUSE_OPERAND (nc
, 0)
13569 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13570 in_decl
, /*integral_constant_expression_p=*/false);
13571 OMP_CLAUSE_OPERAND (nc
, 1)
13572 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13573 in_decl
, /*integral_constant_expression_p=*/false);
13576 case OMP_CLAUSE_NOWAIT
:
13577 case OMP_CLAUSE_ORDERED
:
13578 case OMP_CLAUSE_DEFAULT
:
13579 case OMP_CLAUSE_UNTIED
:
13580 case OMP_CLAUSE_MERGEABLE
:
13581 case OMP_CLAUSE_INBRANCH
:
13582 case OMP_CLAUSE_NOTINBRANCH
:
13583 case OMP_CLAUSE_PROC_BIND
:
13584 case OMP_CLAUSE_FOR
:
13585 case OMP_CLAUSE_PARALLEL
:
13586 case OMP_CLAUSE_SECTIONS
:
13587 case OMP_CLAUSE_TASKGROUP
:
13590 gcc_unreachable ();
13594 new_clauses
= nreverse (new_clauses
);
13596 new_clauses
= finish_omp_clauses (new_clauses
);
13597 return new_clauses
;
13600 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13603 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13606 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13608 tree purpose
, value
, chain
;
13613 if (TREE_CODE (t
) != TREE_LIST
)
13614 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13615 /*function_p=*/false,
13616 /*integral_constant_expression_p=*/false);
13618 if (t
== void_list_node
)
13621 purpose
= TREE_PURPOSE (t
);
13623 purpose
= RECUR (purpose
);
13624 value
= TREE_VALUE (t
);
13627 if (TREE_CODE (value
) != LABEL_DECL
)
13628 value
= RECUR (value
);
13631 value
= lookup_label (DECL_NAME (value
));
13632 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13633 TREE_USED (value
) = 1;
13636 chain
= TREE_CHAIN (t
);
13637 if (chain
&& chain
!= void_type_node
)
13638 chain
= RECUR (chain
);
13639 return tree_cons (purpose
, value
, chain
);
13643 /* Substitute one OMP_FOR iterator. */
13646 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13647 tree condv
, tree incrv
, tree
*clauses
,
13648 tree args
, tsubst_flags_t complain
, tree in_decl
,
13649 bool integral_constant_expression_p
)
13651 #define RECUR(NODE) \
13652 tsubst_expr ((NODE), args, complain, in_decl, \
13653 integral_constant_expression_p)
13654 tree decl
, init
, cond
, incr
;
13656 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13657 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13658 decl
= TREE_OPERAND (init
, 0);
13659 init
= TREE_OPERAND (init
, 1);
13660 tree decl_expr
= NULL_TREE
;
13661 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13663 /* We need to jump through some hoops to handle declarations in the
13664 for-init-statement, since we might need to handle auto deduction,
13665 but we need to keep control of initialization. */
13667 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13668 decl
= tsubst_decl (decl
, args
, complain
);
13671 decl
= RECUR (decl
);
13672 init
= RECUR (init
);
13674 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13675 if (auto_node
&& init
)
13677 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13679 gcc_assert (!type_dependent_expression_p (decl
));
13681 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13685 /* Declare the variable, but don't let that initialize it. */
13686 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13687 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13689 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13692 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13693 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13694 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13696 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13697 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13698 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13699 NOP_EXPR
, rhs
, complain
);
13702 incr
= RECUR (incr
);
13703 TREE_VEC_ELT (declv
, i
) = decl
;
13704 TREE_VEC_ELT (initv
, i
) = init
;
13705 TREE_VEC_ELT (condv
, i
) = cond
;
13706 TREE_VEC_ELT (incrv
, i
) = incr
;
13712 /* Declare and initialize the variable. */
13719 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13721 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13722 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13723 && OMP_CLAUSE_DECL (c
) == decl
)
13725 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13726 && OMP_CLAUSE_DECL (c
) == decl
)
13727 error ("iteration variable %qD should not be firstprivate", decl
);
13728 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13729 && OMP_CLAUSE_DECL (c
) == decl
)
13730 error ("iteration variable %qD should not be reduction", decl
);
13734 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13735 OMP_CLAUSE_DECL (c
) = decl
;
13736 c
= finish_omp_clauses (c
);
13739 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13744 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13745 if (COMPARISON_CLASS_P (cond
))
13747 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13748 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13749 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13752 cond
= RECUR (cond
);
13753 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13754 switch (TREE_CODE (incr
))
13756 case PREINCREMENT_EXPR
:
13757 case PREDECREMENT_EXPR
:
13758 case POSTINCREMENT_EXPR
:
13759 case POSTDECREMENT_EXPR
:
13760 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13761 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13764 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13765 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13767 tree rhs
= TREE_OPERAND (incr
, 1);
13768 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13769 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13770 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13771 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13772 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13776 incr
= RECUR (incr
);
13779 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13780 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13782 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13783 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13784 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13785 TREE_TYPE (decl
), lhs
,
13786 RECUR (TREE_OPERAND (incr
, 2))));
13788 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13789 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13790 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13792 tree rhs
= TREE_OPERAND (incr
, 2);
13793 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13794 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13795 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13796 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13797 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13801 incr
= RECUR (incr
);
13804 incr
= RECUR (incr
);
13808 TREE_VEC_ELT (declv
, i
) = decl
;
13809 TREE_VEC_ELT (initv
, i
) = init
;
13810 TREE_VEC_ELT (condv
, i
) = cond
;
13811 TREE_VEC_ELT (incrv
, i
) = incr
;
13815 /* Like tsubst_copy for expressions, etc. but also does semantic
13819 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13820 bool integral_constant_expression_p
)
13822 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13823 #define RECUR(NODE) \
13824 tsubst_expr ((NODE), args, complain, in_decl, \
13825 integral_constant_expression_p)
13831 if (t
== NULL_TREE
|| t
== error_mark_node
)
13834 loc
= input_location
;
13835 if (EXPR_HAS_LOCATION (t
))
13836 input_location
= EXPR_LOCATION (t
);
13837 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13838 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13840 switch (TREE_CODE (t
))
13842 case STATEMENT_LIST
:
13844 tree_stmt_iterator i
;
13845 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13846 RECUR (tsi_stmt (i
));
13850 case CTOR_INITIALIZER
:
13851 finish_mem_initializers (tsubst_initializer_list
13852 (TREE_OPERAND (t
, 0), args
));
13856 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13860 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13861 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13862 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13864 finish_expr_stmt (tmp
);
13868 do_using_directive (USING_STMT_NAMESPACE (t
));
13873 tree decl
, pattern_decl
;
13876 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13877 if (TREE_CODE (decl
) == LABEL_DECL
)
13878 finish_label_decl (DECL_NAME (decl
));
13879 else if (TREE_CODE (decl
) == USING_DECL
)
13881 tree scope
= USING_DECL_SCOPE (decl
);
13882 tree name
= DECL_NAME (decl
);
13885 scope
= tsubst (scope
, args
, complain
, in_decl
);
13886 decl
= lookup_qualified_name (scope
, name
,
13887 /*is_type_p=*/false,
13888 /*complain=*/false);
13889 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13890 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13892 do_local_using_decl (decl
, scope
, name
);
13894 else if (DECL_PACK_P (decl
))
13896 /* Don't build up decls for a variadic capture proxy, we'll
13897 instantiate the elements directly as needed. */
13902 init
= DECL_INITIAL (decl
);
13903 decl
= tsubst (decl
, args
, complain
, in_decl
);
13904 if (decl
!= error_mark_node
)
13906 /* By marking the declaration as instantiated, we avoid
13907 trying to instantiate it. Since instantiate_decl can't
13908 handle local variables, and since we've already done
13909 all that needs to be done, that's the right thing to
13912 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13914 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13915 /* Anonymous aggregates are a special case. */
13916 finish_anon_union (decl
);
13917 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13919 DECL_CONTEXT (decl
) = current_function_decl
;
13920 if (DECL_NAME (decl
) == this_identifier
)
13922 tree lam
= DECL_CONTEXT (current_function_decl
);
13923 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13924 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13926 insert_capture_proxy (decl
);
13928 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13929 /* We already did a pushtag. */;
13930 else if (TREE_CODE (decl
) == FUNCTION_DECL
13931 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13932 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13934 DECL_CONTEXT (decl
) = NULL_TREE
;
13936 DECL_CONTEXT (decl
) = current_function_decl
;
13937 cp_check_omp_declare_reduction (decl
);
13941 int const_init
= false;
13942 maybe_push_decl (decl
);
13944 && DECL_PRETTY_FUNCTION_P (decl
))
13946 /* For __PRETTY_FUNCTION__ we have to adjust the
13948 const char *const name
13949 = cxx_printable_name (current_function_decl
, 2);
13950 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13953 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
13956 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13958 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13967 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13968 RECUR (FOR_INIT_STMT (t
));
13969 finish_for_init_stmt (stmt
);
13970 tmp
= RECUR (FOR_COND (t
));
13971 finish_for_cond (tmp
, stmt
, false);
13972 tmp
= RECUR (FOR_EXPR (t
));
13973 finish_for_expr (tmp
, stmt
);
13974 RECUR (FOR_BODY (t
));
13975 finish_for_stmt (stmt
);
13978 case RANGE_FOR_STMT
:
13981 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13982 decl
= RANGE_FOR_DECL (t
);
13983 decl
= tsubst (decl
, args
, complain
, in_decl
);
13984 maybe_push_decl (decl
);
13985 expr
= RECUR (RANGE_FOR_EXPR (t
));
13986 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13987 RECUR (RANGE_FOR_BODY (t
));
13988 finish_for_stmt (stmt
);
13993 stmt
= begin_while_stmt ();
13994 tmp
= RECUR (WHILE_COND (t
));
13995 finish_while_stmt_cond (tmp
, stmt
, false);
13996 RECUR (WHILE_BODY (t
));
13997 finish_while_stmt (stmt
);
14001 stmt
= begin_do_stmt ();
14002 RECUR (DO_BODY (t
));
14003 finish_do_body (stmt
);
14004 tmp
= RECUR (DO_COND (t
));
14005 finish_do_stmt (tmp
, stmt
, false);
14009 stmt
= begin_if_stmt ();
14010 tmp
= RECUR (IF_COND (t
));
14011 finish_if_stmt_cond (tmp
, stmt
);
14012 RECUR (THEN_CLAUSE (t
));
14013 finish_then_clause (stmt
);
14015 if (ELSE_CLAUSE (t
))
14017 begin_else_clause (stmt
);
14018 RECUR (ELSE_CLAUSE (t
));
14019 finish_else_clause (stmt
);
14022 finish_if_stmt (stmt
);
14026 if (BIND_EXPR_BODY_BLOCK (t
))
14027 stmt
= begin_function_body ();
14029 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
14030 ? BCS_TRY_BLOCK
: 0);
14032 RECUR (BIND_EXPR_BODY (t
));
14034 if (BIND_EXPR_BODY_BLOCK (t
))
14035 finish_function_body (stmt
);
14037 finish_compound_stmt (stmt
);
14041 finish_break_stmt ();
14044 case CONTINUE_STMT
:
14045 finish_continue_stmt ();
14049 stmt
= begin_switch_stmt ();
14050 tmp
= RECUR (SWITCH_STMT_COND (t
));
14051 finish_switch_cond (tmp
, stmt
);
14052 RECUR (SWITCH_STMT_BODY (t
));
14053 finish_switch_stmt (stmt
);
14056 case CASE_LABEL_EXPR
:
14058 tree low
= RECUR (CASE_LOW (t
));
14059 tree high
= RECUR (CASE_HIGH (t
));
14060 finish_case_label (EXPR_LOCATION (t
), low
, high
);
14066 tree decl
= LABEL_EXPR_LABEL (t
);
14069 label
= finish_label_stmt (DECL_NAME (decl
));
14070 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
14071 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
14076 tmp
= GOTO_DESTINATION (t
);
14077 if (TREE_CODE (tmp
) != LABEL_DECL
)
14078 /* Computed goto's must be tsubst'd into. On the other hand,
14079 non-computed gotos must not be; the identifier in question
14080 will have no binding. */
14083 tmp
= DECL_NAME (tmp
);
14084 finish_goto_stmt (tmp
);
14089 tree string
= RECUR (ASM_STRING (t
));
14090 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
14091 complain
, in_decl
);
14092 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
14093 complain
, in_decl
);
14094 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
14095 complain
, in_decl
);
14096 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
14097 complain
, in_decl
);
14098 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
14100 tree asm_expr
= tmp
;
14101 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
14102 asm_expr
= TREE_OPERAND (asm_expr
, 0);
14103 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
14110 stmt
= begin_try_block ();
14111 RECUR (TRY_STMTS (t
));
14112 finish_cleanup_try_block (stmt
);
14113 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
14117 tree compound_stmt
= NULL_TREE
;
14119 if (FN_TRY_BLOCK_P (t
))
14120 stmt
= begin_function_try_block (&compound_stmt
);
14122 stmt
= begin_try_block ();
14124 RECUR (TRY_STMTS (t
));
14126 if (FN_TRY_BLOCK_P (t
))
14127 finish_function_try_block (stmt
);
14129 finish_try_block (stmt
);
14131 RECUR (TRY_HANDLERS (t
));
14132 if (FN_TRY_BLOCK_P (t
))
14133 finish_function_handler_sequence (stmt
, compound_stmt
);
14135 finish_handler_sequence (stmt
);
14141 tree decl
= HANDLER_PARMS (t
);
14145 decl
= tsubst (decl
, args
, complain
, in_decl
);
14146 /* Prevent instantiate_decl from trying to instantiate
14147 this variable. We've already done all that needs to be
14149 if (decl
!= error_mark_node
)
14150 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
14152 stmt
= begin_handler ();
14153 finish_handler_parms (decl
, stmt
);
14154 RECUR (HANDLER_BODY (t
));
14155 finish_handler (stmt
);
14160 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
14161 if (CLASS_TYPE_P (tmp
))
14163 /* Local classes are not independent templates; they are
14164 instantiated along with their containing function. And this
14165 way we don't have to deal with pushing out of one local class
14166 to instantiate a member of another local class. */
14168 /* Closures are handled by the LAMBDA_EXPR. */
14169 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
14170 complete_type (tmp
);
14171 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
14172 if (!DECL_ARTIFICIAL (fn
))
14173 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
14177 case STATIC_ASSERT
:
14181 ++c_inhibit_evaluation_warnings
;
14183 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
14186 /*integral_constant_expression_p=*/true);
14187 --c_inhibit_evaluation_warnings
;
14189 finish_static_assert (condition
,
14190 STATIC_ASSERT_MESSAGE (t
),
14191 STATIC_ASSERT_SOURCE_LOCATION (t
),
14192 /*member_p=*/false);
14197 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
14198 args
, complain
, in_decl
);
14199 stmt
= begin_omp_parallel ();
14200 RECUR (OMP_PARALLEL_BODY (t
));
14201 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
14202 = OMP_PARALLEL_COMBINED (t
);
14206 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
14207 args
, complain
, in_decl
);
14208 stmt
= begin_omp_task ();
14209 RECUR (OMP_TASK_BODY (t
));
14210 finish_omp_task (tmp
, stmt
);
14217 case OMP_DISTRIBUTE
:
14219 tree clauses
, body
, pre_body
;
14220 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
14221 tree incrv
= NULL_TREE
;
14224 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
14225 args
, complain
, in_decl
);
14226 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14228 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14229 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14230 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14231 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14234 stmt
= begin_omp_structured_block ();
14236 pre_body
= push_stmt_list ();
14237 RECUR (OMP_FOR_PRE_BODY (t
));
14238 pre_body
= pop_stmt_list (pre_body
);
14240 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14241 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
14242 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
14243 &clauses
, args
, complain
, in_decl
,
14244 integral_constant_expression_p
);
14246 body
= push_stmt_list ();
14247 RECUR (OMP_FOR_BODY (t
));
14248 body
= pop_stmt_list (body
);
14250 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14251 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
14252 condv
, incrv
, body
, pre_body
, clauses
);
14255 t
= make_node (TREE_CODE (t
));
14256 TREE_TYPE (t
) = void_type_node
;
14257 OMP_FOR_BODY (t
) = body
;
14258 OMP_FOR_PRE_BODY (t
) = pre_body
;
14259 OMP_FOR_CLAUSES (t
) = clauses
;
14260 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
14264 add_stmt (finish_omp_structured_block (stmt
));
14271 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14272 args
, complain
, in_decl
);
14273 stmt
= push_stmt_list ();
14274 RECUR (OMP_BODY (t
));
14275 stmt
= pop_stmt_list (stmt
);
14278 OMP_BODY (t
) = stmt
;
14279 OMP_CLAUSES (t
) = tmp
;
14283 case OMP_TARGET_DATA
:
14285 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14286 args
, complain
, in_decl
);
14287 keep_next_level (true);
14288 stmt
= begin_omp_structured_block ();
14290 RECUR (OMP_BODY (t
));
14291 stmt
= finish_omp_structured_block (stmt
);
14294 OMP_BODY (t
) = stmt
;
14295 OMP_CLAUSES (t
) = tmp
;
14299 case OMP_TARGET_UPDATE
:
14300 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
14301 args
, complain
, in_decl
);
14303 OMP_TARGET_UPDATE_CLAUSES (t
) = tmp
;
14310 case OMP_TASKGROUP
:
14312 stmt
= push_stmt_list ();
14313 RECUR (OMP_BODY (t
));
14314 stmt
= pop_stmt_list (stmt
);
14317 OMP_BODY (t
) = stmt
;
14322 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14323 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14325 tree op1
= TREE_OPERAND (t
, 1);
14326 tree rhs1
= NULL_TREE
;
14328 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14330 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14331 op1
= TREE_OPERAND (op1
, 1);
14333 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14334 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14335 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14336 NULL_TREE
, NULL_TREE
, rhs1
,
14337 OMP_ATOMIC_SEQ_CST (t
));
14341 tree op1
= TREE_OPERAND (t
, 1);
14342 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14343 tree rhs1
= NULL_TREE
;
14344 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14345 enum tree_code opcode
= NOP_EXPR
;
14346 if (code
== OMP_ATOMIC_READ
)
14348 v
= RECUR (TREE_OPERAND (op1
, 0));
14349 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14351 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14352 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14354 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14355 v
= RECUR (TREE_OPERAND (op1
, 0));
14356 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14357 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14359 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14360 op11
= TREE_OPERAND (op11
, 1);
14362 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14363 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14364 opcode
= TREE_CODE (op11
);
14365 if (opcode
== MODIFY_EXPR
)
14371 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14372 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14374 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14375 OMP_ATOMIC_SEQ_CST (t
));
14379 case TRANSACTION_EXPR
:
14382 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14383 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14385 if (TRANSACTION_EXPR_IS_STMT (t
))
14387 tree body
= TRANSACTION_EXPR_BODY (t
);
14388 tree noex
= NULL_TREE
;
14389 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14391 noex
= MUST_NOT_THROW_COND (body
);
14392 if (noex
== NULL_TREE
)
14393 noex
= boolean_true_node
;
14394 body
= TREE_OPERAND (body
, 0);
14396 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14398 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14402 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14403 RECUR (TRANSACTION_EXPR_BODY (t
)),
14410 case MUST_NOT_THROW_EXPR
:
14412 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14413 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14414 RETURN (build_must_not_throw_expr (op0
, cond
));
14417 case EXPR_PACK_EXPANSION
:
14418 error ("invalid use of pack expansion expression");
14419 RETURN (error_mark_node
);
14421 case NONTYPE_ARGUMENT_PACK
:
14422 error ("use %<...%> to expand argument pack");
14423 RETURN (error_mark_node
);
14425 case CILK_SPAWN_STMT
:
14426 cfun
->calls_cilk_spawn
= 1;
14427 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14429 case CILK_SYNC_STMT
:
14430 RETURN (build_cilk_sync ());
14432 case COMPOUND_EXPR
:
14433 tmp
= RECUR (TREE_OPERAND (t
, 0));
14434 if (tmp
== NULL_TREE
)
14435 /* If the first operand was a statement, we're done with it. */
14436 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14437 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14438 RECUR (TREE_OPERAND (t
, 1)),
14441 case ANNOTATE_EXPR
:
14442 tmp
= RECUR (TREE_OPERAND (t
, 0));
14443 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14444 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14447 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14449 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14450 /*function_p=*/false,
14451 integral_constant_expression_p
));
14454 RETURN (NULL_TREE
);
14456 input_location
= loc
;
14462 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14463 function. For description of the body see comment above
14464 cp_parser_omp_declare_reduction_exprs. */
14467 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14469 if (t
== NULL_TREE
|| t
== error_mark_node
)
14472 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14474 tree_stmt_iterator tsi
;
14477 memset (stmts
, 0, sizeof stmts
);
14478 for (i
= 0, tsi
= tsi_start (t
);
14479 i
< 7 && !tsi_end_p (tsi
);
14480 i
++, tsi_next (&tsi
))
14481 stmts
[i
] = tsi_stmt (tsi
);
14482 gcc_assert (tsi_end_p (tsi
));
14486 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14487 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14488 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14489 args
, complain
, in_decl
);
14490 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14491 args
, complain
, in_decl
);
14492 DECL_CONTEXT (omp_out
) = current_function_decl
;
14493 DECL_CONTEXT (omp_in
) = current_function_decl
;
14494 keep_next_level (true);
14495 tree block
= begin_omp_structured_block ();
14496 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14497 block
= finish_omp_structured_block (block
);
14498 block
= maybe_cleanup_point_expr_void (block
);
14499 add_decl_expr (omp_out
);
14500 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14501 TREE_NO_WARNING (omp_out
) = 1;
14502 add_decl_expr (omp_in
);
14503 finish_expr_stmt (block
);
14507 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14508 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14509 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14510 args
, complain
, in_decl
);
14511 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14512 args
, complain
, in_decl
);
14513 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14514 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14515 keep_next_level (true);
14516 tree block
= begin_omp_structured_block ();
14517 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14518 block
= finish_omp_structured_block (block
);
14519 block
= maybe_cleanup_point_expr_void (block
);
14520 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14521 add_decl_expr (omp_priv
);
14522 add_decl_expr (omp_orig
);
14523 finish_expr_stmt (block
);
14525 add_decl_expr (omp_orig
);
14529 /* T is a postfix-expression that is not being used in a function
14530 call. Return the substituted version of T. */
14533 tsubst_non_call_postfix_expression (tree t
, tree args
,
14534 tsubst_flags_t complain
,
14537 if (TREE_CODE (t
) == SCOPE_REF
)
14538 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14539 /*done=*/false, /*address_p=*/false);
14541 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14542 /*function_p=*/false,
14543 /*integral_constant_expression_p=*/false);
14548 /* Like tsubst but deals with expressions and performs semantic
14549 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14552 tsubst_copy_and_build (tree t
,
14554 tsubst_flags_t complain
,
14557 bool integral_constant_expression_p
)
14559 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14560 #define RECUR(NODE) \
14561 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14562 /*function_p=*/false, \
14563 integral_constant_expression_p)
14568 if (t
== NULL_TREE
|| t
== error_mark_node
)
14571 loc
= input_location
;
14572 if (EXPR_HAS_LOCATION (t
))
14573 input_location
= EXPR_LOCATION (t
);
14575 /* N3276 decltype magic only applies to calls at the top level or on the
14576 right side of a comma. */
14577 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14578 complain
&= ~tf_decltype
;
14580 switch (TREE_CODE (t
))
14584 /* Fall through. */
14585 case IDENTIFIER_NODE
:
14589 bool non_integral_constant_expression_p
;
14590 const char *error_msg
;
14592 if (IDENTIFIER_TYPENAME_P (t
))
14594 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14595 t
= mangle_conv_op_name_for_type (new_type
);
14598 /* Look up the name. */
14599 decl
= lookup_name (t
);
14601 /* By convention, expressions use ERROR_MARK_NODE to indicate
14602 failure, not NULL_TREE. */
14603 if (decl
== NULL_TREE
)
14604 decl
= error_mark_node
;
14606 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14608 integral_constant_expression_p
,
14609 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14610 &non_integral_constant_expression_p
,
14611 /*template_p=*/false,
14613 /*address_p=*/false,
14614 /*template_arg_p=*/false,
14619 if (!function_p
&& identifier_p (decl
))
14621 if (complain
& tf_error
)
14622 unqualified_name_lookup_error (decl
);
14623 decl
= error_mark_node
;
14628 case TEMPLATE_ID_EXPR
:
14631 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14632 tree targs
= TREE_OPERAND (t
, 1);
14635 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14637 if (TREE_CODE (templ
) == COMPONENT_REF
)
14639 object
= TREE_OPERAND (templ
, 0);
14640 templ
= TREE_OPERAND (templ
, 1);
14643 object
= NULL_TREE
;
14644 templ
= lookup_template_function (templ
, targs
);
14647 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14648 object
, templ
, NULL_TREE
));
14650 RETURN (baselink_for_fns (templ
));
14655 tree r
= RECUR (TREE_OPERAND (t
, 0));
14657 if (REFERENCE_REF_P (t
))
14659 /* A type conversion to reference type will be enclosed in
14660 such an indirect ref, but the substitution of the cast
14661 will have also added such an indirect ref. */
14662 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14663 r
= convert_from_reference (r
);
14666 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14667 complain
|decltype_flag
);
14673 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14674 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14675 RETURN (build_nop (type
, op0
));
14678 case IMPLICIT_CONV_EXPR
:
14680 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14681 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14682 int flags
= LOOKUP_IMPLICIT
;
14683 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14684 flags
= LOOKUP_NORMAL
;
14685 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14691 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14692 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14693 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14697 case REINTERPRET_CAST_EXPR
:
14698 case CONST_CAST_EXPR
:
14699 case DYNAMIC_CAST_EXPR
:
14700 case STATIC_CAST_EXPR
:
14703 tree op
, r
= NULL_TREE
;
14705 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14706 if (integral_constant_expression_p
14707 && !cast_valid_in_integral_constant_expression_p (type
))
14709 if (complain
& tf_error
)
14710 error ("a cast to a type other than an integral or "
14711 "enumeration type cannot appear in a constant-expression");
14712 RETURN (error_mark_node
);
14715 op
= RECUR (TREE_OPERAND (t
, 0));
14717 warning_sentinel
s(warn_useless_cast
);
14718 switch (TREE_CODE (t
))
14721 r
= build_functional_cast (type
, op
, complain
);
14723 case REINTERPRET_CAST_EXPR
:
14724 r
= build_reinterpret_cast (type
, op
, complain
);
14726 case CONST_CAST_EXPR
:
14727 r
= build_const_cast (type
, op
, complain
);
14729 case DYNAMIC_CAST_EXPR
:
14730 r
= build_dynamic_cast (type
, op
, complain
);
14732 case STATIC_CAST_EXPR
:
14733 r
= build_static_cast (type
, op
, complain
);
14736 gcc_unreachable ();
14742 case POSTDECREMENT_EXPR
:
14743 case POSTINCREMENT_EXPR
:
14744 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14745 args
, complain
, in_decl
);
14746 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14747 complain
|decltype_flag
));
14749 case PREDECREMENT_EXPR
:
14750 case PREINCREMENT_EXPR
:
14754 case TRUTH_NOT_EXPR
:
14755 case UNARY_PLUS_EXPR
: /* Unary + */
14756 case REALPART_EXPR
:
14757 case IMAGPART_EXPR
:
14758 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14759 RECUR (TREE_OPERAND (t
, 0)),
14760 complain
|decltype_flag
));
14762 case FIX_TRUNC_EXPR
:
14763 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14767 op1
= TREE_OPERAND (t
, 0);
14768 if (TREE_CODE (op1
) == LABEL_DECL
)
14769 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14770 EXPR_LOCATION (op1
)));
14771 if (TREE_CODE (op1
) == SCOPE_REF
)
14772 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14773 /*done=*/true, /*address_p=*/true);
14775 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14777 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14778 complain
|decltype_flag
));
14783 case TRUNC_DIV_EXPR
:
14784 case CEIL_DIV_EXPR
:
14785 case FLOOR_DIV_EXPR
:
14786 case ROUND_DIV_EXPR
:
14787 case EXACT_DIV_EXPR
:
14791 case TRUNC_MOD_EXPR
:
14792 case FLOOR_MOD_EXPR
:
14793 case TRUTH_ANDIF_EXPR
:
14794 case TRUTH_ORIF_EXPR
:
14795 case TRUTH_AND_EXPR
:
14796 case TRUTH_OR_EXPR
:
14812 warning_sentinel
s1(warn_type_limits
);
14813 warning_sentinel
s2(warn_div_by_zero
);
14814 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14815 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14816 tree r
= build_x_binary_op
14817 (input_location
, TREE_CODE (t
),
14819 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14821 : TREE_CODE (TREE_OPERAND (t
, 0))),
14823 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14825 : TREE_CODE (TREE_OPERAND (t
, 1))),
14827 complain
|decltype_flag
);
14828 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14829 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14834 case POINTER_PLUS_EXPR
:
14836 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14837 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14838 return fold_build_pointer_plus (op0
, op1
);
14842 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14843 /*address_p=*/false));
14845 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14846 args
, complain
, in_decl
);
14847 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14848 RECUR (TREE_OPERAND (t
, 1)),
14849 complain
|decltype_flag
));
14851 case ARRAY_NOTATION_REF
:
14853 tree start_index
, length
, stride
;
14854 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14855 args
, complain
, in_decl
);
14856 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14857 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14858 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14859 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14860 length
, stride
, TREE_TYPE (op1
)));
14863 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14864 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14871 op1
= TREE_OPERAND (t
, 0);
14872 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14873 op1
= TREE_TYPE (op1
);
14876 /* When there are no ARGS, we are trying to evaluate a
14877 non-dependent expression from the parser. Trying to do
14878 the substitutions may not work. */
14880 op1
= TREE_TYPE (op1
);
14884 ++cp_unevaluated_operand
;
14885 ++c_inhibit_evaluation_warnings
;
14887 op1
= tsubst (op1
, args
, complain
, in_decl
);
14889 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14890 /*function_p=*/false,
14891 /*integral_constant_expression_p=*/
14893 --cp_unevaluated_operand
;
14894 --c_inhibit_evaluation_warnings
;
14897 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14898 complain
& tf_error
);
14900 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14901 complain
& tf_error
);
14902 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14904 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14906 if (!processing_template_decl
&& TYPE_P (op1
))
14908 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14909 build1 (NOP_EXPR
, op1
, error_mark_node
));
14910 SIZEOF_EXPR_TYPE_P (r
) = 1;
14913 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14914 TREE_SIDE_EFFECTS (r
) = 0;
14915 TREE_READONLY (r
) = 1;
14917 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14922 case AT_ENCODE_EXPR
:
14924 op1
= TREE_OPERAND (t
, 0);
14925 ++cp_unevaluated_operand
;
14926 ++c_inhibit_evaluation_warnings
;
14927 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14928 /*function_p=*/false,
14929 /*integral_constant_expression_p=*/false);
14930 --cp_unevaluated_operand
;
14931 --c_inhibit_evaluation_warnings
;
14932 RETURN (objc_build_encode_expr (op1
));
14935 case NOEXCEPT_EXPR
:
14936 op1
= TREE_OPERAND (t
, 0);
14937 ++cp_unevaluated_operand
;
14938 ++c_inhibit_evaluation_warnings
;
14939 ++cp_noexcept_operand
;
14940 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14941 /*function_p=*/false,
14942 /*integral_constant_expression_p=*/false);
14943 --cp_unevaluated_operand
;
14944 --c_inhibit_evaluation_warnings
;
14945 --cp_noexcept_operand
;
14946 RETURN (finish_noexcept_expr (op1
, complain
));
14950 warning_sentinel
s(warn_div_by_zero
);
14951 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
14952 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
14953 tree r
= build_x_modify_expr
14954 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
14955 complain
|decltype_flag
);
14956 /* TREE_NO_WARNING must be set if either the expression was
14957 parenthesized or it uses an operator such as >>= rather
14958 than plain assignment. In the former case, it was already
14959 set and must be copied. In the latter case,
14960 build_x_modify_expr sets it and it must not be reset
14962 if (TREE_NO_WARNING (t
))
14963 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14969 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14970 args
, complain
, in_decl
);
14971 /* Remember that there was a reference to this entity. */
14973 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
14974 RETURN (error_mark_node
);
14975 RETURN (build_x_arrow (input_location
, op1
, complain
));
14979 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14980 tree init
= RECUR (TREE_OPERAND (t
, 3));
14981 vec
<tree
, va_gc
> *placement_vec
;
14982 vec
<tree
, va_gc
> *init_vec
;
14985 if (placement
== NULL_TREE
)
14986 placement_vec
= NULL
;
14989 placement_vec
= make_tree_vector ();
14990 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14991 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14994 /* If there was an initializer in the original tree, but it
14995 instantiated to an empty list, then we should pass a
14996 non-NULL empty vector to tell build_new that it was an
14997 empty initializer() rather than no initializer. This can
14998 only happen when the initializer is a pack expansion whose
14999 parameter packs are of length zero. */
15000 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
15004 init_vec
= make_tree_vector ();
15005 if (init
== void_node
)
15006 gcc_assert (init_vec
!= NULL
);
15009 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
15010 vec_safe_push (init_vec
, TREE_VALUE (init
));
15014 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15015 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15016 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
15017 NEW_EXPR_USE_GLOBAL (t
),
15020 if (placement_vec
!= NULL
)
15021 release_tree_vector (placement_vec
);
15022 if (init_vec
!= NULL
)
15023 release_tree_vector (init_vec
);
15030 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15031 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15032 RETURN (delete_sanity (op0
, op1
,
15033 DELETE_EXPR_USE_VEC (t
),
15034 DELETE_EXPR_USE_GLOBAL (t
),
15038 case COMPOUND_EXPR
:
15040 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
15041 complain
& ~tf_decltype
, in_decl
,
15042 /*function_p=*/false,
15043 integral_constant_expression_p
);
15044 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
15046 RECUR (TREE_OPERAND (t
, 1)),
15047 complain
|decltype_flag
));
15053 vec
<tree
, va_gc
> *call_args
;
15054 unsigned int nargs
, i
;
15059 function
= CALL_EXPR_FN (t
);
15060 /* When we parsed the expression, we determined whether or
15061 not Koenig lookup should be performed. */
15062 koenig_p
= KOENIG_LOOKUP_P (t
);
15063 if (TREE_CODE (function
) == SCOPE_REF
)
15065 qualified_p
= true;
15066 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
15068 /*address_p=*/false);
15070 else if (koenig_p
&& identifier_p (function
))
15072 /* Do nothing; calling tsubst_copy_and_build on an identifier
15073 would incorrectly perform unqualified lookup again.
15075 Note that we can also have an IDENTIFIER_NODE if the earlier
15076 unqualified lookup found a member function; in that case
15077 koenig_p will be false and we do want to do the lookup
15078 again to find the instantiated member function.
15080 FIXME but doing that causes c++/15272, so we need to stop
15081 using IDENTIFIER_NODE in that situation. */
15082 qualified_p
= false;
15086 if (TREE_CODE (function
) == COMPONENT_REF
)
15088 tree op
= TREE_OPERAND (function
, 1);
15090 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
15091 || (BASELINK_P (op
)
15092 && BASELINK_QUALIFIED_P (op
)));
15095 qualified_p
= false;
15097 if (TREE_CODE (function
) == ADDR_EXPR
15098 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
15099 /* Avoid error about taking the address of a constructor. */
15100 function
= TREE_OPERAND (function
, 0);
15102 function
= tsubst_copy_and_build (function
, args
, complain
,
15105 integral_constant_expression_p
);
15107 if (BASELINK_P (function
))
15108 qualified_p
= true;
15111 nargs
= call_expr_nargs (t
);
15112 call_args
= make_tree_vector ();
15113 for (i
= 0; i
< nargs
; ++i
)
15115 tree arg
= CALL_EXPR_ARG (t
, i
);
15117 if (!PACK_EXPANSION_P (arg
))
15118 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
15121 /* Expand the pack expansion and push each entry onto
15123 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
15124 if (TREE_CODE (arg
) == TREE_VEC
)
15126 unsigned int len
, j
;
15128 len
= TREE_VEC_LENGTH (arg
);
15129 for (j
= 0; j
< len
; ++j
)
15131 tree value
= TREE_VEC_ELT (arg
, j
);
15132 if (value
!= NULL_TREE
)
15133 value
= convert_from_reference (value
);
15134 vec_safe_push (call_args
, value
);
15139 /* A partial substitution. Add one entry. */
15140 vec_safe_push (call_args
, arg
);
15145 /* We do not perform argument-dependent lookup if normal
15146 lookup finds a non-function, in accordance with the
15147 expected resolution of DR 218. */
15149 && ((is_overloaded_fn (function
)
15150 /* If lookup found a member function, the Koenig lookup is
15151 not appropriate, even if an unqualified-name was used
15152 to denote the function. */
15153 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
15154 || identifier_p (function
))
15155 /* Only do this when substitution turns a dependent call
15156 into a non-dependent call. */
15157 && type_dependent_expression_p_push (t
)
15158 && !any_type_dependent_arguments_p (call_args
))
15159 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
15161 if (identifier_p (function
)
15162 && !any_type_dependent_arguments_p (call_args
))
15164 if (koenig_p
&& (complain
& tf_warning_or_error
))
15166 /* For backwards compatibility and good diagnostics, try
15167 the unqualified lookup again if we aren't in SFINAE
15169 tree unq
= (tsubst_copy_and_build
15170 (function
, args
, complain
, in_decl
, true,
15171 integral_constant_expression_p
));
15172 if (unq
== error_mark_node
)
15173 RETURN (error_mark_node
);
15175 if (unq
!= function
)
15178 if (INDIRECT_REF_P (fn
))
15179 fn
= TREE_OPERAND (fn
, 0);
15180 if (TREE_CODE (fn
) == COMPONENT_REF
)
15181 fn
= TREE_OPERAND (fn
, 1);
15182 if (is_overloaded_fn (fn
))
15183 fn
= get_first_fn (fn
);
15184 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
15185 "%qD was not declared in this scope, "
15186 "and no declarations were found by "
15187 "argument-dependent lookup at the point "
15188 "of instantiation", function
))
15191 /* Can't say anything more. */;
15192 else if (DECL_CLASS_SCOPE_P (fn
))
15194 location_t loc
= EXPR_LOC_OR_LOC (t
,
15197 "declarations in dependent base %qT are "
15198 "not found by unqualified lookup",
15199 DECL_CLASS_CONTEXT (fn
));
15200 if (current_class_ptr
)
15202 "use %<this->%D%> instead", function
);
15205 "use %<%T::%D%> instead",
15206 current_class_name
, function
);
15209 inform (0, "%q+D declared here, later in the "
15210 "translation unit", fn
);
15215 if (identifier_p (function
))
15217 if (complain
& tf_error
)
15218 unqualified_name_lookup_error (function
);
15219 release_tree_vector (call_args
);
15220 RETURN (error_mark_node
);
15224 /* Remember that there was a reference to this entity. */
15225 if (DECL_P (function
)
15226 && !mark_used (function
, complain
) && !(complain
& tf_error
))
15227 RETURN (error_mark_node
);
15229 /* Put back tf_decltype for the actual call. */
15230 complain
|= decltype_flag
;
15232 if (TREE_CODE (function
) == OFFSET_REF
)
15233 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
15235 else if (TREE_CODE (function
) == COMPONENT_REF
)
15237 tree instance
= TREE_OPERAND (function
, 0);
15238 tree fn
= TREE_OPERAND (function
, 1);
15240 if (processing_template_decl
15241 && (type_dependent_expression_p (instance
)
15242 || (!BASELINK_P (fn
)
15243 && TREE_CODE (fn
) != FIELD_DECL
)
15244 || type_dependent_expression_p (fn
)
15245 || any_type_dependent_arguments_p (call_args
)))
15246 ret
= build_nt_call_vec (function
, call_args
);
15247 else if (!BASELINK_P (fn
))
15248 ret
= finish_call_expr (function
, &call_args
,
15249 /*disallow_virtual=*/false,
15250 /*koenig_p=*/false,
15253 ret
= (build_new_method_call
15255 &call_args
, NULL_TREE
,
15256 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
15261 ret
= finish_call_expr (function
, &call_args
,
15262 /*disallow_virtual=*/qualified_p
,
15266 release_tree_vector (call_args
);
15273 tree cond
= RECUR (TREE_OPERAND (t
, 0));
15274 tree folded_cond
= fold_non_dependent_expr (cond
);
15277 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
15279 if (integer_zerop (folded_cond
))
15281 ++c_inhibit_evaluation_warnings
;
15282 exp1
= RECUR (TREE_OPERAND (t
, 1));
15283 --c_inhibit_evaluation_warnings
;
15284 exp2
= RECUR (TREE_OPERAND (t
, 2));
15288 exp1
= RECUR (TREE_OPERAND (t
, 1));
15289 ++c_inhibit_evaluation_warnings
;
15290 exp2
= RECUR (TREE_OPERAND (t
, 2));
15291 --c_inhibit_evaluation_warnings
;
15293 cond
= folded_cond
;
15297 exp1
= RECUR (TREE_OPERAND (t
, 1));
15298 exp2
= RECUR (TREE_OPERAND (t
, 2));
15301 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
15302 cond
, exp1
, exp2
, complain
));
15305 case PSEUDO_DTOR_EXPR
:
15307 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15308 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15309 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15310 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
15316 tree purpose
, value
, chain
;
15318 if (t
== void_list_node
)
15321 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15322 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15324 /* We have pack expansions, so expand those and
15325 create a new list out of it. */
15326 tree purposevec
= NULL_TREE
;
15327 tree valuevec
= NULL_TREE
;
15331 /* Expand the argument expressions. */
15332 if (TREE_PURPOSE (t
))
15333 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15334 complain
, in_decl
);
15335 if (TREE_VALUE (t
))
15336 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15337 complain
, in_decl
);
15339 /* Build the rest of the list. */
15340 chain
= TREE_CHAIN (t
);
15341 if (chain
&& chain
!= void_type_node
)
15342 chain
= RECUR (chain
);
15344 /* Determine the number of arguments. */
15345 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15347 len
= TREE_VEC_LENGTH (purposevec
);
15348 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15350 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15351 len
= TREE_VEC_LENGTH (valuevec
);
15354 /* Since we only performed a partial substitution into
15355 the argument pack, we only RETURN (a single list
15357 if (purposevec
== TREE_PURPOSE (t
)
15358 && valuevec
== TREE_VALUE (t
)
15359 && chain
== TREE_CHAIN (t
))
15362 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15365 /* Convert the argument vectors into a TREE_LIST */
15369 /* Grab the Ith values. */
15371 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15374 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15377 /* Build the list (backwards). */
15378 chain
= tree_cons (purpose
, value
, chain
);
15384 purpose
= TREE_PURPOSE (t
);
15386 purpose
= RECUR (purpose
);
15387 value
= TREE_VALUE (t
);
15389 value
= RECUR (value
);
15390 chain
= TREE_CHAIN (t
);
15391 if (chain
&& chain
!= void_type_node
)
15392 chain
= RECUR (chain
);
15393 if (purpose
== TREE_PURPOSE (t
)
15394 && value
== TREE_VALUE (t
)
15395 && chain
== TREE_CHAIN (t
))
15397 RETURN (tree_cons (purpose
, value
, chain
));
15400 case COMPONENT_REF
:
15407 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15408 args
, complain
, in_decl
);
15409 /* Remember that there was a reference to this entity. */
15410 if (DECL_P (object
)
15411 && !mark_used (object
, complain
) && !(complain
& tf_error
))
15412 RETURN (error_mark_node
);
15413 object_type
= TREE_TYPE (object
);
15415 member
= TREE_OPERAND (t
, 1);
15416 if (BASELINK_P (member
))
15417 member
= tsubst_baselink (member
,
15418 non_reference (TREE_TYPE (object
)),
15419 args
, complain
, in_decl
);
15421 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15422 if (member
== error_mark_node
)
15423 RETURN (error_mark_node
);
15425 if (type_dependent_expression_p (object
))
15426 /* We can't do much here. */;
15427 else if (!CLASS_TYPE_P (object_type
))
15429 if (scalarish_type_p (object_type
))
15431 tree s
= NULL_TREE
;
15432 tree dtor
= member
;
15434 if (TREE_CODE (dtor
) == SCOPE_REF
)
15436 s
= TREE_OPERAND (dtor
, 0);
15437 dtor
= TREE_OPERAND (dtor
, 1);
15439 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15441 dtor
= TREE_OPERAND (dtor
, 0);
15443 RETURN (finish_pseudo_destructor_expr
15444 (object
, s
, dtor
, input_location
));
15448 else if (TREE_CODE (member
) == SCOPE_REF
15449 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15451 /* Lookup the template functions now that we know what the
15453 tree scope
= TREE_OPERAND (member
, 0);
15454 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15455 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15456 member
= lookup_qualified_name (scope
, tmpl
,
15457 /*is_type_p=*/false,
15458 /*complain=*/false);
15459 if (BASELINK_P (member
))
15461 BASELINK_FUNCTIONS (member
)
15462 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15464 member
= (adjust_result_of_qualified_name_lookup
15465 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15470 qualified_name_lookup_error (scope
, tmpl
, member
,
15472 RETURN (error_mark_node
);
15475 else if (TREE_CODE (member
) == SCOPE_REF
15476 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15477 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15479 if (complain
& tf_error
)
15481 if (TYPE_P (TREE_OPERAND (member
, 0)))
15482 error ("%qT is not a class or namespace",
15483 TREE_OPERAND (member
, 0));
15485 error ("%qD is not a class or namespace",
15486 TREE_OPERAND (member
, 0));
15488 RETURN (error_mark_node
);
15490 else if (TREE_CODE (member
) == FIELD_DECL
)
15492 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15493 if (TREE_CODE (r
) == COMPONENT_REF
)
15494 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15498 r
= finish_class_member_access_expr (object
, member
,
15499 /*template_p=*/false,
15501 if (TREE_CODE (r
) == COMPONENT_REF
)
15502 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15507 RETURN (build_throw
15508 (RECUR (TREE_OPERAND (t
, 0))));
15512 vec
<constructor_elt
, va_gc
> *n
;
15513 constructor_elt
*ce
;
15514 unsigned HOST_WIDE_INT idx
;
15515 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15516 bool process_index_p
;
15518 bool need_copy_p
= false;
15521 if (type
== error_mark_node
)
15522 RETURN (error_mark_node
);
15524 /* digest_init will do the wrong thing if we let it. */
15525 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15528 /* We do not want to process the index of aggregate
15529 initializers as they are identifier nodes which will be
15530 looked up by digest_init. */
15531 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15533 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15534 newlen
= vec_safe_length (n
);
15535 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15537 if (ce
->index
&& process_index_p
15538 /* An identifier index is looked up in the type
15539 being initialized, not the current scope. */
15540 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15541 ce
->index
= RECUR (ce
->index
);
15543 if (PACK_EXPANSION_P (ce
->value
))
15545 /* Substitute into the pack expansion. */
15546 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15549 if (ce
->value
== error_mark_node
15550 || PACK_EXPANSION_P (ce
->value
))
15552 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15553 /* Just move the argument into place. */
15554 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15557 /* Update the length of the final CONSTRUCTOR
15558 arguments vector, and note that we will need to
15560 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15561 need_copy_p
= true;
15565 ce
->value
= RECUR (ce
->value
);
15570 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15572 vec_alloc (n
, newlen
);
15573 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15575 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15577 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15578 for (i
= 0; i
< len
; ++i
)
15579 CONSTRUCTOR_APPEND_ELT (n
, 0,
15580 TREE_VEC_ELT (ce
->value
, i
));
15583 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15587 r
= build_constructor (init_list_type_node
, n
);
15588 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15590 if (TREE_HAS_CONSTRUCTOR (t
))
15591 RETURN (finish_compound_literal (type
, r
, complain
));
15593 TREE_TYPE (r
) = type
;
15599 tree operand_0
= TREE_OPERAND (t
, 0);
15600 if (TYPE_P (operand_0
))
15602 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15603 RETURN (get_typeid (operand_0
, complain
));
15607 operand_0
= RECUR (operand_0
);
15608 RETURN (build_typeid (operand_0
, complain
));
15615 else if (DECL_PACK_P (t
))
15617 /* We don't build decls for an instantiation of a
15618 variadic capture proxy, we instantiate the elements
15620 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15621 return RECUR (DECL_VALUE_EXPR (t
));
15627 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15628 /* ??? We're doing a subset of finish_id_expression here. */
15630 && !processing_template_decl
15631 && !cp_unevaluated_operand
15632 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
15633 && DECL_THREAD_LOCAL_P (r
))
15635 if (tree wrap
= get_tls_wrapper_fn (r
))
15636 /* Replace an evaluated use of the thread_local variable with
15637 a call to its wrapper. */
15638 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
15640 else if (outer_automatic_var_p (r
))
15641 r
= process_outer_var_ref (r
, complain
);
15643 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15644 /* If the original type was a reference, we'll be wrapped in
15645 the appropriate INDIRECT_REF. */
15646 r
= convert_from_reference (r
);
15652 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15653 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15654 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15657 case OFFSETOF_EXPR
:
15658 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0)),
15659 EXPR_LOCATION (t
)));
15663 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15664 complain
, in_decl
);
15666 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15667 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
15668 type2
= RECUR (type2
);
15670 type2
= tsubst (type2
, args
, complain
, in_decl
);
15672 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15677 tree old_stmt_expr
= cur_stmt_expr
;
15678 tree stmt_expr
= begin_stmt_expr ();
15680 cur_stmt_expr
= stmt_expr
;
15681 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15682 integral_constant_expression_p
);
15683 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15684 cur_stmt_expr
= old_stmt_expr
;
15686 /* If the resulting list of expression statement is empty,
15687 fold it further into void_node. */
15688 if (empty_expr_stmt_p (stmt_expr
))
15689 stmt_expr
= void_node
;
15691 RETURN (stmt_expr
);
15696 tree r
= build_lambda_expr ();
15698 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15699 LAMBDA_EXPR_CLOSURE (r
) = type
;
15700 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15702 LAMBDA_EXPR_LOCATION (r
)
15703 = LAMBDA_EXPR_LOCATION (t
);
15704 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15705 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15706 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15707 LAMBDA_EXPR_DISCRIMINATOR (r
)
15708 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15709 /* For a function scope, we want to use tsubst so that we don't
15710 complain about referring to an auto function before its return
15711 type has been deduced. Otherwise, we want to use tsubst_copy so
15712 that we look up the existing field/parameter/variable rather
15713 than build a new one. */
15714 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15715 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15716 scope
= tsubst (scope
, args
, complain
, in_decl
);
15717 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15719 /* Look up the parameter we want directly, as tsubst_copy
15720 doesn't do what we need. */
15721 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15722 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15723 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15724 parm
= DECL_CHAIN (parm
);
15726 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15727 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15728 DECL_CONTEXT (scope
) = fn
;
15731 scope
= RECUR (scope
);
15732 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15733 LAMBDA_EXPR_RETURN_TYPE (r
)
15734 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15736 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15737 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15739 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15740 determine_visibility (TYPE_NAME (type
));
15741 /* Now that we know visibility, instantiate the type so we have a
15742 declaration of the op() for later calls to lambda_function. */
15743 complete_type (type
);
15745 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15747 RETURN (build_lambda_object (r
));
15751 /* We can get here for a constant initializer of non-dependent type.
15752 FIXME stop folding in cp_parser_initializer_clause. */
15754 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15759 case TRANSACTION_EXPR
:
15760 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15761 integral_constant_expression_p
));
15764 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15766 case VEC_PERM_EXPR
:
15768 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15769 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15770 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15771 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15776 /* Handle Objective-C++ constructs, if appropriate. */
15779 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15780 in_decl
, /*function_p=*/false);
15784 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15790 input_location
= loc
;
15794 /* Verify that the instantiated ARGS are valid. For type arguments,
15795 make sure that the type's linkage is ok. For non-type arguments,
15796 make sure they are constants if they are integral or enumerations.
15797 Emit an error under control of COMPLAIN, and return TRUE on error. */
15800 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15802 if (dependent_template_arg_p (t
))
15804 if (ARGUMENT_PACK_P (t
))
15806 tree vec
= ARGUMENT_PACK_ARGS (t
);
15807 int len
= TREE_VEC_LENGTH (vec
);
15808 bool result
= false;
15811 for (i
= 0; i
< len
; ++i
)
15812 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15816 else if (TYPE_P (t
))
15818 /* [basic.link]: A name with no linkage (notably, the name
15819 of a class or enumeration declared in a local scope)
15820 shall not be used to declare an entity with linkage.
15821 This implies that names with no linkage cannot be used as
15824 DR 757 relaxes this restriction for C++0x. */
15825 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15826 : no_linkage_check (t
, /*relaxed_p=*/false));
15830 /* DR 488 makes use of a type with no linkage cause
15831 type deduction to fail. */
15832 if (complain
& tf_error
)
15834 if (TYPE_ANONYMOUS_P (nt
))
15835 error ("%qT is/uses anonymous type", t
);
15837 error ("template argument for %qD uses local type %qT",
15842 /* In order to avoid all sorts of complications, we do not
15843 allow variably-modified types as template arguments. */
15844 else if (variably_modified_type_p (t
, NULL_TREE
))
15846 if (complain
& tf_error
)
15847 error ("%qT is a variably modified type", t
);
15851 /* Class template and alias template arguments should be OK. */
15852 else if (DECL_TYPE_TEMPLATE_P (t
))
15854 /* A non-type argument of integral or enumerated type must be a
15856 else if (TREE_TYPE (t
)
15857 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15858 && !REFERENCE_REF_P (t
)
15859 && !TREE_CONSTANT (t
))
15861 if (complain
& tf_error
)
15862 error ("integral expression %qE is not constant", t
);
15869 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15871 int ix
, len
= DECL_NTPARMS (tmpl
);
15872 bool result
= false;
15874 for (ix
= 0; ix
!= len
; ix
++)
15876 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15879 if (result
&& (complain
& tf_error
))
15880 error (" trying to instantiate %qD", tmpl
);
15884 /* We're out of SFINAE context now, so generate diagnostics for the access
15885 errors we saw earlier when instantiating D from TMPL and ARGS. */
15888 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15890 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15891 tree type
= TREE_TYPE (pattern
);
15892 location_t loc
= input_location
;
15894 push_access_scope (d
);
15895 push_deferring_access_checks (dk_no_deferred
);
15896 input_location
= DECL_SOURCE_LOCATION (pattern
);
15897 tsubst (type
, args
, tf_warning_or_error
, d
);
15898 input_location
= loc
;
15899 pop_deferring_access_checks ();
15900 pop_access_scope (d
);
15903 /* Instantiate the indicated variable, function, or alias template TMPL with
15904 the template arguments in TARG_PTR. */
15907 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15909 tree targ_ptr
= orig_args
;
15913 bool access_ok
= true;
15915 if (tmpl
== error_mark_node
)
15916 return error_mark_node
;
15918 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15920 /* If this function is a clone, handle it specially. */
15921 if (DECL_CLONED_FUNCTION_P (tmpl
))
15926 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15927 DECL_CLONED_FUNCTION. */
15928 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15929 targ_ptr
, complain
);
15930 if (spec
== error_mark_node
)
15931 return error_mark_node
;
15933 /* Look for the clone. */
15934 FOR_EACH_CLONE (clone
, spec
)
15935 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15937 /* We should always have found the clone by now. */
15938 gcc_unreachable ();
15942 if (targ_ptr
== error_mark_node
)
15943 return error_mark_node
;
15945 /* Check to see if we already have this specialization. */
15946 gen_tmpl
= most_general_template (tmpl
);
15947 if (tmpl
!= gen_tmpl
)
15948 /* The TMPL is a partial instantiation. To get a full set of
15949 arguments we must add the arguments used to perform the
15950 partial instantiation. */
15951 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15954 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15955 but it doesn't seem to be on the hot path. */
15956 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15958 gcc_assert (tmpl
== gen_tmpl
15959 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15961 || fndecl
== NULL_TREE
);
15963 if (spec
!= NULL_TREE
)
15965 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15967 if (complain
& tf_error
)
15968 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15969 return error_mark_node
;
15974 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15976 return error_mark_node
;
15978 /* We are building a FUNCTION_DECL, during which the access of its
15979 parameters and return types have to be checked. However this
15980 FUNCTION_DECL which is the desired context for access checking
15981 is not built yet. We solve this chicken-and-egg problem by
15982 deferring all checks until we have the FUNCTION_DECL. */
15983 push_deferring_access_checks (dk_deferred
);
15985 /* Instantiation of the function happens in the context of the function
15986 template, not the context of the overload resolution we're doing. */
15987 push_to_top_level ();
15988 /* If there are dependent arguments, e.g. because we're doing partial
15989 ordering, make sure processing_template_decl stays set. */
15990 if (uses_template_parms (targ_ptr
))
15991 ++processing_template_decl
;
15992 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15994 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15995 complain
, gen_tmpl
, true);
15996 push_nested_class (ctx
);
15999 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
16001 if (VAR_P (pattern
))
16003 /* We need to determine if we're using a partial or explicit
16004 specialization now, because the type of the variable could be
16006 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
16007 tree elt
= most_specialized_partial_spec (tid
, complain
);
16008 if (elt
== error_mark_node
)
16009 pattern
= error_mark_node
;
16012 tmpl
= TREE_VALUE (elt
);
16013 pattern
= DECL_TEMPLATE_RESULT (tmpl
);
16014 targ_ptr
= TREE_PURPOSE (elt
);
16018 /* Substitute template parameters to obtain the specialization. */
16019 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
16020 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
16021 pop_nested_class ();
16022 pop_from_top_level ();
16024 if (fndecl
== error_mark_node
)
16026 pop_deferring_access_checks ();
16027 return error_mark_node
;
16030 /* The DECL_TI_TEMPLATE should always be the immediate parent
16031 template, not the most general template. */
16032 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
16034 /* Now we know the specialization, compute access previously
16036 push_access_scope (fndecl
);
16037 if (!perform_deferred_access_checks (complain
))
16039 pop_access_scope (fndecl
);
16040 pop_deferring_access_checks ();
16042 /* If we've just instantiated the main entry point for a function,
16043 instantiate all the alternate entry points as well. We do this
16044 by cloning the instantiation of the main entry point, not by
16045 instantiating the template clones. */
16046 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
16047 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
16051 if (!(complain
& tf_error
))
16053 /* Remember to reinstantiate when we're out of SFINAE so the user
16054 can see the errors. */
16055 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
16057 return error_mark_node
;
16062 /* Wrapper for instantiate_template_1. */
16065 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
16068 timevar_push (TV_TEMPLATE_INST
);
16069 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
16070 timevar_pop (TV_TEMPLATE_INST
);
16074 /* Instantiate the alias template TMPL with ARGS. Also push a template
16075 instantiation level, which instantiate_template doesn't do because
16076 functions and variables have sufficient context established by the
16080 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
16082 struct pending_template
*old_last_pend
= last_pending_template
;
16083 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16084 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
16085 return error_mark_node
;
16086 tree tinst
= build_tree_list (tmpl
, args
);
16087 if (!push_tinst_level (tinst
))
16090 return error_mark_node
;
16094 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
16095 args
, tmpl
, complain
,
16096 /*require_all_args=*/true,
16097 /*use_default_args=*/true);
16099 tree r
= instantiate_template (tmpl
, args
, complain
);
16100 pop_tinst_level ();
16101 /* We can't free this if a pending_template entry or last_error_tinst_level
16102 is pointing at it. */
16103 if (last_pending_template
== old_last_pend
16104 && last_error_tinst_level
== old_error_tinst
)
16110 /* PARM is a template parameter pack for FN. Returns true iff
16111 PARM is used in a deducible way in the argument list of FN. */
16114 pack_deducible_p (tree parm
, tree fn
)
16116 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
16117 for (; t
; t
= TREE_CHAIN (t
))
16119 tree type
= TREE_VALUE (t
);
16121 if (!PACK_EXPANSION_P (type
))
16123 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
16124 packs
; packs
= TREE_CHAIN (packs
))
16125 if (template_args_equal (TREE_VALUE (packs
), parm
))
16127 /* The template parameter pack is used in a function parameter
16128 pack. If this is the end of the parameter list, the
16129 template parameter pack is deducible. */
16130 if (TREE_CHAIN (t
) == void_list_node
)
16133 /* Otherwise, not. Well, it could be deduced from
16134 a non-pack parameter, but doing so would end up with
16135 a deduction mismatch, so don't bother. */
16139 /* The template parameter pack isn't used in any function parameter
16140 packs, but it might be used deeper, e.g. tuple<Args...>. */
16144 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
16145 NARGS elements of the arguments that are being used when calling
16146 it. TARGS is a vector into which the deduced template arguments
16149 Returns either a FUNCTION_DECL for the matching specialization of FN or
16150 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
16151 true, diagnostics will be printed to explain why it failed.
16153 If FN is a conversion operator, or we are trying to produce a specific
16154 specialization, RETURN_TYPE is the return type desired.
16156 The EXPLICIT_TARGS are explicit template arguments provided via a
16159 The parameter STRICT is one of:
16162 We are deducing arguments for a function call, as in
16163 [temp.deduct.call].
16166 We are deducing arguments for a conversion function, as in
16167 [temp.deduct.conv].
16170 We are deducing arguments when doing an explicit instantiation
16171 as in [temp.explicit], when determining an explicit specialization
16172 as in [temp.expl.spec], or when taking the address of a function
16173 template, as in [temp.deduct.funcaddr]. */
16176 fn_type_unification (tree fn
,
16177 tree explicit_targs
,
16180 unsigned int nargs
,
16182 unification_kind_t strict
,
16189 tree decl
= NULL_TREE
;
16190 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
16192 static int deduction_depth
;
16193 struct pending_template
*old_last_pend
= last_pending_template
;
16194 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16195 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
16197 tree r
= error_mark_node
;
16200 complain
|= tf_decltype
;
16202 /* In C++0x, it's possible to have a function template whose type depends
16203 on itself recursively. This is most obvious with decltype, but can also
16204 occur with enumeration scope (c++/48969). So we need to catch infinite
16205 recursion and reject the substitution at deduction time; this function
16206 will return error_mark_node for any repeated substitution.
16208 This also catches excessive recursion such as when f<N> depends on
16209 f<N-1> across all integers, and returns error_mark_node for all the
16210 substitutions back up to the initial one.
16212 This is, of course, not reentrant. */
16213 if (excessive_deduction_depth
)
16214 return error_mark_node
;
16215 tinst
= build_tree_list (fn
, NULL_TREE
);
16218 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
16220 fntype
= TREE_TYPE (fn
);
16221 if (explicit_targs
)
16225 The specified template arguments must match the template
16226 parameters in kind (i.e., type, nontype, template), and there
16227 must not be more arguments than there are parameters;
16228 otherwise type deduction fails.
16230 Nontype arguments must match the types of the corresponding
16231 nontype template parameters, or must be convertible to the
16232 types of the corresponding nontype parameters as specified in
16233 _temp.arg.nontype_, otherwise type deduction fails.
16235 All references in the function type of the function template
16236 to the corresponding template parameters are replaced by the
16237 specified template argument values. If a substitution in a
16238 template parameter or in the function type of the function
16239 template results in an invalid type, type deduction fails. */
16240 int i
, len
= TREE_VEC_LENGTH (tparms
);
16241 location_t loc
= input_location
;
16242 bool incomplete
= false;
16244 /* Adjust any explicit template arguments before entering the
16245 substitution context. */
16247 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
16249 /*require_all_args=*/false,
16250 /*use_default_args=*/false));
16251 if (explicit_targs
== error_mark_node
)
16254 /* Substitute the explicit args into the function type. This is
16255 necessary so that, for instance, explicitly declared function
16256 arguments can match null pointed constants. If we were given
16257 an incomplete set of explicit args, we must not do semantic
16258 processing during substitution as we could create partial
16260 for (i
= 0; i
< len
; i
++)
16262 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16263 bool parameter_pack
= false;
16264 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
16266 /* Dig out the actual parm. */
16267 if (TREE_CODE (parm
) == TYPE_DECL
16268 || TREE_CODE (parm
) == TEMPLATE_DECL
)
16270 parm
= TREE_TYPE (parm
);
16271 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
16273 else if (TREE_CODE (parm
) == PARM_DECL
)
16275 parm
= DECL_INITIAL (parm
);
16276 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
16279 if (!parameter_pack
&& targ
== NULL_TREE
)
16280 /* No explicit argument for this template parameter. */
16283 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
16285 /* Mark the argument pack as "incomplete". We could
16286 still deduce more arguments during unification.
16287 We remove this mark in type_unification_real. */
16290 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
16291 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
16292 = ARGUMENT_PACK_ARGS (targ
);
16295 /* We have some incomplete argument packs. */
16300 TREE_VALUE (tinst
) = explicit_targs
;
16301 if (!push_tinst_level (tinst
))
16303 excessive_deduction_depth
= true;
16306 processing_template_decl
+= incomplete
;
16307 input_location
= DECL_SOURCE_LOCATION (fn
);
16308 /* Ignore any access checks; we'll see them again in
16309 instantiate_template and they might have the wrong
16310 access path at this point. */
16311 push_deferring_access_checks (dk_deferred
);
16312 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
16313 complain
| tf_partial
, NULL_TREE
);
16314 pop_deferring_access_checks ();
16315 input_location
= loc
;
16316 processing_template_decl
-= incomplete
;
16317 pop_tinst_level ();
16319 if (fntype
== error_mark_node
)
16322 /* Place the explicitly specified arguments in TARGS. */
16323 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
16324 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
16327 /* Never do unification on the 'this' parameter. */
16328 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
16334 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
16335 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
16336 new_args
[0] = return_type
;
16337 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
16342 /* We allow incomplete unification without an error message here
16343 because the standard doesn't seem to explicitly prohibit it. Our
16344 callers must be ready to deal with unification failures in any
16347 TREE_VALUE (tinst
) = targs
;
16348 /* If we aren't explaining yet, push tinst context so we can see where
16349 any errors (e.g. from class instantiations triggered by instantiation
16350 of default template arguments) come from. If we are explaining, this
16351 context is redundant. */
16352 if (!explain_p
&& !push_tinst_level (tinst
))
16354 excessive_deduction_depth
= true;
16358 /* type_unification_real will pass back any access checks from default
16359 template argument substitution. */
16360 vec
<deferred_access_check
, va_gc
> *checks
;
16363 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16364 targs
, parms
, args
, nargs
, /*subr=*/0,
16365 strict
, flags
, &checks
, explain_p
);
16367 pop_tinst_level ();
16371 /* Now that we have bindings for all of the template arguments,
16372 ensure that the arguments deduced for the template template
16373 parameters have compatible template parameter lists. We cannot
16374 check this property before we have deduced all template
16375 arguments, because the template parameter types of a template
16376 template parameter might depend on prior template parameters
16377 deduced after the template template parameter. The following
16378 ill-formed example illustrates this issue:
16380 template<typename T, template<T> class C> void f(C<5>, T);
16382 template<int N> struct X {};
16385 f(X<5>(), 5l); // error: template argument deduction fails
16388 The template parameter list of 'C' depends on the template type
16389 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16390 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16391 time that we deduce 'C'. */
16392 if (!template_template_parm_bindings_ok_p
16393 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16395 unify_inconsistent_template_template_parameters (explain_p
);
16399 /* All is well so far. Now, check:
16403 When all template arguments have been deduced, all uses of
16404 template parameters in nondeduced contexts are replaced with
16405 the corresponding deduced argument values. If the
16406 substitution results in an invalid type, as described above,
16407 type deduction fails. */
16408 TREE_VALUE (tinst
) = targs
;
16409 if (!push_tinst_level (tinst
))
16411 excessive_deduction_depth
= true;
16415 /* Also collect access checks from the instantiation. */
16416 reopen_deferring_access_checks (checks
);
16418 decl
= instantiate_template (fn
, targs
, complain
);
16420 checks
= get_deferred_access_checks ();
16421 pop_deferring_access_checks ();
16423 pop_tinst_level ();
16425 if (decl
== error_mark_node
)
16428 /* Now perform any access checks encountered during substitution. */
16429 push_access_scope (decl
);
16430 ok
= perform_access_checks (checks
, complain
);
16431 pop_access_scope (decl
);
16435 /* If we're looking for an exact match, check that what we got
16436 is indeed an exact match. It might not be if some template
16437 parameters are used in non-deduced contexts. But don't check
16438 for an exact match if we have dependent template arguments;
16439 in that case we're doing partial ordering, and we already know
16440 that we have two candidates that will provide the actual type. */
16441 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16443 tree substed
= TREE_TYPE (decl
);
16447 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16449 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16450 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16451 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16453 unify_type_mismatch (explain_p
, args
[i
],
16454 TREE_VALUE (sarg
));
16463 if (excessive_deduction_depth
)
16465 if (deduction_depth
== 0)
16466 /* Reset once we're all the way out. */
16467 excessive_deduction_depth
= false;
16470 /* We can't free this if a pending_template entry or last_error_tinst_level
16471 is pointing at it. */
16472 if (last_pending_template
== old_last_pend
16473 && last_error_tinst_level
== old_error_tinst
)
16479 /* Adjust types before performing type deduction, as described in
16480 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16481 sections are symmetric. PARM is the type of a function parameter
16482 or the return type of the conversion function. ARG is the type of
16483 the argument passed to the call, or the type of the value
16484 initialized with the result of the conversion function.
16485 ARG_EXPR is the original argument expression, which may be null. */
16488 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16502 /* Swap PARM and ARG throughout the remainder of this
16503 function; the handling is precisely symmetric since PARM
16504 will initialize ARG rather than vice versa. */
16512 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16513 too, but here handle it by stripping the reference from PARM
16514 rather than by adding it to ARG. */
16515 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16516 && TYPE_REF_IS_RVALUE (*parm
)
16517 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16518 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16519 && TREE_CODE (*arg
) == REFERENCE_TYPE
16520 && !TYPE_REF_IS_RVALUE (*arg
))
16521 *parm
= TREE_TYPE (*parm
);
16522 /* Nothing else to do in this case. */
16526 gcc_unreachable ();
16529 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16531 /* [temp.deduct.call]
16533 If P is not a reference type:
16535 --If A is an array type, the pointer type produced by the
16536 array-to-pointer standard conversion (_conv.array_) is
16537 used in place of A for type deduction; otherwise,
16539 --If A is a function type, the pointer type produced by
16540 the function-to-pointer standard conversion
16541 (_conv.func_) is used in place of A for type deduction;
16544 --If A is a cv-qualified type, the top level
16545 cv-qualifiers of A's type are ignored for type
16547 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16548 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16549 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16550 *arg
= build_pointer_type (*arg
);
16552 *arg
= TYPE_MAIN_VARIANT (*arg
);
16555 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16556 of the form T&&, where T is a template parameter, and the argument
16557 is an lvalue, T is deduced as A& */
16558 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16559 && TYPE_REF_IS_RVALUE (*parm
)
16560 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16561 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16562 && (arg_expr
? real_lvalue_p (arg_expr
)
16563 /* try_one_overload doesn't provide an arg_expr, but
16564 functions are always lvalues. */
16565 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16566 *arg
= build_reference_type (*arg
);
16568 /* [temp.deduct.call]
16570 If P is a cv-qualified type, the top level cv-qualifiers
16571 of P's type are ignored for type deduction. If P is a
16572 reference type, the type referred to by P is used for
16574 *parm
= TYPE_MAIN_VARIANT (*parm
);
16575 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16577 *parm
= TREE_TYPE (*parm
);
16578 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16581 /* DR 322. For conversion deduction, remove a reference type on parm
16582 too (which has been swapped into ARG). */
16583 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16584 *arg
= TREE_TYPE (*arg
);
16589 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16590 template which does contain any deducible template parameters; check if
16591 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16592 unify_one_argument. */
16595 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16596 int flags
, bool explain_p
)
16601 type
= TREE_TYPE (arg
);
16605 if (same_type_p (parm
, type
))
16606 return unify_success (explain_p
);
16608 if (strict
== DEDUCE_CONV
)
16610 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16611 explain_p
? tf_warning_or_error
: tf_none
))
16612 return unify_success (explain_p
);
16614 else if (strict
!= DEDUCE_EXACT
)
16616 if (can_convert_arg (parm
, type
,
16617 TYPE_P (arg
) ? NULL_TREE
: arg
,
16618 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16619 return unify_success (explain_p
);
16622 if (strict
== DEDUCE_EXACT
)
16623 return unify_type_mismatch (explain_p
, parm
, arg
);
16625 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16628 static bool uses_deducible_template_parms (tree type
);
16630 /* Returns true iff the expression EXPR is one from which a template
16631 argument can be deduced. In other words, if it's an undecorated
16632 use of a template non-type parameter. */
16635 deducible_expression (tree expr
)
16637 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16640 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16641 deducible way; that is, if it has a max value of <PARM> - 1. */
16644 deducible_array_bound (tree domain
)
16646 if (domain
== NULL_TREE
)
16649 tree max
= TYPE_MAX_VALUE (domain
);
16650 if (TREE_CODE (max
) != MINUS_EXPR
)
16653 return deducible_expression (TREE_OPERAND (max
, 0));
16656 /* Returns true iff the template arguments ARGS use a template parameter
16657 in a deducible way. */
16660 deducible_template_args (tree args
)
16662 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16665 tree elt
= TREE_VEC_ELT (args
, i
);
16666 if (ARGUMENT_PACK_P (elt
))
16667 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16670 if (PACK_EXPANSION_P (elt
))
16671 elt
= PACK_EXPANSION_PATTERN (elt
);
16672 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16674 else if (TYPE_P (elt
))
16675 deducible
= uses_deducible_template_parms (elt
);
16677 deducible
= deducible_expression (elt
);
16685 /* Returns true iff TYPE contains any deducible references to template
16686 parameters, as per 14.8.2.5. */
16689 uses_deducible_template_parms (tree type
)
16691 if (PACK_EXPANSION_P (type
))
16692 type
= PACK_EXPANSION_PATTERN (type
);
16699 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16700 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16706 if (POINTER_TYPE_P (type
))
16707 return uses_deducible_template_parms (TREE_TYPE (type
));
16709 /* T[integer-constant ]
16711 if (TREE_CODE (type
) == ARRAY_TYPE
)
16712 return (uses_deducible_template_parms (TREE_TYPE (type
))
16713 || deducible_array_bound (TYPE_DOMAIN (type
)));
16725 if (TYPE_PTRMEM_P (type
))
16726 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16727 || (uses_deducible_template_parms
16728 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16730 /* template-name <T> (where template-name refers to a class template)
16731 template-name <i> (where template-name refers to a class template) */
16732 if (CLASS_TYPE_P (type
)
16733 && CLASSTYPE_TEMPLATE_INFO (type
)
16734 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16735 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16736 (CLASSTYPE_TI_ARGS (type
)));
16741 if (TREE_CODE (type
) == FUNCTION_TYPE
16742 || TREE_CODE (type
) == METHOD_TYPE
)
16744 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16746 tree parm
= TYPE_ARG_TYPES (type
);
16747 if (TREE_CODE (type
) == METHOD_TYPE
)
16748 parm
= TREE_CHAIN (parm
);
16749 for (; parm
; parm
= TREE_CHAIN (parm
))
16750 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16757 /* Subroutine of type_unification_real and unify_pack_expansion to
16758 handle unification of a single P/A pair. Parameters are as
16759 for those functions. */
16762 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16763 int subr
, unification_kind_t strict
,
16766 tree arg_expr
= NULL_TREE
;
16769 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16770 return unify_invalid (explain_p
);
16771 if (arg
== unknown_type_node
)
16772 /* We can't deduce anything from this, but we might get all the
16773 template args from other function args. */
16774 return unify_success (explain_p
);
16776 /* Implicit conversions (Clause 4) will be performed on a function
16777 argument to convert it to the type of the corresponding function
16778 parameter if the parameter type contains no template-parameters that
16779 participate in template argument deduction. */
16780 if (strict
!= DEDUCE_EXACT
16781 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16782 /* For function parameters with no deducible template parameters,
16783 just return. We'll check non-dependent conversions later. */
16784 return unify_success (explain_p
);
16789 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16790 | UNIFY_ALLOW_MORE_CV_QUAL
16791 | UNIFY_ALLOW_DERIVED
);
16795 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16799 arg_strict
= UNIFY_ALLOW_NONE
;
16803 gcc_unreachable ();
16806 /* We only do these transformations if this is the top-level
16807 parameter_type_list in a call or declaration matching; in other
16808 situations (nested function declarators, template argument lists) we
16809 won't be comparing a type to an expression, and we don't do any type
16815 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16816 if (type_unknown_p (arg
))
16818 /* [temp.deduct.type] A template-argument can be
16819 deduced from a pointer to function or pointer
16820 to member function argument if the set of
16821 overloaded functions does not contain function
16822 templates and at most one of a set of
16823 overloaded functions provides a unique
16826 if (resolve_overloaded_unification
16827 (tparms
, targs
, parm
, arg
, strict
,
16828 arg_strict
, explain_p
))
16829 return unify_success (explain_p
);
16830 return unify_overload_resolution_failure (explain_p
, arg
);
16834 arg
= unlowered_expr_type (arg
);
16835 if (arg
== error_mark_node
)
16836 return unify_invalid (explain_p
);
16840 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16843 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16844 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
16845 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16847 /* For deduction from an init-list we need the actual list. */
16848 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16850 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16853 /* Most parms like fn_type_unification.
16855 If SUBR is 1, we're being called recursively (to unify the
16856 arguments of a function or method parameter of a function
16859 CHECKS is a pointer to a vector of access checks encountered while
16860 substituting default template arguments. */
16863 type_unification_real (tree tparms
,
16867 unsigned int xnargs
,
16869 unification_kind_t strict
,
16871 vec
<deferred_access_check
, va_gc
> **checks
,
16876 int ntparms
= TREE_VEC_LENGTH (tparms
);
16877 int saw_undeduced
= 0;
16880 unsigned int nargs
;
16883 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16884 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16885 gcc_assert (ntparms
> 0);
16887 /* Reset the number of non-defaulted template arguments contained
16889 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16897 while (parms
&& parms
!= void_list_node
16900 parm
= TREE_VALUE (parms
);
16902 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16903 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16904 /* For a function parameter pack that occurs at the end of the
16905 parameter-declaration-list, the type A of each remaining
16906 argument of the call is compared with the type P of the
16907 declarator-id of the function parameter pack. */
16910 parms
= TREE_CHAIN (parms
);
16912 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16913 /* For a function parameter pack that does not occur at the
16914 end of the parameter-declaration-list, the type of the
16915 parameter pack is a non-deduced context. */
16921 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16927 && parms
!= void_list_node
16928 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16930 /* Unify the remaining arguments with the pack expansion type. */
16932 tree parmvec
= make_tree_vec (1);
16934 /* Allocate a TREE_VEC and copy in all of the arguments */
16935 argvec
= make_tree_vec (nargs
- ia
);
16936 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16937 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16939 /* Copy the parameter into parmvec. */
16940 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16941 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16942 /*subr=*/subr
, explain_p
))
16945 /* Advance to the end of the list of parameters. */
16946 parms
= TREE_CHAIN (parms
);
16949 /* Fail if we've reached the end of the parm list, and more args
16950 are present, and the parm list isn't variadic. */
16951 if (ia
< nargs
&& parms
== void_list_node
)
16952 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16953 /* Fail if parms are left and they don't have default values and
16954 they aren't all deduced as empty packs (c++/57397). This is
16955 consistent with sufficient_parms_p. */
16956 if (parms
&& parms
!= void_list_node
16957 && TREE_PURPOSE (parms
) == NULL_TREE
)
16959 unsigned int count
= nargs
;
16964 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
16967 p
= TREE_CHAIN (p
);
16969 while (p
&& p
!= void_list_node
);
16970 if (count
!= nargs
)
16971 return unify_too_few_arguments (explain_p
, ia
, count
,
16977 tsubst_flags_t complain
= (explain_p
16978 ? tf_warning_or_error
16981 for (i
= 0; i
< ntparms
; i
++)
16983 tree targ
= TREE_VEC_ELT (targs
, i
);
16984 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16986 /* Clear the "incomplete" flags on all argument packs now so that
16987 substituting them into later default arguments works. */
16988 if (targ
&& ARGUMENT_PACK_P (targ
))
16990 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16991 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16994 if (targ
|| tparm
== error_mark_node
)
16996 tparm
= TREE_VALUE (tparm
);
16998 /* If this is an undeduced nontype parameter that depends on
16999 a type parameter, try another pass; its type may have been
17000 deduced from a later argument than the one from which
17001 this parameter can be deduced. */
17002 if (TREE_CODE (tparm
) == PARM_DECL
17003 && uses_template_parms (TREE_TYPE (tparm
))
17004 && saw_undeduced
< 2)
17010 /* Core issue #226 (C++0x) [temp.deduct]:
17012 If a template argument has not been deduced, its
17013 default template argument, if any, is used.
17015 When we are in C++98 mode, TREE_PURPOSE will either
17016 be NULL_TREE or ERROR_MARK_NODE, so we do not need
17017 to explicitly check cxx_dialect here. */
17018 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
17019 /* OK, there is a default argument. Wait until after the
17020 conversion check to do substitution. */
17023 /* If the type parameter is a parameter pack, then it will
17024 be deduced to an empty parameter pack. */
17025 if (template_parameter_pack_p (tparm
))
17029 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
17031 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
17032 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
17033 TREE_CONSTANT (arg
) = 1;
17036 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17038 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
17040 TREE_VEC_ELT (targs
, i
) = arg
;
17044 return unify_parameter_deduction_failure (explain_p
, tparm
);
17047 /* DR 1391: All parameters have args, now check non-dependent parms for
17049 if (saw_undeduced
< 2)
17050 for (ia
= 0, parms
= xparms
, args
= xargs
, nargs
= xnargs
;
17051 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
17053 parm
= TREE_VALUE (parms
);
17055 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
17056 && (!TREE_CHAIN (parms
)
17057 || TREE_CHAIN (parms
) == void_list_node
))
17058 /* For a function parameter pack that occurs at the end of the
17059 parameter-declaration-list, the type A of each remaining
17060 argument of the call is compared with the type P of the
17061 declarator-id of the function parameter pack. */
17064 parms
= TREE_CHAIN (parms
);
17066 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
17067 /* For a function parameter pack that does not occur at the
17068 end of the parameter-declaration-list, the type of the
17069 parameter pack is a non-deduced context. */
17075 if (uses_template_parms (parm
))
17077 if (check_non_deducible_conversion (parm
, arg
, strict
, flags
,
17082 /* Now substitute into the default template arguments. */
17083 for (i
= 0; i
< ntparms
; i
++)
17085 tree targ
= TREE_VEC_ELT (targs
, i
);
17086 tree tparm
= TREE_VEC_ELT (tparms
, i
);
17088 if (targ
|| tparm
== error_mark_node
)
17090 tree parm
= TREE_VALUE (tparm
);
17092 if (TREE_CODE (parm
) == PARM_DECL
17093 && uses_template_parms (TREE_TYPE (parm
))
17094 && saw_undeduced
< 2)
17097 tree arg
= TREE_PURPOSE (tparm
);
17098 reopen_deferring_access_checks (*checks
);
17099 location_t save_loc
= input_location
;
17101 input_location
= DECL_SOURCE_LOCATION (parm
);
17102 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
17103 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
17105 input_location
= save_loc
;
17106 *checks
= get_deferred_access_checks ();
17107 pop_deferring_access_checks ();
17108 if (arg
== error_mark_node
)
17112 TREE_VEC_ELT (targs
, i
) = arg
;
17113 /* The position of the first default template argument,
17114 is also the number of non-defaulted arguments in TARGS.
17116 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
17117 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
17122 if (saw_undeduced
++ == 1)
17125 #ifdef ENABLE_CHECKING
17126 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
17127 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
17130 return unify_success (explain_p
);
17133 /* Subroutine of type_unification_real. Args are like the variables
17134 at the call site. ARG is an overloaded function (or template-id);
17135 we try deducing template args from each of the overloads, and if
17136 only one succeeds, we go with that. Modifies TARGS and returns
17137 true on success. */
17140 resolve_overloaded_unification (tree tparms
,
17144 unification_kind_t strict
,
17148 tree tempargs
= copy_node (targs
);
17150 tree goodfn
= NULL_TREE
;
17153 if (TREE_CODE (arg
) == ADDR_EXPR
)
17155 arg
= TREE_OPERAND (arg
, 0);
17161 if (TREE_CODE (arg
) == COMPONENT_REF
)
17162 /* Handle `&x' where `x' is some static or non-static member
17164 arg
= TREE_OPERAND (arg
, 1);
17166 if (TREE_CODE (arg
) == OFFSET_REF
)
17167 arg
= TREE_OPERAND (arg
, 1);
17169 /* Strip baselink information. */
17170 if (BASELINK_P (arg
))
17171 arg
= BASELINK_FUNCTIONS (arg
);
17173 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
17175 /* If we got some explicit template args, we need to plug them into
17176 the affected templates before we try to unify, in case the
17177 explicit args will completely resolve the templates in question. */
17180 tree expl_subargs
= TREE_OPERAND (arg
, 1);
17181 arg
= TREE_OPERAND (arg
, 0);
17183 for (; arg
; arg
= OVL_NEXT (arg
))
17185 tree fn
= OVL_CURRENT (arg
);
17186 tree subargs
, elem
;
17188 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17191 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17192 expl_subargs
, NULL_TREE
, tf_none
,
17193 /*require_all_args=*/true,
17194 /*use_default_args=*/true);
17195 if (subargs
!= error_mark_node
17196 && !any_dependent_template_arguments_p (subargs
))
17198 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
17199 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17200 elem
, strict
, sub_strict
, addr_p
, explain_p
)
17201 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
17210 /* If no templates (or more than one) are fully resolved by the
17211 explicit arguments, this template-id is a non-deduced context; it
17212 could still be OK if we deduce all template arguments for the
17213 enclosing call through other arguments. */
17217 else if (TREE_CODE (arg
) != OVERLOAD
17218 && TREE_CODE (arg
) != FUNCTION_DECL
)
17219 /* If ARG is, for example, "(0, &f)" then its type will be unknown
17220 -- but the deduction does not succeed because the expression is
17221 not just the function on its own. */
17224 for (; arg
; arg
= OVL_NEXT (arg
))
17225 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17226 TREE_TYPE (OVL_CURRENT (arg
)),
17227 strict
, sub_strict
, addr_p
, explain_p
)
17228 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
17230 goodfn
= OVL_CURRENT (arg
);
17234 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17235 to function or pointer to member function argument if the set of
17236 overloaded functions does not contain function templates and at most
17237 one of a set of overloaded functions provides a unique match.
17239 So if we found multiple possibilities, we return success but don't
17240 deduce anything. */
17244 int i
= TREE_VEC_LENGTH (targs
);
17246 if (TREE_VEC_ELT (tempargs
, i
))
17248 tree old
= TREE_VEC_ELT (targs
, i
);
17249 tree new_
= TREE_VEC_ELT (tempargs
, i
);
17250 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
17251 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
17252 /* Don't forget explicit template arguments in a pack. */
17253 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
17254 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
17255 TREE_VEC_ELT (targs
, i
) = new_
;
17264 /* Core DR 115: In contexts where deduction is done and fails, or in
17265 contexts where deduction is not done, if a template argument list is
17266 specified and it, along with any default template arguments, identifies
17267 a single function template specialization, then the template-id is an
17268 lvalue for the function template specialization. */
17271 resolve_nondeduced_context (tree orig_expr
)
17273 tree expr
, offset
, baselink
;
17276 if (!type_unknown_p (orig_expr
))
17281 offset
= NULL_TREE
;
17282 baselink
= NULL_TREE
;
17284 if (TREE_CODE (expr
) == ADDR_EXPR
)
17286 expr
= TREE_OPERAND (expr
, 0);
17289 if (TREE_CODE (expr
) == OFFSET_REF
)
17292 expr
= TREE_OPERAND (expr
, 1);
17294 if (BASELINK_P (expr
))
17297 expr
= BASELINK_FUNCTIONS (expr
);
17300 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
17303 tree goodfn
= NULL_TREE
;
17305 /* If we got some explicit template args, we need to plug them into
17306 the affected templates before we try to unify, in case the
17307 explicit args will completely resolve the templates in question. */
17309 tree expl_subargs
= TREE_OPERAND (expr
, 1);
17310 tree arg
= TREE_OPERAND (expr
, 0);
17311 tree badfn
= NULL_TREE
;
17312 tree badargs
= NULL_TREE
;
17314 for (; arg
; arg
= OVL_NEXT (arg
))
17316 tree fn
= OVL_CURRENT (arg
);
17317 tree subargs
, elem
;
17319 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17322 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17323 expl_subargs
, NULL_TREE
, tf_none
,
17324 /*require_all_args=*/true,
17325 /*use_default_args=*/true);
17326 if (subargs
!= error_mark_node
17327 && !any_dependent_template_arguments_p (subargs
))
17329 elem
= instantiate_template (fn
, subargs
, tf_none
);
17330 if (elem
== error_mark_node
)
17335 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
17344 mark_used (goodfn
);
17347 expr
= build_baselink (BASELINK_BINFO (baselink
),
17348 BASELINK_ACCESS_BINFO (baselink
),
17349 expr
, BASELINK_OPTYPE (baselink
));
17353 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
17354 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
17357 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
17360 else if (good
== 0 && badargs
)
17361 /* There were no good options and at least one bad one, so let the
17362 user know what the problem is. */
17363 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
17368 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17369 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17370 different overloads deduce different arguments for a given parm.
17371 ADDR_P is true if the expression for which deduction is being
17372 performed was of the form "& fn" rather than simply "fn".
17374 Returns 1 on success. */
17377 try_one_overload (tree tparms
,
17382 unification_kind_t strict
,
17391 if (arg
== error_mark_node
)
17394 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17395 to function or pointer to member function argument if the set of
17396 overloaded functions does not contain function templates and at most
17397 one of a set of overloaded functions provides a unique match.
17399 So if this is a template, just return success. */
17401 if (uses_template_parms (arg
))
17404 if (TREE_CODE (arg
) == METHOD_TYPE
)
17405 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
17407 arg
= build_pointer_type (arg
);
17409 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
17411 /* We don't copy orig_targs for this because if we have already deduced
17412 some template args from previous args, unify would complain when we
17413 try to deduce a template parameter for the same argument, even though
17414 there isn't really a conflict. */
17415 nargs
= TREE_VEC_LENGTH (targs
);
17416 tempargs
= make_tree_vec (nargs
);
17418 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
17421 /* First make sure we didn't deduce anything that conflicts with
17422 explicitly specified args. */
17423 for (i
= nargs
; i
--; )
17425 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17426 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17430 else if (uses_template_parms (elt
))
17431 /* Since we're unifying against ourselves, we will fill in
17432 template args used in the function parm list with our own
17433 template parms. Discard them. */
17434 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17435 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17439 for (i
= nargs
; i
--; )
17441 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17444 TREE_VEC_ELT (targs
, i
) = elt
;
17450 /* PARM is a template class (perhaps with unbound template
17451 parameters). ARG is a fully instantiated type. If ARG can be
17452 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17453 TARGS are as for unify. */
17456 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17459 tree copy_of_targs
;
17461 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17462 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17463 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17466 /* We need to make a new template argument vector for the call to
17467 unify. If we used TARGS, we'd clutter it up with the result of
17468 the attempted unification, even if this class didn't work out.
17469 We also don't want to commit ourselves to all the unifications
17470 we've already done, since unification is supposed to be done on
17471 an argument-by-argument basis. In other words, consider the
17472 following pathological case:
17474 template <int I, int J, int K>
17477 template <int I, int J>
17478 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17480 template <int I, int J, int K>
17481 void f(S<I, J, K>, S<I, I, I>);
17490 Now, by the time we consider the unification involving `s2', we
17491 already know that we must have `f<0, 0, 0>'. But, even though
17492 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17493 because there are two ways to unify base classes of S<0, 1, 2>
17494 with S<I, I, I>. If we kept the already deduced knowledge, we
17495 would reject the possibility I=1. */
17496 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17498 /* If unification failed, we're done. */
17499 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17500 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17506 /* Given a template type PARM and a class type ARG, find the unique
17507 base type in ARG that is an instance of PARM. We do not examine
17508 ARG itself; only its base-classes. If there is not exactly one
17509 appropriate base class, return NULL_TREE. PARM may be the type of
17510 a partial specialization, as well as a plain template type. Used
17513 static enum template_base_result
17514 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17515 bool explain_p
, tree
*result
)
17517 tree rval
= NULL_TREE
;
17520 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17522 binfo
= TYPE_BINFO (complete_type (arg
));
17525 /* The type could not be completed. */
17526 *result
= NULL_TREE
;
17527 return tbr_incomplete_type
;
17530 /* Walk in inheritance graph order. The search order is not
17531 important, and this avoids multiple walks of virtual bases. */
17532 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17534 tree r
= try_class_unification (tparms
, targs
, parm
,
17535 BINFO_TYPE (binfo
), explain_p
);
17539 /* If there is more than one satisfactory baseclass, then:
17543 If they yield more than one possible deduced A, the type
17547 if (rval
&& !same_type_p (r
, rval
))
17549 *result
= NULL_TREE
;
17550 return tbr_ambiguous_baseclass
;
17558 return tbr_success
;
17561 /* Returns the level of DECL, which declares a template parameter. */
17564 template_decl_level (tree decl
)
17566 switch (TREE_CODE (decl
))
17569 case TEMPLATE_DECL
:
17570 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17573 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17576 gcc_unreachable ();
17581 /* Decide whether ARG can be unified with PARM, considering only the
17582 cv-qualifiers of each type, given STRICT as documented for unify.
17583 Returns nonzero iff the unification is OK on that basis. */
17586 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17588 int arg_quals
= cp_type_quals (arg
);
17589 int parm_quals
= cp_type_quals (parm
);
17591 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17592 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17594 /* Although a CVR qualifier is ignored when being applied to a
17595 substituted template parameter ([8.3.2]/1 for example), that
17596 does not allow us to unify "const T" with "int&" because both
17597 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17598 It is ok when we're allowing additional CV qualifiers
17599 at the outer level [14.8.2.1]/3,1st bullet. */
17600 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17601 || TREE_CODE (arg
) == FUNCTION_TYPE
17602 || TREE_CODE (arg
) == METHOD_TYPE
)
17603 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17606 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17607 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17611 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17612 && (arg_quals
& parm_quals
) != parm_quals
)
17615 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17616 && (parm_quals
& arg_quals
) != arg_quals
)
17622 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17624 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17626 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17627 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17628 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17630 *index
= TEMPLATE_TYPE_IDX (parm
);
17631 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17635 *index
= TEMPLATE_PARM_IDX (parm
);
17636 *level
= TEMPLATE_PARM_LEVEL (parm
);
17640 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17642 if (unify (TP, TA, P, A, S, EP)) \
17646 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17647 expansion at the end of PACKED_PARMS. Returns 0 if the type
17648 deduction succeeds, 1 otherwise. STRICT is the same as in
17649 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17650 call argument list. We'll need to adjust the arguments to make them
17651 types. SUBR tells us if this is from a recursive call to
17652 type_unification_real, or for comparing two template argument
17656 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17657 tree packed_args
, unification_kind_t strict
,
17658 bool subr
, bool explain_p
)
17661 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17662 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17663 tree pack
, packs
= NULL_TREE
;
17664 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17666 packed_args
= expand_template_argument_pack (packed_args
);
17668 int len
= TREE_VEC_LENGTH (packed_args
);
17670 /* Determine the parameter packs we will be deducing from the
17671 pattern, and record their current deductions. */
17672 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17673 pack
; pack
= TREE_CHAIN (pack
))
17675 tree parm_pack
= TREE_VALUE (pack
);
17678 /* Determine the index and level of this parameter pack. */
17679 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17681 /* Keep track of the parameter packs and their corresponding
17683 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17684 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17687 /* Loop through all of the arguments that have not yet been
17688 unified and unify each with the pattern. */
17689 for (i
= start
; i
< len
; i
++)
17692 bool any_explicit
= false;
17693 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17695 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17696 or the element of its argument pack at the current index if
17697 this argument was explicitly specified. */
17698 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17702 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17705 if (TREE_VALUE (pack
)
17706 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17707 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17709 any_explicit
= true;
17710 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17712 TMPL_ARG (targs
, level
, idx
) = arg
;
17715 /* If we had explicit template arguments, substitute them into the
17716 pattern before deduction. */
17719 /* Some arguments might still be unspecified or dependent. */
17721 ++processing_template_decl
;
17722 dependent
= any_dependent_template_arguments_p (targs
);
17724 --processing_template_decl
;
17725 parm
= tsubst (pattern
, targs
,
17726 explain_p
? tf_warning_or_error
: tf_none
,
17729 --processing_template_decl
;
17730 if (parm
== error_mark_node
)
17736 /* Unify the pattern with the current argument. */
17737 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17741 /* For each parameter pack, collect the deduced value. */
17742 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17745 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17747 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17748 TMPL_ARG (targs
, level
, idx
);
17752 /* Verify that the results of unification with the parameter packs
17753 produce results consistent with what we've seen before, and make
17754 the deduced argument packs available. */
17755 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17757 tree old_pack
= TREE_VALUE (pack
);
17758 tree new_args
= TREE_TYPE (pack
);
17759 int i
, len
= TREE_VEC_LENGTH (new_args
);
17761 bool nondeduced_p
= false;
17763 /* By default keep the original deduced argument pack.
17764 If necessary, more specific code is going to update the
17765 resulting deduced argument later down in this function. */
17766 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17767 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17769 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17770 actually deduce anything. */
17771 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17772 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17773 nondeduced_p
= true;
17777 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17779 /* If we had fewer function args than explicit template args,
17780 just use the explicits. */
17781 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17782 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17783 if (len
< explicit_len
)
17784 new_args
= explicit_args
;
17790 /* Build the deduced *_ARGUMENT_PACK. */
17791 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17793 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17794 TREE_TYPE (result
) =
17795 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17796 TREE_CONSTANT (result
) = 1;
17799 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17801 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17803 /* Note the deduced argument packs for this parameter
17805 TMPL_ARG (targs
, level
, idx
) = result
;
17807 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17808 && (ARGUMENT_PACK_ARGS (old_pack
)
17809 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17811 /* We only had the explicitly-provided arguments before, but
17812 now we have a complete set of arguments. */
17813 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17815 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17816 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17817 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17821 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17822 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17824 if (!comp_template_args_with_info (old_args
, new_args
,
17825 &bad_old_arg
, &bad_new_arg
))
17826 /* Inconsistent unification of this parameter pack. */
17827 return unify_parameter_pack_inconsistent (explain_p
,
17833 return unify_success (explain_p
);
17836 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17837 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17838 parameters and return value are as for unify. */
17841 unify_array_domain (tree tparms
, tree targs
,
17842 tree parm_dom
, tree arg_dom
,
17850 /* Our representation of array types uses "N - 1" as the
17851 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17852 not an integer constant. We cannot unify arbitrarily
17853 complex expressions, so we eliminate the MINUS_EXPRs
17855 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17856 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17859 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17860 parm_max
= TREE_OPERAND (parm_max
, 0);
17862 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17863 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17866 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17867 trying to unify the type of a variable with the type
17868 of a template parameter. For example:
17870 template <unsigned int N>
17871 void f (char (&) [N]);
17878 Here, the type of the ARG will be "int [g(i)]", and
17879 may be a SAVE_EXPR, etc. */
17880 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17881 return unify_vla_arg (explain_p
, arg_dom
);
17882 arg_max
= TREE_OPERAND (arg_max
, 0);
17885 /* If only one of the bounds used a MINUS_EXPR, compensate
17886 by adding one to the other bound. */
17887 if (parm_cst
&& !arg_cst
)
17888 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17892 else if (arg_cst
&& !parm_cst
)
17893 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17898 return unify (tparms
, targs
, parm_max
, arg_max
,
17899 UNIFY_ALLOW_INTEGER
, explain_p
);
17902 /* Deduce the value of template parameters. TPARMS is the (innermost)
17903 set of template parameters to a template. TARGS is the bindings
17904 for those template parameters, as determined thus far; TARGS may
17905 include template arguments for outer levels of template parameters
17906 as well. PARM is a parameter to a template function, or a
17907 subcomponent of that parameter; ARG is the corresponding argument.
17908 This function attempts to match PARM with ARG in a manner
17909 consistent with the existing assignments in TARGS. If more values
17910 are deduced, then TARGS is updated.
17912 Returns 0 if the type deduction succeeds, 1 otherwise. The
17913 parameter STRICT is a bitwise or of the following flags:
17916 Require an exact match between PARM and ARG.
17917 UNIFY_ALLOW_MORE_CV_QUAL:
17918 Allow the deduced ARG to be more cv-qualified (by qualification
17919 conversion) than ARG.
17920 UNIFY_ALLOW_LESS_CV_QUAL:
17921 Allow the deduced ARG to be less cv-qualified than ARG.
17922 UNIFY_ALLOW_DERIVED:
17923 Allow the deduced ARG to be a template base class of ARG,
17924 or a pointer to a template base class of the type pointed to by
17926 UNIFY_ALLOW_INTEGER:
17927 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17928 case for more information.
17929 UNIFY_ALLOW_OUTER_LEVEL:
17930 This is the outermost level of a deduction. Used to determine validity
17931 of qualification conversions. A valid qualification conversion must
17932 have const qualified pointers leading up to the inner type which
17933 requires additional CV quals, except at the outer level, where const
17934 is not required [conv.qual]. It would be normal to set this flag in
17935 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17936 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17937 This is the outermost level of a deduction, and PARM can be more CV
17938 qualified at this point.
17939 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17940 This is the outermost level of a deduction, and PARM can be less CV
17941 qualified at this point. */
17944 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17950 int strict_in
= strict
;
17952 /* I don't think this will do the right thing with respect to types.
17953 But the only case I've seen it in so far has been array bounds, where
17954 signedness is the only information lost, and I think that will be
17956 while (TREE_CODE (parm
) == NOP_EXPR
)
17957 parm
= TREE_OPERAND (parm
, 0);
17959 if (arg
== error_mark_node
)
17960 return unify_invalid (explain_p
);
17961 if (arg
== unknown_type_node
17962 || arg
== init_list_type_node
)
17963 /* We can't deduce anything from this, but we might get all the
17964 template args from other function args. */
17965 return unify_success (explain_p
);
17967 /* If PARM uses template parameters, then we can't bail out here,
17968 even if ARG == PARM, since we won't record unifications for the
17969 template parameters. We might need them if we're trying to
17970 figure out which of two things is more specialized. */
17971 if (arg
== parm
&& !uses_template_parms (parm
))
17972 return unify_success (explain_p
);
17974 /* Handle init lists early, so the rest of the function can assume
17975 we're dealing with a type. */
17976 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17980 tree orig_parm
= parm
;
17982 /* Replace T with std::initializer_list<T> for deduction. */
17983 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17984 && flag_deduce_init_list
)
17985 parm
= listify (parm
);
17987 if (!is_std_init_list (parm
)
17988 && TREE_CODE (parm
) != ARRAY_TYPE
)
17989 /* We can only deduce from an initializer list argument if the
17990 parameter is std::initializer_list or an array; otherwise this
17991 is a non-deduced context. */
17992 return unify_success (explain_p
);
17994 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17995 elttype
= TREE_TYPE (parm
);
17998 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17999 /* Deduction is defined in terms of a single type, so just punt
18000 on the (bizarre) std::initializer_list<T...>. */
18001 if (PACK_EXPANSION_P (elttype
))
18002 return unify_success (explain_p
);
18005 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
18007 int elt_strict
= strict
;
18009 if (elt
== error_mark_node
)
18010 return unify_invalid (explain_p
);
18012 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
18014 tree type
= TREE_TYPE (elt
);
18015 if (type
== error_mark_node
)
18016 return unify_invalid (explain_p
);
18017 /* It should only be possible to get here for a call. */
18018 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
18019 elt_strict
|= maybe_adjust_types_for_deduction
18020 (DEDUCE_CALL
, &elttype
, &type
, elt
);
18024 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
18028 if (TREE_CODE (parm
) == ARRAY_TYPE
18029 && deducible_array_bound (TYPE_DOMAIN (parm
)))
18031 /* Also deduce from the length of the initializer list. */
18032 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
18033 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
18034 if (idx
== error_mark_node
)
18035 return unify_invalid (explain_p
);
18036 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18040 /* If the std::initializer_list<T> deduction worked, replace the
18041 deduced A with std::initializer_list<A>. */
18042 if (orig_parm
!= parm
)
18044 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
18045 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18046 targ
= listify (targ
);
18047 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
18049 return unify_success (explain_p
);
18052 /* Immediately reject some pairs that won't unify because of
18053 cv-qualification mismatches. */
18054 if (TREE_CODE (arg
) == TREE_CODE (parm
)
18056 /* It is the elements of the array which hold the cv quals of an array
18057 type, and the elements might be template type parms. We'll check
18058 when we recurse. */
18059 && TREE_CODE (arg
) != ARRAY_TYPE
18060 /* We check the cv-qualifiers when unifying with template type
18061 parameters below. We want to allow ARG `const T' to unify with
18062 PARM `T' for example, when computing which of two templates
18063 is more specialized, for example. */
18064 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
18065 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
18066 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18068 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
18069 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
18070 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
18071 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
18072 strict
&= ~UNIFY_ALLOW_DERIVED
;
18073 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
18074 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
18076 switch (TREE_CODE (parm
))
18078 case TYPENAME_TYPE
:
18080 case UNBOUND_CLASS_TEMPLATE
:
18081 /* In a type which contains a nested-name-specifier, template
18082 argument values cannot be deduced for template parameters used
18083 within the nested-name-specifier. */
18084 return unify_success (explain_p
);
18086 case TEMPLATE_TYPE_PARM
:
18087 case TEMPLATE_TEMPLATE_PARM
:
18088 case BOUND_TEMPLATE_TEMPLATE_PARM
:
18089 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18090 if (error_operand_p (tparm
))
18091 return unify_invalid (explain_p
);
18093 if (TEMPLATE_TYPE_LEVEL (parm
)
18094 != template_decl_level (tparm
))
18095 /* The PARM is not one we're trying to unify. Just check
18096 to see if it matches ARG. */
18098 if (TREE_CODE (arg
) == TREE_CODE (parm
)
18099 && (is_auto (parm
) ? is_auto (arg
)
18100 : same_type_p (parm
, arg
)))
18101 return unify_success (explain_p
);
18103 return unify_type_mismatch (explain_p
, parm
, arg
);
18105 idx
= TEMPLATE_TYPE_IDX (parm
);
18106 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18107 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
18108 if (error_operand_p (tparm
))
18109 return unify_invalid (explain_p
);
18111 /* Check for mixed types and values. */
18112 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
18113 && TREE_CODE (tparm
) != TYPE_DECL
)
18114 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18115 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
18116 gcc_unreachable ();
18118 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18120 /* ARG must be constructed from a template class or a template
18121 template parameter. */
18122 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
18123 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
18124 return unify_template_deduction_failure (explain_p
, parm
, arg
);
18126 tree parmvec
= TYPE_TI_ARGS (parm
);
18127 /* An alias template name is never deduced. */
18128 if (TYPE_ALIAS_P (arg
))
18129 arg
= strip_typedefs (arg
);
18130 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
18131 tree full_argvec
= add_to_template_args (targs
, argvec
);
18133 = DECL_INNERMOST_TEMPLATE_PARMS
18134 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
18136 int parm_variadic_p
= 0;
18138 /* The resolution to DR150 makes clear that default
18139 arguments for an N-argument may not be used to bind T
18140 to a template template parameter with fewer than N
18141 parameters. It is not safe to permit the binding of
18142 default arguments as an extension, as that may change
18143 the meaning of a conforming program. Consider:
18145 struct Dense { static const unsigned int dim = 1; };
18147 template <template <typename> class View,
18149 void operator+(float, View<Block> const&);
18151 template <typename Block,
18152 unsigned int Dim = Block::dim>
18153 struct Lvalue_proxy { operator float() const; };
18157 Lvalue_proxy<Dense> p;
18162 Here, if Lvalue_proxy is permitted to bind to View, then
18163 the global operator+ will be used; if they are not, the
18164 Lvalue_proxy will be converted to float. */
18165 if (coerce_template_parms (parm_parms
,
18167 TYPE_TI_TEMPLATE (parm
),
18169 ? tf_warning_or_error
18171 /*require_all_args=*/true,
18172 /*use_default_args=*/false)
18173 == error_mark_node
)
18176 /* Deduce arguments T, i from TT<T> or TT<i>.
18177 We check each element of PARMVEC and ARGVEC individually
18178 rather than the whole TREE_VEC since they can have
18179 different number of elements. */
18181 parmvec
= expand_template_argument_pack (parmvec
);
18182 argvec
= expand_template_argument_pack (argvec
);
18184 len
= TREE_VEC_LENGTH (parmvec
);
18186 /* Check if the parameters end in a pack, making them
18189 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
18190 parm_variadic_p
= 1;
18192 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18193 /* If the template argument list of P contains a pack
18194 expansion that is not the last template argument, the
18195 entire template argument list is a non-deduced
18197 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
18198 return unify_success (explain_p
);
18200 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
18201 return unify_too_few_arguments (explain_p
,
18202 TREE_VEC_LENGTH (argvec
), len
);
18204 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18206 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18207 TREE_VEC_ELT (parmvec
, i
),
18208 TREE_VEC_ELT (argvec
, i
),
18209 UNIFY_ALLOW_NONE
, explain_p
);
18212 if (parm_variadic_p
18213 && unify_pack_expansion (tparms
, targs
,
18216 /*subr=*/true, explain_p
))
18219 arg
= TYPE_TI_TEMPLATE (arg
);
18221 /* Fall through to deduce template name. */
18224 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18225 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18227 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
18229 /* Simple cases: Value already set, does match or doesn't. */
18230 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
18231 return unify_success (explain_p
);
18233 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18237 /* If PARM is `const T' and ARG is only `int', we don't have
18238 a match unless we are allowing additional qualification.
18239 If ARG is `const int' and PARM is just `T' that's OK;
18240 that binds `const int' to `T'. */
18241 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
18243 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18245 /* Consider the case where ARG is `const volatile int' and
18246 PARM is `const T'. Then, T should be `volatile int'. */
18247 arg
= cp_build_qualified_type_real
18248 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
18249 if (arg
== error_mark_node
)
18250 return unify_invalid (explain_p
);
18252 /* Simple cases: Value already set, does match or doesn't. */
18253 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
18254 return unify_success (explain_p
);
18256 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18258 /* Make sure that ARG is not a variable-sized array. (Note
18259 that were talking about variable-sized arrays (like
18260 `int[n]'), rather than arrays of unknown size (like
18261 `int[]').) We'll get very confused by such a type since
18262 the bound of the array is not constant, and therefore
18263 not mangleable. Besides, such types are not allowed in
18264 ISO C++, so we can do as we please here. We do allow
18265 them for 'auto' deduction, since that isn't ABI-exposed. */
18266 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
18267 return unify_vla_arg (explain_p
, arg
);
18269 /* Strip typedefs as in convert_template_argument. */
18270 arg
= canonicalize_type_argument (arg
, tf_none
);
18273 /* If ARG is a parameter pack or an expansion, we cannot unify
18274 against it unless PARM is also a parameter pack. */
18275 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18276 && !template_parameter_pack_p (parm
))
18277 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18279 /* If the argument deduction results is a METHOD_TYPE,
18280 then there is a problem.
18281 METHOD_TYPE doesn't map to any real C++ type the result of
18282 the deduction can not be of that type. */
18283 if (TREE_CODE (arg
) == METHOD_TYPE
)
18284 return unify_method_type_error (explain_p
, arg
);
18286 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18287 return unify_success (explain_p
);
18289 case TEMPLATE_PARM_INDEX
:
18290 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18291 if (error_operand_p (tparm
))
18292 return unify_invalid (explain_p
);
18294 if (TEMPLATE_PARM_LEVEL (parm
)
18295 != template_decl_level (tparm
))
18297 /* The PARM is not one we're trying to unify. Just check
18298 to see if it matches ARG. */
18299 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
18300 && cp_tree_equal (parm
, arg
));
18302 unify_expression_unequal (explain_p
, parm
, arg
);
18306 idx
= TEMPLATE_PARM_IDX (parm
);
18307 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18311 int x
= !cp_tree_equal (targ
, arg
);
18313 unify_inconsistency (explain_p
, parm
, targ
, arg
);
18317 /* [temp.deduct.type] If, in the declaration of a function template
18318 with a non-type template-parameter, the non-type
18319 template-parameter is used in an expression in the function
18320 parameter-list and, if the corresponding template-argument is
18321 deduced, the template-argument type shall match the type of the
18322 template-parameter exactly, except that a template-argument
18323 deduced from an array bound may be of any integral type.
18324 The non-type parameter might use already deduced type parameters. */
18325 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
18326 if (!TREE_TYPE (arg
))
18327 /* Template-parameter dependent expression. Just accept it for now.
18328 It will later be processed in convert_template_argument. */
18330 else if (same_type_p (TREE_TYPE (arg
), tparm
))
18332 else if ((strict
& UNIFY_ALLOW_INTEGER
)
18333 && CP_INTEGRAL_TYPE_P (tparm
))
18334 /* Convert the ARG to the type of PARM; the deduced non-type
18335 template argument must exactly match the types of the
18336 corresponding parameter. */
18337 arg
= fold (build_nop (tparm
, arg
));
18338 else if (uses_template_parms (tparm
))
18339 /* We haven't deduced the type of this parameter yet. Try again
18341 return unify_success (explain_p
);
18343 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
18345 /* If ARG is a parameter pack or an expansion, we cannot unify
18346 against it unless PARM is also a parameter pack. */
18347 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18348 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
18349 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18352 bool removed_attr
= false;
18353 arg
= strip_typedefs_expr (arg
, &removed_attr
);
18355 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18356 return unify_success (explain_p
);
18360 /* A pointer-to-member constant can be unified only with
18361 another constant. */
18362 if (TREE_CODE (arg
) != PTRMEM_CST
)
18363 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
18365 /* Just unify the class member. It would be useless (and possibly
18366 wrong, depending on the strict flags) to unify also
18367 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18368 arg refer to the same variable, even if through different
18369 classes. For instance:
18371 struct A { int x; };
18374 Unification of &A::x and &B::x must succeed. */
18375 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
18376 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
18381 if (!TYPE_PTR_P (arg
))
18382 return unify_type_mismatch (explain_p
, parm
, arg
);
18384 /* [temp.deduct.call]
18386 A can be another pointer or pointer to member type that can
18387 be converted to the deduced A via a qualification
18388 conversion (_conv.qual_).
18390 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18391 This will allow for additional cv-qualification of the
18392 pointed-to types if appropriate. */
18394 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
18395 /* The derived-to-base conversion only persists through one
18396 level of pointers. */
18397 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
18399 return unify (tparms
, targs
, TREE_TYPE (parm
),
18400 TREE_TYPE (arg
), strict
, explain_p
);
18403 case REFERENCE_TYPE
:
18404 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
18405 return unify_type_mismatch (explain_p
, parm
, arg
);
18406 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18407 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18410 if (TREE_CODE (arg
) != ARRAY_TYPE
)
18411 return unify_type_mismatch (explain_p
, parm
, arg
);
18412 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
18413 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
18414 return unify_type_mismatch (explain_p
, parm
, arg
);
18415 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18416 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18417 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
18418 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18419 TYPE_DOMAIN (arg
), explain_p
);
18420 return unify_success (explain_p
);
18427 case ENUMERAL_TYPE
:
18430 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18431 return unify_type_mismatch (explain_p
, parm
, arg
);
18433 /* We have already checked cv-qualification at the top of the
18435 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
18436 return unify_type_mismatch (explain_p
, parm
, arg
);
18438 /* As far as unification is concerned, this wins. Later checks
18439 will invalidate it if necessary. */
18440 return unify_success (explain_p
);
18442 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18443 /* Type INTEGER_CST can come from ordinary constant template args. */
18445 while (TREE_CODE (arg
) == NOP_EXPR
)
18446 arg
= TREE_OPERAND (arg
, 0);
18448 if (TREE_CODE (arg
) != INTEGER_CST
)
18449 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18450 return (tree_int_cst_equal (parm
, arg
)
18451 ? unify_success (explain_p
)
18452 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18456 int i
, len
, argslen
;
18457 int parm_variadic_p
= 0;
18459 if (TREE_CODE (arg
) != TREE_VEC
)
18460 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18462 len
= TREE_VEC_LENGTH (parm
);
18463 argslen
= TREE_VEC_LENGTH (arg
);
18465 /* Check for pack expansions in the parameters. */
18466 for (i
= 0; i
< len
; ++i
)
18468 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18471 /* We can unify against something with a trailing
18473 parm_variadic_p
= 1;
18475 /* [temp.deduct.type]/9: If the template argument list of
18476 P contains a pack expansion that is not the last
18477 template argument, the entire template argument list
18478 is a non-deduced context. */
18479 return unify_success (explain_p
);
18483 /* If we don't have enough arguments to satisfy the parameters
18484 (not counting the pack expression at the end), or we have
18485 too many arguments for a parameter list that doesn't end in
18486 a pack expression, we can't unify. */
18487 if (parm_variadic_p
18488 ? argslen
< len
- parm_variadic_p
18490 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18492 /* Unify all of the parameters that precede the (optional)
18493 pack expression. */
18494 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18496 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18497 TREE_VEC_ELT (parm
, i
),
18498 TREE_VEC_ELT (arg
, i
),
18499 UNIFY_ALLOW_NONE
, explain_p
);
18501 if (parm_variadic_p
)
18502 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18504 /*subr=*/true, explain_p
);
18505 return unify_success (explain_p
);
18510 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18511 return unify_type_mismatch (explain_p
, parm
, arg
);
18513 if (TYPE_PTRMEMFUNC_P (parm
))
18515 if (!TYPE_PTRMEMFUNC_P (arg
))
18516 return unify_type_mismatch (explain_p
, parm
, arg
);
18518 return unify (tparms
, targs
,
18519 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18520 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18521 strict
, explain_p
);
18523 else if (TYPE_PTRMEMFUNC_P (arg
))
18524 return unify_type_mismatch (explain_p
, parm
, arg
);
18526 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18528 tree t
= NULL_TREE
;
18530 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18532 /* First, we try to unify the PARM and ARG directly. */
18533 t
= try_class_unification (tparms
, targs
,
18534 parm
, arg
, explain_p
);
18538 /* Fallback to the special case allowed in
18539 [temp.deduct.call]:
18541 If P is a class, and P has the form
18542 template-id, then A can be a derived class of
18543 the deduced A. Likewise, if P is a pointer to
18544 a class of the form template-id, A can be a
18545 pointer to a derived class pointed to by the
18547 enum template_base_result r
;
18548 r
= get_template_base (tparms
, targs
, parm
, arg
,
18552 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18555 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18556 && (CLASSTYPE_TI_TEMPLATE (parm
)
18557 == CLASSTYPE_TI_TEMPLATE (arg
)))
18558 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18559 Then, we should unify `int' and `U'. */
18562 /* There's no chance of unification succeeding. */
18563 return unify_type_mismatch (explain_p
, parm
, arg
);
18565 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18566 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18568 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18569 return unify_type_mismatch (explain_p
, parm
, arg
);
18570 return unify_success (explain_p
);
18573 case FUNCTION_TYPE
:
18575 unsigned int nargs
;
18580 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18581 return unify_type_mismatch (explain_p
, parm
, arg
);
18583 /* CV qualifications for methods can never be deduced, they must
18584 match exactly. We need to check them explicitly here,
18585 because type_unification_real treats them as any other
18586 cv-qualified parameter. */
18587 if (TREE_CODE (parm
) == METHOD_TYPE
18588 && (!check_cv_quals_for_unify
18590 class_of_this_parm (arg
),
18591 class_of_this_parm (parm
))))
18592 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18594 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18595 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18597 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18598 args
= XALLOCAVEC (tree
, nargs
);
18599 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18600 a
!= NULL_TREE
&& a
!= void_list_node
;
18601 a
= TREE_CHAIN (a
), ++i
)
18602 args
[i
] = TREE_VALUE (a
);
18605 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18606 args
, nargs
, 1, DEDUCE_EXACT
,
18607 LOOKUP_NORMAL
, NULL
, explain_p
);
18611 /* Unify a pointer to member with a pointer to member function, which
18612 deduces the type of the member as a function type. */
18613 if (TYPE_PTRMEMFUNC_P (arg
))
18615 /* Check top-level cv qualifiers */
18616 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18617 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18619 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18620 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18621 UNIFY_ALLOW_NONE
, explain_p
);
18623 /* Determine the type of the function we are unifying against. */
18624 tree fntype
= static_fn_type (arg
);
18626 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18629 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18630 return unify_type_mismatch (explain_p
, parm
, arg
);
18631 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18632 TYPE_OFFSET_BASETYPE (arg
),
18633 UNIFY_ALLOW_NONE
, explain_p
);
18634 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18635 strict
, explain_p
);
18638 if (DECL_TEMPLATE_PARM_P (parm
))
18639 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18640 if (arg
!= scalar_constant_value (parm
))
18641 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18642 return unify_success (explain_p
);
18645 case TEMPLATE_DECL
:
18646 /* Matched cases are handled by the ARG == PARM test above. */
18647 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18650 /* A non-type template parameter that is a variable should be a
18651 an integral constant, in which case, it whould have been
18652 folded into its (constant) value. So we should not be getting
18653 a variable here. */
18654 gcc_unreachable ();
18656 case TYPE_ARGUMENT_PACK
:
18657 case NONTYPE_ARGUMENT_PACK
:
18658 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18659 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18662 case DECLTYPE_TYPE
:
18663 case UNDERLYING_TYPE
:
18664 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18665 or UNDERLYING_TYPE nodes. */
18666 return unify_success (explain_p
);
18669 /* Unification fails if we hit an error node. */
18670 return unify_invalid (explain_p
);
18673 if (REFERENCE_REF_P (parm
))
18675 if (REFERENCE_REF_P (arg
))
18676 arg
= TREE_OPERAND (arg
, 0);
18677 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18678 strict
, explain_p
);
18683 /* An unresolved overload is a nondeduced context. */
18684 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18685 return unify_success (explain_p
);
18686 gcc_assert (EXPR_P (parm
));
18688 /* We must be looking at an expression. This can happen with
18692 void foo(S<I>, S<I + 2>);
18694 This is a "nondeduced context":
18698 The nondeduced contexts are:
18700 --A type that is a template-id in which one or more of
18701 the template-arguments is an expression that references
18702 a template-parameter.
18704 In these cases, we assume deduction succeeded, but don't
18705 actually infer any unifications. */
18707 if (!uses_template_parms (parm
)
18708 && !template_args_equal (parm
, arg
))
18709 return unify_expression_unequal (explain_p
, parm
, arg
);
18711 return unify_success (explain_p
);
18714 #undef RECUR_AND_CHECK_FAILURE
18716 /* Note that DECL can be defined in this translation unit, if
18720 mark_definable (tree decl
)
18723 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18724 FOR_EACH_CLONE (clone
, decl
)
18725 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18728 /* Called if RESULT is explicitly instantiated, or is a member of an
18729 explicitly instantiated class. */
18732 mark_decl_instantiated (tree result
, int extern_p
)
18734 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18736 /* If this entity has already been written out, it's too late to
18737 make any modifications. */
18738 if (TREE_ASM_WRITTEN (result
))
18741 /* For anonymous namespace we don't need to do anything. */
18742 if (decl_anon_ns_mem_p (result
))
18744 gcc_assert (!TREE_PUBLIC (result
));
18748 if (TREE_CODE (result
) != FUNCTION_DECL
)
18749 /* The TREE_PUBLIC flag for function declarations will have been
18750 set correctly by tsubst. */
18751 TREE_PUBLIC (result
) = 1;
18753 /* This might have been set by an earlier implicit instantiation. */
18754 DECL_COMDAT (result
) = 0;
18757 DECL_NOT_REALLY_EXTERN (result
) = 0;
18760 mark_definable (result
);
18761 mark_needed (result
);
18762 /* Always make artificials weak. */
18763 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18764 comdat_linkage (result
);
18765 /* For WIN32 we also want to put explicit instantiations in
18766 linkonce sections. */
18767 else if (TREE_PUBLIC (result
))
18768 maybe_make_one_only (result
);
18771 /* If EXTERN_P, then this function will not be emitted -- unless
18772 followed by an explicit instantiation, at which point its linkage
18773 will be adjusted. If !EXTERN_P, then this function will be
18774 emitted here. In neither circumstance do we want
18775 import_export_decl to adjust the linkage. */
18776 DECL_INTERFACE_KNOWN (result
) = 1;
18779 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18780 important template arguments. If any are missing, we check whether
18781 they're important by using error_mark_node for substituting into any
18782 args that were used for partial ordering (the ones between ARGS and END)
18783 and seeing if it bubbles up. */
18786 check_undeduced_parms (tree targs
, tree args
, tree end
)
18788 bool found
= false;
18790 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18791 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18794 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18798 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18799 if (substed
== error_mark_node
)
18805 /* Given two function templates PAT1 and PAT2, return:
18807 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18808 -1 if PAT2 is more specialized than PAT1.
18809 0 if neither is more specialized.
18811 LEN indicates the number of parameters we should consider
18812 (defaulted parameters should not be considered).
18814 The 1998 std underspecified function template partial ordering, and
18815 DR214 addresses the issue. We take pairs of arguments, one from
18816 each of the templates, and deduce them against each other. One of
18817 the templates will be more specialized if all the *other*
18818 template's arguments deduce against its arguments and at least one
18819 of its arguments *does* *not* deduce against the other template's
18820 corresponding argument. Deduction is done as for class templates.
18821 The arguments used in deduction have reference and top level cv
18822 qualifiers removed. Iff both arguments were originally reference
18823 types *and* deduction succeeds in both directions, an lvalue reference
18824 wins against an rvalue reference and otherwise the template
18825 with the more cv-qualified argument wins for that pairing (if
18826 neither is more cv-qualified, they both are equal). Unlike regular
18827 deduction, after all the arguments have been deduced in this way,
18828 we do *not* verify the deduced template argument values can be
18829 substituted into non-deduced contexts.
18831 The logic can be a bit confusing here, because we look at deduce1 and
18832 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18833 can find template arguments for pat1 to make arg1 look like arg2, that
18834 means that arg2 is at least as specialized as arg1. */
18837 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18839 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18840 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18841 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18842 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18843 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18844 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18845 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18846 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18847 tree origs1
, origs2
;
18848 bool lose1
= false;
18849 bool lose2
= false;
18851 /* Remove the this parameter from non-static member functions. If
18852 one is a non-static member function and the other is not a static
18853 member function, remove the first parameter from that function
18854 also. This situation occurs for operator functions where we
18855 locate both a member function (with this pointer) and non-member
18856 operator (with explicit first operand). */
18857 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18859 len
--; /* LEN is the number of significant arguments for DECL1 */
18860 args1
= TREE_CHAIN (args1
);
18861 if (!DECL_STATIC_FUNCTION_P (decl2
))
18862 args2
= TREE_CHAIN (args2
);
18864 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18866 args2
= TREE_CHAIN (args2
);
18867 if (!DECL_STATIC_FUNCTION_P (decl1
))
18870 args1
= TREE_CHAIN (args1
);
18874 /* If only one is a conversion operator, they are unordered. */
18875 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18878 /* Consider the return type for a conversion function */
18879 if (DECL_CONV_FN_P (decl1
))
18881 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18882 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18886 processing_template_decl
++;
18892 /* Stop when an ellipsis is seen. */
18893 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18895 tree arg1
= TREE_VALUE (args1
);
18896 tree arg2
= TREE_VALUE (args2
);
18897 int deduce1
, deduce2
;
18903 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18904 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18906 /* When both arguments are pack expansions, we need only
18907 unify the patterns themselves. */
18908 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18909 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18911 /* This is the last comparison we need to do. */
18915 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18917 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18918 arg1
= TREE_TYPE (arg1
);
18919 quals1
= cp_type_quals (arg1
);
18922 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18924 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18925 arg2
= TREE_TYPE (arg2
);
18926 quals2
= cp_type_quals (arg2
);
18929 arg1
= TYPE_MAIN_VARIANT (arg1
);
18930 arg2
= TYPE_MAIN_VARIANT (arg2
);
18932 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18934 int i
, len2
= list_length (args2
);
18935 tree parmvec
= make_tree_vec (1);
18936 tree argvec
= make_tree_vec (len2
);
18939 /* Setup the parameter vector, which contains only ARG1. */
18940 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18942 /* Setup the argument vector, which contains the remaining
18944 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18945 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18947 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18948 argvec
, DEDUCE_EXACT
,
18949 /*subr=*/true, /*explain_p=*/false)
18952 /* We cannot deduce in the other direction, because ARG1 is
18953 a pack expansion but ARG2 is not. */
18956 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18958 int i
, len1
= list_length (args1
);
18959 tree parmvec
= make_tree_vec (1);
18960 tree argvec
= make_tree_vec (len1
);
18963 /* Setup the parameter vector, which contains only ARG1. */
18964 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18966 /* Setup the argument vector, which contains the remaining
18968 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18969 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18971 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18972 argvec
, DEDUCE_EXACT
,
18973 /*subr=*/true, /*explain_p=*/false)
18976 /* We cannot deduce in the other direction, because ARG2 is
18977 a pack expansion but ARG1 is not.*/
18983 /* The normal case, where neither argument is a pack
18985 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18986 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18988 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18989 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18993 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18994 arg2, then arg2 is not as specialized as arg1. */
19000 /* "If, for a given type, deduction succeeds in both directions
19001 (i.e., the types are identical after the transformations above)
19002 and both P and A were reference types (before being replaced with
19003 the type referred to above):
19004 - if the type from the argument template was an lvalue reference and
19005 the type from the parameter template was not, the argument type is
19006 considered to be more specialized than the other; otherwise,
19007 - if the type from the argument template is more cv-qualified
19008 than the type from the parameter template (as described above),
19009 the argument type is considered to be more specialized than the other;
19011 - neither type is more specialized than the other." */
19013 if (deduce1
&& deduce2
)
19015 if (ref1
&& ref2
&& ref1
!= ref2
)
19022 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
19024 if ((quals1
& quals2
) == quals2
)
19026 if ((quals1
& quals2
) == quals1
)
19031 if (lose1
&& lose2
)
19032 /* We've failed to deduce something in either direction.
19033 These must be unordered. */
19036 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
19037 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
19038 /* We have already processed all of the arguments in our
19039 handing of the pack expansion type. */
19042 args1
= TREE_CHAIN (args1
);
19043 args2
= TREE_CHAIN (args2
);
19046 /* "In most cases, all template parameters must have values in order for
19047 deduction to succeed, but for partial ordering purposes a template
19048 parameter may remain without a value provided it is not used in the
19049 types being used for partial ordering."
19051 Thus, if we are missing any of the targs1 we need to substitute into
19052 origs1, then pat2 is not as specialized as pat1. This can happen when
19053 there is a nondeduced context. */
19054 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
19056 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
19059 processing_template_decl
--;
19061 /* All things being equal, if the next argument is a pack expansion
19062 for one function but not for the other, prefer the
19063 non-variadic function. FIXME this is bogus; see c++/41958. */
19065 && args1
&& TREE_VALUE (args1
)
19066 && args2
&& TREE_VALUE (args2
))
19068 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
19069 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
19072 if (lose1
== lose2
)
19080 /* Determine which of two partial specializations of TMPL is more
19083 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
19084 to the first partial specialization. The TREE_PURPOSE is the
19085 innermost set of template parameters for the partial
19086 specialization. PAT2 is similar, but for the second template.
19088 Return 1 if the first partial specialization is more specialized;
19089 -1 if the second is more specialized; 0 if neither is more
19092 See [temp.class.order] for information about determining which of
19093 two templates is more specialized. */
19096 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
19100 bool any_deductions
= false;
19102 tree tmpl1
= TREE_VALUE (pat1
);
19103 tree tmpl2
= TREE_VALUE (pat2
);
19104 tree parms1
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl1
);
19105 tree parms2
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl2
);
19106 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
19107 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
19109 /* Just like what happens for functions, if we are ordering between
19110 different template specializations, we may encounter dependent
19111 types in the arguments, and we need our dependency check functions
19112 to behave correctly. */
19113 ++processing_template_decl
;
19114 targs
= get_partial_spec_bindings (tmpl
, parms1
, specargs1
, specargs2
);
19118 any_deductions
= true;
19121 targs
= get_partial_spec_bindings (tmpl
, parms2
, specargs2
, specargs1
);
19125 any_deductions
= true;
19127 --processing_template_decl
;
19129 /* In the case of a tie where at least one of the templates
19130 has a parameter pack at the end, the template with the most
19131 non-packed parameters wins. */
19134 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
19135 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
19137 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
19138 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
19139 int len1
= TREE_VEC_LENGTH (args1
);
19140 int len2
= TREE_VEC_LENGTH (args2
);
19142 /* We don't count the pack expansion at the end. */
19143 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
19145 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
19150 else if (len1
< len2
)
19157 /* Return the template arguments that will produce the function signature
19158 DECL from the function template FN, with the explicit template
19159 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
19160 also match. Return NULL_TREE if no satisfactory arguments could be
19164 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
19166 int ntparms
= DECL_NTPARMS (fn
);
19167 tree targs
= make_tree_vec (ntparms
);
19168 tree decl_type
= TREE_TYPE (decl
);
19169 tree decl_arg_types
;
19171 unsigned int nargs
, ix
;
19174 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
19176 /* Never do unification on the 'this' parameter. */
19177 decl_arg_types
= skip_artificial_parms_for (decl
,
19178 TYPE_ARG_TYPES (decl_type
));
19180 nargs
= list_length (decl_arg_types
);
19181 args
= XALLOCAVEC (tree
, nargs
);
19182 for (arg
= decl_arg_types
, ix
= 0;
19183 arg
!= NULL_TREE
&& arg
!= void_list_node
;
19184 arg
= TREE_CHAIN (arg
), ++ix
)
19185 args
[ix
] = TREE_VALUE (arg
);
19187 if (fn_type_unification (fn
, explicit_args
, targs
,
19189 (check_rettype
|| DECL_CONV_FN_P (fn
)
19190 ? TREE_TYPE (decl_type
) : NULL_TREE
),
19191 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
19193 == error_mark_node
)
19199 /* Return the innermost template arguments that, when applied to a partial
19200 specialization of TMPL whose innermost template parameters are
19201 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
19204 For example, suppose we have:
19206 template <class T, class U> struct S {};
19207 template <class T> struct S<T*, int> {};
19209 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
19210 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
19211 int}. The resulting vector will be {double}, indicating that `T'
19212 is bound to `double'. */
19215 get_partial_spec_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
19217 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
19219 tree innermost_deduced_args
;
19221 innermost_deduced_args
= make_tree_vec (ntparms
);
19222 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19224 deduced_args
= copy_node (args
);
19225 SET_TMPL_ARGS_LEVEL (deduced_args
,
19226 TMPL_ARGS_DEPTH (deduced_args
),
19227 innermost_deduced_args
);
19230 deduced_args
= innermost_deduced_args
;
19232 if (unify (tparms
, deduced_args
,
19233 INNERMOST_TEMPLATE_ARGS (spec_args
),
19234 INNERMOST_TEMPLATE_ARGS (args
),
19235 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
19238 for (i
= 0; i
< ntparms
; ++i
)
19239 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
19242 /* Verify that nondeduced template arguments agree with the type
19243 obtained from argument deduction.
19247 struct A { typedef int X; };
19248 template <class T, class U> struct C {};
19249 template <class T> struct C<T, typename T::X> {};
19251 Then with the instantiation `C<A, int>', we can deduce that
19252 `T' is `A' but unify () does not check whether `typename T::X'
19254 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
19255 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19257 tf_none
, false, false);
19258 if (spec_args
== error_mark_node
19259 /* We only need to check the innermost arguments; the other
19260 arguments will always agree. */
19261 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
19262 INNERMOST_TEMPLATE_ARGS (args
)))
19265 /* Now that we have bindings for all of the template arguments,
19266 ensure that the arguments deduced for the template template
19267 parameters have compatible template parameter lists. See the use
19268 of template_template_parm_bindings_ok_p in fn_type_unification
19269 for more information. */
19270 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
19273 return deduced_args
;
19276 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19277 Return the TREE_LIST node with the most specialized template, if
19278 any. If there is no most specialized template, the error_mark_node
19281 Note that this function does not look at, or modify, the
19282 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19283 returned is one of the elements of INSTANTIATIONS, callers may
19284 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19285 and retrieve it from the value returned. */
19288 most_specialized_instantiation (tree templates
)
19292 ++processing_template_decl
;
19295 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
19299 if (get_bindings (TREE_VALUE (champ
),
19300 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19301 NULL_TREE
, /*check_ret=*/true))
19304 if (get_bindings (TREE_VALUE (fn
),
19305 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19306 NULL_TREE
, /*check_ret=*/true))
19313 /* Equally specialized, move to next function. If there
19314 is no next function, nothing's most specialized. */
19315 fn
= TREE_CHAIN (fn
);
19323 /* Now verify that champ is better than everything earlier in the
19324 instantiation list. */
19325 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
19326 if (get_bindings (TREE_VALUE (champ
),
19327 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19328 NULL_TREE
, /*check_ret=*/true)
19329 || !get_bindings (TREE_VALUE (fn
),
19330 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19331 NULL_TREE
, /*check_ret=*/true))
19337 processing_template_decl
--;
19340 return error_mark_node
;
19345 /* If DECL is a specialization of some template, return the most
19346 general such template. Otherwise, returns NULL_TREE.
19348 For example, given:
19350 template <class T> struct S { template <class U> void f(U); };
19352 if TMPL is `template <class U> void S<int>::f(U)' this will return
19353 the full template. This function will not trace past partial
19354 specializations, however. For example, given in addition:
19356 template <class T> struct S<T*> { template <class U> void f(U); };
19358 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19359 `template <class T> template <class U> S<T*>::f(U)'. */
19362 most_general_template (tree decl
)
19364 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19366 if (tree tinfo
= get_template_info (decl
))
19367 decl
= TI_TEMPLATE (tinfo
);
19368 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19369 template friend, or a FIELD_DECL for a capture pack. */
19370 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19374 /* Look for more and more general templates. */
19375 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
19377 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19378 (See cp-tree.h for details.) */
19379 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
19382 if (CLASS_TYPE_P (TREE_TYPE (decl
))
19383 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
19384 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
19387 /* Stop if we run into an explicitly specialized class template. */
19388 if (!DECL_NAMESPACE_SCOPE_P (decl
)
19389 && DECL_CONTEXT (decl
)
19390 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
19393 decl
= DECL_TI_TEMPLATE (decl
);
19399 /* Return the most specialized of the template partial specializations
19400 which can produce TARGET, a specialization of some class or variable
19401 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
19402 a TEMPLATE_DECL node corresponding to the partial specialization, while
19403 the TREE_PURPOSE is the set of template arguments that must be
19404 substituted into the template pattern in order to generate TARGET.
19406 If the choice of partial specialization is ambiguous, a diagnostic
19407 is issued, and the error_mark_node is returned. If there are no
19408 partial specializations matching TARGET, then NULL_TREE is
19409 returned, indicating that the primary template should be used. */
19412 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
19414 tree list
= NULL_TREE
;
19419 tree outer_args
= NULL_TREE
;
19422 if (TYPE_P (target
))
19424 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
19425 tmpl
= TI_TEMPLATE (tinfo
);
19426 args
= TI_ARGS (tinfo
);
19428 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
19430 tmpl
= TREE_OPERAND (target
, 0);
19431 args
= TREE_OPERAND (target
, 1);
19433 else if (VAR_P (target
))
19435 tree tinfo
= DECL_TEMPLATE_INFO (target
);
19436 tmpl
= TI_TEMPLATE (tinfo
);
19437 args
= TI_ARGS (tinfo
);
19440 gcc_unreachable ();
19442 tree main_tmpl
= most_general_template (tmpl
);
19444 /* For determining which partial specialization to use, only the
19445 innermost args are interesting. */
19446 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19448 outer_args
= strip_innermost_template_args (args
, 1);
19449 args
= INNERMOST_TEMPLATE_ARGS (args
);
19452 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
19454 tree partial_spec_args
;
19456 tree spec_tmpl
= TREE_VALUE (t
);
19458 partial_spec_args
= TREE_PURPOSE (t
);
19460 ++processing_template_decl
;
19464 /* Discard the outer levels of args, and then substitute in the
19465 template args from the enclosing class. */
19466 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19467 partial_spec_args
= tsubst_template_args
19468 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19470 /* And the same for the partial specialization TEMPLATE_DECL. */
19471 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19474 partial_spec_args
=
19475 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19478 /*require_all_args=*/true,
19479 /*use_default_args=*/true);
19481 --processing_template_decl
;
19483 if (partial_spec_args
== error_mark_node
)
19484 return error_mark_node
;
19485 if (spec_tmpl
== error_mark_node
)
19486 return error_mark_node
;
19488 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19489 spec_args
= get_partial_spec_bindings (tmpl
, parms
,
19495 spec_args
= add_to_template_args (outer_args
, spec_args
);
19496 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
19497 TREE_TYPE (list
) = TREE_TYPE (t
);
19504 ambiguous_p
= false;
19507 t
= TREE_CHAIN (t
);
19508 for (; t
; t
= TREE_CHAIN (t
))
19510 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19517 t
= TREE_CHAIN (t
);
19520 ambiguous_p
= true;
19529 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19531 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19534 ambiguous_p
= true;
19542 char *spaces
= NULL
;
19543 if (!(complain
& tf_error
))
19544 return error_mark_node
;
19545 if (TYPE_P (target
))
19546 error ("ambiguous template instantiation for %q#T", target
);
19548 error ("ambiguous template instantiation for %q#D", target
);
19549 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19550 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19552 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
19553 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
19554 "%s %#S", spaces
? spaces
: str
, subst
);
19555 spaces
= spaces
? spaces
: get_spaces (str
);
19558 return error_mark_node
;
19564 /* Explicitly instantiate DECL. */
19567 do_decl_instantiation (tree decl
, tree storage
)
19569 tree result
= NULL_TREE
;
19572 if (!decl
|| decl
== error_mark_node
)
19573 /* An error occurred, for which grokdeclarator has already issued
19574 an appropriate message. */
19576 else if (! DECL_LANG_SPECIFIC (decl
))
19578 error ("explicit instantiation of non-template %q#D", decl
);
19582 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
19583 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
19585 if (VAR_P (decl
) && !var_templ
)
19587 /* There is an asymmetry here in the way VAR_DECLs and
19588 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19589 the latter, the DECL we get back will be marked as a
19590 template instantiation, and the appropriate
19591 DECL_TEMPLATE_INFO will be set up. This does not happen for
19592 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19593 should handle VAR_DECLs as it currently handles
19595 if (!DECL_CLASS_SCOPE_P (decl
))
19597 error ("%qD is not a static data member of a class template", decl
);
19600 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19601 if (!result
|| !VAR_P (result
))
19603 error ("no matching template for %qD found", decl
);
19606 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19608 error ("type %qT for explicit instantiation %qD does not match "
19609 "declared type %qT", TREE_TYPE (result
), decl
,
19614 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
19616 error ("explicit instantiation of %q#D", decl
);
19622 /* Check for various error cases. Note that if the explicit
19623 instantiation is valid the RESULT will currently be marked as an
19624 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19625 until we get here. */
19627 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19629 /* DR 259 [temp.spec].
19631 Both an explicit instantiation and a declaration of an explicit
19632 specialization shall not appear in a program unless the explicit
19633 instantiation follows a declaration of the explicit specialization.
19635 For a given set of template parameters, if an explicit
19636 instantiation of a template appears after a declaration of an
19637 explicit specialization for that template, the explicit
19638 instantiation has no effect. */
19641 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19645 No program shall explicitly instantiate any template more
19648 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19649 the first instantiation was `extern' and the second is not,
19650 and EXTERN_P for the opposite case. */
19651 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19652 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19653 /* If an "extern" explicit instantiation follows an ordinary
19654 explicit instantiation, the template is instantiated. */
19658 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19660 error ("no matching template for %qD found", result
);
19663 else if (!DECL_TEMPLATE_INFO (result
))
19665 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19669 if (storage
== NULL_TREE
)
19671 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19673 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19674 pedwarn (input_location
, OPT_Wpedantic
,
19675 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19680 error ("storage class %qD applied to template instantiation", storage
);
19682 check_explicit_instantiation_namespace (result
);
19683 mark_decl_instantiated (result
, extern_p
);
19685 instantiate_decl (result
, /*defer_ok=*/1,
19686 /*expl_inst_class_mem_p=*/false);
19690 mark_class_instantiated (tree t
, int extern_p
)
19692 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19693 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19694 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19695 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19698 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19699 rest_of_type_compilation (t
, 1);
19703 /* Called from do_type_instantiation through binding_table_foreach to
19704 do recursive instantiation for the type bound in ENTRY. */
19706 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19708 tree storage
= *(tree
*) data
;
19710 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19711 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19712 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19715 /* Called from do_type_instantiation to instantiate a member
19716 (a member function or a static member variable) of an
19717 explicitly instantiated class template. */
19719 instantiate_class_member (tree decl
, int extern_p
)
19721 mark_decl_instantiated (decl
, extern_p
);
19723 instantiate_decl (decl
, /*defer_ok=*/1,
19724 /*expl_inst_class_mem_p=*/true);
19727 /* Perform an explicit instantiation of template class T. STORAGE, if
19728 non-null, is the RID for extern, inline or static. COMPLAIN is
19729 nonzero if this is called from the parser, zero if called recursively,
19730 since the standard is unclear (as detailed below). */
19733 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19738 int previous_instantiation_extern_p
= 0;
19740 if (TREE_CODE (t
) == TYPE_DECL
)
19743 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19746 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19748 error ("explicit instantiation of non-class template %qD", tmpl
);
19750 error ("explicit instantiation of non-template type %qT", t
);
19756 if (!COMPLETE_TYPE_P (t
))
19758 if (complain
& tf_error
)
19759 error ("explicit instantiation of %q#T before definition of template",
19764 if (storage
!= NULL_TREE
)
19766 if (!in_system_header_at (input_location
))
19768 if (storage
== ridpointers
[(int) RID_EXTERN
])
19770 if (cxx_dialect
== cxx98
)
19771 pedwarn (input_location
, OPT_Wpedantic
,
19772 "ISO C++ 1998 forbids the use of %<extern%> on "
19773 "explicit instantiations");
19776 pedwarn (input_location
, OPT_Wpedantic
,
19777 "ISO C++ forbids the use of %qE"
19778 " on explicit instantiations", storage
);
19781 if (storage
== ridpointers
[(int) RID_INLINE
])
19783 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19785 else if (storage
== ridpointers
[(int) RID_STATIC
])
19789 error ("storage class %qD applied to template instantiation",
19795 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19797 /* DR 259 [temp.spec].
19799 Both an explicit instantiation and a declaration of an explicit
19800 specialization shall not appear in a program unless the explicit
19801 instantiation follows a declaration of the explicit specialization.
19803 For a given set of template parameters, if an explicit
19804 instantiation of a template appears after a declaration of an
19805 explicit specialization for that template, the explicit
19806 instantiation has no effect. */
19809 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19813 No program shall explicitly instantiate any template more
19816 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19817 instantiation was `extern'. If EXTERN_P then the second is.
19818 These cases are OK. */
19819 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19821 if (!previous_instantiation_extern_p
&& !extern_p
19822 && (complain
& tf_error
))
19823 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19825 /* If we've already instantiated the template, just return now. */
19826 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19830 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19831 mark_class_instantiated (t
, extern_p
);
19839 /* In contrast to implicit instantiation, where only the
19840 declarations, and not the definitions, of members are
19841 instantiated, we have here:
19845 The explicit instantiation of a class template specialization
19846 implies the instantiation of all of its members not
19847 previously explicitly specialized in the translation unit
19848 containing the explicit instantiation.
19850 Of course, we can't instantiate member template classes, since
19851 we don't have any arguments for them. Note that the standard
19852 is unclear on whether the instantiation of the members are
19853 *explicit* instantiations or not. However, the most natural
19854 interpretation is that it should be an explicit instantiation. */
19857 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19858 if (TREE_CODE (tmp
) == FUNCTION_DECL
19859 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19860 instantiate_class_member (tmp
, extern_p
);
19862 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19863 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19864 instantiate_class_member (tmp
, extern_p
);
19866 if (CLASSTYPE_NESTED_UTDS (t
))
19867 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19868 bt_instantiate_type_proc
, &storage
);
19872 /* Given a function DECL, which is a specialization of TMPL, modify
19873 DECL to be a re-instantiation of TMPL with the same template
19874 arguments. TMPL should be the template into which tsubst'ing
19875 should occur for DECL, not the most general template.
19877 One reason for doing this is a scenario like this:
19880 void f(const T&, int i);
19882 void g() { f(3, 7); }
19885 void f(const T& t, const int i) { }
19887 Note that when the template is first instantiated, with
19888 instantiate_template, the resulting DECL will have no name for the
19889 first parameter, and the wrong type for the second. So, when we go
19890 to instantiate the DECL, we regenerate it. */
19893 regenerate_decl_from_template (tree decl
, tree tmpl
)
19895 /* The arguments used to instantiate DECL, from the most general
19900 args
= DECL_TI_ARGS (decl
);
19901 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19903 /* Make sure that we can see identifiers, and compute access
19905 push_access_scope (decl
);
19907 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19915 args_depth
= TMPL_ARGS_DEPTH (args
);
19916 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19917 if (args_depth
> parms_depth
)
19918 args
= get_innermost_template_args (args
, parms_depth
);
19920 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19921 args
, tf_error
, NULL_TREE
,
19922 /*defer_ok*/false);
19923 if (specs
&& specs
!= error_mark_node
)
19924 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19927 /* Merge parameter declarations. */
19928 decl_parm
= skip_artificial_parms_for (decl
,
19929 DECL_ARGUMENTS (decl
));
19931 = skip_artificial_parms_for (code_pattern
,
19932 DECL_ARGUMENTS (code_pattern
));
19933 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19938 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19939 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19940 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19942 parm_type
= type_decays_to (parm_type
);
19943 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19944 TREE_TYPE (decl_parm
) = parm_type
;
19945 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19946 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19948 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19949 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19951 decl_parm
= DECL_CHAIN (decl_parm
);
19952 pattern_parm
= DECL_CHAIN (pattern_parm
);
19954 /* Merge any parameters that match with the function parameter
19956 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19959 tree expanded_types
;
19960 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19961 the parameters in this function parameter pack. */
19962 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19963 args
, tf_error
, NULL_TREE
);
19964 len
= TREE_VEC_LENGTH (expanded_types
);
19965 for (i
= 0; i
< len
; i
++)
19970 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19971 /* Rename the parameter to include the index. */
19972 DECL_NAME (decl_parm
) =
19973 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19974 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19975 parm_type
= type_decays_to (parm_type
);
19976 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19977 TREE_TYPE (decl_parm
) = parm_type
;
19978 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19979 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19981 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19982 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19984 decl_parm
= DECL_CHAIN (decl_parm
);
19987 /* Merge additional specifiers from the CODE_PATTERN. */
19988 if (DECL_DECLARED_INLINE_P (code_pattern
)
19989 && !DECL_DECLARED_INLINE_P (decl
))
19990 DECL_DECLARED_INLINE_P (decl
) = 1;
19992 else if (VAR_P (decl
))
19994 DECL_INITIAL (decl
) =
19995 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19996 tf_error
, DECL_TI_TEMPLATE (decl
),
19997 /*integral_constant_expression_p=*/false);
19998 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19999 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
20000 tf_error
, DECL_TI_TEMPLATE (decl
));
20003 gcc_unreachable ();
20005 pop_access_scope (decl
);
20008 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
20009 substituted to get DECL. */
20012 template_for_substitution (tree decl
)
20014 tree tmpl
= DECL_TI_TEMPLATE (decl
);
20016 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
20017 for the instantiation. This is not always the most general
20018 template. Consider, for example:
20021 struct S { template <class U> void f();
20022 template <> void f<int>(); };
20024 and an instantiation of S<double>::f<int>. We want TD to be the
20025 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
20026 while (/* An instantiation cannot have a definition, so we need a
20027 more general template. */
20028 DECL_TEMPLATE_INSTANTIATION (tmpl
)
20029 /* We must also deal with friend templates. Given:
20031 template <class T> struct S {
20032 template <class U> friend void f() {};
20035 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
20036 so far as the language is concerned, but that's still
20037 where we get the pattern for the instantiation from. On
20038 other hand, if the definition comes outside the class, say:
20040 template <class T> struct S {
20041 template <class U> friend void f();
20043 template <class U> friend void f() {}
20045 we don't need to look any further. That's what the check for
20046 DECL_INITIAL is for. */
20047 || (TREE_CODE (decl
) == FUNCTION_DECL
20048 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
20049 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
20051 /* The present template, TD, should not be a definition. If it
20052 were a definition, we should be using it! Note that we
20053 cannot restructure the loop to just keep going until we find
20054 a template with a definition, since that might go too far if
20055 a specialization was declared, but not defined. */
20057 /* Fetch the more general template. */
20058 tmpl
= DECL_TI_TEMPLATE (tmpl
);
20064 /* Returns true if we need to instantiate this template instance even if we
20065 know we aren't going to emit it.. */
20068 always_instantiate_p (tree decl
)
20070 /* We always instantiate inline functions so that we can inline them. An
20071 explicit instantiation declaration prohibits implicit instantiation of
20072 non-inline functions. With high levels of optimization, we would
20073 normally inline non-inline functions -- but we're not allowed to do
20074 that for "extern template" functions. Therefore, we check
20075 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
20076 return ((TREE_CODE (decl
) == FUNCTION_DECL
20077 && (DECL_DECLARED_INLINE_P (decl
)
20078 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
20079 /* And we need to instantiate static data members so that
20080 their initializers are available in integral constant
20083 && decl_maybe_constant_var_p (decl
)));
20086 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
20087 instantiate it now, modifying TREE_TYPE (fn). */
20090 maybe_instantiate_noexcept (tree fn
)
20092 tree fntype
, spec
, noex
, clone
;
20094 /* Don't instantiate a noexcept-specification from template context. */
20095 if (processing_template_decl
)
20098 if (DECL_CLONED_FUNCTION_P (fn
))
20099 fn
= DECL_CLONED_FUNCTION (fn
);
20100 fntype
= TREE_TYPE (fn
);
20101 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
20103 if (!spec
|| !TREE_PURPOSE (spec
))
20106 noex
= TREE_PURPOSE (spec
);
20108 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
20110 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
20111 spec
= get_defaulted_eh_spec (fn
);
20112 else if (push_tinst_level (fn
))
20114 push_access_scope (fn
);
20115 push_deferring_access_checks (dk_no_deferred
);
20116 input_location
= DECL_SOURCE_LOCATION (fn
);
20117 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
20118 DEFERRED_NOEXCEPT_ARGS (noex
),
20119 tf_warning_or_error
, fn
,
20120 /*function_p=*/false,
20121 /*integral_constant_expression_p=*/true);
20122 pop_deferring_access_checks ();
20123 pop_access_scope (fn
);
20124 pop_tinst_level ();
20125 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
20126 if (spec
== error_mark_node
)
20127 spec
= noexcept_false_spec
;
20130 spec
= noexcept_false_spec
;
20132 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
20135 FOR_EACH_CLONE (clone
, fn
)
20137 if (TREE_TYPE (clone
) == fntype
)
20138 TREE_TYPE (clone
) = TREE_TYPE (fn
);
20140 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
20144 /* Produce the definition of D, a _DECL generated from a template. If
20145 DEFER_OK is nonzero, then we don't have to actually do the
20146 instantiation now; we just have to do it sometime. Normally it is
20147 an error if this is an explicit instantiation but D is undefined.
20148 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
20149 explicitly instantiated class template. */
20152 instantiate_decl (tree d
, int defer_ok
,
20153 bool expl_inst_class_mem_p
)
20155 tree tmpl
= DECL_TI_TEMPLATE (d
);
20162 bool pattern_defined
;
20163 location_t saved_loc
= input_location
;
20164 int saved_unevaluated_operand
= cp_unevaluated_operand
;
20165 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
20171 /* This function should only be used to instantiate templates for
20172 functions and static member variables. */
20173 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
20175 /* Variables are never deferred; if instantiation is required, they
20176 are instantiated right away. That allows for better code in the
20177 case that an expression refers to the value of the variable --
20178 if the variable has a constant value the referring expression can
20179 take advantage of that fact. */
20181 || DECL_DECLARED_CONSTEXPR_P (d
))
20184 /* Don't instantiate cloned functions. Instead, instantiate the
20185 functions they cloned. */
20186 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
20187 d
= DECL_CLONED_FUNCTION (d
);
20189 if (DECL_TEMPLATE_INSTANTIATED (d
)
20190 || (TREE_CODE (d
) == FUNCTION_DECL
20191 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
20192 || DECL_TEMPLATE_SPECIALIZATION (d
))
20193 /* D has already been instantiated or explicitly specialized, so
20194 there's nothing for us to do here.
20196 It might seem reasonable to check whether or not D is an explicit
20197 instantiation, and, if so, stop here. But when an explicit
20198 instantiation is deferred until the end of the compilation,
20199 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
20200 the instantiation. */
20203 /* Check to see whether we know that this template will be
20204 instantiated in some other file, as with "extern template"
20206 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
20208 /* In general, we do not instantiate such templates. */
20209 if (external_p
&& !always_instantiate_p (d
))
20212 gen_tmpl
= most_general_template (tmpl
);
20213 gen_args
= DECL_TI_ARGS (d
);
20215 if (tmpl
!= gen_tmpl
)
20216 /* We should already have the extra args. */
20217 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
20218 == TMPL_ARGS_DEPTH (gen_args
));
20219 /* And what's in the hash table should match D. */
20220 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
20221 || spec
== NULL_TREE
);
20223 /* This needs to happen before any tsubsting. */
20224 if (! push_tinst_level (d
))
20227 timevar_push (TV_TEMPLATE_INST
);
20229 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
20230 for the instantiation. */
20231 td
= template_for_substitution (d
);
20232 code_pattern
= DECL_TEMPLATE_RESULT (td
);
20234 /* We should never be trying to instantiate a member of a class
20235 template or partial specialization. */
20236 gcc_assert (d
!= code_pattern
);
20238 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
20239 || DECL_TEMPLATE_SPECIALIZATION (td
))
20240 /* In the case of a friend template whose definition is provided
20241 outside the class, we may have too many arguments. Drop the
20242 ones we don't need. The same is true for specializations. */
20243 args
= get_innermost_template_args
20244 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
20248 if (TREE_CODE (d
) == FUNCTION_DECL
)
20250 deleted_p
= DECL_DELETED_FN (code_pattern
);
20251 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
20252 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
20258 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
20261 /* We may be in the middle of deferred access check. Disable it now. */
20262 push_deferring_access_checks (dk_no_deferred
);
20264 /* Unless an explicit instantiation directive has already determined
20265 the linkage of D, remember that a definition is available for
20267 if (pattern_defined
20268 && !DECL_INTERFACE_KNOWN (d
)
20269 && !DECL_NOT_REALLY_EXTERN (d
))
20270 mark_definable (d
);
20272 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
20273 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
20274 input_location
= DECL_SOURCE_LOCATION (d
);
20276 /* If D is a member of an explicitly instantiated class template,
20277 and no definition is available, treat it like an implicit
20279 if (!pattern_defined
&& expl_inst_class_mem_p
20280 && DECL_EXPLICIT_INSTANTIATION (d
))
20282 /* Leave linkage flags alone on instantiations with anonymous
20284 if (TREE_PUBLIC (d
))
20286 DECL_NOT_REALLY_EXTERN (d
) = 0;
20287 DECL_INTERFACE_KNOWN (d
) = 0;
20289 SET_DECL_IMPLICIT_INSTANTIATION (d
);
20292 /* Defer all other templates, unless we have been explicitly
20293 forbidden from doing so. */
20294 if (/* If there is no definition, we cannot instantiate the
20297 /* If it's OK to postpone instantiation, do so. */
20299 /* If this is a static data member that will be defined
20300 elsewhere, we don't want to instantiate the entire data
20301 member, but we do want to instantiate the initializer so that
20302 we can substitute that elsewhere. */
20303 || (external_p
&& VAR_P (d
))
20304 /* Handle here a deleted function too, avoid generating
20305 its body (c++/61080). */
20308 /* The definition of the static data member is now required so
20309 we must substitute the initializer. */
20311 && !DECL_INITIAL (d
)
20312 && DECL_INITIAL (code_pattern
))
20316 bool const_init
= false;
20317 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20319 ns
= decl_namespace_context (d
);
20320 push_nested_namespace (ns
);
20322 push_nested_class (DECL_CONTEXT (d
));
20323 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
20325 tf_warning_or_error
, NULL_TREE
,
20326 /*integral_constant_expression_p=*/false);
20327 /* If instantiating the initializer involved instantiating this
20328 again, don't call cp_finish_decl twice. */
20329 if (!DECL_INITIAL (d
))
20331 /* Make sure the initializer is still constant, in case of
20332 circular dependency (template/instantiate6.C). */
20334 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20335 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
20336 /*asmspec_tree=*/NULL_TREE
,
20337 LOOKUP_ONLYCONVERTING
);
20340 pop_nested_class ();
20341 pop_nested_namespace (ns
);
20344 /* We restore the source position here because it's used by
20345 add_pending_template. */
20346 input_location
= saved_loc
;
20348 if (at_eof
&& !pattern_defined
20349 && DECL_EXPLICIT_INSTANTIATION (d
)
20350 && DECL_NOT_REALLY_EXTERN (d
))
20353 The definition of a non-exported function template, a
20354 non-exported member function template, or a non-exported
20355 member function or static data member of a class template
20356 shall be present in every translation unit in which it is
20357 explicitly instantiated. */
20358 permerror (input_location
, "explicit instantiation of %qD "
20359 "but no definition available", d
);
20361 /* If we're in unevaluated context, we just wanted to get the
20362 constant value; this isn't an odr use, so don't queue
20363 a full instantiation. */
20364 if (cp_unevaluated_operand
!= 0)
20366 /* ??? Historically, we have instantiated inline functions, even
20367 when marked as "extern template". */
20368 if (!(external_p
&& VAR_P (d
)))
20369 add_pending_template (d
);
20372 /* Tell the repository that D is available in this translation unit
20373 -- and see if it is supposed to be instantiated here. */
20374 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
20376 /* In a PCH file, despite the fact that the repository hasn't
20377 requested instantiation in the PCH it is still possible that
20378 an instantiation will be required in a file that includes the
20381 add_pending_template (d
);
20382 /* Instantiate inline functions so that the inliner can do its
20383 job, even though we'll not be emitting a copy of this
20385 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
20389 fn_context
= decl_function_context (d
);
20390 nested
= (current_function_decl
!= NULL_TREE
);
20392 push_to_top_level ();
20396 push_function_context ();
20397 cp_unevaluated_operand
= 0;
20398 c_inhibit_evaluation_warnings
= 0;
20401 /* Mark D as instantiated so that recursive calls to
20402 instantiate_decl do not try to instantiate it again. */
20403 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
20405 /* Regenerate the declaration in case the template has been modified
20406 by a subsequent redeclaration. */
20407 regenerate_decl_from_template (d
, td
);
20409 /* We already set the file and line above. Reset them now in case
20410 they changed as a result of calling regenerate_decl_from_template. */
20411 input_location
= DECL_SOURCE_LOCATION (d
);
20416 bool const_init
= false;
20418 /* Clear out DECL_RTL; whatever was there before may not be right
20419 since we've reset the type of the declaration. */
20420 SET_DECL_RTL (d
, NULL
);
20421 DECL_IN_AGGR_P (d
) = 0;
20423 /* The initializer is placed in DECL_INITIAL by
20424 regenerate_decl_from_template so we don't need to
20425 push/pop_access_scope again here. Pull it out so that
20426 cp_finish_decl can process it. */
20427 init
= DECL_INITIAL (d
);
20428 DECL_INITIAL (d
) = NULL_TREE
;
20429 DECL_INITIALIZED_P (d
) = 0;
20431 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20432 initializer. That function will defer actual emission until
20433 we have a chance to determine linkage. */
20434 DECL_EXTERNAL (d
) = 0;
20436 /* Enter the scope of D so that access-checking works correctly. */
20437 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20439 push_nested_class (DECL_CONTEXT (d
));
20441 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20442 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
20445 pop_nested_class ();
20447 if (variable_template_p (td
))
20448 note_variable_template_instantiation (d
);
20450 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
20451 synthesize_method (d
);
20452 else if (TREE_CODE (d
) == FUNCTION_DECL
)
20454 hash_map
<tree
, tree
> *saved_local_specializations
;
20458 tree block
= NULL_TREE
;
20460 /* Save away the current list, in case we are instantiating one
20461 template from within the body of another. */
20462 saved_local_specializations
= local_specializations
;
20464 /* Set up the list of local specializations. */
20465 local_specializations
= new hash_map
<tree
, tree
>;
20467 /* Set up context. */
20468 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20469 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20470 block
= push_stmt_list ();
20472 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
20474 /* Some typedefs referenced from within the template code need to be
20475 access checked at template instantiation time, i.e now. These
20476 types were added to the template at parsing time. Let's get those
20477 and perform the access checks then. */
20478 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20481 /* Create substitution entries for the parameters. */
20482 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20483 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20484 spec_parm
= DECL_ARGUMENTS (d
);
20485 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20487 register_local_specialization (spec_parm
, tmpl_parm
);
20488 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20489 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20491 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20493 if (!DECL_PACK_P (tmpl_parm
))
20495 register_local_specialization (spec_parm
, tmpl_parm
);
20496 spec_parm
= DECL_CHAIN (spec_parm
);
20500 /* Register the (value) argument pack as a specialization of
20501 TMPL_PARM, then move on. */
20502 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20503 register_local_specialization (argpack
, tmpl_parm
);
20506 gcc_assert (!spec_parm
);
20508 /* Substitute into the body of the function. */
20509 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20510 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20511 tf_warning_or_error
, tmpl
);
20514 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20515 tf_warning_or_error
, tmpl
,
20516 /*integral_constant_expression_p=*/false);
20518 /* Set the current input_location to the end of the function
20519 so that finish_function knows where we are. */
20521 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20523 /* Remember if we saw an infinite loop in the template. */
20524 current_function_infinite_loop
20525 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20528 /* We don't need the local specializations any more. */
20529 delete local_specializations
;
20530 local_specializations
= saved_local_specializations
;
20532 /* Finish the function. */
20533 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20534 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20535 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20538 d
= finish_function (0);
20539 expand_or_defer_fn (d
);
20542 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20543 cp_check_omp_declare_reduction (d
);
20546 /* We're not deferring instantiation any more. */
20547 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20550 pop_from_top_level ();
20552 pop_function_context ();
20555 input_location
= saved_loc
;
20556 cp_unevaluated_operand
= saved_unevaluated_operand
;
20557 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20558 pop_deferring_access_checks ();
20559 pop_tinst_level ();
20561 timevar_pop (TV_TEMPLATE_INST
);
20566 /* Run through the list of templates that we wish we could
20567 instantiate, and instantiate any we can. RETRIES is the
20568 number of times we retry pending template instantiation. */
20571 instantiate_pending_templates (int retries
)
20574 location_t saved_loc
= input_location
;
20576 /* Instantiating templates may trigger vtable generation. This in turn
20577 may require further template instantiations. We place a limit here
20578 to avoid infinite loop. */
20579 if (pending_templates
&& retries
>= max_tinst_depth
)
20581 tree decl
= pending_templates
->tinst
->decl
;
20583 fatal_error (input_location
,
20584 "template instantiation depth exceeds maximum of %d"
20585 " instantiating %q+D, possibly from virtual table generation"
20586 " (use -ftemplate-depth= to increase the maximum)",
20587 max_tinst_depth
, decl
);
20588 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20589 /* Pretend that we defined it. */
20590 DECL_INITIAL (decl
) = error_mark_node
;
20596 struct pending_template
**t
= &pending_templates
;
20597 struct pending_template
*last
= NULL
;
20601 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20602 bool complete
= false;
20604 if (TYPE_P (instantiation
))
20608 if (!COMPLETE_TYPE_P (instantiation
))
20610 instantiate_class_template (instantiation
);
20611 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20612 for (fn
= TYPE_METHODS (instantiation
);
20614 fn
= TREE_CHAIN (fn
))
20615 if (! DECL_ARTIFICIAL (fn
))
20616 instantiate_decl (fn
,
20618 /*expl_inst_class_mem_p=*/false);
20619 if (COMPLETE_TYPE_P (instantiation
))
20623 complete
= COMPLETE_TYPE_P (instantiation
);
20627 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20628 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20631 = instantiate_decl (instantiation
,
20633 /*expl_inst_class_mem_p=*/false);
20634 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20638 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20639 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20643 /* If INSTANTIATION has been instantiated, then we don't
20644 need to consider it again in the future. */
20652 current_tinst_level
= NULL
;
20654 last_pending_template
= last
;
20656 while (reconsider
);
20658 input_location
= saved_loc
;
20661 /* Substitute ARGVEC into T, which is a list of initializers for
20662 either base class or a non-static data member. The TREE_PURPOSEs
20663 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20664 instantiate_decl. */
20667 tsubst_initializer_list (tree t
, tree argvec
)
20669 tree inits
= NULL_TREE
;
20671 for (; t
; t
= TREE_CHAIN (t
))
20675 tree expanded_bases
= NULL_TREE
;
20676 tree expanded_arguments
= NULL_TREE
;
20679 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20684 /* Expand the base class expansion type into separate base
20686 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20687 tf_warning_or_error
,
20689 if (expanded_bases
== error_mark_node
)
20692 /* We'll be building separate TREE_LISTs of arguments for
20694 len
= TREE_VEC_LENGTH (expanded_bases
);
20695 expanded_arguments
= make_tree_vec (len
);
20696 for (i
= 0; i
< len
; i
++)
20697 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20699 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20700 expand each argument in the TREE_VALUE of t. */
20701 expr
= make_node (EXPR_PACK_EXPANSION
);
20702 PACK_EXPANSION_LOCAL_P (expr
) = true;
20703 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20704 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20706 if (TREE_VALUE (t
) == void_type_node
)
20707 /* VOID_TYPE_NODE is used to indicate
20708 value-initialization. */
20710 for (i
= 0; i
< len
; i
++)
20711 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20715 /* Substitute parameter packs into each argument in the
20717 in_base_initializer
= 1;
20718 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20720 tree expanded_exprs
;
20722 /* Expand the argument. */
20723 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20725 = tsubst_pack_expansion (expr
, argvec
,
20726 tf_warning_or_error
,
20728 if (expanded_exprs
== error_mark_node
)
20731 /* Prepend each of the expanded expressions to the
20732 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20733 for (i
= 0; i
< len
; i
++)
20735 TREE_VEC_ELT (expanded_arguments
, i
) =
20736 tree_cons (NULL_TREE
,
20737 TREE_VEC_ELT (expanded_exprs
, i
),
20738 TREE_VEC_ELT (expanded_arguments
, i
));
20741 in_base_initializer
= 0;
20743 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20744 since we built them backwards. */
20745 for (i
= 0; i
< len
; i
++)
20747 TREE_VEC_ELT (expanded_arguments
, i
) =
20748 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20753 for (i
= 0; i
< len
; ++i
)
20755 if (expanded_bases
)
20757 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20758 decl
= expand_member_init (decl
);
20759 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20764 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20765 tf_warning_or_error
, NULL_TREE
);
20767 decl
= expand_member_init (decl
);
20768 if (decl
&& !DECL_P (decl
))
20769 in_base_initializer
= 1;
20771 init
= TREE_VALUE (t
);
20773 if (init
!= void_type_node
)
20774 init
= tsubst_expr (init
, argvec
,
20775 tf_warning_or_error
, NULL_TREE
,
20776 /*integral_constant_expression_p=*/false);
20777 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20778 /* If we had an initializer but it instantiated to nothing,
20779 value-initialize the object. This will only occur when
20780 the initializer was a pack expansion where the parameter
20781 packs used in that expansion were of length zero. */
20782 init
= void_type_node
;
20783 in_base_initializer
= 0;
20788 init
= build_tree_list (decl
, init
);
20789 TREE_CHAIN (init
) = inits
;
20797 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20800 set_current_access_from_decl (tree decl
)
20802 if (TREE_PRIVATE (decl
))
20803 current_access_specifier
= access_private_node
;
20804 else if (TREE_PROTECTED (decl
))
20805 current_access_specifier
= access_protected_node
;
20807 current_access_specifier
= access_public_node
;
20810 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20811 is the instantiation (which should have been created with
20812 start_enum) and ARGS are the template arguments to use. */
20815 tsubst_enum (tree tag
, tree newtag
, tree args
)
20819 if (SCOPED_ENUM_P (newtag
))
20820 begin_scope (sk_scoped_enum
, newtag
);
20822 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20827 decl
= TREE_VALUE (e
);
20828 /* Note that in a template enum, the TREE_VALUE is the
20829 CONST_DECL, not the corresponding INTEGER_CST. */
20830 value
= tsubst_expr (DECL_INITIAL (decl
),
20831 args
, tf_warning_or_error
, NULL_TREE
,
20832 /*integral_constant_expression_p=*/true);
20834 /* Give this enumeration constant the correct access. */
20835 set_current_access_from_decl (decl
);
20837 /* Actually build the enumerator itself. Here we're assuming that
20838 enumerators can't have dependent attributes. */
20839 build_enumerator (DECL_NAME (decl
), value
, newtag
,
20840 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
20843 if (SCOPED_ENUM_P (newtag
))
20846 finish_enum_value_list (newtag
);
20847 finish_enum (newtag
);
20849 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20850 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20853 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20854 its type -- but without substituting the innermost set of template
20855 arguments. So, innermost set of template parameters will appear in
20859 get_mostly_instantiated_function_type (tree decl
)
20861 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
20862 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
20865 /* Return truthvalue if we're processing a template different from
20866 the last one involved in diagnostics. */
20868 problematic_instantiation_changed (void)
20870 return current_tinst_level
!= last_error_tinst_level
;
20873 /* Remember current template involved in diagnostics. */
20875 record_last_problematic_instantiation (void)
20877 last_error_tinst_level
= current_tinst_level
;
20880 struct tinst_level
*
20881 current_instantiation (void)
20883 return current_tinst_level
;
20886 /* Return TRUE if current_function_decl is being instantiated, false
20890 instantiating_current_function_p (void)
20892 return (current_instantiation ()
20893 && current_instantiation ()->decl
== current_function_decl
);
20896 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20897 type. Return zero for ok, nonzero for disallowed. Issue error and
20898 warning messages under control of COMPLAIN. */
20901 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20903 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20905 else if (POINTER_TYPE_P (type
))
20907 else if (TYPE_PTRMEM_P (type
))
20909 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20911 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20913 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20915 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20918 if (complain
& tf_error
)
20920 if (type
== error_mark_node
)
20921 inform (input_location
, "invalid template non-type parameter");
20923 error ("%q#T is not a valid type for a template non-type parameter",
20929 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20930 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20933 dependent_type_p_r (tree type
)
20939 A type is dependent if it is:
20941 -- a template parameter. Template template parameters are types
20942 for us (since TYPE_P holds true for them) so we handle
20944 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20945 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20947 /* -- a qualified-id with a nested-name-specifier which contains a
20948 class-name that names a dependent type or whose unqualified-id
20949 names a dependent type. */
20950 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20952 /* -- a cv-qualified type where the cv-unqualified type is
20954 No code is necessary for this bullet; the code below handles
20955 cv-qualified types, and we don't want to strip aliases with
20956 TYPE_MAIN_VARIANT because of DR 1558. */
20957 /* -- a compound type constructed from any dependent type. */
20958 if (TYPE_PTRMEM_P (type
))
20959 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20960 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20962 else if (TYPE_PTR_P (type
)
20963 || TREE_CODE (type
) == REFERENCE_TYPE
)
20964 return dependent_type_p (TREE_TYPE (type
));
20965 else if (TREE_CODE (type
) == FUNCTION_TYPE
20966 || TREE_CODE (type
) == METHOD_TYPE
)
20970 if (dependent_type_p (TREE_TYPE (type
)))
20972 for (arg_type
= TYPE_ARG_TYPES (type
);
20974 arg_type
= TREE_CHAIN (arg_type
))
20975 if (dependent_type_p (TREE_VALUE (arg_type
)))
20979 /* -- an array type constructed from any dependent type or whose
20980 size is specified by a constant expression that is
20983 We checked for type- and value-dependence of the bounds in
20984 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20985 if (TREE_CODE (type
) == ARRAY_TYPE
)
20987 if (TYPE_DOMAIN (type
)
20988 && dependent_type_p (TYPE_DOMAIN (type
)))
20990 return dependent_type_p (TREE_TYPE (type
));
20993 /* -- a template-id in which either the template name is a template
20995 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20997 /* ... or any of the template arguments is a dependent type or
20998 an expression that is type-dependent or value-dependent. */
20999 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
21000 && (any_dependent_template_arguments_p
21001 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
21003 /* For an alias template specialization, check the arguments both to the
21004 class template and the alias template. */
21005 else if (dependent_alias_template_spec_p (type
))
21008 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
21009 dependent; if the argument of the `typeof' expression is not
21010 type-dependent, then it should already been have resolved. */
21011 if (TREE_CODE (type
) == TYPEOF_TYPE
21012 || TREE_CODE (type
) == DECLTYPE_TYPE
21013 || TREE_CODE (type
) == UNDERLYING_TYPE
)
21016 /* A template argument pack is dependent if any of its packed
21018 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
21020 tree args
= ARGUMENT_PACK_ARGS (type
);
21021 int i
, len
= TREE_VEC_LENGTH (args
);
21022 for (i
= 0; i
< len
; ++i
)
21023 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21027 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
21028 be template parameters. */
21029 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
21032 /* The standard does not specifically mention types that are local
21033 to template functions or local classes, but they should be
21034 considered dependent too. For example:
21036 template <int I> void f() {
21041 The size of `E' cannot be known until the value of `I' has been
21042 determined. Therefore, `E' must be considered dependent. */
21043 scope
= TYPE_CONTEXT (type
);
21044 if (scope
&& TYPE_P (scope
))
21045 return dependent_type_p (scope
);
21046 /* Don't use type_dependent_expression_p here, as it can lead
21047 to infinite recursion trying to determine whether a lambda
21048 nested in a lambda is dependent (c++/47687). */
21049 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
21050 && DECL_LANG_SPECIFIC (scope
)
21051 && DECL_TEMPLATE_INFO (scope
)
21052 && (any_dependent_template_arguments_p
21053 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
21056 /* Other types are non-dependent. */
21060 /* Returns TRUE if TYPE is dependent, in the sense of
21061 [temp.dep.type]. Note that a NULL type is considered dependent. */
21064 dependent_type_p (tree type
)
21066 /* If there are no template parameters in scope, then there can't be
21067 any dependent types. */
21068 if (!processing_template_decl
)
21070 /* If we are not processing a template, then nobody should be
21071 providing us with a dependent type. */
21073 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
21077 /* If the type is NULL, we have not computed a type for the entity
21078 in question; in that case, the type is dependent. */
21082 /* Erroneous types can be considered non-dependent. */
21083 if (type
== error_mark_node
)
21086 /* If we have not already computed the appropriate value for TYPE,
21088 if (!TYPE_DEPENDENT_P_VALID (type
))
21090 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
21091 TYPE_DEPENDENT_P_VALID (type
) = 1;
21094 return TYPE_DEPENDENT_P (type
);
21097 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
21098 lookup. In other words, a dependent type that is not the current
21102 dependent_scope_p (tree scope
)
21104 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
21105 && !currently_open_class (scope
));
21108 /* T is a SCOPE_REF; return whether we need to consider it
21109 instantiation-dependent so that we can check access at instantiation
21110 time even though we know which member it resolves to. */
21113 instantiation_dependent_scope_ref_p (tree t
)
21115 if (DECL_P (TREE_OPERAND (t
, 1))
21116 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
21117 && accessible_in_template_p (TREE_OPERAND (t
, 0),
21118 TREE_OPERAND (t
, 1)))
21124 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
21125 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
21128 /* Note that this predicate is not appropriate for general expressions;
21129 only constant expressions (that satisfy potential_constant_expression)
21130 can be tested for value dependence. */
21133 value_dependent_expression_p (tree expression
)
21135 if (!processing_template_decl
)
21138 /* A name declared with a dependent type. */
21139 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
21142 switch (TREE_CODE (expression
))
21144 case IDENTIFIER_NODE
:
21145 /* A name that has not been looked up -- must be dependent. */
21148 case TEMPLATE_PARM_INDEX
:
21149 /* A non-type template parm. */
21153 /* A non-type template parm. */
21154 if (DECL_TEMPLATE_PARM_P (expression
))
21156 return value_dependent_expression_p (DECL_INITIAL (expression
));
21159 /* A constant with literal type and is initialized
21160 with an expression that is value-dependent.
21162 Note that a non-dependent parenthesized initializer will have
21163 already been replaced with its constant value, so if we see
21164 a TREE_LIST it must be dependent. */
21165 if (DECL_INITIAL (expression
)
21166 && decl_constant_var_p (expression
)
21167 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
21168 /* cp_finish_decl doesn't fold reference initializers. */
21169 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
21170 || value_dependent_expression_p (DECL_INITIAL (expression
))))
21174 case DYNAMIC_CAST_EXPR
:
21175 case STATIC_CAST_EXPR
:
21176 case CONST_CAST_EXPR
:
21177 case REINTERPRET_CAST_EXPR
:
21179 /* These expressions are value-dependent if the type to which
21180 the cast occurs is dependent or the expression being casted
21181 is value-dependent. */
21183 tree type
= TREE_TYPE (expression
);
21185 if (dependent_type_p (type
))
21188 /* A functional cast has a list of operands. */
21189 expression
= TREE_OPERAND (expression
, 0);
21192 /* If there are no operands, it must be an expression such
21193 as "int()". This should not happen for aggregate types
21194 because it would form non-constant expressions. */
21195 gcc_assert (cxx_dialect
>= cxx11
21196 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
21201 if (TREE_CODE (expression
) == TREE_LIST
)
21202 return any_value_dependent_elements_p (expression
);
21204 return value_dependent_expression_p (expression
);
21208 if (SIZEOF_EXPR_TYPE_P (expression
))
21209 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
21213 /* A `sizeof' expression is value-dependent if the operand is
21214 type-dependent or is a pack expansion. */
21215 expression
= TREE_OPERAND (expression
, 0);
21216 if (PACK_EXPANSION_P (expression
))
21218 else if (TYPE_P (expression
))
21219 return dependent_type_p (expression
);
21220 return instantiation_dependent_expression_p (expression
);
21222 case AT_ENCODE_EXPR
:
21223 /* An 'encode' expression is value-dependent if the operand is
21225 expression
= TREE_OPERAND (expression
, 0);
21226 return dependent_type_p (expression
);
21228 case NOEXCEPT_EXPR
:
21229 expression
= TREE_OPERAND (expression
, 0);
21230 return instantiation_dependent_expression_p (expression
);
21233 /* All instantiation-dependent expressions should also be considered
21234 value-dependent. */
21235 return instantiation_dependent_scope_ref_p (expression
);
21237 case COMPONENT_REF
:
21238 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
21239 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
21241 case NONTYPE_ARGUMENT_PACK
:
21242 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
21243 is value-dependent. */
21245 tree values
= ARGUMENT_PACK_ARGS (expression
);
21246 int i
, len
= TREE_VEC_LENGTH (values
);
21248 for (i
= 0; i
< len
; ++i
)
21249 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
21257 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
21258 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
21259 || (type2
? dependent_type_p (type2
) : false));
21263 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21264 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
21267 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21268 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
21272 tree op
= TREE_OPERAND (expression
, 0);
21273 return (value_dependent_expression_p (op
)
21274 || has_value_dependent_address (op
));
21279 tree fn
= get_callee_fndecl (expression
);
21281 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
21283 nargs
= call_expr_nargs (expression
);
21284 for (i
= 0; i
< nargs
; ++i
)
21286 tree op
= CALL_EXPR_ARG (expression
, i
);
21287 /* In a call to a constexpr member function, look through the
21288 implicit ADDR_EXPR on the object argument so that it doesn't
21289 cause the call to be considered value-dependent. We also
21290 look through it in potential_constant_expression. */
21291 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
21292 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
21293 && TREE_CODE (op
) == ADDR_EXPR
)
21294 op
= TREE_OPERAND (op
, 0);
21295 if (value_dependent_expression_p (op
))
21301 case TEMPLATE_ID_EXPR
:
21302 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21304 return type_dependent_expression_p (expression
);
21310 if (dependent_type_p (TREE_TYPE (expression
)))
21312 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
21313 if (value_dependent_expression_p (val
))
21319 /* Treat a GNU statement expression as dependent to avoid crashing
21320 under instantiate_non_dependent_expr; it can't be constant. */
21324 /* A constant expression is value-dependent if any subexpression is
21325 value-dependent. */
21326 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
21328 case tcc_reference
:
21330 case tcc_comparison
:
21332 case tcc_expression
:
21335 int i
, len
= cp_tree_operand_length (expression
);
21337 for (i
= 0; i
< len
; i
++)
21339 tree t
= TREE_OPERAND (expression
, i
);
21341 /* In some cases, some of the operands may be missing.l
21342 (For example, in the case of PREDECREMENT_EXPR, the
21343 amount to increment by may be missing.) That doesn't
21344 make the expression dependent. */
21345 if (t
&& value_dependent_expression_p (t
))
21356 /* The expression is not value-dependent. */
21360 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21361 [temp.dep.expr]. Note that an expression with no type is
21362 considered dependent. Other parts of the compiler arrange for an
21363 expression with type-dependent subexpressions to have no type, so
21364 this function doesn't have to be fully recursive. */
21367 type_dependent_expression_p (tree expression
)
21369 if (!processing_template_decl
)
21372 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
21375 /* An unresolved name is always dependent. */
21376 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
21379 /* Some expression forms are never type-dependent. */
21380 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
21381 || TREE_CODE (expression
) == SIZEOF_EXPR
21382 || TREE_CODE (expression
) == ALIGNOF_EXPR
21383 || TREE_CODE (expression
) == AT_ENCODE_EXPR
21384 || TREE_CODE (expression
) == NOEXCEPT_EXPR
21385 || TREE_CODE (expression
) == TRAIT_EXPR
21386 || TREE_CODE (expression
) == TYPEID_EXPR
21387 || TREE_CODE (expression
) == DELETE_EXPR
21388 || TREE_CODE (expression
) == VEC_DELETE_EXPR
21389 || TREE_CODE (expression
) == THROW_EXPR
)
21392 /* The types of these expressions depends only on the type to which
21393 the cast occurs. */
21394 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
21395 || TREE_CODE (expression
) == STATIC_CAST_EXPR
21396 || TREE_CODE (expression
) == CONST_CAST_EXPR
21397 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
21398 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
21399 || TREE_CODE (expression
) == CAST_EXPR
)
21400 return dependent_type_p (TREE_TYPE (expression
));
21402 /* The types of these expressions depends only on the type created
21403 by the expression. */
21404 if (TREE_CODE (expression
) == NEW_EXPR
21405 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
21407 /* For NEW_EXPR tree nodes created inside a template, either
21408 the object type itself or a TREE_LIST may appear as the
21410 tree type
= TREE_OPERAND (expression
, 1);
21411 if (TREE_CODE (type
) == TREE_LIST
)
21412 /* This is an array type. We need to check array dimensions
21414 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
21415 || value_dependent_expression_p
21416 (TREE_OPERAND (TREE_VALUE (type
), 1));
21418 return dependent_type_p (type
);
21421 if (TREE_CODE (expression
) == SCOPE_REF
)
21423 tree scope
= TREE_OPERAND (expression
, 0);
21424 tree name
= TREE_OPERAND (expression
, 1);
21426 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21427 contains an identifier associated by name lookup with one or more
21428 declarations declared with a dependent type, or...a
21429 nested-name-specifier or qualified-id that names a member of an
21430 unknown specialization. */
21431 return (type_dependent_expression_p (name
)
21432 || dependent_scope_p (scope
));
21435 if (TREE_CODE (expression
) == FUNCTION_DECL
21436 && DECL_LANG_SPECIFIC (expression
)
21437 && DECL_TEMPLATE_INFO (expression
)
21438 && (any_dependent_template_arguments_p
21439 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
21442 if (TREE_CODE (expression
) == TEMPLATE_DECL
21443 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
21446 if (TREE_CODE (expression
) == STMT_EXPR
)
21447 expression
= stmt_expr_value_expr (expression
);
21449 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21454 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21456 if (type_dependent_expression_p (elt
))
21462 /* A static data member of the current instantiation with incomplete
21463 array type is type-dependent, as the definition and specializations
21464 can have different bounds. */
21465 if (VAR_P (expression
)
21466 && DECL_CLASS_SCOPE_P (expression
)
21467 && dependent_type_p (DECL_CONTEXT (expression
))
21468 && VAR_HAD_UNKNOWN_BOUND (expression
))
21471 /* An array of unknown bound depending on a variadic parameter, eg:
21473 template<typename... Args>
21474 void foo (Args... args)
21476 int arr[] = { args... };
21479 template<int... vals>
21482 int arr[] = { vals... };
21485 If the array has no length and has an initializer, it must be that
21486 we couldn't determine its length in cp_complete_array_type because
21487 it is dependent. */
21488 if (VAR_P (expression
)
21489 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21490 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21491 && DECL_INITIAL (expression
))
21494 /* A variable template specialization is type-dependent if it has any
21495 dependent template arguments. */
21496 if (VAR_P (expression
)
21497 && DECL_LANG_SPECIFIC (expression
)
21498 && DECL_TEMPLATE_INFO (expression
)
21499 && variable_template_p (DECL_TI_TEMPLATE (expression
)))
21500 return any_dependent_template_arguments_p (DECL_TI_ARGS (expression
));
21502 /* Always dependent, on the number of arguments if nothing else. */
21503 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21506 if (TREE_TYPE (expression
) == unknown_type_node
)
21508 if (TREE_CODE (expression
) == ADDR_EXPR
)
21509 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21510 if (TREE_CODE (expression
) == COMPONENT_REF
21511 || TREE_CODE (expression
) == OFFSET_REF
)
21513 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21515 expression
= TREE_OPERAND (expression
, 1);
21516 if (identifier_p (expression
))
21519 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21520 if (TREE_CODE (expression
) == SCOPE_REF
)
21523 if (BASELINK_P (expression
))
21525 if (BASELINK_OPTYPE (expression
)
21526 && dependent_type_p (BASELINK_OPTYPE (expression
)))
21528 expression
= BASELINK_FUNCTIONS (expression
);
21531 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21533 if (any_dependent_template_arguments_p
21534 (TREE_OPERAND (expression
, 1)))
21536 expression
= TREE_OPERAND (expression
, 0);
21538 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21539 || TREE_CODE (expression
) == FUNCTION_DECL
);
21543 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21545 expression
= OVL_NEXT (expression
);
21550 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21552 return (dependent_type_p (TREE_TYPE (expression
)));
21555 /* walk_tree callback function for instantiation_dependent_expression_p,
21556 below. Returns non-zero if a dependent subexpression is found. */
21559 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21564 /* We don't have to worry about decltype currently because decltype
21565 of an instantiation-dependent expr is a dependent type. This
21566 might change depending on the resolution of DR 1172. */
21567 *walk_subtrees
= false;
21570 enum tree_code code
= TREE_CODE (*tp
);
21573 /* Don't treat an argument list as dependent just because it has no
21581 /* A constant with a dependent initializer is dependent. */
21582 if (value_dependent_expression_p (*tp
))
21586 case TEMPLATE_PARM_INDEX
:
21589 /* Handle expressions with type operands. */
21593 case AT_ENCODE_EXPR
:
21595 tree op
= TREE_OPERAND (*tp
, 0);
21596 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21597 op
= TREE_TYPE (op
);
21600 if (dependent_type_p (op
))
21604 *walk_subtrees
= false;
21612 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21613 || (TRAIT_EXPR_TYPE2 (*tp
)
21614 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21616 *walk_subtrees
= false;
21619 case COMPONENT_REF
:
21620 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21621 /* In a template, finish_class_member_access_expr creates a
21622 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21623 type-dependent, so that we can check access control at
21624 instantiation time (PR 42277). See also Core issue 1273. */
21629 if (instantiation_dependent_scope_ref_p (*tp
))
21634 /* Treat statement-expressions as dependent. */
21642 if (type_dependent_expression_p (*tp
))
21648 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21649 sense defined by the ABI:
21651 "An expression is instantiation-dependent if it is type-dependent
21652 or value-dependent, or it has a subexpression that is type-dependent
21653 or value-dependent." */
21656 instantiation_dependent_expression_p (tree expression
)
21660 if (!processing_template_decl
)
21663 if (expression
== error_mark_node
)
21666 result
= cp_walk_tree_without_duplicates (&expression
,
21667 instantiation_dependent_r
, NULL
);
21668 return result
!= NULL_TREE
;
21671 /* Like type_dependent_expression_p, but it also works while not processing
21672 a template definition, i.e. during substitution or mangling. */
21675 type_dependent_expression_p_push (tree expr
)
21678 ++processing_template_decl
;
21679 b
= type_dependent_expression_p (expr
);
21680 --processing_template_decl
;
21684 /* Returns TRUE if ARGS contains a type-dependent expression. */
21687 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21692 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21694 if (type_dependent_expression_p (arg
))
21700 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21701 expressions) contains any type-dependent expressions. */
21704 any_type_dependent_elements_p (const_tree list
)
21706 for (; list
; list
= TREE_CHAIN (list
))
21707 if (type_dependent_expression_p (TREE_VALUE (list
)))
21713 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21714 expressions) contains any value-dependent expressions. */
21717 any_value_dependent_elements_p (const_tree list
)
21719 for (; list
; list
= TREE_CHAIN (list
))
21720 if (value_dependent_expression_p (TREE_VALUE (list
)))
21726 /* Returns TRUE if the ARG (a template argument) is dependent. */
21729 dependent_template_arg_p (tree arg
)
21731 if (!processing_template_decl
)
21734 /* Assume a template argument that was wrongly written by the user
21735 is dependent. This is consistent with what
21736 any_dependent_template_arguments_p [that calls this function]
21738 if (!arg
|| arg
== error_mark_node
)
21741 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21742 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21744 if (TREE_CODE (arg
) == TEMPLATE_DECL
21745 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21746 return dependent_template_p (arg
);
21747 else if (ARGUMENT_PACK_P (arg
))
21749 tree args
= ARGUMENT_PACK_ARGS (arg
);
21750 int i
, len
= TREE_VEC_LENGTH (args
);
21751 for (i
= 0; i
< len
; ++i
)
21753 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21759 else if (TYPE_P (arg
))
21760 return dependent_type_p (arg
);
21762 return (type_dependent_expression_p (arg
)
21763 || value_dependent_expression_p (arg
));
21766 /* Returns true if ARGS (a collection of template arguments) contains
21767 any types that require structural equality testing. */
21770 any_template_arguments_need_structural_equality_p (tree args
)
21777 if (args
== error_mark_node
)
21780 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21782 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21783 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21785 tree arg
= TREE_VEC_ELT (level
, j
);
21786 tree packed_args
= NULL_TREE
;
21789 if (ARGUMENT_PACK_P (arg
))
21791 /* Look inside the argument pack. */
21792 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21793 len
= TREE_VEC_LENGTH (packed_args
);
21796 for (k
= 0; k
< len
; ++k
)
21799 arg
= TREE_VEC_ELT (packed_args
, k
);
21801 if (error_operand_p (arg
))
21803 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21805 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21807 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21808 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21817 /* Returns true if ARGS (a collection of template arguments) contains
21818 any dependent arguments. */
21821 any_dependent_template_arguments_p (const_tree args
)
21828 if (args
== error_mark_node
)
21831 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21833 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21834 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21835 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21842 /* Returns TRUE if the template TMPL is dependent. */
21845 dependent_template_p (tree tmpl
)
21847 if (TREE_CODE (tmpl
) == OVERLOAD
)
21851 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21853 tmpl
= OVL_NEXT (tmpl
);
21858 /* Template template parameters are dependent. */
21859 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21860 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21862 /* So are names that have not been looked up. */
21863 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21865 /* So are member templates of dependent classes. */
21866 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21867 return dependent_type_p (DECL_CONTEXT (tmpl
));
21871 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21874 dependent_template_id_p (tree tmpl
, tree args
)
21876 return (dependent_template_p (tmpl
)
21877 || any_dependent_template_arguments_p (args
));
21880 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21884 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21888 if (!processing_template_decl
)
21891 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21893 tree decl
= TREE_VEC_ELT (declv
, i
);
21894 tree init
= TREE_VEC_ELT (initv
, i
);
21895 tree cond
= TREE_VEC_ELT (condv
, i
);
21896 tree incr
= TREE_VEC_ELT (incrv
, i
);
21898 if (type_dependent_expression_p (decl
))
21901 if (init
&& type_dependent_expression_p (init
))
21904 if (type_dependent_expression_p (cond
))
21907 if (COMPARISON_CLASS_P (cond
)
21908 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21909 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21912 if (TREE_CODE (incr
) == MODOP_EXPR
)
21914 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21915 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21918 else if (type_dependent_expression_p (incr
))
21920 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21922 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21924 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21926 tree t
= TREE_OPERAND (incr
, 1);
21927 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21928 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21937 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21938 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21939 no such TYPE can be found. Note that this function peers inside
21940 uninstantiated templates and therefore should be used only in
21941 extremely limited situations. ONLY_CURRENT_P restricts this
21942 peering to the currently open classes hierarchy (which is required
21943 when comparing types). */
21946 resolve_typename_type (tree type
, bool only_current_p
)
21955 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21957 scope
= TYPE_CONTEXT (type
);
21958 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21959 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21960 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21961 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21962 identifier of the TYPENAME_TYPE anymore.
21963 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21964 TYPENAME_TYPE instead, we avoid messing up with a possible
21965 typedef variant case. */
21966 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21968 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21969 it first before we can figure out what NAME refers to. */
21970 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21972 if (TYPENAME_IS_RESOLVING_P (scope
))
21973 /* Given a class template A with a dependent base with nested type C,
21974 typedef typename A::C::C C will land us here, as trying to resolve
21975 the initial A::C leads to the local C typedef, which leads back to
21976 A::C::C. So we break the recursion now. */
21979 scope
= resolve_typename_type (scope
, only_current_p
);
21981 /* If we don't know what SCOPE refers to, then we cannot resolve the
21983 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21985 /* If the SCOPE is a template type parameter, we have no way of
21986 resolving the name. */
21987 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21989 /* If the SCOPE is not the current instantiation, there's no reason
21990 to look inside it. */
21991 if (only_current_p
&& !currently_open_class (scope
))
21993 /* If this is a typedef, we don't want to look inside (c++/11987). */
21994 if (typedef_variant_p (type
))
21996 /* If SCOPE isn't the template itself, it will not have a valid
21997 TYPE_FIELDS list. */
21998 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21999 /* scope is either the template itself or a compatible instantiation
22000 like X<T>, so look up the name in the original template. */
22001 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
22003 /* scope is a partial instantiation, so we can't do the lookup or we
22004 will lose the template arguments. */
22006 /* Enter the SCOPE so that name lookup will be resolved as if we
22007 were in the class definition. In particular, SCOPE will no
22008 longer be considered a dependent type. */
22009 pushed_scope
= push_scope (scope
);
22010 /* Look up the declaration. */
22011 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
22012 tf_warning_or_error
);
22014 result
= NULL_TREE
;
22016 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
22017 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
22020 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
22021 && TREE_CODE (decl
) == TYPE_DECL
)
22023 result
= TREE_TYPE (decl
);
22024 if (result
== error_mark_node
)
22025 result
= NULL_TREE
;
22027 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
22028 && DECL_CLASS_TEMPLATE_P (decl
))
22032 /* Obtain the template and the arguments. */
22033 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
22034 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
22035 /* Instantiate the template. */
22036 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
22037 /*entering_scope=*/0,
22038 tf_error
| tf_user
);
22039 if (result
== error_mark_node
)
22040 result
= NULL_TREE
;
22043 /* Leave the SCOPE. */
22045 pop_scope (pushed_scope
);
22047 /* If we failed to resolve it, return the original typename. */
22051 /* If lookup found a typename type, resolve that too. */
22052 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
22054 /* Ill-formed programs can cause infinite recursion here, so we
22055 must catch that. */
22056 TYPENAME_IS_RESOLVING_P (type
) = 1;
22057 result
= resolve_typename_type (result
, only_current_p
);
22058 TYPENAME_IS_RESOLVING_P (type
) = 0;
22061 /* Qualify the resulting type. */
22062 quals
= cp_type_quals (type
);
22064 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
22069 /* EXPR is an expression which is not type-dependent. Return a proxy
22070 for EXPR that can be used to compute the types of larger
22071 expressions containing EXPR. */
22074 build_non_dependent_expr (tree expr
)
22078 #ifdef ENABLE_CHECKING
22079 /* Try to get a constant value for all non-dependent expressions in
22080 order to expose bugs in *_dependent_expression_p and constexpr. */
22081 if (cxx_dialect
>= cxx11
)
22082 fold_non_dependent_expr (expr
);
22085 /* Preserve OVERLOADs; the functions must be available to resolve
22088 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
22089 inner_expr
= stmt_expr_value_expr (inner_expr
);
22090 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
22091 inner_expr
= TREE_OPERAND (inner_expr
, 0);
22092 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
22093 inner_expr
= TREE_OPERAND (inner_expr
, 1);
22094 if (is_overloaded_fn (inner_expr
)
22095 || TREE_CODE (inner_expr
) == OFFSET_REF
)
22097 /* There is no need to return a proxy for a variable. */
22100 /* Preserve string constants; conversions from string constants to
22101 "char *" are allowed, even though normally a "const char *"
22102 cannot be used to initialize a "char *". */
22103 if (TREE_CODE (expr
) == STRING_CST
)
22105 /* Preserve void and arithmetic constants, as an optimization -- there is no
22106 reason to create a new node. */
22107 if (TREE_CODE (expr
) == VOID_CST
22108 || TREE_CODE (expr
) == INTEGER_CST
22109 || TREE_CODE (expr
) == REAL_CST
)
22111 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
22112 There is at least one place where we want to know that a
22113 particular expression is a throw-expression: when checking a ?:
22114 expression, there are special rules if the second or third
22115 argument is a throw-expression. */
22116 if (TREE_CODE (expr
) == THROW_EXPR
)
22119 /* Don't wrap an initializer list, we need to be able to look inside. */
22120 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
22123 /* Don't wrap a dummy object, we need to be able to test for it. */
22124 if (is_dummy_object (expr
))
22127 if (TREE_CODE (expr
) == COND_EXPR
)
22128 return build3 (COND_EXPR
,
22130 TREE_OPERAND (expr
, 0),
22131 (TREE_OPERAND (expr
, 1)
22132 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
22133 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
22134 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
22135 if (TREE_CODE (expr
) == COMPOUND_EXPR
22136 && !COMPOUND_EXPR_OVERLOADED (expr
))
22137 return build2 (COMPOUND_EXPR
,
22139 TREE_OPERAND (expr
, 0),
22140 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
22142 /* If the type is unknown, it can't really be non-dependent */
22143 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
22145 /* Otherwise, build a NON_DEPENDENT_EXPR. */
22146 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
22149 /* ARGS is a vector of expressions as arguments to a function call.
22150 Replace the arguments with equivalent non-dependent expressions.
22151 This modifies ARGS in place. */
22154 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
22159 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
22161 tree newarg
= build_non_dependent_expr (arg
);
22163 (*args
)[ix
] = newarg
;
22167 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
22168 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
22172 make_auto_1 (tree name
)
22174 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
22175 TYPE_NAME (au
) = build_decl (input_location
,
22176 TYPE_DECL
, name
, au
);
22177 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
22178 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
22179 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
22180 TYPE_NAME (au
), NULL_TREE
);
22181 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
22182 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
22183 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
22189 make_decltype_auto (void)
22191 return make_auto_1 (get_identifier ("decltype(auto)"));
22197 return make_auto_1 (get_identifier ("auto"));
22200 /* Given type ARG, return std::initializer_list<ARG>. */
22205 tree std_init_list
= namespace_binding
22206 (get_identifier ("initializer_list"), std_node
);
22208 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
22210 error ("deducing from brace-enclosed initializer list requires "
22211 "#include <initializer_list>");
22212 return error_mark_node
;
22214 argvec
= make_tree_vec (1);
22215 TREE_VEC_ELT (argvec
, 0) = arg
;
22216 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
22217 NULL_TREE
, 0, tf_warning_or_error
);
22220 /* Replace auto in TYPE with std::initializer_list<auto>. */
22223 listify_autos (tree type
, tree auto_node
)
22225 tree init_auto
= listify (auto_node
);
22226 tree argvec
= make_tree_vec (1);
22227 TREE_VEC_ELT (argvec
, 0) = init_auto
;
22228 if (processing_template_decl
)
22229 argvec
= add_to_template_args (current_template_args (), argvec
);
22230 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22233 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
22234 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
22237 do_auto_deduction (tree type
, tree init
, tree auto_node
)
22241 if (init
== error_mark_node
)
22242 return error_mark_node
;
22244 if (type_dependent_expression_p (init
))
22245 /* Defining a subset of type-dependent expressions that we can deduce
22246 from ahead of time isn't worth the trouble. */
22249 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
22250 with either a new invented type template parameter U or, if the
22251 initializer is a braced-init-list (8.5.4), with
22252 std::initializer_list<U>. */
22253 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
22255 if (!DIRECT_LIST_INIT_P (init
))
22256 type
= listify_autos (type
, auto_node
);
22257 else if (CONSTRUCTOR_NELTS (init
) == 1)
22258 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
22261 if (permerror (input_location
, "direct-list-initialization of "
22262 "%<auto%> requires exactly one element"))
22263 inform (input_location
,
22264 "for deduction to %<std::initializer_list%>, use copy-"
22265 "list-initialization (i.e. add %<=%> before the %<{%>)");
22266 type
= listify_autos (type
, auto_node
);
22270 init
= resolve_nondeduced_context (init
);
22272 targs
= make_tree_vec (1);
22273 if (AUTO_IS_DECLTYPE (auto_node
))
22275 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
22276 && !REF_PARENTHESIZED_P (init
)));
22277 TREE_VEC_ELT (targs
, 0)
22278 = finish_decltype_type (init
, id
, tf_warning_or_error
);
22279 if (type
!= auto_node
)
22281 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
22282 return error_mark_node
;
22287 tree parms
= build_tree_list (NULL_TREE
, type
);
22288 tree tparms
= make_tree_vec (1);
22291 TREE_VEC_ELT (tparms
, 0)
22292 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
22293 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
22294 DEDUCE_CALL
, LOOKUP_NORMAL
,
22295 NULL
, /*explain_p=*/false);
22298 if (processing_template_decl
)
22299 /* Try again at instantiation time. */
22301 if (type
&& type
!= error_mark_node
)
22302 /* If type is error_mark_node a diagnostic must have been
22303 emitted by now. Also, having a mention to '<type error>'
22304 in the diagnostic is not really useful to the user. */
22306 if (cfun
&& auto_node
== current_function_auto_return_pattern
22307 && LAMBDA_FUNCTION_P (current_function_decl
))
22308 error ("unable to deduce lambda return type from %qE", init
);
22310 error ("unable to deduce %qT from %qE", type
, init
);
22312 return error_mark_node
;
22316 /* If the list of declarators contains more than one declarator, the type
22317 of each declared variable is determined as described above. If the
22318 type deduced for the template parameter U is not the same in each
22319 deduction, the program is ill-formed. */
22320 if (TREE_TYPE (auto_node
)
22321 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
22323 if (cfun
&& auto_node
== current_function_auto_return_pattern
22324 && LAMBDA_FUNCTION_P (current_function_decl
))
22325 error ("inconsistent types %qT and %qT deduced for "
22326 "lambda return type", TREE_TYPE (auto_node
),
22327 TREE_VEC_ELT (targs
, 0));
22329 error ("inconsistent deduction for %qT: %qT and then %qT",
22330 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
22331 return error_mark_node
;
22333 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
22335 if (processing_template_decl
)
22336 targs
= add_to_template_args (current_template_args (), targs
);
22337 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
22340 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22344 splice_late_return_type (tree type
, tree late_return_type
)
22348 if (late_return_type
== NULL_TREE
)
22350 argvec
= make_tree_vec (1);
22351 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
22352 if (processing_template_parmlist
)
22353 /* For a late-specified return type in a template type-parameter, we
22354 need to add a dummy argument level for its parmlist. */
22355 argvec
= add_to_template_args
22356 (make_tree_vec (processing_template_parmlist
), argvec
);
22357 if (current_template_parms
)
22358 argvec
= add_to_template_args (current_template_args (), argvec
);
22359 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22362 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22363 'decltype(auto)'. */
22366 is_auto (const_tree type
)
22368 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
22369 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
22370 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
22376 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22377 a use of `auto'. Returns NULL_TREE otherwise. */
22380 type_uses_auto (tree type
)
22382 return find_type_usage (type
, is_auto
);
22385 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22386 'decltype(auto)' or a concept. */
22389 is_auto_or_concept (const_tree type
)
22391 return is_auto (type
); // or concept
22394 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22395 a concept identifier) iff TYPE contains a use of a generic type. Returns
22396 NULL_TREE otherwise. */
22399 type_uses_auto_or_concept (tree type
)
22401 return find_type_usage (type
, is_auto_or_concept
);
22405 /* For a given template T, return the vector of typedefs referenced
22406 in T for which access check is needed at T instantiation time.
22407 T is either a FUNCTION_DECL or a RECORD_TYPE.
22408 Those typedefs were added to T by the function
22409 append_type_to_template_for_access_check. */
22411 vec
<qualified_typedef_usage_t
, va_gc
> *
22412 get_types_needing_access_check (tree t
)
22415 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
22417 if (!t
|| t
== error_mark_node
)
22420 if (!(ti
= get_template_info (t
)))
22423 if (CLASS_TYPE_P (t
)
22424 || TREE_CODE (t
) == FUNCTION_DECL
)
22426 if (!TI_TEMPLATE (ti
))
22429 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
22435 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22436 tied to T. That list of typedefs will be access checked at
22437 T instantiation time.
22438 T is either a FUNCTION_DECL or a RECORD_TYPE.
22439 TYPE_DECL is a TYPE_DECL node representing a typedef.
22440 SCOPE is the scope through which TYPE_DECL is accessed.
22441 LOCATION is the location of the usage point of TYPE_DECL.
22443 This function is a subroutine of
22444 append_type_to_template_for_access_check. */
22447 append_type_to_template_for_access_check_1 (tree t
,
22450 location_t location
)
22452 qualified_typedef_usage_t typedef_usage
;
22455 if (!t
|| t
== error_mark_node
)
22458 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
22459 || CLASS_TYPE_P (t
))
22461 && TREE_CODE (type_decl
) == TYPE_DECL
22464 if (!(ti
= get_template_info (t
)))
22467 gcc_assert (TI_TEMPLATE (ti
));
22469 typedef_usage
.typedef_decl
= type_decl
;
22470 typedef_usage
.context
= scope
;
22471 typedef_usage
.locus
= location
;
22473 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22476 /* Append TYPE_DECL to the template TEMPL.
22477 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22478 At TEMPL instanciation time, TYPE_DECL will be checked to see
22479 if it can be accessed through SCOPE.
22480 LOCATION is the location of the usage point of TYPE_DECL.
22482 e.g. consider the following code snippet:
22489 template<class U> struct S
22491 C::myint mi; // <-- usage point of the typedef C::myint
22496 At S<char> instantiation time, we need to check the access of C::myint
22497 In other words, we need to check the access of the myint typedef through
22498 the C scope. For that purpose, this function will add the myint typedef
22499 and the scope C through which its being accessed to a list of typedefs
22500 tied to the template S. That list will be walked at template instantiation
22501 time and access check performed on each typedefs it contains.
22502 Note that this particular code snippet should yield an error because
22503 myint is private to C. */
22506 append_type_to_template_for_access_check (tree templ
,
22509 location_t location
)
22511 qualified_typedef_usage_t
*iter
;
22514 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22516 /* Make sure we don't append the type to the template twice. */
22517 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22518 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22521 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22525 /* Convert the generic type parameters in PARM that match the types given in the
22526 range [START_IDX, END_IDX) from the current_template_parms into generic type
22530 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22532 tree current
= current_template_parms
;
22533 int depth
= TMPL_PARMS_DEPTH (current
);
22534 current
= INNERMOST_TEMPLATE_PARMS (current
);
22535 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22537 for (int i
= 0; i
< start_idx
; ++i
)
22538 TREE_VEC_ELT (replacement
, i
)
22539 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22541 for (int i
= start_idx
; i
< end_idx
; ++i
)
22543 /* Create a distinct parameter pack type from the current parm and add it
22544 to the replacement args to tsubst below into the generic function
22547 tree o
= TREE_TYPE (TREE_VALUE
22548 (TREE_VEC_ELT (current
, i
)));
22549 tree t
= copy_type (o
);
22550 TEMPLATE_TYPE_PARM_INDEX (t
)
22551 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22553 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22554 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22555 TYPE_MAIN_VARIANT (t
) = t
;
22556 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22557 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22558 TREE_VEC_ELT (replacement
, i
) = t
;
22559 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22562 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22563 TREE_VEC_ELT (replacement
, i
)
22564 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22566 /* If there are more levels then build up the replacement with the outer
22569 replacement
= add_to_template_args (template_parms_to_args
22570 (TREE_CHAIN (current_template_parms
)),
22573 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22577 /* Set up the hash tables for template instantiations. */
22580 init_template_processing (void)
22582 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22583 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22586 /* Print stats about the template hash tables for -fstats. */
22589 print_template_statistics (void)
22591 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22592 "%f collisions\n", (long) decl_specializations
->size (),
22593 (long) decl_specializations
->elements (),
22594 decl_specializations
->collisions ());
22595 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22596 "%f collisions\n", (long) type_specializations
->size (),
22597 (long) type_specializations
->elements (),
22598 type_specializations
->collisions ());
22601 #include "gt-cp-pt.h"