1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2015 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Known bugs or deficiencies include:
24 all methods must be provided in header files; can't use a source
25 file that contains only the method templates and "just win". */
29 #include "coretypes.h"
34 #include "stringpool.h"
37 #include "stor-layout.h"
41 #include "c-family/c-common.h"
42 #include "c-family/c-objc.h"
43 #include "cp-objcp-common.h"
44 #include "tree-inline.h"
48 #include "tree-iterator.h"
49 #include "type-utils.h"
52 /* The type of functions taking a tree, and some additional data, and
54 typedef int (*tree_fn_t
) (tree
, void*);
56 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
57 instantiations have been deferred, either because their definitions
58 were not yet available, or because we were putting off doing the work. */
59 struct GTY ((chain_next ("%h.next"))) pending_template
{
60 struct pending_template
*next
;
61 struct tinst_level
*tinst
;
64 static GTY(()) struct pending_template
*pending_templates
;
65 static GTY(()) struct pending_template
*last_pending_template
;
67 int processing_template_parmlist
;
68 static int template_header_count
;
70 static GTY(()) tree saved_trees
;
71 static vec
<int> inline_parm_levels
;
73 static GTY(()) struct tinst_level
*current_tinst_level
;
75 static GTY(()) tree saved_access_scope
;
77 /* Live only within one (recursive) call to tsubst_expr. We use
78 this to pass the statement expression node from the STMT_EXPR
79 to the EXPR_STMT that is its result. */
80 static tree cur_stmt_expr
;
82 /* True if we've recursed into fn_type_unification too many times. */
83 static bool excessive_deduction_depth
;
85 struct GTY((for_user
)) spec_entry
92 struct spec_hasher
: ggc_ptr_hash
<spec_entry
>
94 static hashval_t
hash (spec_entry
*);
95 static bool equal (spec_entry
*, spec_entry
*);
98 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
100 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
102 /* Contains canonical template parameter types. The vector is indexed by
103 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
104 TREE_LIST, whose TREE_VALUEs contain the canonical template
105 parameters of various types and levels. */
106 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
108 #define UNIFY_ALLOW_NONE 0
109 #define UNIFY_ALLOW_MORE_CV_QUAL 1
110 #define UNIFY_ALLOW_LESS_CV_QUAL 2
111 #define UNIFY_ALLOW_DERIVED 4
112 #define UNIFY_ALLOW_INTEGER 8
113 #define UNIFY_ALLOW_OUTER_LEVEL 16
114 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
115 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
117 enum template_base_result
{
119 tbr_ambiguous_baseclass
,
123 static void push_access_scope (tree
);
124 static void pop_access_scope (tree
);
125 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
126 unification_kind_t
, int,
128 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
129 unification_kind_t
, int, bool, bool);
130 static int unify (tree
, tree
, tree
, tree
, int, bool);
131 static void add_pending_template (tree
);
132 static tree
reopen_tinst_level (struct tinst_level
*);
133 static tree
tsubst_initializer_list (tree
, tree
);
134 static tree
get_partial_spec_bindings (tree
, tree
, tree
, tree
);
135 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
137 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
139 static void tsubst_enum (tree
, tree
, tree
);
140 static tree
add_to_template_args (tree
, tree
);
141 static tree
add_outermost_template_args (tree
, tree
);
142 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
143 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
145 static int type_unification_real (tree
, tree
, tree
, const tree
*,
146 unsigned int, int, unification_kind_t
, int,
147 vec
<deferred_access_check
, va_gc
> **,
149 static void note_template_header (int);
150 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
151 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
152 static tree
convert_template_argument (tree
, tree
, tree
,
153 tsubst_flags_t
, int, tree
);
154 static int for_each_template_parm (tree
, tree_fn_t
, void*,
155 hash_set
<tree
> *, bool);
156 static tree
expand_template_argument_pack (tree
);
157 static tree
build_template_parm_index (int, int, int, tree
, tree
);
158 static bool inline_needs_template_parms (tree
, bool);
159 static void push_inline_template_parms_recursive (tree
, int);
160 static tree
retrieve_local_specialization (tree
);
161 static void register_local_specialization (tree
, tree
);
162 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
163 static int mark_template_parm (tree
, void *);
164 static int template_parm_this_level_p (tree
, void *);
165 static tree
tsubst_friend_function (tree
, tree
);
166 static tree
tsubst_friend_class (tree
, tree
);
167 static int can_complete_type_without_circularity (tree
);
168 static tree
get_bindings (tree
, tree
, tree
, bool);
169 static int template_decl_level (tree
);
170 static int check_cv_quals_for_unify (int, tree
, tree
);
171 static void template_parm_level_and_index (tree
, int*, int*);
172 static int unify_pack_expansion (tree
, tree
, tree
,
173 tree
, unification_kind_t
, bool, bool);
174 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
175 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
176 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
177 static void regenerate_decl_from_template (tree
, tree
);
178 static tree
most_specialized_partial_spec (tree
, tsubst_flags_t
);
179 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
180 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
181 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
182 static bool check_specialization_scope (void);
183 static tree
process_partial_specialization (tree
);
184 static void set_current_access_from_decl (tree
);
185 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
187 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
188 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
190 static bool template_template_parm_bindings_ok_p (tree
, tree
);
191 static int template_args_equal (tree
, tree
);
192 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
193 static tree
for_each_template_parm_r (tree
*, int *, void *);
194 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
195 static void copy_default_args_to_explicit_spec (tree
);
196 static int invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
197 static bool dependent_template_arg_p (tree
);
198 static bool any_template_arguments_need_structural_equality_p (tree
);
199 static bool dependent_type_p_r (tree
);
200 static tree
tsubst_expr (tree
, tree
, tsubst_flags_t
, tree
, bool);
201 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
202 static tree
tsubst_pack_expansion (tree
, tree
, tsubst_flags_t
, tree
);
203 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
204 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
205 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
207 static tree
listify (tree
);
208 static tree
listify_autos (tree
, tree
);
209 static tree
template_parm_to_arg (tree t
);
210 static tree
current_template_args (void);
211 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
212 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
213 static bool complex_alias_template_p (const_tree tmpl
);
215 /* Make the current scope suitable for access checking when we are
216 processing T. T can be FUNCTION_DECL for instantiated function
217 template, VAR_DECL for static member variable, or TYPE_DECL for
218 alias template (needed by instantiate_decl). */
221 push_access_scope (tree t
)
223 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
224 || TREE_CODE (t
) == TYPE_DECL
);
226 if (DECL_FRIEND_CONTEXT (t
))
227 push_nested_class (DECL_FRIEND_CONTEXT (t
));
228 else if (DECL_CLASS_SCOPE_P (t
))
229 push_nested_class (DECL_CONTEXT (t
));
231 push_to_top_level ();
233 if (TREE_CODE (t
) == FUNCTION_DECL
)
235 saved_access_scope
= tree_cons
236 (NULL_TREE
, current_function_decl
, saved_access_scope
);
237 current_function_decl
= t
;
241 /* Restore the scope set up by push_access_scope. T is the node we
245 pop_access_scope (tree t
)
247 if (TREE_CODE (t
) == FUNCTION_DECL
)
249 current_function_decl
= TREE_VALUE (saved_access_scope
);
250 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
253 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
256 pop_from_top_level ();
259 /* Do any processing required when DECL (a member template
260 declaration) is finished. Returns the TEMPLATE_DECL corresponding
261 to DECL, unless it is a specialization, in which case the DECL
262 itself is returned. */
265 finish_member_template_decl (tree decl
)
267 if (decl
== error_mark_node
)
268 return error_mark_node
;
270 gcc_assert (DECL_P (decl
));
272 if (TREE_CODE (decl
) == TYPE_DECL
)
276 type
= TREE_TYPE (decl
);
277 if (type
== error_mark_node
)
278 return error_mark_node
;
279 if (MAYBE_CLASS_TYPE_P (type
)
280 && CLASSTYPE_TEMPLATE_INFO (type
)
281 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
283 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
284 check_member_template (tmpl
);
289 else if (TREE_CODE (decl
) == FIELD_DECL
)
290 error ("data member %qD cannot be a member template", decl
);
291 else if (DECL_TEMPLATE_INFO (decl
))
293 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
295 check_member_template (DECL_TI_TEMPLATE (decl
));
296 return DECL_TI_TEMPLATE (decl
);
302 error ("invalid member template declaration %qD", decl
);
304 return error_mark_node
;
307 /* Create a template info node. */
310 build_template_info (tree template_decl
, tree template_args
)
312 tree result
= make_node (TEMPLATE_INFO
);
313 TI_TEMPLATE (result
) = template_decl
;
314 TI_ARGS (result
) = template_args
;
318 /* Return the template info node corresponding to T, whatever T is. */
321 get_template_info (const_tree t
)
323 tree tinfo
= NULL_TREE
;
325 if (!t
|| t
== error_mark_node
)
328 if (TREE_CODE (t
) == NAMESPACE_DECL
)
331 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
332 tinfo
= DECL_TEMPLATE_INFO (t
);
334 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
337 if (OVERLOAD_TYPE_P (t
))
338 tinfo
= TYPE_TEMPLATE_INFO (t
);
339 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
340 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
345 /* Returns the template nesting level of the indicated class TYPE.
355 A<T>::B<U> has depth two, while A<T> has depth one.
356 Both A<T>::B<int> and A<int>::B<U> have depth one, if
357 they are instantiations, not specializations.
359 This function is guaranteed to return 0 if passed NULL_TREE so
360 that, for example, `template_class_depth (current_class_type)' is
364 template_class_depth (tree type
)
369 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
370 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
371 ? CP_DECL_CONTEXT (type
) : CP_TYPE_CONTEXT (type
))
373 tree tinfo
= get_template_info (type
);
375 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
376 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
383 /* Subroutine of maybe_begin_member_template_processing.
384 Returns true if processing DECL needs us to push template parms. */
387 inline_needs_template_parms (tree decl
, bool nsdmi
)
389 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
392 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
393 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
396 /* Subroutine of maybe_begin_member_template_processing.
397 Push the template parms in PARMS, starting from LEVELS steps into the
398 chain, and ending at the beginning, since template parms are listed
402 push_inline_template_parms_recursive (tree parmlist
, int levels
)
404 tree parms
= TREE_VALUE (parmlist
);
408 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
410 ++processing_template_decl
;
411 current_template_parms
412 = tree_cons (size_int (processing_template_decl
),
413 parms
, current_template_parms
);
414 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
416 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
418 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
420 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
422 if (error_operand_p (parm
))
425 gcc_assert (DECL_P (parm
));
427 switch (TREE_CODE (parm
))
436 /* Make a CONST_DECL as is done in process_template_parm.
437 It is ugly that we recreate this here; the original
438 version built in process_template_parm is no longer
440 tree decl
= build_decl (DECL_SOURCE_LOCATION (parm
),
441 CONST_DECL
, DECL_NAME (parm
),
443 DECL_ARTIFICIAL (decl
) = 1;
444 TREE_CONSTANT (decl
) = 1;
445 TREE_READONLY (decl
) = 1;
446 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
447 SET_DECL_TEMPLATE_PARM_P (decl
);
458 /* Restore the template parameter context for a member template, a
459 friend template defined in a class definition, or a non-template
460 member of template class. */
463 maybe_begin_member_template_processing (tree decl
)
467 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
471 tree ctx
= DECL_CONTEXT (decl
);
472 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
473 /* Disregard full specializations (c++/60999). */
474 && uses_template_parms (ctx
)
475 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
478 if (inline_needs_template_parms (decl
, nsdmi
))
480 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
481 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
483 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
486 parms
= TREE_CHAIN (parms
);
489 push_inline_template_parms_recursive (parms
, levels
);
492 /* Remember how many levels of template parameters we pushed so that
493 we can pop them later. */
494 inline_parm_levels
.safe_push (levels
);
497 /* Undo the effects of maybe_begin_member_template_processing. */
500 maybe_end_member_template_processing (void)
505 if (inline_parm_levels
.length () == 0)
508 last
= inline_parm_levels
.pop ();
509 for (i
= 0; i
< last
; ++i
)
511 --processing_template_decl
;
512 current_template_parms
= TREE_CHAIN (current_template_parms
);
517 /* Return a new template argument vector which contains all of ARGS,
518 but has as its innermost set of arguments the EXTRA_ARGS. */
521 add_to_template_args (tree args
, tree extra_args
)
528 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
531 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
532 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
534 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
535 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
537 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
538 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
543 /* Like add_to_template_args, but only the outermost ARGS are added to
544 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
545 (EXTRA_ARGS) levels are added. This function is used to combine
546 the template arguments from a partial instantiation with the
547 template arguments used to attain the full instantiation from the
548 partial instantiation. */
551 add_outermost_template_args (tree args
, tree extra_args
)
555 /* If there are more levels of EXTRA_ARGS than there are ARGS,
556 something very fishy is going on. */
557 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
559 /* If *all* the new arguments will be the EXTRA_ARGS, just return
561 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
564 /* For the moment, we make ARGS look like it contains fewer levels. */
565 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
567 new_args
= add_to_template_args (args
, extra_args
);
569 /* Now, we restore ARGS to its full dimensions. */
570 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
575 /* Return the N levels of innermost template arguments from the ARGS. */
578 get_innermost_template_args (tree args
, int n
)
586 /* If N is 1, just return the innermost set of template arguments. */
588 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
590 /* If we're not removing anything, just return the arguments we were
592 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
593 gcc_assert (extra_levels
>= 0);
594 if (extra_levels
== 0)
597 /* Make a new set of arguments, not containing the outer arguments. */
598 new_args
= make_tree_vec (n
);
599 for (i
= 1; i
<= n
; ++i
)
600 SET_TMPL_ARGS_LEVEL (new_args
, i
,
601 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
606 /* The inverse of get_innermost_template_args: Return all but the innermost
607 EXTRA_LEVELS levels of template arguments from the ARGS. */
610 strip_innermost_template_args (tree args
, int extra_levels
)
613 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
618 /* If N is 1, just return the outermost set of template arguments. */
620 return TMPL_ARGS_LEVEL (args
, 1);
622 /* If we're not removing anything, just return the arguments we were
624 gcc_assert (extra_levels
>= 0);
625 if (extra_levels
== 0)
628 /* Make a new set of arguments, not containing the inner arguments. */
629 new_args
= make_tree_vec (n
);
630 for (i
= 1; i
<= n
; ++i
)
631 SET_TMPL_ARGS_LEVEL (new_args
, i
,
632 TMPL_ARGS_LEVEL (args
, i
));
637 /* We've got a template header coming up; push to a new level for storing
641 begin_template_parm_list (void)
643 /* We use a non-tag-transparent scope here, which causes pushtag to
644 put tags in this scope, rather than in the enclosing class or
645 namespace scope. This is the right thing, since we want
646 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
647 global template class, push_template_decl handles putting the
648 TEMPLATE_DECL into top-level scope. For a nested template class,
651 template <class T> struct S1 {
652 template <class T> struct S2 {};
655 pushtag contains special code to call pushdecl_with_scope on the
656 TEMPLATE_DECL for S2. */
657 begin_scope (sk_template_parms
, NULL
);
658 ++processing_template_decl
;
659 ++processing_template_parmlist
;
660 note_template_header (0);
663 /* This routine is called when a specialization is declared. If it is
664 invalid to declare a specialization here, an error is reported and
665 false is returned, otherwise this routine will return true. */
668 check_specialization_scope (void)
670 tree scope
= current_scope ();
674 An explicit specialization shall be declared in the namespace of
675 which the template is a member, or, for member templates, in the
676 namespace of which the enclosing class or enclosing class
677 template is a member. An explicit specialization of a member
678 function, member class or static data member of a class template
679 shall be declared in the namespace of which the class template
681 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
683 error ("explicit specialization in non-namespace scope %qD", scope
);
689 In an explicit specialization declaration for a member of a class
690 template or a member template that appears in namespace scope,
691 the member template and some of its enclosing class templates may
692 remain unspecialized, except that the declaration shall not
693 explicitly specialize a class member template if its enclosing
694 class templates are not explicitly specialized as well. */
695 if (current_template_parms
)
697 error ("enclosing class templates are not explicitly specialized");
704 /* We've just seen template <>. */
707 begin_specialization (void)
709 begin_scope (sk_template_spec
, NULL
);
710 note_template_header (1);
711 return check_specialization_scope ();
714 /* Called at then end of processing a declaration preceded by
718 end_specialization (void)
721 reset_specialization ();
724 /* Any template <>'s that we have seen thus far are not referring to a
725 function specialization. */
728 reset_specialization (void)
730 processing_specialization
= 0;
731 template_header_count
= 0;
734 /* We've just seen a template header. If SPECIALIZATION is nonzero,
735 it was of the form template <>. */
738 note_template_header (int specialization
)
740 processing_specialization
= specialization
;
741 template_header_count
++;
744 /* We're beginning an explicit instantiation. */
747 begin_explicit_instantiation (void)
749 gcc_assert (!processing_explicit_instantiation
);
750 processing_explicit_instantiation
= true;
755 end_explicit_instantiation (void)
757 gcc_assert (processing_explicit_instantiation
);
758 processing_explicit_instantiation
= false;
761 /* An explicit specialization or partial specialization of TMPL is being
762 declared. Check that the namespace in which the specialization is
763 occurring is permissible. Returns false iff it is invalid to
764 specialize TMPL in the current namespace. */
767 check_specialization_namespace (tree tmpl
)
769 tree tpl_ns
= decl_namespace_context (tmpl
);
773 An explicit specialization shall be declared in the namespace of
774 which the template is a member, or, for member templates, in the
775 namespace of which the enclosing class or enclosing class
776 template is a member. An explicit specialization of a member
777 function, member class or static data member of a class template
778 shall be declared in the namespace of which the class template is
780 if (current_scope() != DECL_CONTEXT (tmpl
)
781 && !at_namespace_scope_p ())
783 error ("specialization of %qD must appear at namespace scope", tmpl
);
786 if (is_associated_namespace (current_namespace
, tpl_ns
))
787 /* Same or super-using namespace. */
791 permerror (input_location
, "specialization of %qD in different namespace", tmpl
);
792 permerror (input_location
, " from definition of %q+#D", tmpl
);
797 /* SPEC is an explicit instantiation. Check that it is valid to
798 perform this explicit instantiation in the current namespace. */
801 check_explicit_instantiation_namespace (tree spec
)
805 /* DR 275: An explicit instantiation shall appear in an enclosing
806 namespace of its template. */
807 ns
= decl_namespace_context (spec
);
808 if (!is_ancestor (current_namespace
, ns
))
809 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
810 "(which does not enclose namespace %qD)",
811 spec
, current_namespace
, ns
);
814 /* The TYPE is being declared. If it is a template type, that means it
815 is a partial specialization. Do appropriate error-checking. */
818 maybe_process_partial_specialization (tree type
)
822 if (type
== error_mark_node
)
823 return error_mark_node
;
825 /* A lambda that appears in specialization context is not itself a
827 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
830 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
832 error ("name of class shadows template template parameter %qD",
834 return error_mark_node
;
837 context
= TYPE_CONTEXT (type
);
839 if (TYPE_ALIAS_P (type
))
841 if (TYPE_TEMPLATE_INFO (type
)
842 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type
)))
843 error ("specialization of alias template %qD",
844 TYPE_TI_TEMPLATE (type
));
846 error ("explicit specialization of non-template %qT", type
);
847 return error_mark_node
;
849 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
851 /* This is for ordinary explicit specialization and partial
852 specialization of a template class such as:
854 template <> class C<int>;
858 template <class T> class C<T*>;
860 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
862 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
863 && !COMPLETE_TYPE_P (type
))
865 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type
))
866 && !at_namespace_scope_p ())
867 return error_mark_node
;
868 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
869 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
870 if (processing_template_decl
)
872 if (push_template_decl (TYPE_MAIN_DECL (type
))
874 return error_mark_node
;
877 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
878 error ("specialization of %qT after instantiation", type
);
879 else if (errorcount
&& !processing_specialization
880 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
881 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
882 /* Trying to define a specialization either without a template<> header
883 or in an inappropriate place. We've already given an error, so just
884 bail now so we don't actually define the specialization. */
885 return error_mark_node
;
887 else if (CLASS_TYPE_P (type
)
888 && !CLASSTYPE_USE_TEMPLATE (type
)
889 && CLASSTYPE_TEMPLATE_INFO (type
)
890 && context
&& CLASS_TYPE_P (context
)
891 && CLASSTYPE_TEMPLATE_INFO (context
))
893 /* This is for an explicit specialization of member class
894 template according to [temp.expl.spec/18]:
896 template <> template <class U> class C<int>::D;
898 The context `C<int>' must be an implicit instantiation.
899 Otherwise this is just a member class template declared
902 template <> class C<int> { template <class U> class D; };
903 template <> template <class U> class C<int>::D;
905 In the first case, `C<int>::D' is a specialization of `C<T>::D'
906 while in the second case, `C<int>::D' is a primary template
907 and `C<T>::D' may not exist. */
909 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
910 && !COMPLETE_TYPE_P (type
))
913 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
915 if (current_namespace
916 != decl_namespace_context (tmpl
))
918 permerror (input_location
, "specializing %q#T in different namespace", type
);
919 permerror (input_location
, " from definition of %q+#D", tmpl
);
922 /* Check for invalid specialization after instantiation:
924 template <> template <> class C<int>::D<int>;
925 template <> template <class U> class C<int>::D; */
927 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
928 t
; t
= TREE_CHAIN (t
))
930 tree inst
= TREE_VALUE (t
);
931 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
932 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
934 /* We already have a full specialization of this partial
935 instantiation, or a full specialization has been
936 looked up but not instantiated. Reassign it to the
937 new member specialization template. */
941 elt
.tmpl
= most_general_template (tmpl
);
942 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
945 type_specializations
->remove_elt (&elt
);
948 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
951 = type_specializations
->find_slot (&elt
, INSERT
);
952 entry
= ggc_alloc
<spec_entry
> ();
957 /* But if we've had an implicit instantiation, that's a
958 problem ([temp.expl.spec]/6). */
959 error ("specialization %qT after instantiation %qT",
963 /* Mark TYPE as a specialization. And as a result, we only
964 have one level of template argument for the innermost
966 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
967 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
968 CLASSTYPE_TI_ARGS (type
)
969 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
972 else if (processing_specialization
)
974 /* Someday C++0x may allow for enum template specialization. */
975 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
976 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
977 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
978 "of %qD not allowed by ISO C++", type
);
981 error ("explicit specialization of non-template %qT", type
);
982 return error_mark_node
;
989 /* Returns nonzero if we can optimize the retrieval of specializations
990 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
991 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
994 optimize_specialization_lookup_p (tree tmpl
)
996 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
997 && DECL_CLASS_SCOPE_P (tmpl
)
998 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1000 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1001 /* The optimized lookup depends on the fact that the
1002 template arguments for the member function template apply
1003 purely to the containing class, which is not true if the
1004 containing class is an explicit or partial
1006 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1007 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1008 && !DECL_CONV_FN_P (tmpl
)
1009 /* It is possible to have a template that is not a member
1010 template and is not a member of a template class:
1012 template <typename T>
1013 struct S { friend A::f(); };
1015 Here, the friend function is a template, but the context does
1016 not have template information. The optimized lookup relies
1017 on having ARGS be the template arguments for both the class
1018 and the function template. */
1019 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1022 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1023 gone through coerce_template_parms by now. */
1026 check_unstripped_args (tree args ATTRIBUTE_UNUSED
)
1028 #ifdef ENABLE_CHECKING
1029 ++processing_template_decl
;
1030 if (!any_dependent_template_arguments_p (args
))
1032 tree inner
= INNERMOST_TEMPLATE_ARGS (args
);
1033 for (int i
= 0; i
< TREE_VEC_LENGTH (inner
); ++i
)
1035 tree arg
= TREE_VEC_ELT (inner
, i
);
1036 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1038 else if (TYPE_P (arg
))
1039 gcc_assert (strip_typedefs (arg
, NULL
) == arg
);
1040 else if (strip_typedefs (TREE_TYPE (arg
), NULL
) != TREE_TYPE (arg
))
1041 /* Allow typedefs on the type of a non-type argument, since a
1042 parameter can have them. */;
1044 gcc_assert (strip_typedefs_expr (arg
, NULL
) == arg
);
1047 --processing_template_decl
;
1051 /* Retrieve the specialization (in the sense of [temp.spec] - a
1052 specialization is either an instantiation or an explicit
1053 specialization) of TMPL for the given template ARGS. If there is
1054 no such specialization, return NULL_TREE. The ARGS are a vector of
1055 arguments, or a vector of vectors of arguments, in the case of
1056 templates with more than one level of parameters.
1058 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1059 then we search for a partial specialization matching ARGS. This
1060 parameter is ignored if TMPL is not a class template.
1062 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1063 result is a NONTYPE_ARGUMENT_PACK. */
1066 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1068 if (tmpl
== NULL_TREE
)
1071 if (args
== error_mark_node
)
1074 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1075 || TREE_CODE (tmpl
) == FIELD_DECL
);
1077 /* There should be as many levels of arguments as there are
1078 levels of parameters. */
1079 gcc_assert (TMPL_ARGS_DEPTH (args
)
1080 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1081 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1082 : template_class_depth (DECL_CONTEXT (tmpl
))));
1084 check_unstripped_args (args
);
1086 if (optimize_specialization_lookup_p (tmpl
))
1088 tree class_template
;
1089 tree class_specialization
;
1090 vec
<tree
, va_gc
> *methods
;
1094 /* The template arguments actually apply to the containing
1095 class. Find the class specialization with those
1097 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1098 class_specialization
1099 = retrieve_specialization (class_template
, args
, 0);
1100 if (!class_specialization
)
1102 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1103 for the specialization. */
1104 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
1107 /* Iterate through the methods with the indicated name, looking
1108 for the one that has an instance of TMPL. */
1109 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
1110 for (fns
= (*methods
)[idx
]; fns
; fns
= OVL_NEXT (fns
))
1112 tree fn
= OVL_CURRENT (fns
);
1113 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1114 /* using-declarations can add base methods to the method vec,
1115 and we don't want those here. */
1116 && DECL_CONTEXT (fn
) == class_specialization
)
1125 hash_table
<spec_hasher
> *specializations
;
1129 elt
.spec
= NULL_TREE
;
1131 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1132 specializations
= type_specializations
;
1134 specializations
= decl_specializations
;
1137 hash
= spec_hasher::hash (&elt
);
1138 found
= specializations
->find_with_hash (&elt
, hash
);
1146 /* Like retrieve_specialization, but for local declarations. */
1149 retrieve_local_specialization (tree tmpl
)
1151 if (local_specializations
== NULL
)
1154 tree
*slot
= local_specializations
->get (tmpl
);
1155 return slot
? *slot
: NULL_TREE
;
1158 /* Returns nonzero iff DECL is a specialization of TMPL. */
1161 is_specialization_of (tree decl
, tree tmpl
)
1165 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1169 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1175 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1177 for (t
= TREE_TYPE (decl
);
1179 t
= CLASSTYPE_USE_TEMPLATE (t
)
1180 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1181 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1188 /* Returns nonzero iff DECL is a specialization of friend declaration
1189 FRIEND_DECL according to [temp.friend]. */
1192 is_specialization_of_friend (tree decl
, tree friend_decl
)
1194 bool need_template
= true;
1197 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1198 || TREE_CODE (decl
) == TYPE_DECL
);
1200 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1201 of a template class, we want to check if DECL is a specialization
1203 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1204 && DECL_TEMPLATE_INFO (friend_decl
)
1205 && !DECL_USE_TEMPLATE (friend_decl
))
1207 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1208 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1209 need_template
= false;
1211 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1212 && !PRIMARY_TEMPLATE_P (friend_decl
))
1213 need_template
= false;
1215 /* There is nothing to do if this is not a template friend. */
1216 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1219 if (is_specialization_of (decl
, friend_decl
))
1223 A member of a class template may be declared to be a friend of a
1224 non-template class. In this case, the corresponding member of
1225 every specialization of the class template is a friend of the
1226 class granting friendship.
1228 For example, given a template friend declaration
1230 template <class T> friend void A<T>::f();
1232 the member function below is considered a friend
1234 template <> struct A<int> {
1238 For this type of template friend, TEMPLATE_DEPTH below will be
1239 nonzero. To determine if DECL is a friend of FRIEND, we first
1240 check if the enclosing class is a specialization of another. */
1242 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1244 && DECL_CLASS_SCOPE_P (decl
)
1245 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1246 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1248 /* Next, we check the members themselves. In order to handle
1249 a few tricky cases, such as when FRIEND_DECL's are
1251 template <class T> friend void A<T>::g(T t);
1252 template <class T> template <T t> friend void A<T>::h();
1256 void A<int>::g(int);
1257 template <int> void A<int>::h();
1259 we need to figure out ARGS, the template arguments from
1260 the context of DECL. This is required for template substitution
1261 of `T' in the function parameter of `g' and template parameter
1262 of `h' in the above examples. Here ARGS corresponds to `int'. */
1264 tree context
= DECL_CONTEXT (decl
);
1265 tree args
= NULL_TREE
;
1266 int current_depth
= 0;
1268 while (current_depth
< template_depth
)
1270 if (CLASSTYPE_TEMPLATE_INFO (context
))
1272 if (current_depth
== 0)
1273 args
= TYPE_TI_ARGS (context
);
1275 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1278 context
= TYPE_CONTEXT (context
);
1281 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1286 tree friend_args_type
;
1287 tree decl_args_type
;
1289 /* Make sure that both DECL and FRIEND_DECL are templates or
1291 is_template
= DECL_TEMPLATE_INFO (decl
)
1292 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1293 if (need_template
^ is_template
)
1295 else if (is_template
)
1297 /* If both are templates, check template parameter list. */
1299 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1301 if (!comp_template_parms
1302 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1306 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1309 decl_type
= TREE_TYPE (decl
);
1311 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1312 tf_none
, NULL_TREE
);
1313 if (friend_type
== error_mark_node
)
1316 /* Check if return types match. */
1317 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1320 /* Check if function parameter types match, ignoring the
1321 `this' parameter. */
1322 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1323 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1324 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1325 friend_args_type
= TREE_CHAIN (friend_args_type
);
1326 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1327 decl_args_type
= TREE_CHAIN (decl_args_type
);
1329 return compparms (decl_args_type
, friend_args_type
);
1333 /* DECL is a TYPE_DECL */
1335 tree decl_type
= TREE_TYPE (decl
);
1337 /* Make sure that both DECL and FRIEND_DECL are templates or
1340 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1341 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1343 if (need_template
^ is_template
)
1345 else if (is_template
)
1348 /* If both are templates, check the name of the two
1349 TEMPLATE_DECL's first because is_friend didn't. */
1350 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1351 != DECL_NAME (friend_decl
))
1354 /* Now check template parameter list. */
1356 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1358 return comp_template_parms
1359 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1363 return (DECL_NAME (decl
)
1364 == DECL_NAME (friend_decl
));
1370 /* Register the specialization SPEC as a specialization of TMPL with
1371 the indicated ARGS. IS_FRIEND indicates whether the specialization
1372 is actually just a friend declaration. Returns SPEC, or an
1373 equivalent prior declaration, if available.
1375 We also store instantiations of field packs in the hash table, even
1376 though they are not themselves templates, to make lookup easier. */
1379 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1383 spec_entry
**slot
= NULL
;
1386 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1387 || (TREE_CODE (tmpl
) == FIELD_DECL
1388 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1390 if (TREE_CODE (spec
) == FUNCTION_DECL
1391 && uses_template_parms (DECL_TI_ARGS (spec
)))
1392 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1393 register it; we want the corresponding TEMPLATE_DECL instead.
1394 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1395 the more obvious `uses_template_parms (spec)' to avoid problems
1396 with default function arguments. In particular, given
1397 something like this:
1399 template <class T> void f(T t1, T t = T())
1401 the default argument expression is not substituted for in an
1402 instantiation unless and until it is actually needed. */
1405 if (optimize_specialization_lookup_p (tmpl
))
1406 /* We don't put these specializations in the hash table, but we might
1407 want to give an error about a mismatch. */
1408 fn
= retrieve_specialization (tmpl
, args
, 0);
1416 hash
= spec_hasher::hash (&elt
);
1419 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1421 fn
= ((spec_entry
*) *slot
)->spec
;
1426 /* We can sometimes try to re-register a specialization that we've
1427 already got. In particular, regenerate_decl_from_template calls
1428 duplicate_decls which will update the specialization list. But,
1429 we'll still get called again here anyhow. It's more convenient
1430 to simply allow this than to try to prevent it. */
1433 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1435 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1437 if (DECL_ODR_USED (fn
)
1438 || DECL_EXPLICIT_INSTANTIATION (fn
))
1440 error ("specialization of %qD after instantiation",
1442 return error_mark_node
;
1447 /* This situation should occur only if the first
1448 specialization is an implicit instantiation, the
1449 second is an explicit specialization, and the
1450 implicit instantiation has not yet been used. That
1451 situation can occur if we have implicitly
1452 instantiated a member function and then specialized
1455 We can also wind up here if a friend declaration that
1456 looked like an instantiation turns out to be a
1459 template <class T> void foo(T);
1460 class S { friend void foo<>(int) };
1461 template <> void foo(int);
1463 We transform the existing DECL in place so that any
1464 pointers to it become pointers to the updated
1467 If there was a definition for the template, but not
1468 for the specialization, we want this to look as if
1469 there were no definition, and vice versa. */
1470 DECL_INITIAL (fn
) = NULL_TREE
;
1471 duplicate_decls (spec
, fn
, is_friend
);
1472 /* The call to duplicate_decls will have applied
1475 An explicit specialization of a function template
1476 is inline only if it is explicitly declared to be,
1477 and independently of whether its function template
1480 to the primary function; now copy the inline bits to
1481 the various clones. */
1482 FOR_EACH_CLONE (clone
, fn
)
1484 DECL_DECLARED_INLINE_P (clone
)
1485 = DECL_DECLARED_INLINE_P (fn
);
1486 DECL_SOURCE_LOCATION (clone
)
1487 = DECL_SOURCE_LOCATION (fn
);
1488 DECL_DELETED_FN (clone
)
1489 = DECL_DELETED_FN (fn
);
1491 check_specialization_namespace (tmpl
);
1496 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1498 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1499 /* Dup decl failed, but this is a new definition. Set the
1500 line number so any errors match this new
1502 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1508 return duplicate_decls (spec
, fn
, is_friend
);
1510 /* A specialization must be declared in the same namespace as the
1511 template it is specializing. */
1512 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1513 && !check_specialization_namespace (tmpl
))
1514 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1516 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1518 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1519 gcc_assert (tmpl
&& args
&& spec
);
1522 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1523 && PRIMARY_TEMPLATE_P (tmpl
)
1524 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1525 || variable_template_p (tmpl
))
1526 /* If TMPL is a forward declaration of a template function, keep a list
1527 of all specializations in case we need to reassign them to a friend
1528 template later in tsubst_friend_function.
1530 Also keep a list of all variable template instantiations so that
1531 process_partial_specialization can check whether a later partial
1532 specialization would have used it. */
1533 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1534 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1540 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1541 TMPL and ARGS members, ignores SPEC. */
1543 int comparing_specializations
;
1546 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1550 ++comparing_specializations
;
1551 equal
= (e1
->tmpl
== e2
->tmpl
1552 && comp_template_args (e1
->args
, e2
->args
));
1553 --comparing_specializations
;
1558 /* Returns a hash for a template TMPL and template arguments ARGS. */
1561 hash_tmpl_and_args (tree tmpl
, tree args
)
1563 hashval_t val
= DECL_UID (tmpl
);
1564 return iterative_hash_template_arg (args
, val
);
1567 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1571 spec_hasher::hash (spec_entry
*e
)
1573 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1576 /* Recursively calculate a hash value for a template argument ARG, for use
1577 in the hash tables of template specializations. */
1580 iterative_hash_template_arg (tree arg
, hashval_t val
)
1582 unsigned HOST_WIDE_INT i
;
1583 enum tree_code code
;
1586 if (arg
== NULL_TREE
)
1587 return iterative_hash_object (arg
, val
);
1592 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1593 /* We can get one of these when re-hashing a previous entry in the middle
1594 of substituting into a pack expansion. Just look through it. */
1595 arg
= ARGUMENT_PACK_SELECT_FROM_PACK (arg
);
1597 code
= TREE_CODE (arg
);
1598 tclass
= TREE_CODE_CLASS (code
);
1600 val
= iterative_hash_object (code
, val
);
1607 case IDENTIFIER_NODE
:
1608 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1612 int i
, len
= TREE_VEC_LENGTH (arg
);
1613 for (i
= 0; i
< len
; ++i
)
1614 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1618 case TYPE_PACK_EXPANSION
:
1619 case EXPR_PACK_EXPANSION
:
1620 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1621 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1623 case TYPE_ARGUMENT_PACK
:
1624 case NONTYPE_ARGUMENT_PACK
:
1625 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1628 for (; arg
; arg
= TREE_CHAIN (arg
))
1629 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1633 for (; arg
; arg
= OVL_NEXT (arg
))
1634 val
= iterative_hash_template_arg (OVL_CURRENT (arg
), val
);
1640 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1641 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1643 val
= iterative_hash_template_arg (field
, val
);
1644 val
= iterative_hash_template_arg (value
, val
);
1650 if (!DECL_ARTIFICIAL (arg
))
1652 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1653 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1655 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1658 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1661 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1662 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1664 case TEMPLATE_PARM_INDEX
:
1665 val
= iterative_hash_template_arg
1666 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1667 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1668 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1671 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1672 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1673 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1676 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1678 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1682 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1683 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1684 val
= iterative_hash_object (code
, val
);
1685 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1688 /* A lambda can't appear in a template arg, but don't crash on
1690 gcc_assert (seen_error ());
1694 case IMPLICIT_CONV_EXPR
:
1695 case STATIC_CAST_EXPR
:
1696 case REINTERPRET_CAST_EXPR
:
1697 case CONST_CAST_EXPR
:
1698 case DYNAMIC_CAST_EXPR
:
1700 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1701 /* Now hash operands as usual. */
1711 if (alias_template_specialization_p (arg
))
1713 // We want an alias specialization that survived strip_typedefs
1714 // to hash differently from its TYPE_CANONICAL, to avoid hash
1715 // collisions that compare as different in template_args_equal.
1716 // These could be dependent specializations that strip_typedefs
1717 // left alone, or untouched specializations because
1718 // coerce_template_parms returns the unconverted template
1719 // arguments if it sees incomplete argument packs.
1720 tree ti
= TYPE_TEMPLATE_INFO (arg
);
1721 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1723 if (TYPE_CANONICAL (arg
))
1724 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1726 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1727 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1728 /* Otherwise just compare the types during lookup. */
1731 case tcc_declaration
:
1733 return iterative_hash_expr (arg
, val
);
1736 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1738 unsigned n
= cp_tree_operand_length (arg
);
1739 for (i
= 0; i
< n
; ++i
)
1740 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1748 /* Unregister the specialization SPEC as a specialization of TMPL.
1749 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1750 if the SPEC was listed as a specialization of TMPL.
1752 Note that SPEC has been ggc_freed, so we can't look inside it. */
1755 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1760 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1761 elt
.args
= TI_ARGS (tinfo
);
1762 elt
.spec
= NULL_TREE
;
1764 entry
= decl_specializations
->find (&elt
);
1767 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1768 gcc_assert (new_spec
!= NULL_TREE
);
1769 entry
->spec
= new_spec
;
1776 /* Like register_specialization, but for local declarations. We are
1777 registering SPEC, an instantiation of TMPL. */
1780 register_local_specialization (tree spec
, tree tmpl
)
1782 local_specializations
->put (tmpl
, spec
);
1785 /* TYPE is a class type. Returns true if TYPE is an explicitly
1786 specialized class. */
1789 explicit_class_specialization_p (tree type
)
1791 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1793 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1796 /* Print the list of functions at FNS, going through all the overloads
1797 for each element of the list. Alternatively, FNS can not be a
1798 TREE_LIST, in which case it will be printed together with all the
1801 MORE and *STR should respectively be FALSE and NULL when the function
1802 is called from the outside. They are used internally on recursive
1803 calls. print_candidates manages the two parameters and leaves NULL
1804 in *STR when it ends. */
1807 print_candidates_1 (tree fns
, bool more
, const char **str
)
1810 char *spaces
= NULL
;
1812 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
1813 if (TREE_CODE (fn
) == TREE_LIST
)
1815 for (fn2
= fn
; fn2
!= NULL_TREE
; fn2
= TREE_CHAIN (fn2
))
1816 print_candidates_1 (TREE_VALUE (fn2
),
1817 TREE_CHAIN (fn2
) || more
, str
);
1821 tree cand
= OVL_CURRENT (fn
);
1824 /* Pick the prefix string. */
1825 if (!more
&& !OVL_NEXT (fns
))
1827 inform (DECL_SOURCE_LOCATION (cand
),
1828 "candidate is: %#D", cand
);
1832 *str
= _("candidates are:");
1833 spaces
= get_spaces (*str
);
1835 inform (DECL_SOURCE_LOCATION (cand
), "%s %#D", *str
, cand
);
1836 *str
= spaces
? spaces
: *str
;
1846 /* Print the list of candidate FNS in an error message. FNS can also
1847 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1850 print_candidates (tree fns
)
1852 const char *str
= NULL
;
1853 print_candidates_1 (fns
, false, &str
);
1854 gcc_assert (str
== NULL
);
1857 /* Returns the template (one of the functions given by TEMPLATE_ID)
1858 which can be specialized to match the indicated DECL with the
1859 explicit template args given in TEMPLATE_ID. The DECL may be
1860 NULL_TREE if none is available. In that case, the functions in
1861 TEMPLATE_ID are non-members.
1863 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1864 specialization of a member template.
1866 The TEMPLATE_COUNT is the number of references to qualifying
1867 template classes that appeared in the name of the function. See
1868 check_explicit_specialization for a more accurate description.
1870 TSK indicates what kind of template declaration (if any) is being
1871 declared. TSK_TEMPLATE indicates that the declaration given by
1872 DECL, though a FUNCTION_DECL, has template parameters, and is
1873 therefore a template function.
1875 The template args (those explicitly specified and those deduced)
1876 are output in a newly created vector *TARGS_OUT.
1878 If it is impossible to determine the result, an error message is
1879 issued. The error_mark_node is returned to indicate failure. */
1882 determine_specialization (tree template_id
,
1885 int need_member_template
,
1891 tree explicit_targs
;
1892 tree candidates
= NULL_TREE
;
1893 /* A TREE_LIST of templates of which DECL may be a specialization.
1894 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1895 corresponding TREE_PURPOSE is the set of template arguments that,
1896 when used to instantiate the template, would produce a function
1897 with the signature of DECL. */
1898 tree templates
= NULL_TREE
;
1900 cp_binding_level
*b
;
1902 *targs_out
= NULL_TREE
;
1904 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
1905 return error_mark_node
;
1907 /* We shouldn't be specializing a member template of an
1908 unspecialized class template; we already gave an error in
1909 check_specialization_scope, now avoid crashing. */
1910 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
1911 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
1913 gcc_assert (errorcount
);
1914 return error_mark_node
;
1917 fns
= TREE_OPERAND (template_id
, 0);
1918 explicit_targs
= TREE_OPERAND (template_id
, 1);
1920 if (fns
== error_mark_node
)
1921 return error_mark_node
;
1923 /* Check for baselinks. */
1924 if (BASELINK_P (fns
))
1925 fns
= BASELINK_FUNCTIONS (fns
);
1927 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
1929 error ("%qD is not a function template", fns
);
1930 return error_mark_node
;
1932 else if (VAR_P (decl
) && !variable_template_p (fns
))
1934 error ("%qD is not a variable template", fns
);
1935 return error_mark_node
;
1938 /* Count the number of template headers specified for this
1941 for (b
= current_binding_level
;
1942 b
->kind
== sk_template_parms
;
1946 if (variable_template_p (fns
))
1948 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
1949 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
1950 tf_warning_or_error
,
1951 /*req_all*/true, /*use_defarg*/true);
1952 templates
= tree_cons (targs
, fns
, templates
);
1954 else for (; fns
; fns
= OVL_NEXT (fns
))
1956 tree fn
= OVL_CURRENT (fns
);
1958 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1960 tree decl_arg_types
;
1964 /* In case of explicit specialization, we need to check if
1965 the number of template headers appearing in the specialization
1966 is correct. This is usually done in check_explicit_specialization,
1967 but the check done there cannot be exhaustive when specializing
1968 member functions. Consider the following code:
1970 template <> void A<int>::f(int);
1971 template <> template <> void A<int>::f(int);
1973 Assuming that A<int> is not itself an explicit specialization
1974 already, the first line specializes "f" which is a non-template
1975 member function, whilst the second line specializes "f" which
1976 is a template member function. So both lines are syntactically
1977 correct, and check_explicit_specialization does not reject
1980 Here, we can do better, as we are matching the specialization
1981 against the declarations. We count the number of template
1982 headers, and we check if they match TEMPLATE_COUNT + 1
1983 (TEMPLATE_COUNT is the number of qualifying template classes,
1984 plus there must be another header for the member template
1987 Notice that if header_count is zero, this is not a
1988 specialization but rather a template instantiation, so there
1989 is no check we can perform here. */
1990 if (header_count
&& header_count
!= template_count
+ 1)
1993 /* Check that the number of template arguments at the
1994 innermost level for DECL is the same as for FN. */
1995 if (current_binding_level
->kind
== sk_template_parms
1996 && !current_binding_level
->explicit_spec_p
1997 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
1998 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1999 (current_template_parms
))))
2002 /* DECL might be a specialization of FN. */
2003 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2004 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2006 /* For a non-static member function, we need to make sure
2007 that the const qualification is the same. Since
2008 get_bindings does not try to merge the "this" parameter,
2009 we must do the comparison explicitly. */
2010 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2011 && !same_type_p (TREE_VALUE (fn_arg_types
),
2012 TREE_VALUE (decl_arg_types
)))
2015 /* Skip the "this" parameter and, for constructors of
2016 classes with virtual bases, the VTT parameter. A
2017 full specialization of a constructor will have a VTT
2018 parameter, but a template never will. */
2020 = skip_artificial_parms_for (decl
, decl_arg_types
);
2022 = skip_artificial_parms_for (fn
, fn_arg_types
);
2024 /* Function templates cannot be specializations; there are
2025 no partial specializations of functions. Therefore, if
2026 the type of DECL does not match FN, there is no
2028 if (tsk
== tsk_template
)
2030 if (compparms (fn_arg_types
, decl_arg_types
))
2031 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2035 /* See whether this function might be a specialization of this
2036 template. Suppress access control because we might be trying
2037 to make this specialization a friend, and we have already done
2038 access control for the declaration of the specialization. */
2039 push_deferring_access_checks (dk_no_check
);
2040 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2041 pop_deferring_access_checks ();
2044 /* We cannot deduce template arguments that when used to
2045 specialize TMPL will produce DECL. */
2048 /* Make sure that the deduced arguments actually work. */
2049 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
);
2050 if (insttype
== error_mark_node
)
2053 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2054 if (!compparms (fn_arg_types
, decl_arg_types
))
2057 /* Save this template, and the arguments deduced. */
2058 templates
= tree_cons (targs
, fn
, templates
);
2060 else if (need_member_template
)
2061 /* FN is an ordinary member function, and we need a
2062 specialization of a member template. */
2064 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2065 /* We can get IDENTIFIER_NODEs here in certain erroneous
2068 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2069 /* This is just an ordinary non-member function. Nothing can
2070 be a specialization of that. */
2072 else if (DECL_ARTIFICIAL (fn
))
2073 /* Cannot specialize functions that are created implicitly. */
2077 tree decl_arg_types
;
2079 /* This is an ordinary member function. However, since
2080 we're here, we can assume its enclosing class is a
2081 template class. For example,
2083 template <typename T> struct S { void f(); };
2084 template <> void S<int>::f() {}
2086 Here, S<int>::f is a non-template, but S<int> is a
2087 template class. If FN has the same type as DECL, we
2088 might be in business. */
2090 if (!DECL_TEMPLATE_INFO (fn
))
2091 /* Its enclosing class is an explicit specialization
2092 of a template class. This is not a candidate. */
2095 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2096 TREE_TYPE (TREE_TYPE (fn
))))
2097 /* The return types differ. */
2100 /* Adjust the type of DECL in case FN is a static member. */
2101 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2102 if (DECL_STATIC_FUNCTION_P (fn
)
2103 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2104 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2106 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2109 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2113 if (templates
&& TREE_CHAIN (templates
))
2119 It is possible for a specialization with a given function
2120 signature to be instantiated from more than one function
2121 template. In such cases, explicit specification of the
2122 template arguments must be used to uniquely identify the
2123 function template specialization being specialized.
2125 Note that here, there's no suggestion that we're supposed to
2126 determine which of the candidate templates is most
2127 specialized. However, we, also have:
2131 Partial ordering of overloaded function template
2132 declarations is used in the following contexts to select
2133 the function template to which a function template
2134 specialization refers:
2136 -- when an explicit specialization refers to a function
2139 So, we do use the partial ordering rules, at least for now.
2140 This extension can only serve to make invalid programs valid,
2141 so it's safe. And, there is strong anecdotal evidence that
2142 the committee intended the partial ordering rules to apply;
2143 the EDG front end has that behavior, and John Spicer claims
2144 that the committee simply forgot to delete the wording in
2145 [temp.expl.spec]. */
2146 tree tmpl
= most_specialized_instantiation (templates
);
2147 if (tmpl
!= error_mark_node
)
2150 TREE_CHAIN (templates
) = NULL_TREE
;
2154 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2156 error ("template-id %qD for %q+D does not match any template "
2157 "declaration", template_id
, decl
);
2158 if (header_count
&& header_count
!= template_count
+ 1)
2159 inform (input_location
, "saw %d %<template<>%>, need %d for "
2160 "specializing a member function template",
2161 header_count
, template_count
+ 1);
2162 return error_mark_node
;
2164 else if ((templates
&& TREE_CHAIN (templates
))
2165 || (candidates
&& TREE_CHAIN (candidates
))
2166 || (templates
&& candidates
))
2168 error ("ambiguous template specialization %qD for %q+D",
2170 candidates
= chainon (candidates
, templates
);
2171 print_candidates (candidates
);
2172 return error_mark_node
;
2175 /* We have one, and exactly one, match. */
2178 tree fn
= TREE_VALUE (candidates
);
2179 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2180 /* DECL is a re-declaration or partial instantiation of a template
2182 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2184 /* It was a specialization of an ordinary member function in a
2186 return DECL_TI_TEMPLATE (fn
);
2189 /* It was a specialization of a template. */
2190 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2191 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2193 *targs_out
= copy_node (targs
);
2194 SET_TMPL_ARGS_LEVEL (*targs_out
,
2195 TMPL_ARGS_DEPTH (*targs_out
),
2196 TREE_PURPOSE (templates
));
2199 *targs_out
= TREE_PURPOSE (templates
);
2200 return TREE_VALUE (templates
);
2203 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2204 but with the default argument values filled in from those in the
2208 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2211 tree new_spec_types
;
2216 if (spec_types
== void_list_node
)
2217 return void_list_node
;
2219 /* Substitute into the rest of the list. */
2221 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2222 TREE_CHAIN (tmpl_types
));
2224 /* Add the default argument for this parameter. */
2225 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2226 TREE_VALUE (spec_types
),
2230 /* DECL is an explicit specialization. Replicate default arguments
2231 from the template it specializes. (That way, code like:
2233 template <class T> void f(T = 3);
2234 template <> void f(double);
2237 works, as required.) An alternative approach would be to look up
2238 the correct default arguments at the call-site, but this approach
2239 is consistent with how implicit instantiations are handled. */
2242 copy_default_args_to_explicit_spec (tree decl
)
2247 tree new_spec_types
;
2251 tree object_type
= NULL_TREE
;
2252 tree in_charge
= NULL_TREE
;
2253 tree vtt
= NULL_TREE
;
2255 /* See if there's anything we need to do. */
2256 tmpl
= DECL_TI_TEMPLATE (decl
);
2257 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2258 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2259 if (TREE_PURPOSE (t
))
2264 old_type
= TREE_TYPE (decl
);
2265 spec_types
= TYPE_ARG_TYPES (old_type
);
2267 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2269 /* Remove the this pointer, but remember the object's type for
2271 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2272 spec_types
= TREE_CHAIN (spec_types
);
2273 tmpl_types
= TREE_CHAIN (tmpl_types
);
2275 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2277 /* DECL may contain more parameters than TMPL due to the extra
2278 in-charge parameter in constructors and destructors. */
2279 in_charge
= spec_types
;
2280 spec_types
= TREE_CHAIN (spec_types
);
2282 if (DECL_HAS_VTT_PARM_P (decl
))
2285 spec_types
= TREE_CHAIN (spec_types
);
2289 /* Compute the merged default arguments. */
2291 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2293 /* Compute the new FUNCTION_TYPE. */
2297 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2302 /* Put the in-charge parameter back. */
2303 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2304 TREE_VALUE (in_charge
),
2307 new_type
= build_method_type_directly (object_type
,
2308 TREE_TYPE (old_type
),
2312 new_type
= build_function_type (TREE_TYPE (old_type
),
2314 new_type
= cp_build_type_attribute_variant (new_type
,
2315 TYPE_ATTRIBUTES (old_type
));
2316 new_type
= build_exception_variant (new_type
,
2317 TYPE_RAISES_EXCEPTIONS (old_type
));
2319 if (TYPE_HAS_LATE_RETURN_TYPE (old_type
))
2320 TYPE_HAS_LATE_RETURN_TYPE (new_type
) = 1;
2322 TREE_TYPE (decl
) = new_type
;
2325 /* Return the number of template headers we expect to see for a definition
2326 or specialization of CTYPE or one of its non-template members. */
2329 num_template_headers_for_class (tree ctype
)
2331 int num_templates
= 0;
2333 while (ctype
&& CLASS_TYPE_P (ctype
))
2335 /* You're supposed to have one `template <...>' for every
2336 template class, but you don't need one for a full
2337 specialization. For example:
2339 template <class T> struct S{};
2340 template <> struct S<int> { void f(); };
2341 void S<int>::f () {}
2343 is correct; there shouldn't be a `template <>' for the
2344 definition of `S<int>::f'. */
2345 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2346 /* If CTYPE does not have template information of any
2347 kind, then it is not a template, nor is it nested
2348 within a template. */
2350 if (explicit_class_specialization_p (ctype
))
2352 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2355 ctype
= TYPE_CONTEXT (ctype
);
2358 return num_templates
;
2361 /* Do a simple sanity check on the template headers that precede the
2362 variable declaration DECL. */
2365 check_template_variable (tree decl
)
2367 tree ctx
= CP_DECL_CONTEXT (decl
);
2368 int wanted
= num_template_headers_for_class (ctx
);
2369 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2370 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2372 if (cxx_dialect
< cxx14
)
2373 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2374 "variable templates only available with "
2375 "-std=c++14 or -std=gnu++14");
2377 // Namespace-scope variable templates should have a template header.
2380 if (template_header_count
> wanted
)
2382 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2383 "too many template headers for %D (should be %d)",
2385 if (warned
&& CLASS_TYPE_P (ctx
)
2386 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2387 inform (DECL_SOURCE_LOCATION (decl
),
2388 "members of an explicitly specialized class are defined "
2389 "without a template header");
2393 /* Check to see if the function just declared, as indicated in
2394 DECLARATOR, and in DECL, is a specialization of a function
2395 template. We may also discover that the declaration is an explicit
2396 instantiation at this point.
2398 Returns DECL, or an equivalent declaration that should be used
2399 instead if all goes well. Issues an error message if something is
2400 amiss. Returns error_mark_node if the error is not easily
2403 FLAGS is a bitmask consisting of the following flags:
2405 2: The function has a definition.
2406 4: The function is a friend.
2408 The TEMPLATE_COUNT is the number of references to qualifying
2409 template classes that appeared in the name of the function. For
2412 template <class T> struct S { void f(); };
2415 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2416 classes are not counted in the TEMPLATE_COUNT, so that in
2418 template <class T> struct S {};
2419 template <> struct S<int> { void f(); }
2420 template <> void S<int>::f();
2422 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2423 invalid; there should be no template <>.)
2425 If the function is a specialization, it is marked as such via
2426 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2427 is set up correctly, and it is added to the list of specializations
2428 for that template. */
2431 check_explicit_specialization (tree declarator
,
2436 int have_def
= flags
& 2;
2437 int is_friend
= flags
& 4;
2438 int specialization
= 0;
2439 int explicit_instantiation
= 0;
2440 int member_specialization
= 0;
2441 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2442 tree dname
= DECL_NAME (decl
);
2447 if (!processing_specialization
)
2450 tsk
= tsk_excessive_parms
;
2453 tsk
= current_tmpl_spec_kind (template_count
);
2458 if (processing_specialization
&& !VAR_P (decl
))
2461 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2463 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2466 /* This could be something like:
2468 template <class T> void f(T);
2469 class S { friend void f<>(int); } */
2473 /* This case handles bogus declarations like template <>
2474 template <class T> void f<int>(); */
2476 error ("template-id %qD in declaration of primary template",
2483 case tsk_invalid_member_spec
:
2484 /* The error has already been reported in
2485 check_specialization_scope. */
2486 return error_mark_node
;
2488 case tsk_invalid_expl_inst
:
2489 error ("template parameter list used in explicit instantiation");
2495 error ("definition provided for explicit instantiation");
2497 explicit_instantiation
= 1;
2500 case tsk_excessive_parms
:
2501 case tsk_insufficient_parms
:
2502 if (tsk
== tsk_excessive_parms
)
2503 error ("too many template parameter lists in declaration of %qD",
2505 else if (template_header_count
)
2506 error("too few template parameter lists in declaration of %qD", decl
);
2508 error("explicit specialization of %qD must be introduced by "
2509 "%<template <>%>", decl
);
2513 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2514 /* In cases like template<> constexpr bool v = true;
2515 We'll give an error in check_template_variable. */
2518 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2520 member_specialization
= 1;
2526 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2528 /* This case handles bogus declarations like template <>
2529 template <class T> void f<int>(); */
2531 if (!uses_template_parms (declarator
))
2532 error ("template-id %qD in declaration of primary template",
2534 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2536 /* Partial specialization of variable template. */
2537 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2541 else if (cxx_dialect
< cxx14
)
2542 error ("non-type partial specialization %qD "
2543 "is not allowed", declarator
);
2545 error ("non-class, non-variable partial specialization %qD "
2546 "is not allowed", declarator
);
2551 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2552 /* This is a specialization of a member template, without
2553 specialization the containing class. Something like:
2555 template <class T> struct S {
2556 template <class U> void f (U);
2558 template <> template <class U> void S<int>::f(U) {}
2560 That's a specialization -- but of the entire template. */
2568 if ((specialization
|| member_specialization
)
2569 /* This doesn't apply to variable templates. */
2570 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2571 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
2573 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2574 for (; t
; t
= TREE_CHAIN (t
))
2575 if (TREE_PURPOSE (t
))
2577 permerror (input_location
,
2578 "default argument specified in explicit specialization");
2583 if (specialization
|| member_specialization
|| explicit_instantiation
)
2585 tree tmpl
= NULL_TREE
;
2586 tree targs
= NULL_TREE
;
2587 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2589 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2590 if (!was_template_id
)
2594 gcc_assert (identifier_p (declarator
));
2599 /* If there is no class context, the explicit instantiation
2600 must be at namespace scope. */
2601 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2603 /* Find the namespace binding, using the declaration
2605 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2607 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2609 error ("%qD is not a template function", dname
);
2610 fns
= error_mark_node
;
2614 tree fn
= OVL_CURRENT (fns
);
2615 if (!is_associated_namespace (CP_DECL_CONTEXT (decl
),
2616 CP_DECL_CONTEXT (fn
)))
2617 error ("%qD is not declared in %qD",
2618 decl
, current_namespace
);
2622 declarator
= lookup_template_function (fns
, NULL_TREE
);
2625 if (declarator
== error_mark_node
)
2626 return error_mark_node
;
2628 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2630 if (!explicit_instantiation
)
2631 /* A specialization in class scope. This is invalid,
2632 but the error will already have been flagged by
2633 check_specialization_scope. */
2634 return error_mark_node
;
2637 /* It's not valid to write an explicit instantiation in
2640 class C { template void f(); }
2642 This case is caught by the parser. However, on
2645 template class C { void f(); };
2647 (which is invalid) we can get here. The error will be
2654 else if (ctype
!= NULL_TREE
2655 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2657 // We'll match variable templates in start_decl.
2661 /* Find the list of functions in ctype that have the same
2662 name as the declared function. */
2663 tree name
= TREE_OPERAND (declarator
, 0);
2664 tree fns
= NULL_TREE
;
2667 if (constructor_name_p (name
, ctype
))
2669 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2671 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2672 : !CLASSTYPE_DESTRUCTORS (ctype
))
2674 /* From [temp.expl.spec]:
2676 If such an explicit specialization for the member
2677 of a class template names an implicitly-declared
2678 special member function (clause _special_), the
2679 program is ill-formed.
2681 Similar language is found in [temp.explicit]. */
2682 error ("specialization of implicitly-declared special member function");
2683 return error_mark_node
;
2686 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2689 if (!DECL_CONV_FN_P (decl
))
2691 idx
= lookup_fnfields_1 (ctype
, name
);
2693 fns
= (*CLASSTYPE_METHOD_VEC (ctype
))[idx
];
2697 vec
<tree
, va_gc
> *methods
;
2700 /* For a type-conversion operator, we cannot do a
2701 name-based lookup. We might be looking for `operator
2702 int' which will be a specialization of `operator T'.
2703 So, we find *all* the conversion operators, and then
2704 select from them. */
2707 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2709 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2710 methods
->iterate (idx
, &ovl
);
2713 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2714 /* There are no more conversion functions. */
2717 /* Glue all these conversion functions together
2718 with those we already have. */
2719 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2720 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2724 if (fns
== NULL_TREE
)
2726 error ("no member function %qD declared in %qT", name
, ctype
);
2727 return error_mark_node
;
2730 TREE_OPERAND (declarator
, 0) = fns
;
2733 /* Figure out what exactly is being specialized at this point.
2734 Note that for an explicit instantiation, even one for a
2735 member function, we cannot tell apriori whether the
2736 instantiation is for a member template, or just a member
2737 function of a template class. Even if a member template is
2738 being instantiated, the member template arguments may be
2739 elided if they can be deduced from the rest of the
2741 tmpl
= determine_specialization (declarator
, decl
,
2743 member_specialization
,
2747 if (!tmpl
|| tmpl
== error_mark_node
)
2748 /* We couldn't figure out what this declaration was
2750 return error_mark_node
;
2753 tree gen_tmpl
= most_general_template (tmpl
);
2755 if (explicit_instantiation
)
2757 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2758 is done by do_decl_instantiation later. */
2760 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2761 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2763 if (arg_depth
> parm_depth
)
2765 /* If TMPL is not the most general template (for
2766 example, if TMPL is a friend template that is
2767 injected into namespace scope), then there will
2768 be too many levels of TARGS. Remove some of them
2773 new_targs
= make_tree_vec (parm_depth
);
2774 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2775 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2776 = TREE_VEC_ELT (targs
, i
);
2780 return instantiate_template (tmpl
, targs
, tf_error
);
2783 /* If we thought that the DECL was a member function, but it
2784 turns out to be specializing a static member function,
2785 make DECL a static member function as well. */
2786 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
2787 && DECL_STATIC_FUNCTION_P (tmpl
)
2788 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2789 revert_static_member_fn (decl
);
2791 /* If this is a specialization of a member template of a
2792 template class, we want to return the TEMPLATE_DECL, not
2793 the specialization of it. */
2794 if (tsk
== tsk_template
&& !was_template_id
)
2796 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
2797 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2798 DECL_INITIAL (result
) = NULL_TREE
;
2802 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2803 DECL_SOURCE_LOCATION (result
)
2804 = DECL_SOURCE_LOCATION (decl
);
2805 /* We want to use the argument list specified in the
2806 definition, not in the original declaration. */
2807 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
2808 for (parm
= DECL_ARGUMENTS (result
); parm
;
2809 parm
= DECL_CHAIN (parm
))
2810 DECL_CONTEXT (parm
) = result
;
2812 return register_specialization (tmpl
, gen_tmpl
, targs
,
2816 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2817 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
2819 if (was_template_id
)
2820 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
)) = true;
2822 /* Inherit default function arguments from the template
2823 DECL is specializing. */
2824 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
2825 copy_default_args_to_explicit_spec (decl
);
2827 /* This specialization has the same protection as the
2828 template it specializes. */
2829 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
2830 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
2832 /* 7.1.1-1 [dcl.stc]
2834 A storage-class-specifier shall not be specified in an
2835 explicit specialization...
2837 The parser rejects these, so unless action is taken here,
2838 explicit function specializations will always appear with
2841 The action recommended by the C++ CWG in response to C++
2842 defect report 605 is to make the storage class and linkage
2843 of the explicit specialization match the templated function:
2845 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2847 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
2849 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
2850 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
2852 /* This specialization has the same linkage and visibility as
2853 the function template it specializes. */
2854 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
2855 if (! TREE_PUBLIC (decl
))
2857 DECL_INTERFACE_KNOWN (decl
) = 1;
2858 DECL_NOT_REALLY_EXTERN (decl
) = 1;
2860 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
2861 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
2863 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
2864 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
2868 /* If DECL is a friend declaration, declared using an
2869 unqualified name, the namespace associated with DECL may
2870 have been set incorrectly. For example, in:
2872 template <typename T> void f(T);
2874 struct S { friend void f<int>(int); }
2877 we will have set the DECL_CONTEXT for the friend
2878 declaration to N, rather than to the global namespace. */
2879 if (DECL_NAMESPACE_SCOPE_P (decl
))
2880 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
2882 if (is_friend
&& !have_def
)
2883 /* This is not really a declaration of a specialization.
2884 It's just the name of an instantiation. But, it's not
2885 a request for an instantiation, either. */
2886 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
2887 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2888 /* A specialization is not necessarily COMDAT. */
2889 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
2890 && DECL_DECLARED_INLINE_P (decl
));
2891 else if (VAR_P (decl
))
2892 DECL_COMDAT (decl
) = false;
2894 /* Register this specialization so that we can find it
2896 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
, 0);
2898 /* A 'structor should already have clones. */
2899 gcc_assert (decl
== error_mark_node
2900 || variable_template_p (tmpl
)
2901 || !(DECL_CONSTRUCTOR_P (decl
)
2902 || DECL_DESTRUCTOR_P (decl
))
2903 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
2910 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2911 parameters. These are represented in the same format used for
2912 DECL_TEMPLATE_PARMS. */
2915 comp_template_parms (const_tree parms1
, const_tree parms2
)
2920 if (parms1
== parms2
)
2923 for (p1
= parms1
, p2
= parms2
;
2924 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2925 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2927 tree t1
= TREE_VALUE (p1
);
2928 tree t2
= TREE_VALUE (p2
);
2931 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2932 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2934 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2937 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2939 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2940 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2942 /* If either of the template parameters are invalid, assume
2943 they match for the sake of error recovery. */
2944 if (error_operand_p (parm1
) || error_operand_p (parm2
))
2947 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2950 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2951 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2952 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2954 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2959 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2960 /* One set of parameters has more parameters lists than the
2967 /* Determine whether PARM is a parameter pack. */
2970 template_parameter_pack_p (const_tree parm
)
2972 /* Determine if we have a non-type template parameter pack. */
2973 if (TREE_CODE (parm
) == PARM_DECL
)
2974 return (DECL_TEMPLATE_PARM_P (parm
)
2975 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2976 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
2977 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
2979 /* If this is a list of template parameters, we could get a
2980 TYPE_DECL or a TEMPLATE_DECL. */
2981 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2982 parm
= TREE_TYPE (parm
);
2984 /* Otherwise it must be a type template parameter. */
2985 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2986 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2987 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2990 /* Determine if T is a function parameter pack. */
2993 function_parameter_pack_p (const_tree t
)
2995 if (t
&& TREE_CODE (t
) == PARM_DECL
)
2996 return DECL_PACK_P (t
);
3000 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3001 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3004 get_function_template_decl (const_tree primary_func_tmpl_inst
)
3006 if (! primary_func_tmpl_inst
3007 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
3008 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
3011 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
3014 /* Return true iff the function parameter PARAM_DECL was expanded
3015 from the function parameter pack PACK. */
3018 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
3020 if (DECL_ARTIFICIAL (param_decl
)
3021 || !function_parameter_pack_p (pack
))
3024 /* The parameter pack and its pack arguments have the same
3026 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
3029 /* Determine whether ARGS describes a variadic template args list,
3030 i.e., one that is terminated by a template argument pack. */
3033 template_args_variadic_p (tree args
)
3038 if (args
== NULL_TREE
)
3041 args
= INNERMOST_TEMPLATE_ARGS (args
);
3042 nargs
= TREE_VEC_LENGTH (args
);
3047 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
3049 return ARGUMENT_PACK_P (last_parm
);
3052 /* Generate a new name for the parameter pack name NAME (an
3053 IDENTIFIER_NODE) that incorporates its */
3056 make_ith_pack_parameter_name (tree name
, int i
)
3058 /* Munge the name to include the parameter index. */
3059 #define NUMBUF_LEN 128
3060 char numbuf
[NUMBUF_LEN
];
3064 if (name
== NULL_TREE
)
3066 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
3067 newname_len
= IDENTIFIER_LENGTH (name
)
3068 + strlen (numbuf
) + 2;
3069 newname
= (char*)alloca (newname_len
);
3070 snprintf (newname
, newname_len
,
3071 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3072 return get_identifier (newname
);
3075 /* Return true if T is a primary function, class or alias template
3079 primary_template_instantiation_p (const_tree t
)
3084 if (TREE_CODE (t
) == FUNCTION_DECL
)
3085 return DECL_LANG_SPECIFIC (t
)
3086 && DECL_TEMPLATE_INSTANTIATION (t
)
3087 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
3088 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3089 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
3090 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
3091 else if (alias_template_specialization_p (t
))
3096 /* Return true if PARM is a template template parameter. */
3099 template_template_parameter_p (const_tree parm
)
3101 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3104 /* Return true iff PARM is a DECL representing a type template
3108 template_type_parameter_p (const_tree parm
)
3111 && (TREE_CODE (parm
) == TYPE_DECL
3112 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3113 && DECL_TEMPLATE_PARM_P (parm
));
3116 /* Return the template parameters of T if T is a
3117 primary template instantiation, NULL otherwise. */
3120 get_primary_template_innermost_parameters (const_tree t
)
3122 tree parms
= NULL
, template_info
= NULL
;
3124 if ((template_info
= get_template_info (t
))
3125 && primary_template_instantiation_p (t
))
3126 parms
= INNERMOST_TEMPLATE_PARMS
3127 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3132 /* Return the template parameters of the LEVELth level from the full list
3133 of template parameters PARMS. */
3136 get_template_parms_at_level (tree parms
, int level
)
3140 || TREE_CODE (parms
) != TREE_LIST
3141 || level
> TMPL_PARMS_DEPTH (parms
))
3144 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3145 if (TMPL_PARMS_DEPTH (p
) == level
)
3151 /* Returns the template arguments of T if T is a template instantiation,
3155 get_template_innermost_arguments (const_tree t
)
3157 tree args
= NULL
, template_info
= NULL
;
3159 if ((template_info
= get_template_info (t
))
3160 && TI_ARGS (template_info
))
3161 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3166 /* Return the argument pack elements of T if T is a template argument pack,
3170 get_template_argument_pack_elems (const_tree t
)
3172 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3173 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3176 return ARGUMENT_PACK_ARGS (t
);
3179 /* Structure used to track the progress of find_parameter_packs_r. */
3180 struct find_parameter_pack_data
3182 /* TREE_LIST that will contain all of the parameter packs found by
3184 tree
* parameter_packs
;
3186 /* Set of AST nodes that have been visited by the traversal. */
3187 hash_set
<tree
> *visited
;
3190 /* Identifies all of the argument packs that occur in a template
3191 argument and appends them to the TREE_LIST inside DATA, which is a
3192 find_parameter_pack_data structure. This is a subroutine of
3193 make_pack_expansion and uses_parameter_packs. */
3195 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3198 struct find_parameter_pack_data
* ppd
=
3199 (struct find_parameter_pack_data
*)data
;
3200 bool parameter_pack_p
= false;
3202 /* Handle type aliases/typedefs. */
3203 if (TYPE_ALIAS_P (t
))
3205 if (TYPE_TEMPLATE_INFO (t
))
3206 cp_walk_tree (&TYPE_TI_ARGS (t
),
3207 &find_parameter_packs_r
,
3213 /* Identify whether this is a parameter pack or not. */
3214 switch (TREE_CODE (t
))
3216 case TEMPLATE_PARM_INDEX
:
3217 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3218 parameter_pack_p
= true;
3221 case TEMPLATE_TYPE_PARM
:
3222 t
= TYPE_MAIN_VARIANT (t
);
3223 case TEMPLATE_TEMPLATE_PARM
:
3224 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3225 parameter_pack_p
= true;
3230 if (DECL_PACK_P (t
))
3232 /* We don't want to walk into the type of a PARM_DECL,
3233 because we don't want to see the type parameter pack. */
3235 parameter_pack_p
= true;
3239 /* Look through a lambda capture proxy to the field pack. */
3241 if (DECL_HAS_VALUE_EXPR_P (t
))
3243 tree v
= DECL_VALUE_EXPR (t
);
3245 &find_parameter_packs_r
,
3252 parameter_pack_p
= true;
3255 /* Not a parameter pack. */
3259 if (parameter_pack_p
)
3261 /* Add this parameter pack to the list. */
3262 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3266 cp_walk_tree (&TYPE_CONTEXT (t
),
3267 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3269 /* This switch statement will return immediately if we don't find a
3271 switch (TREE_CODE (t
))
3273 case TEMPLATE_PARM_INDEX
:
3276 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3277 /* Check the template itself. */
3278 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3279 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3280 /* Check the template arguments. */
3281 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3286 case TEMPLATE_TYPE_PARM
:
3287 case TEMPLATE_TEMPLATE_PARM
:
3294 if (TYPE_PTRMEMFUNC_P (t
))
3300 if (TYPE_TEMPLATE_INFO (t
))
3301 cp_walk_tree (&TYPE_TI_ARGS (t
),
3302 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3309 cp_walk_tree (&TREE_TYPE (t
),
3310 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3314 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3319 case TYPE_PACK_EXPANSION
:
3320 case EXPR_PACK_EXPANSION
:
3325 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3330 case IDENTIFIER_NODE
:
3331 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3343 /* Determines if the expression or type T uses any parameter packs. */
3345 uses_parameter_packs (tree t
)
3347 tree parameter_packs
= NULL_TREE
;
3348 struct find_parameter_pack_data ppd
;
3349 ppd
.parameter_packs
= ¶meter_packs
;
3350 ppd
.visited
= new hash_set
<tree
>;
3351 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3353 return parameter_packs
!= NULL_TREE
;
3356 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3357 representation a base-class initializer into a parameter pack
3358 expansion. If all goes well, the resulting node will be an
3359 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3362 make_pack_expansion (tree arg
)
3365 tree parameter_packs
= NULL_TREE
;
3366 bool for_types
= false;
3367 struct find_parameter_pack_data ppd
;
3369 if (!arg
|| arg
== error_mark_node
)
3372 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
3374 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3375 class initializer. In this case, the TREE_PURPOSE will be a
3376 _TYPE node (representing the base class expansion we're
3377 initializing) and the TREE_VALUE will be a TREE_LIST
3378 containing the initialization arguments.
3380 The resulting expansion looks somewhat different from most
3381 expansions. Rather than returning just one _EXPANSION, we
3382 return a TREE_LIST whose TREE_PURPOSE is a
3383 TYPE_PACK_EXPANSION containing the bases that will be
3384 initialized. The TREE_VALUE will be identical to the
3385 original TREE_VALUE, which is a list of arguments that will
3386 be passed to each base. We do not introduce any new pack
3387 expansion nodes into the TREE_VALUE (although it is possible
3388 that some already exist), because the TREE_PURPOSE and
3389 TREE_VALUE all need to be expanded together with the same
3390 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3391 resulting TREE_PURPOSE will mention the parameter packs in
3392 both the bases and the arguments to the bases. */
3395 tree parameter_packs
= NULL_TREE
;
3397 /* Determine which parameter packs will be used by the base
3399 ppd
.visited
= new hash_set
<tree
>;
3400 ppd
.parameter_packs
= ¶meter_packs
;
3401 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3404 if (parameter_packs
== NULL_TREE
)
3406 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3408 return error_mark_node
;
3411 if (TREE_VALUE (arg
) != void_type_node
)
3413 /* Collect the sets of parameter packs used in each of the
3414 initialization arguments. */
3415 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3417 /* Determine which parameter packs will be expanded in this
3419 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3426 /* Create the pack expansion type for the base type. */
3427 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3428 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3429 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3431 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3432 they will rarely be compared to anything. */
3433 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3435 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3438 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3441 /* Build the PACK_EXPANSION_* node. */
3443 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3444 : make_node (EXPR_PACK_EXPANSION
);
3445 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3446 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3448 /* Propagate type and const-expression information. */
3449 TREE_TYPE (result
) = TREE_TYPE (arg
);
3450 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3453 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3454 they will rarely be compared to anything. */
3455 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3457 /* Determine which parameter packs will be expanded. */
3458 ppd
.parameter_packs
= ¶meter_packs
;
3459 ppd
.visited
= new hash_set
<tree
>;
3460 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3463 /* Make sure we found some parameter packs. */
3464 if (parameter_packs
== NULL_TREE
)
3467 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3469 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3470 return error_mark_node
;
3472 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3474 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3479 /* Checks T for any "bare" parameter packs, which have not yet been
3480 expanded, and issues an error if any are found. This operation can
3481 only be done on full expressions or types (e.g., an expression
3482 statement, "if" condition, etc.), because we could have expressions like:
3484 foo(f(g(h(args)))...)
3486 where "args" is a parameter pack. check_for_bare_parameter_packs
3487 should not be called for the subexpressions args, h(args),
3488 g(h(args)), or f(g(h(args))), because we would produce erroneous
3491 Returns TRUE and emits an error if there were bare parameter packs,
3492 returns FALSE otherwise. */
3494 check_for_bare_parameter_packs (tree t
)
3496 tree parameter_packs
= NULL_TREE
;
3497 struct find_parameter_pack_data ppd
;
3499 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3502 if (TREE_CODE (t
) == TYPE_DECL
)
3505 ppd
.parameter_packs
= ¶meter_packs
;
3506 ppd
.visited
= new hash_set
<tree
>;
3507 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3510 if (parameter_packs
)
3512 error ("parameter packs not expanded with %<...%>:");
3513 while (parameter_packs
)
3515 tree pack
= TREE_VALUE (parameter_packs
);
3516 tree name
= NULL_TREE
;
3518 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3519 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3520 name
= TYPE_NAME (pack
);
3521 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3522 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3524 name
= DECL_NAME (pack
);
3527 inform (input_location
, " %qD", name
);
3529 inform (input_location
, " <anonymous>");
3531 parameter_packs
= TREE_CHAIN (parameter_packs
);
3540 /* Expand any parameter packs that occur in the template arguments in
3543 expand_template_argument_pack (tree args
)
3545 tree result_args
= NULL_TREE
;
3546 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3547 int num_result_args
= -1;
3548 int non_default_args_count
= -1;
3550 /* First, determine if we need to expand anything, and the number of
3551 slots we'll need. */
3552 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3554 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3555 if (arg
== NULL_TREE
)
3557 if (ARGUMENT_PACK_P (arg
))
3559 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3560 if (num_result_args
< 0)
3561 num_result_args
= in_arg
+ num_packed
;
3563 num_result_args
+= num_packed
;
3567 if (num_result_args
>= 0)
3572 /* If no expansion is necessary, we're done. */
3573 if (num_result_args
< 0)
3576 /* Expand arguments. */
3577 result_args
= make_tree_vec (num_result_args
);
3578 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3579 non_default_args_count
=
3580 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3581 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3583 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3584 if (ARGUMENT_PACK_P (arg
))
3586 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3587 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3588 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3589 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3590 if (non_default_args_count
> 0)
3591 non_default_args_count
+= num_packed
- 1;
3595 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3599 if (non_default_args_count
>= 0)
3600 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3604 /* Checks if DECL shadows a template parameter.
3606 [temp.local]: A template-parameter shall not be redeclared within its
3607 scope (including nested scopes).
3609 Emits an error and returns TRUE if the DECL shadows a parameter,
3610 returns FALSE otherwise. */
3613 check_template_shadow (tree decl
)
3617 /* If we're not in a template, we can't possibly shadow a template
3619 if (!current_template_parms
)
3622 /* Figure out what we're shadowing. */
3623 if (TREE_CODE (decl
) == OVERLOAD
)
3624 decl
= OVL_CURRENT (decl
);
3625 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3627 /* If there's no previous binding for this name, we're not shadowing
3628 anything, let alone a template parameter. */
3632 /* If we're not shadowing a template parameter, we're done. Note
3633 that OLDDECL might be an OVERLOAD (or perhaps even an
3634 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3636 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3639 /* We check for decl != olddecl to avoid bogus errors for using a
3640 name inside a class. We check TPFI to avoid duplicate errors for
3641 inline member templates. */
3643 || (DECL_TEMPLATE_PARM_P (decl
)
3644 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
3647 /* Don't complain about the injected class name, as we've already
3648 complained about the class itself. */
3649 if (DECL_SELF_REFERENCE_P (decl
))
3652 error ("declaration of %q+#D", decl
);
3653 error (" shadows template parm %q+#D", olddecl
);
3657 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3658 ORIG_LEVEL, DECL, and TYPE. */
3661 build_template_parm_index (int index
,
3667 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3668 TEMPLATE_PARM_IDX (t
) = index
;
3669 TEMPLATE_PARM_LEVEL (t
) = level
;
3670 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3671 TEMPLATE_PARM_DECL (t
) = decl
;
3672 TREE_TYPE (t
) = type
;
3673 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3674 TREE_READONLY (t
) = TREE_READONLY (decl
);
3679 /* Find the canonical type parameter for the given template type
3680 parameter. Returns the canonical type parameter, which may be TYPE
3681 if no such parameter existed. */
3684 canonical_type_parameter (tree type
)
3687 int idx
= TEMPLATE_TYPE_IDX (type
);
3688 if (!canonical_template_parms
)
3689 vec_alloc (canonical_template_parms
, idx
+1);
3691 while (canonical_template_parms
->length () <= (unsigned)idx
)
3692 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3694 list
= (*canonical_template_parms
)[idx
];
3695 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3696 list
= TREE_CHAIN (list
);
3699 return TREE_VALUE (list
);
3702 (*canonical_template_parms
)[idx
]
3703 = tree_cons (NULL_TREE
, type
,
3704 (*canonical_template_parms
)[idx
]);
3709 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3710 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3711 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3712 new one is created. */
3715 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3716 tsubst_flags_t complain
)
3718 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3719 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3720 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3721 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3723 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3726 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3727 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3728 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3729 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3730 DECL_ARTIFICIAL (decl
) = 1;
3731 SET_DECL_TEMPLATE_PARM_P (decl
);
3733 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3734 TEMPLATE_PARM_LEVEL (index
) - levels
,
3735 TEMPLATE_PARM_ORIG_LEVEL (index
),
3737 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3738 TEMPLATE_PARM_PARAMETER_PACK (t
)
3739 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3741 /* Template template parameters need this. */
3742 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3743 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3744 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
)),
3748 return TEMPLATE_PARM_DESCENDANTS (index
);
3751 /* Process information from new template parameter PARM and append it
3752 to the LIST being built. This new parameter is a non-type
3753 parameter iff IS_NON_TYPE is true. This new parameter is a
3754 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3758 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
3759 bool is_non_type
, bool is_parameter_pack
)
3765 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
3766 defval
= TREE_PURPOSE (parm
);
3770 tree p
= tree_last (list
);
3772 if (p
&& TREE_VALUE (p
) != error_mark_node
)
3775 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
3776 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
3778 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
3786 parm
= TREE_VALUE (parm
);
3788 SET_DECL_TEMPLATE_PARM_P (parm
);
3790 if (TREE_TYPE (parm
) != error_mark_node
)
3794 The top-level cv-qualifiers on the template-parameter are
3795 ignored when determining its type. */
3796 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
3797 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
3798 TREE_TYPE (parm
) = error_mark_node
;
3799 else if (uses_parameter_packs (TREE_TYPE (parm
))
3800 && !is_parameter_pack
3801 /* If we're in a nested template parameter list, the template
3802 template parameter could be a parameter pack. */
3803 && processing_template_parmlist
== 1)
3805 /* This template parameter is not a parameter pack, but it
3806 should be. Complain about "bare" parameter packs. */
3807 check_for_bare_parameter_packs (TREE_TYPE (parm
));
3809 /* Recover by calling this a parameter pack. */
3810 is_parameter_pack
= true;
3814 /* A template parameter is not modifiable. */
3815 TREE_CONSTANT (parm
) = 1;
3816 TREE_READONLY (parm
) = 1;
3817 decl
= build_decl (parm_loc
,
3818 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
3819 TREE_CONSTANT (decl
) = 1;
3820 TREE_READONLY (decl
) = 1;
3821 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
3822 = build_template_parm_index (idx
, processing_template_decl
,
3823 processing_template_decl
,
3824 decl
, TREE_TYPE (parm
));
3826 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
3827 = is_parameter_pack
;
3832 parm
= TREE_VALUE (TREE_VALUE (parm
));
3834 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
3836 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
3837 /* This is for distinguishing between real templates and template
3838 template parameters */
3839 TREE_TYPE (parm
) = t
;
3840 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
3845 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
3846 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3847 decl
= build_decl (parm_loc
,
3848 TYPE_DECL
, parm
, t
);
3851 TYPE_NAME (t
) = decl
;
3852 TYPE_STUB_DECL (t
) = decl
;
3854 TEMPLATE_TYPE_PARM_INDEX (t
)
3855 = build_template_parm_index (idx
, processing_template_decl
,
3856 processing_template_decl
,
3857 decl
, TREE_TYPE (parm
));
3858 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
3859 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
3861 DECL_ARTIFICIAL (decl
) = 1;
3862 SET_DECL_TEMPLATE_PARM_P (decl
);
3864 parm
= build_tree_list (defval
, parm
);
3865 return chainon (list
, parm
);
3868 /* The end of a template parameter list has been reached. Process the
3869 tree list into a parameter vector, converting each parameter into a more
3870 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3874 end_template_parm_list (tree parms
)
3878 tree saved_parmlist
= make_tree_vec (list_length (parms
));
3880 current_template_parms
3881 = tree_cons (size_int (processing_template_decl
),
3882 saved_parmlist
, current_template_parms
);
3884 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3886 next
= TREE_CHAIN (parm
);
3887 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3888 TREE_CHAIN (parm
) = NULL_TREE
;
3891 --processing_template_parmlist
;
3893 return saved_parmlist
;
3896 /* end_template_decl is called after a template declaration is seen. */
3899 end_template_decl (void)
3901 reset_specialization ();
3903 if (! processing_template_decl
)
3906 /* This matches the pushlevel in begin_template_parm_list. */
3909 --processing_template_decl
;
3910 current_template_parms
= TREE_CHAIN (current_template_parms
);
3913 /* Takes a TREE_LIST representing a template parameter and convert it
3914 into an argument suitable to be passed to the type substitution
3915 functions. Note that If the TREE_LIST contains an error_mark
3916 node, the returned argument is error_mark_node. */
3919 template_parm_to_arg (tree t
)
3923 || TREE_CODE (t
) != TREE_LIST
)
3926 if (error_operand_p (TREE_VALUE (t
)))
3927 return error_mark_node
;
3931 if (TREE_CODE (t
) == TYPE_DECL
3932 || TREE_CODE (t
) == TEMPLATE_DECL
)
3936 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3938 /* Turn this argument into a TYPE_ARGUMENT_PACK
3939 with a single element, which expands T. */
3940 tree vec
= make_tree_vec (1);
3941 #ifdef ENABLE_CHECKING
3942 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3943 (vec
, TREE_VEC_LENGTH (vec
));
3945 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3947 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
3948 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3953 t
= DECL_INITIAL (t
);
3955 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3957 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3958 with a single element, which expands T. */
3959 tree vec
= make_tree_vec (1);
3960 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3961 #ifdef ENABLE_CHECKING
3962 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3963 (vec
, TREE_VEC_LENGTH (vec
));
3965 t
= convert_from_reference (t
);
3966 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3968 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3969 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3970 TREE_TYPE (t
) = type
;
3973 t
= convert_from_reference (t
);
3978 /* Given a set of template parameters, return them as a set of template
3979 arguments. The template parameters are represented as a TREE_VEC, in
3980 the form documented in cp-tree.h for template arguments. */
3983 template_parms_to_args (tree parms
)
3986 tree args
= NULL_TREE
;
3987 int length
= TMPL_PARMS_DEPTH (parms
);
3990 /* If there is only one level of template parameters, we do not
3991 create a TREE_VEC of TREE_VECs. Instead, we return a single
3992 TREE_VEC containing the arguments. */
3994 args
= make_tree_vec (length
);
3996 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
3998 tree a
= copy_node (TREE_VALUE (header
));
4001 TREE_TYPE (a
) = NULL_TREE
;
4002 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
4003 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
4005 #ifdef ENABLE_CHECKING
4006 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
4010 TREE_VEC_ELT (args
, --l
) = a
;
4015 if (length
> 1 && TREE_VEC_ELT (args
, 0) == NULL_TREE
)
4016 /* This can happen for template parms of a template template
4019 template<template<class T, class U> class TT> struct S;
4021 Consider the level of the parms of TT; T and U both have
4022 level 2; TT has no template parm of level 1. So in this case
4023 the first element of full_template_args is NULL_TREE. If we
4024 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
4025 of 2. This will make tsubst wrongly consider that T and U
4026 have level 1. Instead, let's create a dummy vector as the
4027 first element of full_template_args so that TMPL_ARGS_DEPTH
4028 returns the correct depth for args. */
4029 TREE_VEC_ELT (args
, 0) = make_tree_vec (1);
4033 /* Within the declaration of a template, return the currently active
4034 template parameters as an argument TREE_VEC. */
4037 current_template_args (void)
4039 return template_parms_to_args (current_template_parms
);
4042 /* Update the declared TYPE by doing any lookups which were thought to be
4043 dependent, but are not now that we know the SCOPE of the declarator. */
4046 maybe_update_decl_type (tree orig_type
, tree scope
)
4048 tree type
= orig_type
;
4050 if (type
== NULL_TREE
)
4053 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4054 type
= TREE_TYPE (type
);
4056 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4057 && dependent_type_p (type
)
4058 /* Don't bother building up the args in this case. */
4059 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4061 /* tsubst in the args corresponding to the template parameters,
4062 including auto if present. Most things will be unchanged, but
4063 make_typename_type and tsubst_qualified_id will resolve
4064 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4065 tree args
= current_template_args ();
4066 tree auto_node
= type_uses_auto (type
);
4070 tree auto_vec
= make_tree_vec (1);
4071 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4072 args
= add_to_template_args (args
, auto_vec
);
4074 pushed
= push_scope (scope
);
4075 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4080 if (type
== error_mark_node
)
4083 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4085 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4088 type
= TYPE_NAME (type
);
4093 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4094 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
4095 a member template. Used by push_template_decl below. */
4098 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4100 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4101 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4102 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4103 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4104 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4109 struct template_parm_data
4111 /* The level of the template parameters we are currently
4115 /* The index of the specialization argument we are currently
4119 /* An array whose size is the number of template parameters. The
4120 elements are nonzero if the parameter has been used in any one
4121 of the arguments processed so far. */
4124 /* An array whose size is the number of template arguments. The
4125 elements are nonzero if the argument makes use of template
4126 parameters of this level. */
4127 int* arg_uses_template_parms
;
4130 /* Subroutine of push_template_decl used to see if each template
4131 parameter in a partial specialization is used in the explicit
4132 argument list. If T is of the LEVEL given in DATA (which is
4133 treated as a template_parm_data*), then DATA->PARMS is marked
4137 mark_template_parm (tree t
, void* data
)
4141 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4143 template_parm_level_and_index (t
, &level
, &idx
);
4145 if (level
== tpd
->level
)
4147 tpd
->parms
[idx
] = 1;
4148 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4151 /* Return zero so that for_each_template_parm will continue the
4152 traversal of the tree; we want to mark *every* template parm. */
4156 /* Process the partial specialization DECL. */
4159 process_partial_specialization (tree decl
)
4161 tree type
= TREE_TYPE (decl
);
4162 tree tinfo
= get_template_info (decl
);
4163 tree maintmpl
= TI_TEMPLATE (tinfo
);
4164 tree specargs
= TI_ARGS (tinfo
);
4165 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4166 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4169 int nargs
= TREE_VEC_LENGTH (inner_args
);
4172 bool did_error_intro
= false;
4173 struct template_parm_data tpd
;
4174 struct template_parm_data tpd2
;
4176 gcc_assert (current_template_parms
);
4178 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4179 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4181 /* We check that each of the template parameters given in the
4182 partial specialization is used in the argument list to the
4183 specialization. For example:
4185 template <class T> struct S;
4186 template <class T> struct S<T*>;
4188 The second declaration is OK because `T*' uses the template
4189 parameter T, whereas
4191 template <class T> struct S<int>;
4193 is no good. Even trickier is:
4204 The S2<T> declaration is actually invalid; it is a
4205 full-specialization. Of course,
4208 struct S2<T (*)(U)>;
4210 or some such would have been OK. */
4211 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4212 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4213 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4215 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4216 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4217 for (i
= 0; i
< nargs
; ++i
)
4219 tpd
.current_arg
= i
;
4220 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4221 &mark_template_parm
,
4224 /*include_nondeduced_p=*/false);
4226 for (i
= 0; i
< ntparms
; ++i
)
4227 if (tpd
.parms
[i
] == 0)
4229 /* One of the template parms was not used in a deduced context in the
4231 if (!did_error_intro
)
4233 error ("template parameters not deducible in "
4234 "partial specialization:");
4235 did_error_intro
= true;
4238 inform (input_location
, " %qD",
4239 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4242 if (did_error_intro
)
4243 return error_mark_node
;
4245 /* [temp.class.spec]
4247 The argument list of the specialization shall not be identical to
4248 the implicit argument list of the primary template. */
4250 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4251 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
)))
4252 error ("partial specialization %qD does not specialize "
4253 "any template arguments", decl
);
4255 /* A partial specialization that replaces multiple parameters of the
4256 primary template with a pack expansion is less specialized for those
4258 if (nargs
< DECL_NTPARMS (maintmpl
))
4260 error ("partial specialization is not more specialized than the "
4261 "primary template because it replaces multiple parameters "
4262 "with a pack expansion");
4263 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4267 /* [temp.class.spec]
4269 A partially specialized non-type argument expression shall not
4270 involve template parameters of the partial specialization except
4271 when the argument expression is a simple identifier.
4273 The type of a template parameter corresponding to a specialized
4274 non-type argument shall not be dependent on a parameter of the
4277 Also, we verify that pack expansions only occur at the
4278 end of the argument list. */
4279 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4281 for (i
= 0; i
< nargs
; ++i
)
4283 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4284 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4285 tree packed_args
= NULL_TREE
;
4288 if (ARGUMENT_PACK_P (arg
))
4290 /* Extract the arguments from the argument pack. We'll be
4291 iterating over these in the following loop. */
4292 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4293 len
= TREE_VEC_LENGTH (packed_args
);
4296 for (j
= 0; j
< len
; j
++)
4299 /* Get the Jth argument in the parameter pack. */
4300 arg
= TREE_VEC_ELT (packed_args
, j
);
4302 if (PACK_EXPANSION_P (arg
))
4304 /* Pack expansions must come at the end of the
4306 if ((packed_args
&& j
< len
- 1)
4307 || (!packed_args
&& i
< nargs
- 1))
4309 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4310 error ("parameter pack argument %qE must be at the "
4311 "end of the template argument list", arg
);
4313 error ("parameter pack argument %qT must be at the "
4314 "end of the template argument list", arg
);
4318 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4319 /* We only care about the pattern. */
4320 arg
= PACK_EXPANSION_PATTERN (arg
);
4322 if (/* These first two lines are the `non-type' bit. */
4324 && TREE_CODE (arg
) != TEMPLATE_DECL
4325 /* This next two lines are the `argument expression is not just a
4326 simple identifier' condition and also the `specialized
4327 non-type argument' bit. */
4328 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4329 && !(REFERENCE_REF_P (arg
)
4330 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4332 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4333 || (packed_args
&& uses_template_parms (arg
)))
4334 error ("template argument %qE involves template parameter(s)",
4338 /* Look at the corresponding template parameter,
4339 marking which template parameters its type depends
4341 tree type
= TREE_TYPE (parm
);
4345 /* We haven't yet initialized TPD2. Do so now. */
4346 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4347 /* The number of parameters here is the number in the
4348 main template, which, as checked in the assertion
4350 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4352 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4355 /* Mark the template parameters. But this time, we're
4356 looking for the template parameters of the main
4357 template, not in the specialization. */
4358 tpd2
.current_arg
= i
;
4359 tpd2
.arg_uses_template_parms
[i
] = 0;
4360 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4361 for_each_template_parm (type
,
4362 &mark_template_parm
,
4365 /*include_nondeduced_p=*/false);
4367 if (tpd2
.arg_uses_template_parms
[i
])
4369 /* The type depended on some template parameters.
4370 If they are fully specialized in the
4371 specialization, that's OK. */
4374 for (j
= 0; j
< nargs
; ++j
)
4375 if (tpd2
.parms
[j
] != 0
4376 && tpd
.arg_uses_template_parms
[j
])
4379 error_n (input_location
, count
,
4380 "type %qT of template argument %qE depends "
4381 "on a template parameter",
4382 "type %qT of template argument %qE depends "
4383 "on template parameters",
4392 /* We should only get here once. */
4393 if (TREE_CODE (decl
) == TYPE_DECL
)
4394 gcc_assert (!COMPLETE_TYPE_P (type
));
4396 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4397 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4398 TREE_TYPE (tmpl
) = type
;
4399 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4400 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4401 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4402 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4404 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4405 = tree_cons (specargs
, tmpl
,
4406 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4407 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4409 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4410 inst
= TREE_CHAIN (inst
))
4412 tree instance
= TREE_VALUE (inst
);
4413 if (TYPE_P (instance
)
4414 ? (COMPLETE_TYPE_P (instance
)
4415 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
4416 : DECL_TEMPLATE_INSTANTIATION (instance
))
4418 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
4419 if (spec
&& TREE_VALUE (spec
) == tmpl
)
4421 tree inst_decl
= (DECL_P (instance
)
4422 ? instance
: TYPE_NAME (instance
));
4423 permerror (input_location
,
4424 "partial specialization of %qD after instantiation "
4425 "of %qD", decl
, inst_decl
);
4433 /* PARM is a template parameter of some form; return the corresponding
4434 TEMPLATE_PARM_INDEX. */
4437 get_template_parm_index (tree parm
)
4439 if (TREE_CODE (parm
) == PARM_DECL
4440 || TREE_CODE (parm
) == CONST_DECL
)
4441 parm
= DECL_INITIAL (parm
);
4442 else if (TREE_CODE (parm
) == TYPE_DECL
4443 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4444 parm
= TREE_TYPE (parm
);
4445 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4446 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
4447 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4448 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4449 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4453 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4454 parameter packs used by the template parameter PARM. */
4457 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4459 /* A type parm can't refer to another parm. */
4460 if (TREE_CODE (parm
) == TYPE_DECL
)
4462 else if (TREE_CODE (parm
) == PARM_DECL
)
4464 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4469 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4471 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4472 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4473 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4476 /* PARM is a template parameter pack. Return any parameter packs used in
4477 its type or the type of any of its template parameters. If there are
4478 any such packs, it will be instantiated into a fixed template parameter
4479 list by partial instantiation rather than be fully deduced. */
4482 fixed_parameter_pack_p (tree parm
)
4484 /* This can only be true in a member template. */
4485 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4487 /* This can only be true for a parameter pack. */
4488 if (!template_parameter_pack_p (parm
))
4490 /* A type parm can't refer to another parm. */
4491 if (TREE_CODE (parm
) == TYPE_DECL
)
4494 tree parameter_packs
= NULL_TREE
;
4495 struct find_parameter_pack_data ppd
;
4496 ppd
.parameter_packs
= ¶meter_packs
;
4497 ppd
.visited
= new hash_set
<tree
>;
4499 fixed_parameter_pack_p_1 (parm
, &ppd
);
4502 return parameter_packs
;
4505 /* Check that a template declaration's use of default arguments and
4506 parameter packs is not invalid. Here, PARMS are the template
4507 parameters. IS_PRIMARY is true if DECL is the thing declared by
4508 a primary template. IS_PARTIAL is true if DECL is a partial
4511 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4512 declaration (but not a definition); 1 indicates a declaration, 2
4513 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4514 emitted for extraneous default arguments.
4516 Returns TRUE if there were no errors found, FALSE otherwise. */
4519 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4520 bool is_partial
, int is_friend_decl
)
4523 int last_level_to_check
;
4525 bool no_errors
= true;
4529 A default template-argument shall not be specified in a
4530 function template declaration or a function template definition, nor
4531 in the template-parameter-list of the definition of a member of a
4534 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
4535 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
4536 /* You can't have a function template declaration in a local
4537 scope, nor you can you define a member of a class template in a
4541 if ((TREE_CODE (decl
) == TYPE_DECL
4543 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4544 || (TREE_CODE (decl
) == FUNCTION_DECL
4545 && LAMBDA_FUNCTION_P (decl
)))
4546 /* A lambda doesn't have an explicit declaration; don't complain
4547 about the parms of the enclosing class. */
4550 if (current_class_type
4551 && !TYPE_BEING_DEFINED (current_class_type
)
4552 && DECL_LANG_SPECIFIC (decl
)
4553 && DECL_DECLARES_FUNCTION_P (decl
)
4554 /* If this is either a friend defined in the scope of the class
4555 or a member function. */
4556 && (DECL_FUNCTION_MEMBER_P (decl
)
4557 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4558 : DECL_FRIEND_CONTEXT (decl
)
4559 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4561 /* And, if it was a member function, it really was defined in
4562 the scope of the class. */
4563 && (!DECL_FUNCTION_MEMBER_P (decl
)
4564 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4565 /* We already checked these parameters when the template was
4566 declared, so there's no need to do it again now. This function
4567 was defined in class scope, but we're processing its body now
4568 that the class is complete. */
4571 /* Core issue 226 (C++0x only): the following only applies to class
4574 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4578 If a template-parameter has a default template-argument, all
4579 subsequent template-parameters shall have a default
4580 template-argument supplied. */
4581 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4583 tree inner_parms
= TREE_VALUE (parm_level
);
4584 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4585 int seen_def_arg_p
= 0;
4588 for (i
= 0; i
< ntparms
; ++i
)
4590 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4592 if (parm
== error_mark_node
)
4595 if (TREE_PURPOSE (parm
))
4597 else if (seen_def_arg_p
4598 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4600 error ("no default argument for %qD", TREE_VALUE (parm
));
4601 /* For better subsequent error-recovery, we indicate that
4602 there should have been a default argument. */
4603 TREE_PURPOSE (parm
) = error_mark_node
;
4606 else if (!is_partial
4608 /* Don't complain about an enclosing partial
4610 && parm_level
== parms
4611 && TREE_CODE (decl
) == TYPE_DECL
4613 && template_parameter_pack_p (TREE_VALUE (parm
))
4614 /* A fixed parameter pack will be partially
4615 instantiated into a fixed length list. */
4616 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4618 /* A primary class template can only have one
4619 parameter pack, at the end of the template
4622 error ("parameter pack %q+D must be at the end of the"
4623 " template parameter list", TREE_VALUE (parm
));
4625 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4633 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4637 /* For an ordinary class template, default template arguments are
4638 allowed at the innermost level, e.g.:
4639 template <class T = int>
4641 but, in a partial specialization, they're not allowed even
4642 there, as we have in [temp.class.spec]:
4644 The template parameter list of a specialization shall not
4645 contain default template argument values.
4647 So, for a partial specialization, or for a function template
4648 (in C++98/C++03), we look at all of them. */
4651 /* But, for a primary class template that is not a partial
4652 specialization we look at all template parameters except the
4654 parms
= TREE_CHAIN (parms
);
4656 /* Figure out what error message to issue. */
4657 if (is_friend_decl
== 2)
4658 msg
= G_("default template arguments may not be used in function template "
4659 "friend re-declaration");
4660 else if (is_friend_decl
)
4661 msg
= G_("default template arguments may not be used in function template "
4662 "friend declarations");
4663 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4664 msg
= G_("default template arguments may not be used in function templates "
4665 "without -std=c++11 or -std=gnu++11");
4666 else if (is_partial
)
4667 msg
= G_("default template arguments may not be used in "
4668 "partial specializations");
4670 msg
= G_("default argument for template parameter for class enclosing %qD");
4672 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4673 /* If we're inside a class definition, there's no need to
4674 examine the parameters to the class itself. On the one
4675 hand, they will be checked when the class is defined, and,
4676 on the other, default arguments are valid in things like:
4677 template <class T = double>
4678 struct S { template <class U> void f(U); };
4679 Here the default argument for `S' has no bearing on the
4680 declaration of `f'. */
4681 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4683 /* Check everything. */
4684 last_level_to_check
= 0;
4686 for (parm_level
= parms
;
4687 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4688 parm_level
= TREE_CHAIN (parm_level
))
4690 tree inner_parms
= TREE_VALUE (parm_level
);
4694 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4695 for (i
= 0; i
< ntparms
; ++i
)
4697 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4700 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4705 if (is_friend_decl
== 2)
4712 /* Clear out the default argument so that we are not
4714 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
4718 /* At this point, if we're still interested in issuing messages,
4719 they must apply to classes surrounding the object declared. */
4721 msg
= G_("default argument for template parameter for class "
4728 /* Worker for push_template_decl_real, called via
4729 for_each_template_parm. DATA is really an int, indicating the
4730 level of the parameters we are interested in. If T is a template
4731 parameter of that level, return nonzero. */
4734 template_parm_this_level_p (tree t
, void* data
)
4736 int this_level
= *(int *)data
;
4739 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4740 level
= TEMPLATE_PARM_LEVEL (t
);
4742 level
= TEMPLATE_TYPE_LEVEL (t
);
4743 return level
== this_level
;
4746 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4747 parameters given by current_template_args, or reuses a
4748 previously existing one, if appropriate. Returns the DECL, or an
4749 equivalent one, if it is replaced via a call to duplicate_decls.
4751 If IS_FRIEND is true, DECL is a friend declaration. */
4754 push_template_decl_real (tree decl
, bool is_friend
)
4762 int new_template_p
= 0;
4763 /* True if the template is a member template, in the sense of
4765 bool member_template_p
= false;
4767 if (decl
== error_mark_node
|| !current_template_parms
)
4768 return error_mark_node
;
4770 /* See if this is a partial specialization. */
4771 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
4772 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
4773 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
4775 && DECL_LANG_SPECIFIC (decl
)
4776 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4777 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
4779 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
4783 /* For a friend, we want the context of the friend function, not
4784 the type of which it is a friend. */
4785 ctx
= CP_DECL_CONTEXT (decl
);
4786 else if (CP_DECL_CONTEXT (decl
)
4787 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4788 /* In the case of a virtual function, we want the class in which
4790 ctx
= CP_DECL_CONTEXT (decl
);
4792 /* Otherwise, if we're currently defining some class, the DECL
4793 is assumed to be a member of the class. */
4794 ctx
= current_scope ();
4796 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
4799 if (!DECL_CONTEXT (decl
))
4800 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
4802 /* See if this is a primary template. */
4803 if (is_friend
&& ctx
4804 && uses_template_parms_level (ctx
, processing_template_decl
))
4805 /* A friend template that specifies a class context, i.e.
4806 template <typename T> friend void A<T>::f();
4809 else if (TREE_CODE (decl
) == TYPE_DECL
4810 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4813 is_primary
= template_parm_scope_p ();
4817 if (DECL_CLASS_SCOPE_P (decl
))
4818 member_template_p
= true;
4819 if (TREE_CODE (decl
) == TYPE_DECL
4820 && anon_aggrname_p (DECL_NAME (decl
)))
4822 error ("template class without a name");
4823 return error_mark_node
;
4825 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
4827 if (member_template_p
)
4829 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
4830 error ("member template %qD may not have virt-specifiers", decl
);
4832 if (DECL_DESTRUCTOR_P (decl
))
4836 A destructor shall not be a member template. */
4837 error ("destructor %qD declared as member template", decl
);
4838 return error_mark_node
;
4840 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
4841 && (!prototype_p (TREE_TYPE (decl
))
4842 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
4843 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
4844 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
4845 == void_list_node
)))
4847 /* [basic.stc.dynamic.allocation]
4849 An allocation function can be a function
4850 template. ... Template allocation functions shall
4851 have two or more parameters. */
4852 error ("invalid template declaration of %qD", decl
);
4853 return error_mark_node
;
4856 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4857 && CLASS_TYPE_P (TREE_TYPE (decl
)))
4859 else if (TREE_CODE (decl
) == TYPE_DECL
4860 && TYPE_DECL_ALIAS_P (decl
))
4861 /* alias-declaration */
4862 gcc_assert (!DECL_ARTIFICIAL (decl
));
4863 else if (VAR_P (decl
))
4864 /* C++14 variable template. */;
4867 error ("template declaration of %q#D", decl
);
4868 return error_mark_node
;
4872 /* Check to see that the rules regarding the use of default
4873 arguments are not being violated. */
4874 check_default_tmpl_args (decl
, current_template_parms
,
4875 is_primary
, is_partial
, /*is_friend_decl=*/0);
4877 /* Ensure that there are no parameter packs in the type of this
4878 declaration that have not been expanded. */
4879 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4881 /* Check each of the arguments individually to see if there are
4882 any bare parameter packs. */
4883 tree type
= TREE_TYPE (decl
);
4884 tree arg
= DECL_ARGUMENTS (decl
);
4885 tree argtype
= TYPE_ARG_TYPES (type
);
4887 while (arg
&& argtype
)
4889 if (!DECL_PACK_P (arg
)
4890 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
4892 /* This is a PARM_DECL that contains unexpanded parameter
4893 packs. We have already complained about this in the
4894 check_for_bare_parameter_packs call, so just replace
4895 these types with ERROR_MARK_NODE. */
4896 TREE_TYPE (arg
) = error_mark_node
;
4897 TREE_VALUE (argtype
) = error_mark_node
;
4900 arg
= DECL_CHAIN (arg
);
4901 argtype
= TREE_CHAIN (argtype
);
4904 /* Check for bare parameter packs in the return type and the
4905 exception specifiers. */
4906 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
4907 /* Errors were already issued, set return type to int
4908 as the frontend doesn't expect error_mark_node as
4910 TREE_TYPE (type
) = integer_type_node
;
4911 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
4912 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
4914 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
4915 && TYPE_DECL_ALIAS_P (decl
))
4916 ? DECL_ORIGINAL_TYPE (decl
)
4917 : TREE_TYPE (decl
)))
4919 TREE_TYPE (decl
) = error_mark_node
;
4920 return error_mark_node
;
4924 return process_partial_specialization (decl
);
4926 args
= current_template_args ();
4929 || TREE_CODE (ctx
) == FUNCTION_DECL
4930 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
4931 || (TREE_CODE (decl
) == TYPE_DECL
4932 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4933 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
4935 if (DECL_LANG_SPECIFIC (decl
)
4936 && DECL_TEMPLATE_INFO (decl
)
4937 && DECL_TI_TEMPLATE (decl
))
4938 tmpl
= DECL_TI_TEMPLATE (decl
);
4939 /* If DECL is a TYPE_DECL for a class-template, then there won't
4940 be DECL_LANG_SPECIFIC. The information equivalent to
4941 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4942 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4943 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
4944 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
4946 /* Since a template declaration already existed for this
4947 class-type, we must be redeclaring it here. Make sure
4948 that the redeclaration is valid. */
4949 redeclare_class_template (TREE_TYPE (decl
),
4950 current_template_parms
);
4951 /* We don't need to create a new TEMPLATE_DECL; just use the
4952 one we already had. */
4953 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
4957 tmpl
= build_template_decl (decl
, current_template_parms
,
4961 if (DECL_LANG_SPECIFIC (decl
)
4962 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4964 /* A specialization of a member template of a template
4966 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4967 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
4968 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
4974 tree a
, t
, current
, parms
;
4976 tree tinfo
= get_template_info (decl
);
4980 error ("template definition of non-template %q#D", decl
);
4981 return error_mark_node
;
4984 tmpl
= TI_TEMPLATE (tinfo
);
4986 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
4987 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
4988 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4989 && DECL_MEMBER_TEMPLATE_P (tmpl
))
4993 /* The declaration is a specialization of a member
4994 template, declared outside the class. Therefore, the
4995 innermost template arguments will be NULL, so we
4996 replace them with the arguments determined by the
4997 earlier call to check_explicit_specialization. */
4998 args
= DECL_TI_ARGS (decl
);
5001 = build_template_decl (decl
, current_template_parms
,
5003 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
5004 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
5005 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
5006 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
5007 DECL_TEMPLATE_INFO (new_tmpl
)
5008 = build_template_info (tmpl
, args
);
5010 register_specialization (new_tmpl
,
5011 most_general_template (tmpl
),
5017 /* Make sure the template headers we got make sense. */
5019 parms
= DECL_TEMPLATE_PARMS (tmpl
);
5020 i
= TMPL_PARMS_DEPTH (parms
);
5021 if (TMPL_ARGS_DEPTH (args
) != i
)
5023 error ("expected %d levels of template parms for %q#D, got %d",
5024 i
, decl
, TMPL_ARGS_DEPTH (args
));
5025 DECL_INTERFACE_KNOWN (decl
) = 1;
5026 return error_mark_node
;
5029 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5031 a
= TMPL_ARGS_LEVEL (args
, i
);
5032 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5034 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5036 if (current
== decl
)
5037 error ("got %d template parameters for %q#D",
5038 TREE_VEC_LENGTH (a
), decl
);
5040 error ("got %d template parameters for %q#T",
5041 TREE_VEC_LENGTH (a
), current
);
5042 error (" but %d required", TREE_VEC_LENGTH (t
));
5043 /* Avoid crash in import_export_decl. */
5044 DECL_INTERFACE_KNOWN (decl
) = 1;
5045 return error_mark_node
;
5048 if (current
== decl
)
5050 else if (current
== NULL_TREE
)
5051 /* Can happen in erroneous input. */
5054 current
= get_containing_scope (current
);
5057 /* Check that the parms are used in the appropriate qualifying scopes
5058 in the declarator. */
5059 if (!comp_template_args
5061 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5064 template arguments to %qD do not match original template %qD",
5065 decl
, DECL_TEMPLATE_RESULT (tmpl
));
5066 if (!uses_template_parms (TI_ARGS (tinfo
)))
5067 inform (input_location
, "use template<> for an explicit specialization");
5068 /* Avoid crash in import_export_decl. */
5069 DECL_INTERFACE_KNOWN (decl
) = 1;
5070 return error_mark_node
;
5074 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5075 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5077 /* Push template declarations for global functions and types. Note
5078 that we do not try to push a global template friend declared in a
5079 template class; such a thing may well depend on the template
5080 parameters of the class. */
5081 if (new_template_p
&& !ctx
5082 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5084 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5085 if (tmpl
== error_mark_node
)
5086 return error_mark_node
;
5088 /* Hide template friend classes that haven't been declared yet. */
5089 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5091 DECL_ANTICIPATED (tmpl
) = 1;
5092 DECL_FRIEND_P (tmpl
) = 1;
5098 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5101 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5102 if (DECL_CONV_FN_P (tmpl
))
5104 int depth
= TMPL_PARMS_DEPTH (parms
);
5106 /* It is a conversion operator. See if the type converted to
5107 depends on innermost template operands. */
5109 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
5111 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
5114 /* Give template template parms a DECL_CONTEXT of the template
5115 for which they are a parameter. */
5116 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5117 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5119 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5120 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5121 DECL_CONTEXT (parm
) = tmpl
;
5124 if (TREE_CODE (decl
) == TYPE_DECL
5125 && TYPE_DECL_ALIAS_P (decl
)
5126 && complex_alias_template_p (tmpl
))
5127 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
5130 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5131 back to its most general template. If TMPL is a specialization,
5132 ARGS may only have the innermost set of arguments. Add the missing
5133 argument levels if necessary. */
5134 if (DECL_TEMPLATE_INFO (tmpl
))
5135 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5137 info
= build_template_info (tmpl
, args
);
5139 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5140 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5143 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5144 retrofit_lang_decl (decl
);
5145 if (DECL_LANG_SPECIFIC (decl
))
5146 DECL_TEMPLATE_INFO (decl
) = info
;
5149 if (flag_implicit_templates
5151 && TREE_PUBLIC (decl
)
5152 && VAR_OR_FUNCTION_DECL_P (decl
))
5153 /* Set DECL_COMDAT on template instantiations; if we force
5154 them to be emitted by explicit instantiation or -frepo,
5155 mark_needed will tell cgraph to do the right thing. */
5156 DECL_COMDAT (decl
) = true;
5158 return DECL_TEMPLATE_RESULT (tmpl
);
5162 push_template_decl (tree decl
)
5164 return push_template_decl_real (decl
, false);
5167 /* FN is an inheriting constructor that inherits from the constructor
5168 template INHERITED; turn FN into a constructor template with a matching
5172 add_inherited_template_parms (tree fn
, tree inherited
)
5175 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5176 inner_parms
= copy_node (inner_parms
);
5178 = tree_cons (size_int (processing_template_decl
+ 1),
5179 inner_parms
, current_template_parms
);
5180 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5181 tree args
= template_parms_to_args (parms
);
5182 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5183 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5184 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5185 DECL_ARTIFICIAL (tmpl
) = true;
5186 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5190 /* Called when a class template TYPE is redeclared with the indicated
5191 template PARMS, e.g.:
5193 template <class T> struct S;
5194 template <class T> struct S {}; */
5197 redeclare_class_template (tree type
, tree parms
)
5203 if (!TYPE_TEMPLATE_INFO (type
))
5205 error ("%qT is not a template type", type
);
5209 tmpl
= TYPE_TI_TEMPLATE (type
);
5210 if (!PRIMARY_TEMPLATE_P (tmpl
))
5211 /* The type is nested in some template class. Nothing to worry
5212 about here; there are no new template parameters for the nested
5218 error ("template specifiers not specified in declaration of %qD",
5223 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5224 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5226 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5228 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5229 "redeclared with %d template parameter",
5230 "redeclared with %d template parameters",
5231 TREE_VEC_LENGTH (parms
));
5232 inform_n (input_location
, TREE_VEC_LENGTH (tmpl_parms
),
5233 "previous declaration %q+D used %d template parameter",
5234 "previous declaration %q+D used %d template parameters",
5235 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5239 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5246 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5247 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5250 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5251 if (error_operand_p (tmpl_parm
))
5254 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5255 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5256 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5258 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5260 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5261 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5262 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5263 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5264 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5265 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5266 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5267 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5268 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5270 error ("template parameter %q+#D", tmpl_parm
);
5271 error ("redeclared here as %q#D", parm
);
5275 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5277 /* We have in [temp.param]:
5279 A template-parameter may not be given default arguments
5280 by two different declarations in the same scope. */
5281 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5282 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5283 "original definition appeared here");
5287 if (parm_default
!= NULL_TREE
)
5288 /* Update the previous template parameters (which are the ones
5289 that will really count) with the new default value. */
5290 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5291 else if (tmpl_default
!= NULL_TREE
)
5292 /* Update the new parameters, too; they'll be used as the
5293 parameters for any members. */
5294 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5300 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5301 to be used when the caller has already checked
5302 (processing_template_decl
5303 && !instantiation_dependent_expression_p (expr)
5304 && potential_constant_expression (expr))
5305 and cleared processing_template_decl. */
5308 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
5310 return tsubst_copy_and_build (expr
,
5313 /*in_decl=*/NULL_TREE
,
5314 /*function_p=*/false,
5315 /*integral_constant_expression_p=*/true);
5318 /* Simplify EXPR if it is a non-dependent expression. Returns the
5319 (possibly simplified) expression. */
5322 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5324 if (expr
== NULL_TREE
)
5327 /* If we're in a template, but EXPR isn't value dependent, simplify
5328 it. We're supposed to treat:
5330 template <typename T> void f(T[1 + 1]);
5331 template <typename T> void f(T[2]);
5333 as two declarations of the same function, for example. */
5334 if (processing_template_decl
5335 && !instantiation_dependent_expression_p (expr
)
5336 && potential_constant_expression (expr
))
5338 processing_template_decl_sentinel s
;
5339 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
5345 instantiate_non_dependent_expr (tree expr
)
5347 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
5350 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5351 template declaration, or a TYPE_DECL for an alias declaration. */
5354 alias_type_or_template_p (tree t
)
5358 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5361 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5362 || DECL_ALIAS_TEMPLATE_P (t
));
5365 /* Return TRUE iff T is a specialization of an alias template. */
5368 alias_template_specialization_p (const_tree t
)
5370 /* It's an alias template specialization if it's an alias and its
5371 TYPE_NAME is a specialization of a primary template. */
5372 if (TYPE_ALIAS_P (t
))
5374 tree name
= TYPE_NAME (t
);
5375 if (DECL_LANG_SPECIFIC (name
))
5376 if (tree ti
= DECL_TEMPLATE_INFO (name
))
5378 tree tmpl
= TI_TEMPLATE (ti
);
5379 return PRIMARY_TEMPLATE_P (tmpl
);
5385 /* An alias template is complex from a SFINAE perspective if a template-id
5386 using that alias can be ill-formed when the expansion is not, as with
5387 the void_t template. We determine this by checking whether the
5388 expansion for the alias template uses all its template parameters. */
5390 struct uses_all_template_parms_data
5397 uses_all_template_parms_r (tree t
, void *data_
)
5399 struct uses_all_template_parms_data
&data
5400 = *(struct uses_all_template_parms_data
*)data_
;
5401 tree idx
= get_template_parm_index (t
);
5403 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
5404 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
5409 complex_alias_template_p (const_tree tmpl
)
5411 struct uses_all_template_parms_data data
;
5412 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5413 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5414 data
.level
= TMPL_PARMS_DEPTH (parms
);
5415 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
5416 data
.seen
= XALLOCAVEC (bool, len
);
5417 for (int i
= 0; i
< len
; ++i
)
5418 data
.seen
[i
] = false;
5420 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
5421 for (int i
= 0; i
< len
; ++i
)
5427 /* Return TRUE iff T is a specialization of a complex alias template with
5428 dependent template-arguments. */
5431 dependent_alias_template_spec_p (const_tree t
)
5433 return (alias_template_specialization_p (t
)
5434 && TEMPLATE_DECL_COMPLEX_ALIAS_P (DECL_TI_TEMPLATE (TYPE_NAME (t
)))
5435 && (any_dependent_template_arguments_p
5436 (INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (t
)))));
5439 /* Return the number of innermost template parameters in TMPL. */
5442 num_innermost_template_parms (tree tmpl
)
5444 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5445 return TREE_VEC_LENGTH (parms
);
5448 /* Return either TMPL or another template that it is equivalent to under DR
5449 1286: An alias that just changes the name of a template is equivalent to
5450 the other template. */
5453 get_underlying_template (tree tmpl
)
5455 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5456 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5458 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5459 if (TYPE_TEMPLATE_INFO (result
))
5461 tree sub
= TYPE_TI_TEMPLATE (result
);
5462 if (PRIMARY_TEMPLATE_P (sub
)
5463 && (num_innermost_template_parms (tmpl
)
5464 == num_innermost_template_parms (sub
)))
5466 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5467 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5468 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5470 /* The alias type is equivalent to the pattern of the
5471 underlying template, so strip the alias. */
5481 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5482 must be a function or a pointer-to-function type, as specified
5483 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5484 and check that the resulting function has external linkage. */
5487 convert_nontype_argument_function (tree type
, tree expr
,
5488 tsubst_flags_t complain
)
5492 linkage_kind linkage
;
5494 fn
= instantiate_type (type
, fns
, tf_none
);
5495 if (fn
== error_mark_node
)
5496 return error_mark_node
;
5499 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5500 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5501 if (BASELINK_P (fn_no_ptr
))
5502 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5504 /* [temp.arg.nontype]/1
5506 A template-argument for a non-type, non-template template-parameter
5509 -- the address of an object or function with external [C++11: or
5510 internal] linkage. */
5512 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5514 if (complain
& tf_error
)
5516 error ("%qE is not a valid template argument for type %qT",
5518 if (TYPE_PTR_P (type
))
5519 error ("it must be the address of a function with "
5520 "external linkage");
5522 error ("it must be the name of a function with "
5523 "external linkage");
5528 linkage
= decl_linkage (fn_no_ptr
);
5529 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5531 if (complain
& tf_error
)
5533 if (cxx_dialect
>= cxx11
)
5534 error ("%qE is not a valid template argument for type %qT "
5535 "because %qD has no linkage",
5536 expr
, type
, fn_no_ptr
);
5538 error ("%qE is not a valid template argument for type %qT "
5539 "because %qD does not have external linkage",
5540 expr
, type
, fn_no_ptr
);
5548 /* Subroutine of convert_nontype_argument.
5549 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5550 Emit an error otherwise. */
5553 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5554 tsubst_flags_t complain
)
5557 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5559 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5561 if (processing_template_decl
5562 && TREE_CODE (expr
) == ADDR_EXPR
5563 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
5565 if (complain
& tf_error
)
5567 error ("%qE is not a valid template argument for type %qT",
5569 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5574 /* Returns TRUE iff the address of OP is value-dependent.
5576 14.6.2.4 [temp.dep.temp]:
5577 A non-integral non-type template-argument is dependent if its type is
5578 dependent or it has either of the following forms
5581 and contains a nested-name-specifier which specifies a class-name that
5582 names a dependent type.
5584 We generalize this to just say that the address of a member of a
5585 dependent class is value-dependent; the above doesn't cover the
5586 address of a static data member named with an unqualified-id. */
5589 has_value_dependent_address (tree op
)
5591 /* We could use get_inner_reference here, but there's no need;
5592 this is only relevant for template non-type arguments, which
5593 can only be expressed as &id-expression. */
5596 tree ctx
= CP_DECL_CONTEXT (op
);
5597 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5604 /* The next set of functions are used for providing helpful explanatory
5605 diagnostics for failed overload resolution. Their messages should be
5606 indented by two spaces for consistency with the messages in
5610 unify_success (bool /*explain_p*/)
5616 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5619 inform (input_location
,
5620 " couldn't deduce template parameter %qD", parm
);
5625 unify_invalid (bool /*explain_p*/)
5631 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5634 inform (input_location
,
5635 " types %qT and %qT have incompatible cv-qualifiers",
5641 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5644 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5649 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5652 inform (input_location
,
5653 " template parameter %qD is not a parameter pack, but "
5660 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5663 inform (input_location
,
5664 " template argument %qE does not match "
5665 "pointer-to-member constant %qE",
5671 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5674 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5679 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5682 inform (input_location
,
5683 " inconsistent parameter pack deduction with %qT and %qT",
5689 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5694 inform (input_location
,
5695 " deduced conflicting types for parameter %qT (%qT and %qT)",
5696 parm
, first
, second
);
5698 inform (input_location
,
5699 " deduced conflicting values for non-type parameter "
5700 "%qE (%qE and %qE)", parm
, first
, second
);
5706 unify_vla_arg (bool explain_p
, tree arg
)
5709 inform (input_location
,
5710 " variable-sized array type %qT is not "
5711 "a valid template argument",
5717 unify_method_type_error (bool explain_p
, tree arg
)
5720 inform (input_location
,
5721 " member function type %qT is not a valid template argument",
5727 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
5732 inform_n (input_location
, wanted
,
5733 " candidate expects at least %d argument, %d provided",
5734 " candidate expects at least %d arguments, %d provided",
5737 inform_n (input_location
, wanted
,
5738 " candidate expects %d argument, %d provided",
5739 " candidate expects %d arguments, %d provided",
5746 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5748 return unify_arity (explain_p
, have
, wanted
);
5752 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
5753 bool least_p
= false)
5755 return unify_arity (explain_p
, have
, wanted
, least_p
);
5759 unify_arg_conversion (bool explain_p
, tree to_type
,
5760 tree from_type
, tree arg
)
5763 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5764 " cannot convert %qE (type %qT) to type %qT",
5765 arg
, from_type
, to_type
);
5770 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5771 tree parm
, tree arg
)
5776 case tbr_ambiguous_baseclass
:
5777 inform (input_location
, " %qT is an ambiguous base class of %qT",
5781 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5788 unify_inconsistent_template_template_parameters (bool explain_p
)
5791 inform (input_location
,
5792 " template parameters of a template template argument are "
5793 "inconsistent with other deduced template arguments");
5798 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5801 inform (input_location
,
5802 " can't deduce a template for %qT from non-template type %qT",
5808 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5811 inform (input_location
,
5812 " template argument %qE does not match %qD", arg
, parm
);
5817 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5820 inform (input_location
,
5821 " could not resolve address from overloaded function %qE",
5826 /* Attempt to convert the non-type template parameter EXPR to the
5827 indicated TYPE. If the conversion is successful, return the
5828 converted value. If the conversion is unsuccessful, return
5829 NULL_TREE if we issued an error message, or error_mark_node if we
5830 did not. We issue error messages for out-and-out bad template
5831 parameters, but not simply because the conversion failed, since we
5832 might be just trying to do argument deduction. Both TYPE and EXPR
5833 must be non-dependent.
5835 The conversion follows the special rules described in
5836 [temp.arg.nontype], and it is much more strict than an implicit
5839 This function is called twice for each template argument (see
5840 lookup_template_class for a more accurate description of this
5841 problem). This means that we need to handle expressions which
5842 are not valid in a C++ source, but can be created from the
5843 first call (for instance, casts to perform conversions). These
5844 hacks can go away after we fix the double coercion problem. */
5847 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5851 /* Detect immediately string literals as invalid non-type argument.
5852 This special-case is not needed for correctness (we would easily
5853 catch this later), but only to provide better diagnostic for this
5854 common user mistake. As suggested by DR 100, we do not mention
5855 linkage issues in the diagnostic as this is not the point. */
5856 /* FIXME we're making this OK. */
5857 if (TREE_CODE (expr
) == STRING_CST
)
5859 if (complain
& tf_error
)
5860 error ("%qE is not a valid template argument for type %qT "
5861 "because string literals can never be used in this context",
5866 /* Add the ADDR_EXPR now for the benefit of
5867 value_dependent_expression_p. */
5868 if (TYPE_PTROBV_P (type
)
5869 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5871 expr
= decay_conversion (expr
, complain
);
5872 if (expr
== error_mark_node
)
5873 return error_mark_node
;
5876 /* If we are in a template, EXPR may be non-dependent, but still
5877 have a syntactic, rather than semantic, form. For example, EXPR
5878 might be a SCOPE_REF, rather than the VAR_DECL to which the
5879 SCOPE_REF refers. Preserving the qualifying scope is necessary
5880 so that access checking can be performed when the template is
5881 instantiated -- but here we need the resolved form so that we can
5882 convert the argument. */
5883 bool non_dep
= false;
5884 if (TYPE_REF_OBJ_P (type
)
5885 && has_value_dependent_address (expr
))
5886 /* If we want the address and it's value-dependent, don't fold. */;
5887 else if (!type_unknown_p (expr
)
5888 && processing_template_decl
5889 && !instantiation_dependent_expression_p (expr
)
5890 && potential_constant_expression (expr
))
5892 if (error_operand_p (expr
))
5893 return error_mark_node
;
5894 expr_type
= TREE_TYPE (expr
);
5895 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5896 expr
= mark_lvalue_use (expr
);
5898 expr
= mark_rvalue_use (expr
);
5900 /* If the argument is non-dependent, perform any conversions in
5901 non-dependent context as well. */
5902 processing_template_decl_sentinel
s (non_dep
);
5904 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
5906 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5907 to a non-type argument of "nullptr". */
5908 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5909 expr
= convert (type
, expr
);
5911 /* In C++11, integral or enumeration non-type template arguments can be
5912 arbitrary constant expressions. Pointer and pointer to
5913 member arguments can be general constant expressions that evaluate
5914 to a null value, but otherwise still need to be of a specific form. */
5915 if (cxx_dialect
>= cxx11
)
5917 if (TREE_CODE (expr
) == PTRMEM_CST
)
5918 /* A PTRMEM_CST is already constant, and a valid template
5919 argument for a parameter of pointer to member type, we just want
5920 to leave it in that form rather than lower it to a
5922 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5923 expr
= maybe_constant_value (expr
);
5924 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5926 tree folded
= maybe_constant_value (expr
);
5927 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5928 : null_member_pointer_value_p (folded
))
5933 /* HACK: Due to double coercion, we can get a
5934 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5935 which is the tree that we built on the first call (see
5936 below when coercing to reference to object or to reference to
5937 function). We just strip everything and get to the arg.
5938 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5940 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5942 tree probe_type
, probe
= expr
;
5943 if (REFERENCE_REF_P (probe
))
5944 probe
= TREE_OPERAND (probe
, 0);
5945 probe_type
= TREE_TYPE (probe
);
5946 if (TREE_CODE (probe
) == NOP_EXPR
)
5948 /* ??? Maybe we could use convert_from_reference here, but we
5949 would need to relax its constraints because the NOP_EXPR
5950 could actually change the type to something more cv-qualified,
5951 and this is not folded by convert_from_reference. */
5952 tree addr
= TREE_OPERAND (probe
, 0);
5953 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5954 && TREE_CODE (addr
) == ADDR_EXPR
5955 && TYPE_PTR_P (TREE_TYPE (addr
))
5956 && (same_type_ignoring_top_level_qualifiers_p
5957 (TREE_TYPE (probe_type
),
5958 TREE_TYPE (TREE_TYPE (addr
)))))
5960 expr
= TREE_OPERAND (addr
, 0);
5961 expr_type
= TREE_TYPE (probe_type
);
5966 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5967 parameter is a pointer to object, through decay and
5968 qualification conversion. Let's strip everything. */
5969 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5973 if (TREE_CODE (probe
) == ADDR_EXPR
5974 && TYPE_PTR_P (TREE_TYPE (probe
)))
5976 /* Skip the ADDR_EXPR only if it is part of the decay for
5977 an array. Otherwise, it is part of the original argument
5978 in the source code. */
5979 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5980 probe
= TREE_OPERAND (probe
, 0);
5982 expr_type
= TREE_TYPE (expr
);
5986 /* [temp.arg.nontype]/5, bullet 1
5988 For a non-type template-parameter of integral or enumeration type,
5989 integral promotions (_conv.prom_) and integral conversions
5990 (_conv.integral_) are applied. */
5991 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5993 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5994 t
= maybe_constant_value (t
);
5995 if (t
!= error_mark_node
)
5998 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5999 return error_mark_node
;
6001 /* Notice that there are constant expressions like '4 % 0' which
6002 do not fold into integer constants. */
6003 if (TREE_CODE (expr
) != INTEGER_CST
)
6005 if (complain
& tf_error
)
6007 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
6008 if (processing_template_decl
6009 && !require_potential_constant_expression (expr
))
6011 expr
= cxx_constant_value (expr
);
6012 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
6013 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
6014 "in template argument for type %qT ", type
);
6015 if (expr
== error_mark_node
)
6017 /* else cxx_constant_value complained but gave us
6018 a real constant, so go ahead. */
6019 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
6025 /* Avoid typedef problems. */
6026 if (TREE_TYPE (expr
) != type
)
6027 expr
= fold_convert (type
, expr
);
6029 /* [temp.arg.nontype]/5, bullet 2
6031 For a non-type template-parameter of type pointer to object,
6032 qualification conversions (_conv.qual_) and the array-to-pointer
6033 conversion (_conv.array_) are applied. */
6034 else if (TYPE_PTROBV_P (type
))
6036 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6038 A template-argument for a non-type, non-template template-parameter
6039 shall be one of: [...]
6041 -- the name of a non-type template-parameter;
6042 -- the address of an object or function with external linkage, [...]
6043 expressed as "& id-expression" where the & is optional if the name
6044 refers to a function or array, or if the corresponding
6045 template-parameter is a reference.
6047 Here, we do not care about functions, as they are invalid anyway
6048 for a parameter of type pointer-to-object. */
6050 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
6051 /* Non-type template parameters are OK. */
6053 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6054 /* Null pointer values are OK in C++11. */;
6055 else if (TREE_CODE (expr
) != ADDR_EXPR
6056 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
6060 if (complain
& tf_error
)
6061 error ("%qD is not a valid template argument "
6062 "because %qD is a variable, not the address of "
6063 "a variable", expr
, expr
);
6066 if (POINTER_TYPE_P (expr_type
))
6068 if (complain
& tf_error
)
6069 error ("%qE is not a valid template argument for %qT "
6070 "because it is not the address of a variable",
6074 /* Other values, like integer constants, might be valid
6075 non-type arguments of some other type. */
6076 return error_mark_node
;
6082 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
6083 ? TREE_OPERAND (expr
, 0) : expr
);
6086 if (complain
& tf_error
)
6087 error ("%qE is not a valid template argument of type %qT "
6088 "because %qE is not a variable", expr
, type
, decl
);
6091 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6093 if (complain
& tf_error
)
6094 error ("%qE is not a valid template argument of type %qT "
6095 "because %qD does not have external linkage",
6099 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
6101 if (complain
& tf_error
)
6102 error ("%qE is not a valid template argument of type %qT "
6103 "because %qD has no linkage", expr
, type
, decl
);
6108 expr
= decay_conversion (expr
, complain
);
6109 if (expr
== error_mark_node
)
6110 return error_mark_node
;
6112 expr
= perform_qualification_conversions (type
, expr
);
6113 if (expr
== error_mark_node
)
6114 return error_mark_node
;
6116 /* [temp.arg.nontype]/5, bullet 3
6118 For a non-type template-parameter of type reference to object, no
6119 conversions apply. The type referred to by the reference may be more
6120 cv-qualified than the (otherwise identical) type of the
6121 template-argument. The template-parameter is bound directly to the
6122 template-argument, which must be an lvalue. */
6123 else if (TYPE_REF_OBJ_P (type
))
6125 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
6127 return error_mark_node
;
6129 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
6131 if (complain
& tf_error
)
6132 error ("%qE is not a valid template argument for type %qT "
6133 "because of conflicts in cv-qualification", expr
, type
);
6137 if (!real_lvalue_p (expr
))
6139 if (complain
& tf_error
)
6140 error ("%qE is not a valid template argument for type %qT "
6141 "because it is not an lvalue", expr
, type
);
6145 /* [temp.arg.nontype]/1
6147 A template-argument for a non-type, non-template template-parameter
6148 shall be one of: [...]
6150 -- the address of an object or function with external linkage. */
6151 if (INDIRECT_REF_P (expr
)
6152 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
6154 expr
= TREE_OPERAND (expr
, 0);
6157 if (complain
& tf_error
)
6158 error ("%q#D is not a valid template argument for type %qT "
6159 "because a reference variable does not have a constant "
6160 "address", expr
, type
);
6167 if (complain
& tf_error
)
6168 error ("%qE is not a valid template argument for type %qT "
6169 "because it is not an object with external linkage",
6174 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
6176 if (complain
& tf_error
)
6177 error ("%qE is not a valid template argument for type %qT "
6178 "because object %qD has not external linkage",
6183 expr
= build_nop (type
, build_address (expr
));
6185 /* [temp.arg.nontype]/5, bullet 4
6187 For a non-type template-parameter of type pointer to function, only
6188 the function-to-pointer conversion (_conv.func_) is applied. If the
6189 template-argument represents a set of overloaded functions (or a
6190 pointer to such), the matching function is selected from the set
6192 else if (TYPE_PTRFN_P (type
))
6194 /* If the argument is a template-id, we might not have enough
6195 context information to decay the pointer. */
6196 if (!type_unknown_p (expr_type
))
6198 expr
= decay_conversion (expr
, complain
);
6199 if (expr
== error_mark_node
)
6200 return error_mark_node
;
6203 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6204 /* Null pointer values are OK in C++11. */
6205 return perform_qualification_conversions (type
, expr
);
6207 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6208 if (!expr
|| expr
== error_mark_node
)
6211 /* [temp.arg.nontype]/5, bullet 5
6213 For a non-type template-parameter of type reference to function, no
6214 conversions apply. If the template-argument represents a set of
6215 overloaded functions, the matching function is selected from the set
6217 else if (TYPE_REFFN_P (type
))
6219 if (TREE_CODE (expr
) == ADDR_EXPR
)
6221 if (complain
& tf_error
)
6223 error ("%qE is not a valid template argument for type %qT "
6224 "because it is a pointer", expr
, type
);
6225 inform (input_location
, "try using %qE instead",
6226 TREE_OPERAND (expr
, 0));
6231 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6232 if (!expr
|| expr
== error_mark_node
)
6235 expr
= build_nop (type
, build_address (expr
));
6237 /* [temp.arg.nontype]/5, bullet 6
6239 For a non-type template-parameter of type pointer to member function,
6240 no conversions apply. If the template-argument represents a set of
6241 overloaded member functions, the matching member function is selected
6242 from the set (_over.over_). */
6243 else if (TYPE_PTRMEMFUNC_P (type
))
6245 expr
= instantiate_type (type
, expr
, tf_none
);
6246 if (expr
== error_mark_node
)
6247 return error_mark_node
;
6249 /* [temp.arg.nontype] bullet 1 says the pointer to member
6250 expression must be a pointer-to-member constant. */
6251 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6252 return error_mark_node
;
6254 /* There is no way to disable standard conversions in
6255 resolve_address_of_overloaded_function (called by
6256 instantiate_type). It is possible that the call succeeded by
6257 converting &B::I to &D::I (where B is a base of D), so we need
6258 to reject this conversion here.
6260 Actually, even if there was a way to disable standard conversions,
6261 it would still be better to reject them here so that we can
6262 provide a superior diagnostic. */
6263 if (!same_type_p (TREE_TYPE (expr
), type
))
6265 if (complain
& tf_error
)
6267 error ("%qE is not a valid template argument for type %qT "
6268 "because it is of type %qT", expr
, type
,
6270 /* If we are just one standard conversion off, explain. */
6271 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6272 inform (input_location
,
6273 "standard conversions are not allowed in this context");
6278 /* [temp.arg.nontype]/5, bullet 7
6280 For a non-type template-parameter of type pointer to data member,
6281 qualification conversions (_conv.qual_) are applied. */
6282 else if (TYPE_PTRDATAMEM_P (type
))
6284 /* [temp.arg.nontype] bullet 1 says the pointer to member
6285 expression must be a pointer-to-member constant. */
6286 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6287 return error_mark_node
;
6289 expr
= perform_qualification_conversions (type
, expr
);
6290 if (expr
== error_mark_node
)
6293 else if (NULLPTR_TYPE_P (type
))
6295 if (expr
!= nullptr_node
)
6297 if (complain
& tf_error
)
6298 error ("%qE is not a valid template argument for type %qT "
6299 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6304 /* A template non-type parameter must be one of the above. */
6308 /* Sanity check: did we actually convert the argument to the
6310 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6311 (type
, TREE_TYPE (expr
)));
6312 return convert_from_reference (expr
);
6315 /* Subroutine of coerce_template_template_parms, which returns 1 if
6316 PARM_PARM and ARG_PARM match using the rule for the template
6317 parameters of template template parameters. Both PARM and ARG are
6318 template parameters; the rest of the arguments are the same as for
6319 coerce_template_template_parms.
6322 coerce_template_template_parm (tree parm
,
6324 tsubst_flags_t complain
,
6328 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6329 || parm
== NULL_TREE
|| error_operand_p (parm
))
6332 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6335 switch (TREE_CODE (parm
))
6338 /* We encounter instantiations of templates like
6339 template <template <template <class> class> class TT>
6342 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6343 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6345 if (!coerce_template_template_parms
6346 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6352 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6353 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6354 /* Argument is a parameter pack but parameter is not. */
6359 /* The tsubst call is used to handle cases such as
6361 template <int> class C {};
6362 template <class T, template <T> class TT> class D {};
6365 i.e. the parameter list of TT depends on earlier parameters. */
6366 if (!uses_template_parms (TREE_TYPE (arg
))
6368 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6372 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6373 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6374 /* Argument is a parameter pack but parameter is not. */
6387 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6388 template template parameters. Both PARM_PARMS and ARG_PARMS are
6389 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6392 Consider the example:
6393 template <class T> class A;
6394 template<template <class U> class TT> class B;
6396 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6397 the parameters to A, and OUTER_ARGS contains A. */
6400 coerce_template_template_parms (tree parm_parms
,
6402 tsubst_flags_t complain
,
6406 int nparms
, nargs
, i
;
6410 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6411 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6413 nparms
= TREE_VEC_LENGTH (parm_parms
);
6414 nargs
= TREE_VEC_LENGTH (arg_parms
);
6416 /* Determine whether we have a parameter pack at the end of the
6417 template template parameter's template parameter list. */
6418 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6420 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6422 if (error_operand_p (parm
))
6425 switch (TREE_CODE (parm
))
6429 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6434 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6444 && !(variadic_p
&& nargs
>= nparms
- 1))
6447 /* Check all of the template parameters except the parameter pack at
6448 the end (if any). */
6449 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6451 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6452 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6455 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6456 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6458 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6466 /* Check each of the template parameters in the template
6467 argument against the template parameter pack at the end of
6468 the template template parameter. */
6469 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6472 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6474 for (; i
< nargs
; ++i
)
6476 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6479 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6481 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6490 /* Verifies that the deduced template arguments (in TARGS) for the
6491 template template parameters (in TPARMS) represent valid bindings,
6492 by comparing the template parameter list of each template argument
6493 to the template parameter list of its corresponding template
6494 template parameter, in accordance with DR150. This
6495 routine can only be called after all template arguments have been
6496 deduced. It will return TRUE if all of the template template
6497 parameter bindings are okay, FALSE otherwise. */
6499 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6501 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6504 /* We're dealing with template parms in this process. */
6505 ++processing_template_decl
;
6507 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6509 for (i
= 0; i
< ntparms
; ++i
)
6511 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6512 tree targ
= TREE_VEC_ELT (targs
, i
);
6514 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6516 tree packed_args
= NULL_TREE
;
6519 if (ARGUMENT_PACK_P (targ
))
6521 /* Look inside the argument pack. */
6522 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6523 len
= TREE_VEC_LENGTH (packed_args
);
6526 for (idx
= 0; idx
< len
; ++idx
)
6528 tree targ_parms
= NULL_TREE
;
6531 /* Extract the next argument from the argument
6533 targ
= TREE_VEC_ELT (packed_args
, idx
);
6535 if (PACK_EXPANSION_P (targ
))
6536 /* Look at the pattern of the pack expansion. */
6537 targ
= PACK_EXPANSION_PATTERN (targ
);
6539 /* Extract the template parameters from the template
6541 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6542 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6543 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6544 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6546 /* Verify that we can coerce the template template
6547 parameters from the template argument to the template
6548 parameter. This requires an exact match. */
6550 && !coerce_template_template_parms
6551 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6566 --processing_template_decl
;
6570 /* Since type attributes aren't mangled, we need to strip them from
6571 template type arguments. */
6574 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6576 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6578 bool removed_attributes
= false;
6579 tree canon
= strip_typedefs (arg
, &removed_attributes
);
6580 if (removed_attributes
6581 && (complain
& tf_warning
))
6582 warning (0, "ignoring attributes on template argument %qT", arg
);
6586 /* Convert the indicated template ARG as necessary to match the
6587 indicated template PARM. Returns the converted ARG, or
6588 error_mark_node if the conversion was unsuccessful. Error and
6589 warning messages are issued under control of COMPLAIN. This
6590 conversion is for the Ith parameter in the parameter list. ARGS is
6591 the full set of template arguments deduced so far. */
6594 convert_template_argument (tree parm
,
6597 tsubst_flags_t complain
,
6603 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6605 if (parm
== error_mark_node
)
6606 return error_mark_node
;
6608 if (TREE_CODE (arg
) == TREE_LIST
6609 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6611 /* The template argument was the name of some
6612 member function. That's usually
6613 invalid, but static members are OK. In any
6614 case, grab the underlying fields/functions
6615 and issue an error later if required. */
6616 orig_arg
= TREE_VALUE (arg
);
6617 TREE_TYPE (arg
) = unknown_type_node
;
6622 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6623 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6624 || requires_tmpl_type
);
6626 /* When determining whether an argument pack expansion is a template,
6627 look at the pattern. */
6628 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6629 arg
= PACK_EXPANSION_PATTERN (arg
);
6631 /* Deal with an injected-class-name used as a template template arg. */
6632 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6634 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6635 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6637 if (cxx_dialect
>= cxx11
)
6638 /* OK under DR 1004. */;
6639 else if (complain
& tf_warning_or_error
)
6640 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6641 " used as template template argument", TYPE_NAME (arg
));
6642 else if (flag_pedantic_errors
)
6650 ((TREE_CODE (arg
) == TEMPLATE_DECL
6651 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6652 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6653 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6654 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6657 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6658 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6659 arg
= TYPE_STUB_DECL (arg
);
6661 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6663 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6664 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6666 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6668 if (complain
& tf_error
)
6669 error ("invalid use of destructor %qE as a type", orig_arg
);
6670 return error_mark_node
;
6673 permerror (input_location
,
6674 "to refer to a type member of a template parameter, "
6675 "use %<typename %E%>", orig_arg
);
6677 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6678 TREE_OPERAND (arg
, 1),
6684 if (is_type
!= requires_type
)
6688 if (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 constant of type %qT, got %qT",
6697 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6698 else if (requires_tmpl_type
)
6699 inform (input_location
,
6700 " expected a class template, got %qE", orig_arg
);
6702 inform (input_location
,
6703 " expected a type, got %qE", orig_arg
);
6706 return error_mark_node
;
6708 if (is_tmpl_type
^ requires_tmpl_type
)
6710 if (in_decl
&& (complain
& tf_error
))
6712 error ("type/value mismatch at argument %d in template "
6713 "parameter list for %qD",
6716 inform (input_location
,
6717 " expected a type, got %qT", DECL_NAME (arg
));
6719 inform (input_location
,
6720 " expected a class template, got %qT", orig_arg
);
6722 return error_mark_node
;
6727 if (requires_tmpl_type
)
6729 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6731 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6732 /* The number of argument required is not known yet.
6733 Just accept it for now. */
6734 val
= TREE_TYPE (arg
);
6737 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6740 /* Strip alias templates that are equivalent to another
6742 arg
= get_underlying_template (arg
);
6743 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6745 if (coerce_template_template_parms (parmparm
, argparm
,
6751 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6753 if (val
!= error_mark_node
)
6755 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6756 val
= TREE_TYPE (val
);
6757 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6758 val
= make_pack_expansion (val
);
6763 if (in_decl
&& (complain
& tf_error
))
6765 error ("type/value mismatch at argument %d in "
6766 "template parameter list for %qD",
6768 inform (input_location
,
6769 " expected a template of type %qD, got %qT",
6773 val
= error_mark_node
;
6779 /* We only form one instance of each template specialization.
6780 Therefore, if we use a non-canonical variant (i.e., a
6781 typedef), any future messages referring to the type will use
6782 the typedef, which is confusing if those future uses do not
6783 themselves also use the typedef. */
6785 val
= canonicalize_type_argument (val
, complain
);
6789 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6791 if (invalid_nontype_parm_type_p (t
, complain
))
6792 return error_mark_node
;
6794 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6796 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6800 /* Not sure if this is reachable, but it doesn't hurt
6802 error ("type mismatch in nontype parameter pack");
6803 val
= error_mark_node
;
6806 else if (!dependent_template_arg_p (orig_arg
)
6807 && !uses_template_parms (t
))
6808 /* We used to call digest_init here. However, digest_init
6809 will report errors, which we don't want when complain
6810 is zero. More importantly, digest_init will try too
6811 hard to convert things: for example, `0' should not be
6812 converted to pointer type at this point according to
6813 the standard. Accepting this is not merely an
6814 extension, since deciding whether or not these
6815 conversions can occur is part of determining which
6816 function template to call, or whether a given explicit
6817 argument specification is valid. */
6818 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6821 bool removed_attr
= false;
6822 val
= strip_typedefs_expr (orig_arg
, &removed_attr
);
6825 if (val
== NULL_TREE
)
6826 val
= error_mark_node
;
6827 else if (val
== error_mark_node
&& (complain
& tf_error
))
6828 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6830 if (TREE_CODE (val
) == SCOPE_REF
)
6832 /* Strip typedefs from the SCOPE_REF. */
6833 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6834 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6836 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6837 QUALIFIED_NAME_IS_TEMPLATE (val
));
6844 /* Coerces the remaining template arguments in INNER_ARGS (from
6845 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6846 Returns the coerced argument pack. PARM_IDX is the position of this
6847 parameter in the template parameter list. ARGS is the original
6848 template argument list. */
6850 coerce_template_parameter_pack (tree parms
,
6858 tsubst_flags_t complain
)
6860 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6861 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6864 tree packed_parms
= NULL_TREE
;
6866 if (arg_idx
> nargs
)
6869 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6871 /* When the template parameter is a non-type template parameter pack
6872 or template template parameter pack whose type or template
6873 parameters use parameter packs, we know exactly how many arguments
6874 we are looking for. Build a vector of the instantiated decls for
6875 these template parameters in PACKED_PARMS. */
6876 /* We can't use make_pack_expansion here because it would interpret a
6877 _DECL as a use rather than a declaration. */
6878 tree decl
= TREE_VALUE (parm
);
6879 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6880 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6881 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6882 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6884 TREE_VEC_LENGTH (args
)--;
6885 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6886 TREE_VEC_LENGTH (args
)++;
6888 if (packed_parms
== error_mark_node
)
6889 return error_mark_node
;
6891 /* If we're doing a partial instantiation of a member template,
6892 verify that all of the types used for the non-type
6893 template parameter pack are, in fact, valid for non-type
6894 template parameters. */
6896 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6898 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6899 for (j
= 0; j
< len
; ++j
)
6901 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6902 if (invalid_nontype_parm_type_p (t
, complain
))
6903 return error_mark_node
;
6905 /* We don't know how many args we have yet, just
6906 use the unconverted ones for now. */
6910 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6913 packed_args
= make_tree_vec (nargs
- arg_idx
);
6915 /* Convert the remaining arguments, which will be a part of the
6916 parameter pack "parm". */
6917 for (; arg_idx
< nargs
; ++arg_idx
)
6919 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6920 tree actual_parm
= TREE_VALUE (parm
);
6921 int pack_idx
= arg_idx
- parm_idx
;
6925 /* Once we've packed as many args as we have types, stop. */
6926 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6928 else if (PACK_EXPANSION_P (arg
))
6929 /* We don't know how many args we have yet, just
6930 use the unconverted ones for now. */
6933 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6936 if (arg
== error_mark_node
)
6938 if (complain
& tf_error
)
6939 error ("template argument %d is invalid", arg_idx
+ 1);
6942 arg
= convert_template_argument (actual_parm
,
6943 arg
, new_args
, complain
, parm_idx
,
6945 if (arg
== error_mark_node
)
6947 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6950 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6951 && TREE_VEC_LENGTH (packed_args
) > 0)
6953 if (complain
& tf_error
)
6954 error ("wrong number of template arguments (%d, should be %d)",
6955 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6956 return error_mark_node
;
6959 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6960 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6961 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6964 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6965 TREE_TYPE (argument_pack
)
6966 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6967 TREE_CONSTANT (argument_pack
) = 1;
6970 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6971 #ifdef ENABLE_CHECKING
6972 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6973 TREE_VEC_LENGTH (packed_args
));
6975 return argument_pack
;
6978 /* Returns the number of pack expansions in the template argument vector
6982 pack_expansion_args_count (tree args
)
6987 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6989 tree elt
= TREE_VEC_ELT (args
, i
);
6990 if (elt
&& PACK_EXPANSION_P (elt
))
6996 /* Convert all template arguments to their appropriate types, and
6997 return a vector containing the innermost resulting template
6998 arguments. If any error occurs, return error_mark_node. Error and
6999 warning messages are issued under control of COMPLAIN.
7001 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
7002 for arguments not specified in ARGS. Otherwise, if
7003 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
7004 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
7005 USE_DEFAULT_ARGS is false, then all arguments must be specified in
7009 coerce_template_parms (tree parms
,
7012 tsubst_flags_t complain
,
7013 bool require_all_args
,
7014 bool use_default_args
)
7016 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
7017 tree orig_inner_args
;
7020 tree new_inner_args
;
7021 int saved_unevaluated_operand
;
7022 int saved_inhibit_evaluation_warnings
;
7024 /* When used as a boolean value, indicates whether this is a
7025 variadic template parameter list. Since it's an int, we can also
7026 subtract it from nparms to get the number of non-variadic
7029 int variadic_args_p
= 0;
7030 int post_variadic_parms
= 0;
7032 /* Likewise for parameters with default arguments. */
7035 if (args
== error_mark_node
)
7036 return error_mark_node
;
7038 nparms
= TREE_VEC_LENGTH (parms
);
7040 /* Determine if there are any parameter packs or default arguments. */
7041 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
7043 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
7045 ++post_variadic_parms
;
7046 if (template_parameter_pack_p (TREE_VALUE (parm
)))
7048 if (TREE_PURPOSE (parm
))
7052 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
7053 /* If there are no parameters that follow a parameter pack, we need to
7054 expand any argument packs so that we can deduce a parameter pack from
7055 some non-packed args followed by an argument pack, as in variadic85.C.
7056 If there are such parameters, we need to leave argument packs intact
7057 so the arguments are assigned properly. This can happen when dealing
7058 with a nested class inside a partial specialization of a class
7059 template, as in variadic92.C, or when deducing a template parameter pack
7060 from a sub-declarator, as in variadic114.C. */
7061 if (!post_variadic_parms
)
7062 inner_args
= expand_template_argument_pack (inner_args
);
7064 /* Count any pack expansion args. */
7065 variadic_args_p
= pack_expansion_args_count (inner_args
);
7067 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
7068 if ((nargs
> nparms
&& !variadic_p
)
7069 || (nargs
< nparms
- variadic_p
7072 && (!use_default_args
7073 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
7074 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
7076 if (complain
& tf_error
)
7078 if (variadic_p
|| default_p
)
7080 nparms
-= variadic_p
+ default_p
;
7081 error ("wrong number of template arguments "
7082 "(%d, should be at least %d)", nargs
, nparms
);
7085 error ("wrong number of template arguments "
7086 "(%d, should be %d)", nargs
, nparms
);
7089 inform (input_location
, "provided for %q+D", in_decl
);
7092 return error_mark_node
;
7094 /* We can't pass a pack expansion to a non-pack parameter of an alias
7095 template (DR 1430). */
7096 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
7098 && nargs
- variadic_args_p
< nparms
- variadic_p
)
7100 if (complain
& tf_error
)
7102 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
7104 tree arg
= TREE_VEC_ELT (inner_args
, i
);
7105 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
7107 if (PACK_EXPANSION_P (arg
)
7108 && !template_parameter_pack_p (parm
))
7110 error ("pack expansion argument for non-pack parameter "
7111 "%qD of alias template %qD", parm
, in_decl
);
7112 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
7119 return error_mark_node
;
7122 /* We need to evaluate the template arguments, even though this
7123 template-id may be nested within a "sizeof". */
7124 saved_unevaluated_operand
= cp_unevaluated_operand
;
7125 cp_unevaluated_operand
= 0;
7126 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
7127 c_inhibit_evaluation_warnings
= 0;
7128 new_inner_args
= make_tree_vec (nparms
);
7129 new_args
= add_outermost_template_args (args
, new_inner_args
);
7130 int pack_adjust
= 0;
7131 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
7136 /* Get the Ith template parameter. */
7137 parm
= TREE_VEC_ELT (parms
, parm_idx
);
7139 if (parm
== error_mark_node
)
7141 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
7145 /* Calculate the next argument. */
7146 if (arg_idx
< nargs
)
7147 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
7151 if (template_parameter_pack_p (TREE_VALUE (parm
))
7152 && !(arg
&& ARGUMENT_PACK_P (arg
)))
7154 /* Some arguments will be placed in the
7155 template parameter pack PARM. */
7156 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
7157 inner_args
, arg_idx
,
7161 if (arg
== NULL_TREE
)
7163 /* We don't know how many args we have yet, just use the
7164 unconverted (and still packed) ones for now. */
7165 new_inner_args
= orig_inner_args
;
7170 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
7172 /* Store this argument. */
7173 if (arg
== error_mark_node
)
7176 /* We are done with all of the arguments. */
7181 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
7182 arg_idx
+= pack_adjust
;
7189 if (PACK_EXPANSION_P (arg
))
7191 /* "If every valid specialization of a variadic template
7192 requires an empty template parameter pack, the template is
7193 ill-formed, no diagnostic required." So check that the
7194 pattern works with this parameter. */
7195 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
7196 tree conv
= convert_template_argument (TREE_VALUE (parm
),
7200 if (conv
== error_mark_node
)
7202 inform (input_location
, "so any instantiation with a "
7203 "non-empty parameter pack would be ill-formed");
7206 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
7207 /* Recover from missing typename. */
7208 TREE_VEC_ELT (inner_args
, arg_idx
)
7209 = make_pack_expansion (conv
);
7211 /* We don't know how many args we have yet, just
7212 use the unconverted ones for now. */
7213 new_inner_args
= inner_args
;
7218 else if (require_all_args
)
7220 /* There must be a default arg in this case. */
7221 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
7223 /* The position of the first default template argument,
7224 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7226 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7227 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7228 arg_idx
- pack_adjust
);
7233 if (arg
== error_mark_node
)
7235 if (complain
& tf_error
)
7236 error ("template argument %d is invalid", arg_idx
+ 1);
7239 /* This only occurs if there was an error in the template
7240 parameter list itself (which we would already have
7241 reported) that we are trying to recover from, e.g., a class
7242 template with a parameter list such as
7243 template<typename..., typename>. */
7246 arg
= convert_template_argument (TREE_VALUE (parm
),
7247 arg
, new_args
, complain
,
7250 if (arg
== error_mark_node
)
7252 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7254 cp_unevaluated_operand
= saved_unevaluated_operand
;
7255 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7257 if (variadic_p
&& arg_idx
< nargs
)
7259 if (complain
& tf_error
)
7261 error ("wrong number of template arguments "
7262 "(%d, should be %d)", nargs
, arg_idx
);
7264 error ("provided for %q+D", in_decl
);
7266 return error_mark_node
;
7270 return error_mark_node
;
7272 #ifdef ENABLE_CHECKING
7273 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7274 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7275 TREE_VEC_LENGTH (new_inner_args
));
7278 return new_inner_args
;
7281 /* Like coerce_template_parms. If PARMS represents all template
7282 parameters levels, this function returns a vector of vectors
7283 representing all the resulting argument levels. Note that in this
7284 case, only the innermost arguments are coerced because the
7285 outermost ones are supposed to have been coerced already.
7287 Otherwise, if PARMS represents only (the innermost) vector of
7288 parameters, this function returns a vector containing just the
7289 innermost resulting arguments. */
7292 coerce_innermost_template_parms (tree parms
,
7295 tsubst_flags_t complain
,
7296 bool require_all_args
,
7297 bool use_default_args
)
7299 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7300 int args_depth
= TMPL_ARGS_DEPTH (args
);
7303 if (parms_depth
> 1)
7305 coerced_args
= make_tree_vec (parms_depth
);
7309 for (level
= parms
, cur_depth
= parms_depth
;
7310 parms_depth
> 0 && level
!= NULL_TREE
;
7311 level
= TREE_CHAIN (level
), --cur_depth
)
7314 if (cur_depth
== args_depth
)
7315 l
= coerce_template_parms (TREE_VALUE (level
),
7316 args
, in_decl
, complain
,
7320 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7322 if (l
== error_mark_node
)
7323 return error_mark_node
;
7325 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7329 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7330 args
, in_decl
, complain
,
7333 return coerced_args
;
7336 /* Returns 1 if template args OT and NT are equivalent. */
7339 template_args_equal (tree ot
, tree nt
)
7343 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7346 if (TREE_CODE (nt
) == TREE_VEC
)
7347 /* For member templates */
7348 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7349 else if (PACK_EXPANSION_P (ot
))
7350 return (PACK_EXPANSION_P (nt
)
7351 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7352 PACK_EXPANSION_PATTERN (nt
))
7353 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7354 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7355 else if (ARGUMENT_PACK_P (ot
))
7360 if (!ARGUMENT_PACK_P (nt
))
7363 opack
= ARGUMENT_PACK_ARGS (ot
);
7364 npack
= ARGUMENT_PACK_ARGS (nt
);
7365 len
= TREE_VEC_LENGTH (opack
);
7366 if (TREE_VEC_LENGTH (npack
) != len
)
7368 for (i
= 0; i
< len
; ++i
)
7369 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7370 TREE_VEC_ELT (npack
, i
)))
7374 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7376 /* We get here probably because we are in the middle of substituting
7377 into the pattern of a pack expansion. In that case the
7378 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7379 interested in. So we want to use the initial pack argument for
7381 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7382 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7383 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7384 return template_args_equal (ot
, nt
);
7386 else if (TYPE_P (nt
))
7390 /* Don't treat an alias template specialization with dependent
7391 arguments as equivalent to its underlying type when used as a
7392 template argument; we need them to be distinct so that we
7393 substitute into the specialization arguments at instantiation
7394 time. And aliases can't be equivalent without being ==, so
7395 we don't need to look any deeper. */
7396 if (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
))
7399 return same_type_p (ot
, nt
);
7401 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7405 /* Try to treat a template non-type argument that has been converted
7406 to the parameter type as equivalent to one that hasn't yet. */
7407 for (enum tree_code code1
= TREE_CODE (ot
);
7408 CONVERT_EXPR_CODE_P (code1
)
7409 || code1
== NON_LVALUE_EXPR
;
7410 code1
= TREE_CODE (ot
))
7411 ot
= TREE_OPERAND (ot
, 0);
7412 for (enum tree_code code2
= TREE_CODE (nt
);
7413 CONVERT_EXPR_CODE_P (code2
)
7414 || code2
== NON_LVALUE_EXPR
;
7415 code2
= TREE_CODE (nt
))
7416 nt
= TREE_OPERAND (nt
, 0);
7418 return cp_tree_equal (ot
, nt
);
7422 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7423 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7424 NEWARG_PTR with the offending arguments if they are non-NULL. */
7427 comp_template_args_with_info (tree oldargs
, tree newargs
,
7428 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7432 if (oldargs
== newargs
)
7435 if (!oldargs
|| !newargs
)
7438 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7441 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7443 tree nt
= TREE_VEC_ELT (newargs
, i
);
7444 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7446 if (! template_args_equal (ot
, nt
))
7448 if (oldarg_ptr
!= NULL
)
7450 if (newarg_ptr
!= NULL
)
7458 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7459 of template arguments. Returns 0 otherwise. */
7462 comp_template_args (tree oldargs
, tree newargs
)
7464 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7468 add_pending_template (tree d
)
7470 tree ti
= (TYPE_P (d
)
7471 ? CLASSTYPE_TEMPLATE_INFO (d
)
7472 : DECL_TEMPLATE_INFO (d
));
7473 struct pending_template
*pt
;
7476 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7479 /* We are called both from instantiate_decl, where we've already had a
7480 tinst_level pushed, and instantiate_template, where we haven't.
7482 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7485 push_tinst_level (d
);
7487 pt
= ggc_alloc
<pending_template
> ();
7489 pt
->tinst
= current_tinst_level
;
7490 if (last_pending_template
)
7491 last_pending_template
->next
= pt
;
7493 pending_templates
= pt
;
7495 last_pending_template
= pt
;
7497 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7504 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7505 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7506 documentation for TEMPLATE_ID_EXPR. */
7509 lookup_template_function (tree fns
, tree arglist
)
7513 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7514 return error_mark_node
;
7516 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7518 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7520 error ("%q#D is not a function template", fns
);
7521 return error_mark_node
;
7524 if (BASELINK_P (fns
))
7526 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7528 BASELINK_FUNCTIONS (fns
),
7533 type
= TREE_TYPE (fns
);
7534 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7535 type
= unknown_type_node
;
7537 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7540 /* Within the scope of a template class S<T>, the name S gets bound
7541 (in build_self_reference) to a TYPE_DECL for the class, not a
7542 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7543 or one of its enclosing classes, and that type is a template,
7544 return the associated TEMPLATE_DECL. Otherwise, the original
7547 Also handle the case when DECL is a TREE_LIST of ambiguous
7548 injected-class-names from different bases. */
7551 maybe_get_template_decl_from_type_decl (tree decl
)
7553 if (decl
== NULL_TREE
)
7556 /* DR 176: A lookup that finds an injected-class-name (10.2
7557 [class.member.lookup]) can result in an ambiguity in certain cases
7558 (for example, if it is found in more than one base class). If all of
7559 the injected-class-names that are found refer to specializations of
7560 the same class template, and if the name is followed by a
7561 template-argument-list, the reference refers to the class template
7562 itself and not a specialization thereof, and is not ambiguous. */
7563 if (TREE_CODE (decl
) == TREE_LIST
)
7565 tree t
, tmpl
= NULL_TREE
;
7566 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7568 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7571 else if (tmpl
!= elt
)
7574 if (tmpl
&& t
== NULL_TREE
)
7580 return (decl
!= NULL_TREE
7581 && DECL_SELF_REFERENCE_P (decl
)
7582 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7583 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7586 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7587 parameters, find the desired type.
7589 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7591 IN_DECL, if non-NULL, is the template declaration we are trying to
7594 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7595 the class we are looking up.
7597 Issue error and warning messages under control of COMPLAIN.
7599 If the template class is really a local class in a template
7600 function, then the FUNCTION_CONTEXT is the function in which it is
7603 ??? Note that this function is currently called *twice* for each
7604 template-id: the first time from the parser, while creating the
7605 incomplete type (finish_template_type), and the second type during the
7606 real instantiation (instantiate_template_class). This is surely something
7607 that we want to avoid. It also causes some problems with argument
7608 coercion (see convert_nontype_argument for more information on this). */
7611 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7612 int entering_scope
, tsubst_flags_t complain
)
7614 tree templ
= NULL_TREE
, parmlist
;
7621 if (identifier_p (d1
))
7623 tree value
= innermost_non_namespace_value (d1
);
7624 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7629 push_decl_namespace (context
);
7630 templ
= lookup_name (d1
);
7631 templ
= maybe_get_template_decl_from_type_decl (templ
);
7633 pop_decl_namespace ();
7636 context
= DECL_CONTEXT (templ
);
7638 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7640 tree type
= TREE_TYPE (d1
);
7642 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7643 an implicit typename for the second A. Deal with it. */
7644 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7645 type
= TREE_TYPE (type
);
7647 if (CLASSTYPE_TEMPLATE_INFO (type
))
7649 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7650 d1
= DECL_NAME (templ
);
7653 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7654 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7656 templ
= TYPE_TI_TEMPLATE (d1
);
7657 d1
= DECL_NAME (templ
);
7659 else if (DECL_TYPE_TEMPLATE_P (d1
))
7662 d1
= DECL_NAME (templ
);
7663 context
= DECL_CONTEXT (templ
);
7665 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7668 d1
= DECL_NAME (templ
);
7671 /* Issue an error message if we didn't find a template. */
7674 if (complain
& tf_error
)
7675 error ("%qT is not a template", d1
);
7676 return error_mark_node
;
7679 if (TREE_CODE (templ
) != TEMPLATE_DECL
7680 /* Make sure it's a user visible template, if it was named by
7682 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7683 && !PRIMARY_TEMPLATE_P (templ
)))
7685 if (complain
& tf_error
)
7687 error ("non-template type %qT used as a template", d1
);
7689 error ("for template declaration %q+D", in_decl
);
7691 return error_mark_node
;
7694 complain
&= ~tf_user
;
7696 /* An alias that just changes the name of a template is equivalent to the
7697 other template, so if any of the arguments are pack expansions, strip
7698 the alias to avoid problems with a pack expansion passed to a non-pack
7699 alias template parameter (DR 1430). */
7700 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7701 templ
= get_underlying_template (templ
);
7703 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7705 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7706 template arguments */
7712 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7714 /* Consider an example where a template template parameter declared as
7716 template <class T, class U = std::allocator<T> > class TT
7718 The template parameter level of T and U are one level larger than
7719 of TT. To proper process the default argument of U, say when an
7720 instantiation `TT<int>' is seen, we need to build the full
7721 arguments containing {int} as the innermost level. Outer levels,
7722 available when not appearing as default template argument, can be
7723 obtained from the arguments of the enclosing template.
7725 Suppose that TT is later substituted with std::vector. The above
7726 instantiation is `TT<int, std::allocator<T> >' with TT at
7727 level 1, and T at level 2, while the template arguments at level 1
7728 becomes {std::vector} and the inner level 2 is {int}. */
7730 outer
= DECL_CONTEXT (templ
);
7732 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7733 else if (current_template_parms
)
7734 /* This is an argument of the current template, so we haven't set
7735 DECL_CONTEXT yet. */
7736 outer
= current_template_args ();
7739 arglist
= add_to_template_args (outer
, arglist
);
7741 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7743 /*require_all_args=*/true,
7744 /*use_default_args=*/true);
7745 if (arglist2
== error_mark_node
7746 || (!uses_template_parms (arglist2
)
7747 && check_instantiated_args (templ
, arglist2
, complain
)))
7748 return error_mark_node
;
7750 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7755 tree template_type
= TREE_TYPE (templ
);
7758 tree found
= NULL_TREE
;
7761 int is_dependent_type
;
7762 int use_partial_inst_tmpl
= false;
7764 if (template_type
== error_mark_node
)
7765 /* An error occurred while building the template TEMPL, and a
7766 diagnostic has most certainly been emitted for that
7767 already. Let's propagate that error. */
7768 return error_mark_node
;
7770 gen_tmpl
= most_general_template (templ
);
7771 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7772 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7773 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7775 if (arg_depth
== 1 && parm_depth
> 1)
7777 /* We've been given an incomplete set of template arguments.
7780 template <class T> struct S1 {
7781 template <class U> struct S2 {};
7782 template <class U> struct S2<U*> {};
7785 we will be called with an ARGLIST of `U*', but the
7786 TEMPLATE will be `template <class T> template
7787 <class U> struct S1<T>::S2'. We must fill in the missing
7790 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7792 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7795 /* Now we should have enough arguments. */
7796 gcc_assert (parm_depth
== arg_depth
);
7798 /* From here on, we're only interested in the most general
7801 /* Calculate the BOUND_ARGS. These will be the args that are
7802 actually tsubst'd into the definition to create the
7804 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
7806 /*require_all_args=*/true,
7807 /*use_default_args=*/true);
7809 if (arglist
== error_mark_node
)
7810 /* We were unable to bind the arguments. */
7811 return error_mark_node
;
7813 /* In the scope of a template class, explicit references to the
7814 template class refer to the type of the template, not any
7815 instantiation of it. For example, in:
7817 template <class T> class C { void f(C<T>); }
7819 the `C<T>' is just the same as `C'. Outside of the
7820 class, however, such a reference is an instantiation. */
7822 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7823 || currently_open_class (template_type
))
7824 /* comp_template_args is expensive, check it last. */
7825 && comp_template_args (TYPE_TI_ARGS (template_type
),
7827 return template_type
;
7829 /* If we already have this specialization, return it. */
7830 elt
.tmpl
= gen_tmpl
;
7832 hash
= spec_hasher::hash (&elt
);
7833 entry
= type_specializations
->find_with_hash (&elt
, hash
);
7838 is_dependent_type
= uses_template_parms (arglist
);
7840 /* If the deduced arguments are invalid, then the binding
7842 if (!is_dependent_type
7843 && check_instantiated_args (gen_tmpl
,
7844 INNERMOST_TEMPLATE_ARGS (arglist
),
7846 return error_mark_node
;
7848 if (!is_dependent_type
7849 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7850 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7851 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7853 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7854 DECL_NAME (gen_tmpl
),
7855 /*tag_scope=*/ts_global
);
7859 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7861 if (context
== error_mark_node
)
7862 return error_mark_node
;
7865 context
= global_namespace
;
7867 /* Create the type. */
7868 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7870 /* The user referred to a specialization of an alias
7871 template represented by GEN_TMPL.
7873 [temp.alias]/2 says:
7875 When a template-id refers to the specialization of an
7876 alias template, it is equivalent to the associated
7877 type obtained by substitution of its
7878 template-arguments for the template-parameters in the
7879 type-id of the alias template. */
7881 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7882 /* Note that the call above (by indirectly calling
7883 register_specialization in tsubst_decl) registers the
7884 TYPE_DECL representing the specialization of the alias
7885 template. So next time someone substitutes ARGLIST for
7886 the template parms into the alias template (GEN_TMPL),
7887 she'll get that TYPE_DECL back. */
7889 if (t
== error_mark_node
)
7892 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7894 if (!is_dependent_type
)
7896 set_current_access_from_decl (TYPE_NAME (template_type
));
7897 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7898 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7899 arglist
, complain
, in_decl
),
7900 SCOPED_ENUM_P (template_type
), NULL
);
7902 if (t
== error_mark_node
)
7907 /* We don't want to call start_enum for this type, since
7908 the values for the enumeration constants may involve
7909 template parameters. And, no one should be interested
7910 in the enumeration constants for such a type. */
7911 t
= cxx_make_type (ENUMERAL_TYPE
);
7912 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7914 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7915 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7916 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7918 else if (CLASS_TYPE_P (template_type
))
7920 t
= make_class_type (TREE_CODE (template_type
));
7921 CLASSTYPE_DECLARED_CLASS (t
)
7922 = CLASSTYPE_DECLARED_CLASS (template_type
);
7923 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7924 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7926 /* A local class. Make sure the decl gets registered properly. */
7927 if (context
== current_function_decl
)
7928 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7930 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7931 /* This instantiation is another name for the primary
7932 template type. Set the TYPE_CANONICAL field
7934 TYPE_CANONICAL (t
) = template_type
;
7935 else if (any_template_arguments_need_structural_equality_p (arglist
))
7936 /* Some of the template arguments require structural
7937 equality testing, so this template class requires
7938 structural equality testing. */
7939 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7944 /* If we called start_enum or pushtag above, this information
7945 will already be set up. */
7948 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7950 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7951 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7952 DECL_SOURCE_LOCATION (type_decl
)
7953 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7956 type_decl
= TYPE_NAME (t
);
7958 if (CLASS_TYPE_P (template_type
))
7960 TREE_PRIVATE (type_decl
)
7961 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7962 TREE_PROTECTED (type_decl
)
7963 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7964 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7966 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7967 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7971 if (OVERLOAD_TYPE_P (t
)
7972 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7974 static const char *tags
[] = {"abi_tag", "may_alias"};
7976 for (unsigned ix
= 0; ix
!= 2; ix
++)
7979 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
7983 else if (!TREE_CHAIN (attributes
) && !TYPE_ATTRIBUTES (t
))
7984 TYPE_ATTRIBUTES (t
) = attributes
;
7987 = tree_cons (TREE_PURPOSE (attributes
),
7988 TREE_VALUE (attributes
),
7989 TYPE_ATTRIBUTES (t
));
7993 /* Let's consider the explicit specialization of a member
7994 of a class template specialization that is implicitly instantiated,
7999 template<class U> struct M {}; //#0
8004 struct S<int>::M<char> //#1
8008 [temp.expl.spec]/4 says this is valid.
8010 In this case, when we write:
8013 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
8016 When we encounter #1, we want to store the partial instantiation
8017 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
8019 For all cases other than this "explicit specialization of member of a
8020 class template", we just want to store the most general template into
8021 the CLASSTYPE_TI_TEMPLATE of M.
8023 This case of "explicit specialization of member of a class template"
8025 1/ the enclosing class is an instantiation of, and therefore not
8026 the same as, the context of the most general template, and
8027 2/ we aren't looking at the partial instantiation itself, i.e.
8028 the innermost arguments are not the same as the innermost parms of
8029 the most general template.
8031 So it's only when 1/ and 2/ happens that we want to use the partial
8032 instantiation of the member template in lieu of its most general
8035 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
8036 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
8037 /* the enclosing class must be an instantiation... */
8038 && CLASS_TYPE_P (context
)
8039 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
8041 tree partial_inst_args
;
8042 TREE_VEC_LENGTH (arglist
)--;
8043 ++processing_template_decl
;
8045 tsubst (INNERMOST_TEMPLATE_ARGS
8046 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
8047 arglist
, complain
, NULL_TREE
);
8048 --processing_template_decl
;
8049 TREE_VEC_LENGTH (arglist
)++;
8050 use_partial_inst_tmpl
=
8051 /*...and we must not be looking at the partial instantiation
8053 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
8057 if (!use_partial_inst_tmpl
)
8058 /* This case is easy; there are no member templates involved. */
8062 /* This is a full instantiation of a member template. Find
8063 the partial instantiation of which this is an instance. */
8065 /* Temporarily reduce by one the number of levels in the ARGLIST
8066 so as to avoid comparing the last set of arguments. */
8067 TREE_VEC_LENGTH (arglist
)--;
8068 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
8069 TREE_VEC_LENGTH (arglist
)++;
8070 /* FOUND is either a proper class type, or an alias
8071 template specialization. In the later case, it's a
8072 TYPE_DECL, resulting from the substituting of arguments
8073 for parameters in the TYPE_DECL of the alias template
8074 done earlier. So be careful while getting the template
8076 found
= TREE_CODE (found
) == TYPE_DECL
8077 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
8078 : CLASSTYPE_TI_TEMPLATE (found
);
8081 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
8084 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
8085 entry
= ggc_alloc
<spec_entry
> ();
8089 /* Note this use of the partial instantiation so we can check it
8090 later in maybe_process_partial_specialization. */
8091 DECL_TEMPLATE_INSTANTIATIONS (found
)
8092 = tree_cons (arglist
, t
,
8093 DECL_TEMPLATE_INSTANTIATIONS (found
));
8095 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
8096 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8097 /* Now that the type has been registered on the instantiations
8098 list, we set up the enumerators. Because the enumeration
8099 constants may involve the enumeration type itself, we make
8100 sure to register the type first, and then create the
8101 constants. That way, doing tsubst_expr for the enumeration
8102 constants won't result in recursive calls here; we'll find
8103 the instantiation and exit above. */
8104 tsubst_enum (template_type
, t
, arglist
);
8106 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
8107 /* If the type makes use of template parameters, the
8108 code that generates debugging information will crash. */
8109 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
8111 /* Possibly limit visibility based on template args. */
8112 TREE_PUBLIC (type_decl
) = 1;
8113 determine_visibility (type_decl
);
8115 inherit_targ_abi_tags (t
);
8121 /* Wrapper for lookup_template_class_1. */
8124 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
8125 int entering_scope
, tsubst_flags_t complain
)
8128 timevar_push (TV_TEMPLATE_INST
);
8129 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
8130 entering_scope
, complain
);
8131 timevar_pop (TV_TEMPLATE_INST
);
8135 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST.
8136 The type of the expression is the unknown_type_node since the
8137 template-id could refer to an explicit or partial specialization. */
8140 lookup_template_variable (tree templ
, tree arglist
)
8142 tree type
= unknown_type_node
;
8143 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
8146 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
8149 finish_template_variable (tree var
)
8151 tree templ
= TREE_OPERAND (var
, 0);
8153 tree arglist
= TREE_OPERAND (var
, 1);
8154 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
8155 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
8157 tree parms
= DECL_TEMPLATE_PARMS (templ
);
8158 tsubst_flags_t complain
= tf_warning_or_error
;
8159 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
8161 /*use_default*/true);
8163 return instantiate_template (templ
, arglist
, complain
);
8170 /* True when we should also visit template parameters that occur in
8171 non-deduced contexts. */
8172 bool include_nondeduced_p
;
8173 hash_set
<tree
> *visited
;
8176 /* Called from for_each_template_parm via walk_tree. */
8179 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
8182 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
8183 tree_fn_t fn
= pfd
->fn
;
8184 void *data
= pfd
->data
;
8187 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
8188 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
8189 pfd
->include_nondeduced_p
))
8190 return error_mark_node
;
8192 switch (TREE_CODE (t
))
8195 if (TYPE_PTRMEMFUNC_P (t
))
8201 if (!TYPE_TEMPLATE_INFO (t
))
8203 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
8204 fn
, data
, pfd
->visited
,
8205 pfd
->include_nondeduced_p
))
8206 return error_mark_node
;
8210 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
8211 fn
, data
, pfd
->visited
,
8212 pfd
->include_nondeduced_p
)
8213 || for_each_template_parm (TYPE_MAX_VALUE (t
),
8214 fn
, data
, pfd
->visited
,
8215 pfd
->include_nondeduced_p
))
8216 return error_mark_node
;
8220 /* Since we're not going to walk subtrees, we have to do this
8222 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
8223 pfd
->visited
, pfd
->include_nondeduced_p
))
8224 return error_mark_node
;
8228 /* Check the return type. */
8229 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8230 pfd
->include_nondeduced_p
))
8231 return error_mark_node
;
8233 /* Check the parameter types. Since default arguments are not
8234 instantiated until they are needed, the TYPE_ARG_TYPES may
8235 contain expressions that involve template parameters. But,
8236 no-one should be looking at them yet. And, once they're
8237 instantiated, they don't contain template parameters, so
8238 there's no point in looking at them then, either. */
8242 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
8243 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
8244 pfd
->visited
, pfd
->include_nondeduced_p
))
8245 return error_mark_node
;
8247 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8248 want walk_tree walking into them itself. */
8254 case UNDERLYING_TYPE
:
8255 if (pfd
->include_nondeduced_p
8256 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
8258 pfd
->include_nondeduced_p
))
8259 return error_mark_node
;
8264 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
8265 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
8266 pfd
->visited
, pfd
->include_nondeduced_p
))
8267 return error_mark_node
;
8272 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
8273 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
8274 pfd
->visited
, pfd
->include_nondeduced_p
))
8275 return error_mark_node
;
8276 if (DECL_CONTEXT (t
)
8277 && pfd
->include_nondeduced_p
8278 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
8279 pfd
->visited
, pfd
->include_nondeduced_p
))
8280 return error_mark_node
;
8283 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8284 /* Record template parameters such as `T' inside `TT<T>'. */
8285 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
8286 pfd
->include_nondeduced_p
))
8287 return error_mark_node
;
8290 case TEMPLATE_TEMPLATE_PARM
:
8291 case TEMPLATE_TYPE_PARM
:
8292 case TEMPLATE_PARM_INDEX
:
8293 if (fn
&& (*fn
)(t
, data
))
8294 return error_mark_node
;
8296 return error_mark_node
;
8300 /* A template template parameter is encountered. */
8301 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
8302 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8303 pfd
->include_nondeduced_p
))
8304 return error_mark_node
;
8306 /* Already substituted template template parameter */
8312 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8314 pfd
->include_nondeduced_p
))
8315 return error_mark_node
;
8319 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8320 && pfd
->include_nondeduced_p
8321 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8322 (TREE_TYPE (t
)), fn
, data
,
8323 pfd
->visited
, pfd
->include_nondeduced_p
))
8324 return error_mark_node
;
8329 /* If there's no type, then this thing must be some expression
8330 involving template parameters. */
8331 if (!fn
&& !TREE_TYPE (t
))
8332 return error_mark_node
;
8337 case IMPLICIT_CONV_EXPR
:
8338 case REINTERPRET_CAST_EXPR
:
8339 case CONST_CAST_EXPR
:
8340 case STATIC_CAST_EXPR
:
8341 case DYNAMIC_CAST_EXPR
:
8345 case PSEUDO_DTOR_EXPR
:
8347 return error_mark_node
;
8354 /* We didn't find any template parameters we liked. */
8358 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8359 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8360 call FN with the parameter and the DATA.
8361 If FN returns nonzero, the iteration is terminated, and
8362 for_each_template_parm returns 1. Otherwise, the iteration
8363 continues. If FN never returns a nonzero value, the value
8364 returned by for_each_template_parm is 0. If FN is NULL, it is
8365 considered to be the function which always returns 1.
8367 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8368 parameters that occur in non-deduced contexts. When false, only
8369 visits those template parameters that can be deduced. */
8372 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8373 hash_set
<tree
> *visited
,
8374 bool include_nondeduced_p
)
8376 struct pair_fn_data pfd
;
8382 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8384 /* Walk the tree. (Conceptually, we would like to walk without
8385 duplicates, but for_each_template_parm_r recursively calls
8386 for_each_template_parm, so we would need to reorganize a fair
8387 bit to use walk_tree_without_duplicates, so we keep our own
8390 pfd
.visited
= visited
;
8392 pfd
.visited
= new hash_set
<tree
>;
8393 result
= cp_walk_tree (&t
,
8394 for_each_template_parm_r
,
8396 pfd
.visited
) != NULL_TREE
;
8408 /* Returns true if T depends on any template parameter. */
8411 uses_template_parms (tree t
)
8417 int saved_processing_template_decl
;
8419 saved_processing_template_decl
= processing_template_decl
;
8420 if (!saved_processing_template_decl
)
8421 processing_template_decl
= 1;
8423 dependent_p
= dependent_type_p (t
);
8424 else if (TREE_CODE (t
) == TREE_VEC
)
8425 dependent_p
= any_dependent_template_arguments_p (t
);
8426 else if (TREE_CODE (t
) == TREE_LIST
)
8427 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8428 || uses_template_parms (TREE_CHAIN (t
)));
8429 else if (TREE_CODE (t
) == TYPE_DECL
)
8430 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8433 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8434 || TREE_CODE (t
) == OVERLOAD
8437 || TREE_CODE (t
) == TRAIT_EXPR
8438 || TREE_CODE (t
) == CONSTRUCTOR
8439 || CONSTANT_CLASS_P (t
))
8440 dependent_p
= (type_dependent_expression_p (t
)
8441 || value_dependent_expression_p (t
));
8444 gcc_assert (t
== error_mark_node
);
8445 dependent_p
= false;
8448 processing_template_decl
= saved_processing_template_decl
;
8453 /* Returns true iff current_function_decl is an incompletely instantiated
8454 template. Useful instead of processing_template_decl because the latter
8455 is set to 0 during instantiate_non_dependent_expr. */
8458 in_template_function (void)
8460 tree fn
= current_function_decl
;
8462 ++processing_template_decl
;
8463 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8464 && DECL_TEMPLATE_INFO (fn
)
8465 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8466 --processing_template_decl
;
8470 /* Returns true if T depends on any template parameter with level LEVEL. */
8473 uses_template_parms_level (tree t
, int level
)
8475 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8476 /*include_nondeduced_p=*/true);
8479 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8480 ill-formed translation unit, i.e. a variable or function that isn't
8481 usable in a constant expression. */
8484 neglectable_inst_p (tree d
)
8487 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8488 : decl_maybe_constant_var_p (d
)));
8491 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8492 neglectable and instantiated from within an erroneous instantiation. */
8495 limit_bad_template_recursion (tree decl
)
8497 struct tinst_level
*lev
= current_tinst_level
;
8498 int errs
= errorcount
+ sorrycount
;
8499 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8502 for (; lev
; lev
= lev
->next
)
8503 if (neglectable_inst_p (lev
->decl
))
8506 return (lev
&& errs
> lev
->errors
);
8509 static int tinst_depth
;
8510 extern int max_tinst_depth
;
8513 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8515 /* We're starting to instantiate D; record the template instantiation context
8516 for diagnostics and to restore it later. */
8519 push_tinst_level (tree d
)
8521 return push_tinst_level_loc (d
, input_location
);
8524 /* We're starting to instantiate D; record the template instantiation context
8525 at LOC for diagnostics and to restore it later. */
8528 push_tinst_level_loc (tree d
, location_t loc
)
8530 struct tinst_level
*new_level
;
8532 if (tinst_depth
>= max_tinst_depth
)
8534 fatal_error (input_location
,
8535 "template instantiation depth exceeds maximum of %d"
8536 " (use -ftemplate-depth= to increase the maximum)",
8541 /* If the current instantiation caused problems, don't let it instantiate
8542 anything else. Do allow deduction substitution and decls usable in
8543 constant expressions. */
8544 if (limit_bad_template_recursion (d
))
8547 new_level
= ggc_alloc
<tinst_level
> ();
8548 new_level
->decl
= d
;
8549 new_level
->locus
= loc
;
8550 new_level
->errors
= errorcount
+sorrycount
;
8551 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8552 new_level
->next
= current_tinst_level
;
8553 current_tinst_level
= new_level
;
8556 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8557 depth_reached
= tinst_depth
;
8562 /* We're done instantiating this template; return to the instantiation
8566 pop_tinst_level (void)
8568 /* Restore the filename and line number stashed away when we started
8569 this instantiation. */
8570 input_location
= current_tinst_level
->locus
;
8571 current_tinst_level
= current_tinst_level
->next
;
8575 /* We're instantiating a deferred template; restore the template
8576 instantiation context in which the instantiation was requested, which
8577 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8580 reopen_tinst_level (struct tinst_level
*level
)
8582 struct tinst_level
*t
;
8585 for (t
= level
; t
; t
= t
->next
)
8588 current_tinst_level
= level
;
8590 if (current_tinst_level
)
8591 current_tinst_level
->errors
= errorcount
+sorrycount
;
8595 /* Returns the TINST_LEVEL which gives the original instantiation
8598 struct tinst_level
*
8599 outermost_tinst_level (void)
8601 struct tinst_level
*level
= current_tinst_level
;
8604 level
= level
->next
;
8608 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8609 vector of template arguments, as for tsubst.
8611 Returns an appropriate tsubst'd friend declaration. */
8614 tsubst_friend_function (tree decl
, tree args
)
8618 if (TREE_CODE (decl
) == FUNCTION_DECL
8619 && DECL_TEMPLATE_INSTANTIATION (decl
)
8620 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8621 /* This was a friend declared with an explicit template
8622 argument list, e.g.:
8626 to indicate that f was a template instantiation, not a new
8627 function declaration. Now, we have to figure out what
8628 instantiation of what template. */
8630 tree template_id
, arglist
, fns
;
8633 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8635 /* Friend functions are looked up in the containing namespace scope.
8636 We must enter that scope, to avoid finding member functions of the
8637 current class with same name. */
8638 push_nested_namespace (ns
);
8639 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8640 tf_warning_or_error
, NULL_TREE
,
8641 /*integral_constant_expression_p=*/false);
8642 pop_nested_namespace (ns
);
8643 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8644 tf_warning_or_error
, NULL_TREE
);
8645 template_id
= lookup_template_function (fns
, arglist
);
8647 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8648 tmpl
= determine_specialization (template_id
, new_friend
,
8650 /*need_member_template=*/0,
8651 TREE_VEC_LENGTH (args
),
8653 return instantiate_template (tmpl
, new_args
, tf_error
);
8656 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8658 /* The NEW_FRIEND will look like an instantiation, to the
8659 compiler, but is not an instantiation from the point of view of
8660 the language. For example, we might have had:
8662 template <class T> struct S {
8663 template <class U> friend void f(T, U);
8666 Then, in S<int>, template <class U> void f(int, U) is not an
8667 instantiation of anything. */
8668 if (new_friend
== error_mark_node
)
8669 return error_mark_node
;
8671 DECL_USE_TEMPLATE (new_friend
) = 0;
8672 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8674 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8675 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8676 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8679 /* The mangled name for the NEW_FRIEND is incorrect. The function
8680 is not a template instantiation and should not be mangled like
8681 one. Therefore, we forget the mangling here; we'll recompute it
8682 later if we need it. */
8683 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8685 SET_DECL_RTL (new_friend
, NULL
);
8686 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8689 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8692 tree new_friend_template_info
;
8693 tree new_friend_result_template_info
;
8695 int new_friend_is_defn
;
8697 /* We must save some information from NEW_FRIEND before calling
8698 duplicate decls since that function will free NEW_FRIEND if
8700 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8701 new_friend_is_defn
=
8702 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8703 (template_for_substitution (new_friend
)))
8705 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8707 /* This declaration is a `primary' template. */
8708 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8710 new_friend_result_template_info
8711 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8714 new_friend_result_template_info
= NULL_TREE
;
8716 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8717 if (new_friend_is_defn
)
8718 DECL_INITIAL (new_friend
) = error_mark_node
;
8720 /* Inside pushdecl_namespace_level, we will push into the
8721 current namespace. However, the friend function should go
8722 into the namespace of the template. */
8723 ns
= decl_namespace_context (new_friend
);
8724 push_nested_namespace (ns
);
8725 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8726 pop_nested_namespace (ns
);
8728 if (old_decl
== error_mark_node
)
8729 return error_mark_node
;
8731 if (old_decl
!= new_friend
)
8733 /* This new friend declaration matched an existing
8734 declaration. For example, given:
8736 template <class T> void f(T);
8737 template <class U> class C {
8738 template <class T> friend void f(T) {}
8741 the friend declaration actually provides the definition
8742 of `f', once C has been instantiated for some type. So,
8743 old_decl will be the out-of-class template declaration,
8744 while new_friend is the in-class definition.
8746 But, if `f' was called before this point, the
8747 instantiation of `f' will have DECL_TI_ARGS corresponding
8748 to `T' but not to `U', references to which might appear
8749 in the definition of `f'. Previously, the most general
8750 template for an instantiation of `f' was the out-of-class
8751 version; now it is the in-class version. Therefore, we
8752 run through all specialization of `f', adding to their
8753 DECL_TI_ARGS appropriately. In particular, they need a
8754 new set of outer arguments, corresponding to the
8755 arguments for this class instantiation.
8757 The same situation can arise with something like this:
8760 template <class T> class C {
8764 when `C<int>' is instantiated. Now, `f(int)' is defined
8767 if (!new_friend_is_defn
)
8768 /* On the other hand, if the in-class declaration does
8769 *not* provide a definition, then we don't want to alter
8770 existing definitions. We can just leave everything
8775 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8776 tree new_args
= TI_ARGS (new_friend_template_info
);
8778 /* Overwrite whatever template info was there before, if
8779 any, with the new template information pertaining to
8781 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8783 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8785 /* We should have called reregister_specialization in
8787 gcc_assert (retrieve_specialization (new_template
,
8791 /* Instantiate it if the global has already been used. */
8792 if (DECL_ODR_USED (old_decl
))
8793 instantiate_decl (old_decl
, /*defer_ok=*/true,
8794 /*expl_inst_class_mem_p=*/false);
8800 /* Indicate that the old function template is a partial
8802 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8803 = new_friend_result_template_info
;
8805 gcc_assert (new_template
8806 == most_general_template (new_template
));
8807 gcc_assert (new_template
!= old_decl
);
8809 /* Reassign any specializations already in the hash table
8810 to the new more general template, and add the
8811 additional template args. */
8812 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8816 tree spec
= TREE_VALUE (t
);
8819 elt
.tmpl
= old_decl
;
8820 elt
.args
= DECL_TI_ARGS (spec
);
8821 elt
.spec
= NULL_TREE
;
8823 decl_specializations
->remove_elt (&elt
);
8826 = add_outermost_template_args (new_args
,
8827 DECL_TI_ARGS (spec
));
8829 register_specialization
8830 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8833 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8837 /* The information from NEW_FRIEND has been merged into OLD_DECL
8838 by duplicate_decls. */
8839 new_friend
= old_decl
;
8844 tree context
= DECL_CONTEXT (new_friend
);
8848 template <class T> class C {
8849 template <class U> friend void C1<U>::f (); // case 1
8850 friend void C2<T>::f (); // case 2
8852 we only need to make sure CONTEXT is a complete type for
8853 case 2. To distinguish between the two cases, we note that
8854 CONTEXT of case 1 remains dependent type after tsubst while
8855 this isn't true for case 2. */
8856 ++processing_template_decl
;
8857 dependent_p
= dependent_type_p (context
);
8858 --processing_template_decl
;
8861 && !complete_type_or_else (context
, NULL_TREE
))
8862 return error_mark_node
;
8864 if (COMPLETE_TYPE_P (context
))
8866 tree fn
= new_friend
;
8867 /* do_friend adds the TEMPLATE_DECL for any member friend
8868 template even if it isn't a member template, i.e.
8869 template <class T> friend A<T>::f();
8870 Look through it in that case. */
8871 if (TREE_CODE (fn
) == TEMPLATE_DECL
8872 && !PRIMARY_TEMPLATE_P (fn
))
8873 fn
= DECL_TEMPLATE_RESULT (fn
);
8874 /* Check to see that the declaration is really present, and,
8875 possibly obtain an improved declaration. */
8876 fn
= check_classfn (context
, fn
, NULL_TREE
);
8886 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8887 template arguments, as for tsubst.
8889 Returns an appropriate tsubst'd friend type or error_mark_node on
8893 tsubst_friend_class (tree friend_tmpl
, tree args
)
8899 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8901 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8902 return TREE_TYPE (t
);
8905 context
= CP_DECL_CONTEXT (friend_tmpl
);
8907 if (context
!= global_namespace
)
8909 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8910 push_nested_namespace (context
);
8912 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8915 /* Look for a class template declaration. We look for hidden names
8916 because two friend declarations of the same template are the
8917 same. For example, in:
8920 template <typename> friend class F;
8922 template <typename> struct B {
8923 template <typename> friend class F;
8926 both F templates are the same. */
8927 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8928 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8930 /* But, if we don't find one, it might be because we're in a
8931 situation like this:
8939 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8940 for `S<int>', not the TEMPLATE_DECL. */
8941 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8943 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8944 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8947 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8949 /* The friend template has already been declared. Just
8950 check to see that the declarations match, and install any new
8951 default parameters. We must tsubst the default parameters,
8952 of course. We only need the innermost template parameters
8953 because that is all that redeclare_class_template will look
8955 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8956 > TMPL_ARGS_DEPTH (args
))
8959 location_t saved_input_location
;
8960 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8961 args
, tf_warning_or_error
);
8963 saved_input_location
= input_location
;
8964 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8965 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8966 input_location
= saved_input_location
;
8970 friend_type
= TREE_TYPE (tmpl
);
8974 /* The friend template has not already been declared. In this
8975 case, the instantiation of the template class will cause the
8976 injection of this template into the global scope. */
8977 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8978 if (tmpl
== error_mark_node
)
8979 return error_mark_node
;
8981 /* The new TMPL is not an instantiation of anything, so we
8982 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8983 the new type because that is supposed to be the corresponding
8984 template decl, i.e., TMPL. */
8985 DECL_USE_TEMPLATE (tmpl
) = 0;
8986 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8987 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8988 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8989 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8991 /* Inject this template into the global scope. */
8992 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8995 if (context
!= global_namespace
)
8997 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8998 pop_nested_namespace (context
);
9000 pop_nested_class ();
9006 /* Returns zero if TYPE cannot be completed later due to circularity.
9007 Otherwise returns one. */
9010 can_complete_type_without_circularity (tree type
)
9012 if (type
== NULL_TREE
|| type
== error_mark_node
)
9014 else if (COMPLETE_TYPE_P (type
))
9016 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
9017 return can_complete_type_without_circularity (TREE_TYPE (type
));
9018 else if (CLASS_TYPE_P (type
)
9019 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
9025 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
9027 /* Apply any attributes which had to be deferred until instantiation
9028 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
9029 ARGS, COMPLAIN, IN_DECL are as tsubst. */
9032 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
9033 tree args
, tsubst_flags_t complain
, tree in_decl
)
9035 tree last_dep
= NULL_TREE
;
9039 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
9040 if (ATTR_IS_DEPENDENT (t
))
9043 attributes
= copy_list (attributes
);
9047 if (DECL_P (*decl_p
))
9049 if (TREE_TYPE (*decl_p
) == error_mark_node
)
9051 p
= &DECL_ATTRIBUTES (*decl_p
);
9054 p
= &TYPE_ATTRIBUTES (*decl_p
);
9058 tree late_attrs
= NULL_TREE
;
9059 tree
*q
= &late_attrs
;
9061 for (*p
= attributes
; *p
; )
9064 if (ATTR_IS_DEPENDENT (t
))
9066 *p
= TREE_CHAIN (t
);
9067 TREE_CHAIN (t
) = NULL_TREE
;
9068 if ((flag_openmp
|| flag_cilkplus
)
9069 && is_attribute_p ("omp declare simd",
9070 get_attribute_name (t
))
9073 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
9074 clauses
= tsubst_omp_clauses (clauses
, true, args
,
9076 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
9077 clauses
= finish_omp_clauses (clauses
);
9078 tree parms
= DECL_ARGUMENTS (*decl_p
);
9080 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
9082 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
9084 TREE_VALUE (t
) = NULL_TREE
;
9086 /* If the first attribute argument is an identifier, don't
9087 pass it through tsubst. Attributes like mode, format,
9088 cleanup and several target specific attributes expect it
9090 else if (attribute_takes_identifier_p (get_attribute_name (t
))
9094 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
9096 /*integral_constant_expression_p=*/false);
9097 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
9099 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
9102 else if (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
)))
9104 /* An attribute pack expansion. */
9105 tree purp
= TREE_PURPOSE (t
);
9106 tree pack
= (tsubst_pack_expansion
9107 (TREE_VALUE (t
), args
, complain
, in_decl
));
9108 int len
= TREE_VEC_LENGTH (pack
);
9109 for (int i
= 0; i
< len
; ++i
)
9111 tree elt
= TREE_VEC_ELT (pack
, i
);
9112 *q
= build_tree_list (purp
, elt
);
9113 q
= &TREE_CHAIN (*q
);
9119 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
9120 /*integral_constant_expression_p=*/false);
9122 q
= &TREE_CHAIN (t
);
9125 p
= &TREE_CHAIN (t
);
9128 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
9132 /* Perform (or defer) access check for typedefs that were referenced
9133 from within the template TMPL code.
9134 This is a subroutine of instantiate_decl and instantiate_class_template.
9135 TMPL is the template to consider and TARGS is the list of arguments of
9139 perform_typedefs_access_check (tree tmpl
, tree targs
)
9141 location_t saved_location
;
9143 qualified_typedef_usage_t
*iter
;
9146 || (!CLASS_TYPE_P (tmpl
)
9147 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
9150 saved_location
= input_location
;
9151 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
9153 tree type_decl
= iter
->typedef_decl
;
9154 tree type_scope
= iter
->context
;
9156 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
9159 if (uses_template_parms (type_decl
))
9160 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
9161 if (uses_template_parms (type_scope
))
9162 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
9164 /* Make access check error messages point to the location
9165 of the use of the typedef. */
9166 input_location
= iter
->locus
;
9167 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
9168 type_decl
, type_decl
,
9169 tf_warning_or_error
);
9171 input_location
= saved_location
;
9175 instantiate_class_template_1 (tree type
)
9177 tree templ
, args
, pattern
, t
, member
;
9181 unsigned int saved_maximum_field_alignment
;
9184 if (type
== error_mark_node
)
9185 return error_mark_node
;
9187 if (COMPLETE_OR_OPEN_TYPE_P (type
)
9188 || uses_template_parms (type
))
9191 /* Figure out which template is being instantiated. */
9192 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
9193 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
9195 /* Determine what specialization of the original template to
9197 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
9198 if (t
== error_mark_node
)
9200 TYPE_BEING_DEFINED (type
) = 1;
9201 return error_mark_node
;
9205 /* This TYPE is actually an instantiation of a partial
9206 specialization. We replace the innermost set of ARGS with
9207 the arguments appropriate for substitution. For example,
9210 template <class T> struct S {};
9211 template <class T> struct S<T*> {};
9213 and supposing that we are instantiating S<int*>, ARGS will
9214 presently be {int*} -- but we need {int}. */
9215 pattern
= TREE_TYPE (t
);
9216 args
= TREE_PURPOSE (t
);
9220 pattern
= TREE_TYPE (templ
);
9221 args
= CLASSTYPE_TI_ARGS (type
);
9224 /* If the template we're instantiating is incomplete, then clearly
9225 there's nothing we can do. */
9226 if (!COMPLETE_TYPE_P (pattern
))
9229 /* If we've recursively instantiated too many templates, stop. */
9230 if (! push_tinst_level (type
))
9233 /* Now we're really doing the instantiation. Mark the type as in
9234 the process of being defined. */
9235 TYPE_BEING_DEFINED (type
) = 1;
9237 /* We may be in the middle of deferred access check. Disable
9239 push_deferring_access_checks (dk_no_deferred
);
9241 int saved_unevaluated_operand
= cp_unevaluated_operand
;
9242 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
9244 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
9245 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9246 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
9247 fn_context
= error_mark_node
;
9249 push_to_top_level ();
9252 cp_unevaluated_operand
= 0;
9253 c_inhibit_evaluation_warnings
= 0;
9255 /* Use #pragma pack from the template context. */
9256 saved_maximum_field_alignment
= maximum_field_alignment
;
9257 maximum_field_alignment
= TYPE_PRECISION (pattern
);
9259 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
9261 /* Set the input location to the most specialized template definition.
9262 This is needed if tsubsting causes an error. */
9263 typedecl
= TYPE_MAIN_DECL (pattern
);
9264 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
9265 DECL_SOURCE_LOCATION (typedecl
);
9267 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
9268 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
9269 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
9270 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
9271 if (ANON_AGGR_TYPE_P (pattern
))
9272 SET_ANON_AGGR_TYPE_P (type
);
9273 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
9275 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
9276 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
9277 /* Adjust visibility for template arguments. */
9278 determine_visibility (TYPE_MAIN_DECL (type
));
9280 if (CLASS_TYPE_P (type
))
9281 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
9283 pbinfo
= TYPE_BINFO (pattern
);
9285 /* We should never instantiate a nested class before its enclosing
9286 class; we need to look up the nested class by name before we can
9287 instantiate it, and that lookup should instantiate the enclosing
9289 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
9290 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
9292 base_list
= NULL_TREE
;
9293 if (BINFO_N_BASE_BINFOS (pbinfo
))
9299 /* We must enter the scope containing the type, as that is where
9300 the accessibility of types named in dependent bases are
9302 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9304 /* Substitute into each of the bases to determine the actual
9306 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9309 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9310 tree expanded_bases
= NULL_TREE
;
9313 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9316 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9317 args
, tf_error
, NULL_TREE
);
9318 if (expanded_bases
== error_mark_node
)
9321 len
= TREE_VEC_LENGTH (expanded_bases
);
9324 for (idx
= 0; idx
< len
; idx
++)
9327 /* Extract the already-expanded base class. */
9328 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9330 /* Substitute to figure out the base class. */
9331 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9334 if (base
== error_mark_node
)
9337 base_list
= tree_cons (access
, base
, base_list
);
9338 if (BINFO_VIRTUAL_P (pbase_binfo
))
9339 TREE_TYPE (base_list
) = integer_type_node
;
9343 /* The list is now in reverse order; correct that. */
9344 base_list
= nreverse (base_list
);
9347 pop_scope (pushed_scope
);
9349 /* Now call xref_basetypes to set up all the base-class
9351 xref_basetypes (type
, base_list
);
9353 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9354 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9355 args
, tf_error
, NULL_TREE
);
9356 fixup_attribute_variants (type
);
9358 /* Now that our base classes are set up, enter the scope of the
9359 class, so that name lookups into base classes, etc. will work
9360 correctly. This is precisely analogous to what we do in
9361 begin_class_definition when defining an ordinary non-template
9362 class, except we also need to push the enclosing classes. */
9363 push_nested_class (type
);
9365 /* Now members are processed in the order of declaration. */
9366 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9367 member
; member
= TREE_CHAIN (member
))
9369 tree t
= TREE_VALUE (member
);
9371 if (TREE_PURPOSE (member
))
9375 /* Build new CLASSTYPE_NESTED_UTDS. */
9378 bool class_template_p
;
9380 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9381 && TYPE_LANG_SPECIFIC (t
)
9382 && CLASSTYPE_IS_TEMPLATE (t
));
9383 /* If the member is a class template, then -- even after
9384 substitution -- there may be dependent types in the
9385 template argument list for the class. We increment
9386 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9387 that function will assume that no types are dependent
9388 when outside of a template. */
9389 if (class_template_p
)
9390 ++processing_template_decl
;
9391 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9392 if (class_template_p
)
9393 --processing_template_decl
;
9394 if (newtag
== error_mark_node
)
9397 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9399 tree name
= TYPE_IDENTIFIER (t
);
9401 if (class_template_p
)
9402 /* Unfortunately, lookup_template_class sets
9403 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9404 instantiation (i.e., for the type of a member
9405 template class nested within a template class.)
9406 This behavior is required for
9407 maybe_process_partial_specialization to work
9408 correctly, but is not accurate in this case;
9409 the TAG is not an instantiation of anything.
9410 (The corresponding TEMPLATE_DECL is an
9411 instantiation, but the TYPE is not.) */
9412 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9414 /* Now, we call pushtag to put this NEWTAG into the scope of
9415 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9416 pushtag calling push_template_decl. We don't have to do
9417 this for enums because it will already have been done in
9420 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9421 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9424 else if (DECL_DECLARES_FUNCTION_P (t
))
9426 /* Build new TYPE_METHODS. */
9429 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9430 ++processing_template_decl
;
9431 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9432 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9433 --processing_template_decl
;
9434 set_current_access_from_decl (r
);
9435 finish_member_declaration (r
);
9436 /* Instantiate members marked with attribute used. */
9437 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9439 if (TREE_CODE (r
) == FUNCTION_DECL
9440 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9441 cp_check_omp_declare_reduction (r
);
9443 else if (DECL_CLASS_TEMPLATE_P (t
)
9444 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
9445 /* A closure type for a lambda in a default argument for a
9446 member template. Ignore it; it will be instantiated with
9447 the default argument. */;
9450 /* Build new TYPE_FIELDS. */
9451 if (TREE_CODE (t
) == STATIC_ASSERT
)
9455 ++c_inhibit_evaluation_warnings
;
9457 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9458 tf_warning_or_error
, NULL_TREE
,
9459 /*integral_constant_expression_p=*/true);
9460 --c_inhibit_evaluation_warnings
;
9462 finish_static_assert (condition
,
9463 STATIC_ASSERT_MESSAGE (t
),
9464 STATIC_ASSERT_SOURCE_LOCATION (t
),
9467 else if (TREE_CODE (t
) != CONST_DECL
)
9470 tree vec
= NULL_TREE
;
9473 /* The file and line for this declaration, to
9474 assist in error message reporting. Since we
9475 called push_tinst_level above, we don't need to
9477 input_location
= DECL_SOURCE_LOCATION (t
);
9479 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9480 ++processing_template_decl
;
9481 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9482 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9483 --processing_template_decl
;
9485 if (TREE_CODE (r
) == TREE_VEC
)
9487 /* A capture pack became multiple fields. */
9489 len
= TREE_VEC_LENGTH (vec
);
9492 for (int i
= 0; i
< len
; ++i
)
9495 r
= TREE_VEC_ELT (vec
, i
);
9500 [t]he initialization (and any associated
9501 side-effects) of a static data member does
9502 not occur unless the static data member is
9503 itself used in a way that requires the
9504 definition of the static data member to
9507 Therefore, we do not substitute into the
9508 initialized for the static data member here. */
9509 finish_static_data_member_decl
9512 /*init_const_expr_p=*/false,
9513 /*asmspec_tree=*/NULL_TREE
,
9515 /* Instantiate members marked with attribute used. */
9516 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9519 else if (TREE_CODE (r
) == FIELD_DECL
)
9521 /* Determine whether R has a valid type and can be
9522 completed later. If R is invalid, then its type
9523 is replaced by error_mark_node. */
9524 tree rtype
= TREE_TYPE (r
);
9525 if (can_complete_type_without_circularity (rtype
))
9526 complete_type (rtype
);
9528 if (!COMPLETE_TYPE_P (rtype
))
9530 cxx_incomplete_type_error (r
, rtype
);
9531 TREE_TYPE (r
) = error_mark_node
;
9535 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9536 such a thing will already have been added to the field
9537 list by tsubst_enum in finish_member_declaration in the
9538 CLASSTYPE_NESTED_UTDS case above. */
9539 if (!(TREE_CODE (r
) == TYPE_DECL
9540 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9541 && DECL_ARTIFICIAL (r
)))
9543 set_current_access_from_decl (r
);
9544 finish_member_declaration (r
);
9552 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9553 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9555 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9557 tree friend_type
= t
;
9558 bool adjust_processing_template_decl
= false;
9560 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9562 /* template <class T> friend class C; */
9563 friend_type
= tsubst_friend_class (friend_type
, args
);
9564 adjust_processing_template_decl
= true;
9566 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9568 /* template <class T> friend class C::D; */
9569 friend_type
= tsubst (friend_type
, args
,
9570 tf_warning_or_error
, NULL_TREE
);
9571 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9572 friend_type
= TREE_TYPE (friend_type
);
9573 adjust_processing_template_decl
= true;
9575 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9576 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9578 /* This could be either
9582 when dependent_type_p is false or
9584 template <class U> friend class T::C;
9587 friend_type
= tsubst (friend_type
, args
,
9588 tf_warning_or_error
, NULL_TREE
);
9589 /* Bump processing_template_decl for correct
9590 dependent_type_p calculation. */
9591 ++processing_template_decl
;
9592 if (dependent_type_p (friend_type
))
9593 adjust_processing_template_decl
= true;
9594 --processing_template_decl
;
9596 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9597 && hidden_name_p (TYPE_NAME (friend_type
)))
9601 where C hasn't been declared yet. Let's lookup name
9602 from namespace scope directly, bypassing any name that
9603 come from dependent base class. */
9604 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9606 /* The call to xref_tag_from_type does injection for friend
9608 push_nested_namespace (ns
);
9610 xref_tag_from_type (friend_type
, NULL_TREE
,
9611 /*tag_scope=*/ts_current
);
9612 pop_nested_namespace (ns
);
9614 else if (uses_template_parms (friend_type
))
9615 /* friend class C<T>; */
9616 friend_type
= tsubst (friend_type
, args
,
9617 tf_warning_or_error
, NULL_TREE
);
9622 where C is already declared or
9624 friend class C<int>;
9626 We don't have to do anything in these cases. */
9628 if (adjust_processing_template_decl
)
9629 /* Trick make_friend_class into realizing that the friend
9630 we're adding is a template, not an ordinary class. It's
9631 important that we use make_friend_class since it will
9632 perform some error-checking and output cross-reference
9634 ++processing_template_decl
;
9636 if (friend_type
!= error_mark_node
)
9637 make_friend_class (type
, friend_type
, /*complain=*/false);
9639 if (adjust_processing_template_decl
)
9640 --processing_template_decl
;
9644 /* Build new DECL_FRIENDLIST. */
9647 /* The file and line for this declaration, to
9648 assist in error message reporting. Since we
9649 called push_tinst_level above, we don't need to
9651 input_location
= DECL_SOURCE_LOCATION (t
);
9653 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9655 ++processing_template_decl
;
9656 push_deferring_access_checks (dk_no_check
);
9659 r
= tsubst_friend_function (t
, args
);
9660 add_friend (type
, r
, /*complain=*/false);
9661 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9663 pop_deferring_access_checks ();
9664 --processing_template_decl
;
9672 /* Restore these before substituting into the lambda capture
9674 cp_unevaluated_operand
= saved_unevaluated_operand
;
9675 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
9678 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9680 tree decl
= lambda_function (type
);
9683 if (!DECL_TEMPLATE_INFO (decl
)
9684 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9685 instantiate_decl (decl
, false, false);
9687 /* We need to instantiate the capture list from the template
9688 after we've instantiated the closure members, but before we
9689 consider adding the conversion op. Also keep any captures
9690 that may have been added during instantiation of the op(). */
9691 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9693 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9694 args
, tf_warning_or_error
, NULL_TREE
,
9697 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9698 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9700 maybe_add_lambda_conv_op (type
);
9703 gcc_assert (errorcount
);
9706 /* Set the file and line number information to whatever is given for
9707 the class itself. This puts error messages involving generated
9708 implicit functions at a predictable point, and the same point
9709 that would be used for non-template classes. */
9710 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9712 unreverse_member_declarations (type
);
9713 finish_struct_1 (type
);
9714 TYPE_BEING_DEFINED (type
) = 0;
9716 /* We don't instantiate default arguments for member functions. 14.7.1:
9718 The implicit instantiation of a class template specialization causes
9719 the implicit instantiation of the declarations, but not of the
9720 definitions or default arguments, of the class member functions,
9721 member classes, static data members and member templates.... */
9723 /* Some typedefs referenced from within the template code need to be access
9724 checked at template instantiation time, i.e now. These types were
9725 added to the template at parsing time. Let's get those and perform
9726 the access checks then. */
9727 perform_typedefs_access_check (pattern
, args
);
9728 perform_deferred_access_checks (tf_warning_or_error
);
9729 pop_nested_class ();
9730 maximum_field_alignment
= saved_maximum_field_alignment
;
9732 pop_from_top_level ();
9733 pop_deferring_access_checks ();
9736 /* The vtable for a template class can be emitted in any translation
9737 unit in which the class is instantiated. When there is no key
9738 method, however, finish_struct_1 will already have added TYPE to
9739 the keyed_classes list. */
9740 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9741 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9746 /* Wrapper for instantiate_class_template_1. */
9749 instantiate_class_template (tree type
)
9752 timevar_push (TV_TEMPLATE_INST
);
9753 ret
= instantiate_class_template_1 (type
);
9754 timevar_pop (TV_TEMPLATE_INST
);
9759 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9765 else if (TYPE_P (t
))
9766 r
= tsubst (t
, args
, complain
, in_decl
);
9769 if (!(complain
& tf_warning
))
9770 ++c_inhibit_evaluation_warnings
;
9771 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9772 /*integral_constant_expression_p=*/true);
9773 if (!(complain
& tf_warning
))
9774 --c_inhibit_evaluation_warnings
;
9779 /* Given a function parameter pack TMPL_PARM and some function parameters
9780 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9781 and set *SPEC_P to point at the next point in the list. */
9784 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9786 /* Collect all of the extra "packed" parameters into an
9790 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9791 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9792 tree spec_parm
= *spec_p
;
9795 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9797 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9800 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9801 parmvec
= make_tree_vec (len
);
9802 parmtypevec
= make_tree_vec (len
);
9803 spec_parm
= *spec_p
;
9804 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9806 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9807 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9810 /* Build the argument packs. */
9811 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9812 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9813 TREE_TYPE (argpack
) = argtypepack
;
9814 *spec_p
= spec_parm
;
9819 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9820 NONTYPE_ARGUMENT_PACK. */
9823 make_fnparm_pack (tree spec_parm
)
9825 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9828 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
9829 pack expansion with no extra args, 2 if it has extra args, or 0
9830 if it is not a pack expansion. */
9833 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9835 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9836 if (i
>= TREE_VEC_LENGTH (vec
))
9838 tree elt
= TREE_VEC_ELT (vec
, i
);
9839 if (!PACK_EXPANSION_P (elt
))
9841 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
9847 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9850 make_argument_pack_select (tree arg_pack
, unsigned index
)
9852 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9854 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9855 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9860 /* This is a subroutine of tsubst_pack_expansion.
9862 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9863 mechanism to store the (non complete list of) arguments of the
9864 substitution and return a non substituted pack expansion, in order
9865 to wait for when we have enough arguments to really perform the
9869 use_pack_expansion_extra_args_p (tree parm_packs
,
9873 /* If one pack has an expansion and another pack has a normal
9874 argument or if one pack has an empty argument and an another
9875 one hasn't then tsubst_pack_expansion cannot perform the
9876 substitution and need to fall back on the
9877 PACK_EXPANSION_EXTRA mechanism. */
9878 if (parm_packs
== NULL_TREE
)
9880 else if (has_empty_arg
)
9883 bool has_expansion_arg
= false;
9884 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9886 bool has_non_expansion_arg
= false;
9887 for (tree parm_pack
= parm_packs
;
9889 parm_pack
= TREE_CHAIN (parm_pack
))
9891 tree arg
= TREE_VALUE (parm_pack
);
9893 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
9895 /* We can't substitute a pack expansion with extra args into
9899 has_expansion_arg
= true;
9901 has_non_expansion_arg
= true;
9904 if (has_expansion_arg
&& has_non_expansion_arg
)
9910 /* [temp.variadic]/6 says that:
9912 The instantiation of a pack expansion [...]
9913 produces a list E1,E2, ..., En, where N is the number of elements
9914 in the pack expansion parameters.
9916 This subroutine of tsubst_pack_expansion produces one of these Ei.
9918 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9919 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9920 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9921 INDEX is the index 'i' of the element Ei to produce. ARGS,
9922 COMPLAIN, and IN_DECL are the same parameters as for the
9923 tsubst_pack_expansion function.
9925 The function returns the resulting Ei upon successful completion,
9928 Note that this function possibly modifies the ARGS parameter, so
9929 it's the responsibility of the caller to restore it. */
9932 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9935 tree args
/* This parm gets
9937 tsubst_flags_t complain
,
9941 bool ith_elem_is_expansion
= false;
9943 /* For each parameter pack, change the substitution of the parameter
9944 pack to the ith argument in its argument pack, then expand the
9946 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9948 tree parm
= TREE_PURPOSE (pack
);
9949 tree arg_pack
= TREE_VALUE (pack
);
9950 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9952 ith_elem_is_expansion
|=
9953 argument_pack_element_is_expansion_p (arg_pack
, index
);
9955 /* Select the Ith argument from the pack. */
9956 if (TREE_CODE (parm
) == PARM_DECL
9957 || TREE_CODE (parm
) == FIELD_DECL
)
9961 aps
= make_argument_pack_select (arg_pack
, index
);
9962 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
9963 return error_mark_node
;
9964 register_local_specialization (aps
, parm
);
9967 aps
= retrieve_local_specialization (parm
);
9972 template_parm_level_and_index (parm
, &level
, &idx
);
9976 aps
= make_argument_pack_select (arg_pack
, index
);
9977 /* Update the corresponding argument. */
9978 TMPL_ARG (args
, level
, idx
) = aps
;
9981 /* Re-use the ARGUMENT_PACK_SELECT. */
9982 aps
= TMPL_ARG (args
, level
, idx
);
9984 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9987 /* Substitute into the PATTERN with the (possibly altered)
9989 if (pattern
== in_decl
)
9990 /* Expanding a fixed parameter pack from
9991 coerce_template_parameter_pack. */
9992 t
= tsubst_decl (pattern
, args
, complain
);
9993 else if (!TYPE_P (pattern
))
9994 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9995 /*integral_constant_expression_p=*/false);
9997 t
= tsubst (pattern
, args
, complain
, in_decl
);
9999 /* If the Ith argument pack element is a pack expansion, then
10000 the Ith element resulting from the substituting is going to
10001 be a pack expansion as well. */
10002 if (ith_elem_is_expansion
)
10003 t
= make_pack_expansion (t
);
10008 /* Substitute ARGS into T, which is an pack expansion
10009 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
10010 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
10011 (if only a partial substitution could be performed) or
10012 ERROR_MARK_NODE if there was an error. */
10014 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
10018 tree pack
, packs
= NULL_TREE
;
10019 bool unsubstituted_packs
= false;
10022 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
10023 bool need_local_specializations
= false;
10026 gcc_assert (PACK_EXPANSION_P (t
));
10027 pattern
= PACK_EXPANSION_PATTERN (t
);
10029 /* Add in any args remembered from an earlier partial instantiation. */
10030 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
10032 levels
= TMPL_ARGS_DEPTH (args
);
10034 /* Determine the argument packs that will instantiate the parameter
10035 packs used in the expansion expression. While we're at it,
10036 compute the number of arguments to be expanded and make sure it
10038 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
10039 pack
= TREE_CHAIN (pack
))
10041 tree parm_pack
= TREE_VALUE (pack
);
10042 tree arg_pack
= NULL_TREE
;
10043 tree orig_arg
= NULL_TREE
;
10046 if (TREE_CODE (parm_pack
) == BASES
)
10048 if (BASES_DIRECT (parm_pack
))
10049 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
10050 args
, complain
, in_decl
, false));
10052 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
10053 args
, complain
, in_decl
, false));
10055 if (TREE_CODE (parm_pack
) == PARM_DECL
)
10057 if (PACK_EXPANSION_LOCAL_P (t
))
10058 arg_pack
= retrieve_local_specialization (parm_pack
);
10061 /* We can't rely on local_specializations for a parameter
10062 name used later in a function declaration (such as in a
10063 late-specified return type). Even if it exists, it might
10064 have the wrong value for a recursive call. Just make a
10065 dummy decl, since it's only used for its type. */
10066 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
10067 if (arg_pack
&& DECL_PACK_P (arg_pack
))
10068 /* Partial instantiation of the parm_pack, we can't build
10069 up an argument pack yet. */
10070 arg_pack
= NULL_TREE
;
10072 arg_pack
= make_fnparm_pack (arg_pack
);
10073 need_local_specializations
= true;
10076 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
10077 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
10081 template_parm_level_and_index (parm_pack
, &level
, &idx
);
10083 if (level
<= levels
)
10084 arg_pack
= TMPL_ARG (args
, level
, idx
);
10087 orig_arg
= arg_pack
;
10088 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
10089 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
10091 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
10092 /* This can only happen if we forget to expand an argument
10093 pack somewhere else. Just return an error, silently. */
10095 result
= make_tree_vec (1);
10096 TREE_VEC_ELT (result
, 0) = error_mark_node
;
10103 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
10105 /* Don't bother trying to do a partial substitution with
10106 incomplete packs; we'll try again after deduction. */
10107 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
10112 else if (len
!= my_len
)
10114 if (!(complain
& tf_error
))
10115 /* Fail quietly. */;
10116 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
10117 error ("mismatched argument pack lengths while expanding "
10121 error ("mismatched argument pack lengths while expanding "
10124 return error_mark_node
;
10127 /* Keep track of the parameter packs and their corresponding
10129 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
10130 TREE_TYPE (packs
) = orig_arg
;
10134 /* We can't substitute for this parameter pack. We use a flag as
10135 well as the missing_level counter because function parameter
10136 packs don't have a level. */
10137 unsubstituted_packs
= true;
10141 /* If the expansion is just T..., return the matching argument pack. */
10142 if (!unsubstituted_packs
10143 && TREE_PURPOSE (packs
) == pattern
)
10145 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
10146 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
10147 || pack_expansion_args_count (args
))
10149 /* Otherwise use the normal path so we get convert_from_reference. */
10152 /* We cannot expand this expansion expression, because we don't have
10153 all of the argument packs we need. */
10154 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
10156 /* We got some full packs, but we can't substitute them in until we
10157 have values for all the packs. So remember these until then. */
10159 t
= make_pack_expansion (pattern
);
10160 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
10163 else if (unsubstituted_packs
)
10165 /* There were no real arguments, we're just replacing a parameter
10166 pack with another version of itself. Substitute into the
10167 pattern and return a PACK_EXPANSION_*. The caller will need to
10169 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
10170 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
10171 /*integral_constant_expression_p=*/false);
10173 t
= tsubst (pattern
, args
, complain
, in_decl
);
10174 t
= make_pack_expansion (t
);
10178 gcc_assert (len
>= 0);
10180 if (need_local_specializations
)
10182 /* We're in a late-specified return type, so create our own local
10183 specializations map; the current map is either NULL or (in the
10184 case of recursive unification) might have bindings that we don't
10185 want to use or alter. */
10186 saved_local_specializations
= local_specializations
;
10187 local_specializations
= new hash_map
<tree
, tree
>;
10190 /* For each argument in each argument pack, substitute into the
10192 result
= make_tree_vec (len
);
10193 for (i
= 0; i
< len
; ++i
)
10195 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
10199 TREE_VEC_ELT (result
, i
) = t
;
10200 if (t
== error_mark_node
)
10202 result
= error_mark_node
;
10207 /* Update ARGS to restore the substitution from parameter packs to
10208 their argument packs. */
10209 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
10211 tree parm
= TREE_PURPOSE (pack
);
10213 if (TREE_CODE (parm
) == PARM_DECL
10214 || TREE_CODE (parm
) == FIELD_DECL
)
10215 register_local_specialization (TREE_TYPE (pack
), parm
);
10220 if (TREE_VALUE (pack
) == NULL_TREE
)
10223 template_parm_level_and_index (parm
, &level
, &idx
);
10225 /* Update the corresponding argument. */
10226 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
10227 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
10230 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
10234 if (need_local_specializations
)
10236 delete local_specializations
;
10237 local_specializations
= saved_local_specializations
;
10243 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10244 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10245 parameter packs; all parms generated from a function parameter pack will
10246 have the same DECL_PARM_INDEX. */
10249 get_pattern_parm (tree parm
, tree tmpl
)
10251 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
10254 if (DECL_ARTIFICIAL (parm
))
10256 for (patparm
= DECL_ARGUMENTS (pattern
);
10257 patparm
; patparm
= DECL_CHAIN (patparm
))
10258 if (DECL_ARTIFICIAL (patparm
)
10259 && DECL_NAME (parm
) == DECL_NAME (patparm
))
10264 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
10265 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
10266 gcc_assert (DECL_PARM_INDEX (patparm
)
10267 == DECL_PARM_INDEX (parm
));
10273 /* Substitute ARGS into the vector or list of template arguments T. */
10276 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10279 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
10282 if (t
== error_mark_node
)
10283 return error_mark_node
;
10285 len
= TREE_VEC_LENGTH (t
);
10286 elts
= XALLOCAVEC (tree
, len
);
10288 for (i
= 0; i
< len
; i
++)
10290 tree orig_arg
= TREE_VEC_ELT (t
, i
);
10293 if (TREE_CODE (orig_arg
) == TREE_VEC
)
10294 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
10295 else if (PACK_EXPANSION_P (orig_arg
))
10297 /* Substitute into an expansion expression. */
10298 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
10300 if (TREE_CODE (new_arg
) == TREE_VEC
)
10301 /* Add to the expanded length adjustment the number of
10302 expanded arguments. We subtract one from this
10303 measurement, because the argument pack expression
10304 itself is already counted as 1 in
10305 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10306 the argument pack is empty. */
10307 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
10309 else if (ARGUMENT_PACK_P (orig_arg
))
10311 /* Substitute into each of the arguments. */
10312 new_arg
= TYPE_P (orig_arg
)
10313 ? cxx_make_type (TREE_CODE (orig_arg
))
10314 : make_node (TREE_CODE (orig_arg
));
10316 SET_ARGUMENT_PACK_ARGS (
10318 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
10319 args
, complain
, in_decl
));
10321 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
10322 new_arg
= error_mark_node
;
10324 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
10325 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
10326 complain
, in_decl
);
10327 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
10329 if (TREE_TYPE (new_arg
) == error_mark_node
)
10330 new_arg
= error_mark_node
;
10334 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
10336 if (new_arg
== error_mark_node
)
10337 return error_mark_node
;
10340 if (new_arg
!= orig_arg
)
10347 /* Make space for the expanded arguments coming from template
10349 t
= make_tree_vec (len
+ expanded_len_adjust
);
10350 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10351 arguments for a member template.
10352 In that case each TREE_VEC in ORIG_T represents a level of template
10353 arguments, and ORIG_T won't carry any non defaulted argument count.
10354 It will rather be the nested TREE_VECs that will carry one.
10355 In other words, ORIG_T carries a non defaulted argument count only
10356 if it doesn't contain any nested TREE_VEC. */
10357 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
10359 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
10360 count
+= expanded_len_adjust
;
10361 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
10363 for (i
= 0, out
= 0; i
< len
; i
++)
10365 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
10366 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
10367 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10371 /* Now expand the template argument pack "in place". */
10372 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10373 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10377 TREE_VEC_ELT (t
, out
) = elts
[i
];
10385 /* Return the result of substituting ARGS into the template parameters
10386 given by PARMS. If there are m levels of ARGS and m + n levels of
10387 PARMS, then the result will contain n levels of PARMS. For
10388 example, if PARMS is `template <class T> template <class U>
10389 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10390 result will be `template <int*, double, class V>'. */
10393 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10395 tree r
= NULL_TREE
;
10398 /* When substituting into a template, we must set
10399 PROCESSING_TEMPLATE_DECL as the template parameters may be
10400 dependent if they are based on one-another, and the dependency
10401 predicates are short-circuit outside of templates. */
10402 ++processing_template_decl
;
10404 for (new_parms
= &r
;
10405 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10406 new_parms
= &(TREE_CHAIN (*new_parms
)),
10407 parms
= TREE_CHAIN (parms
))
10410 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10413 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10417 if (parms
== error_mark_node
)
10420 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10422 if (tuple
== error_mark_node
)
10425 TREE_VEC_ELT (new_vec
, i
) =
10426 tsubst_template_parm (tuple
, args
, complain
);
10430 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10431 - TMPL_ARGS_DEPTH (args
)),
10432 new_vec
, NULL_TREE
);
10435 --processing_template_decl
;
10440 /* Return the result of substituting ARGS into one template parameter
10441 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10442 parameter and which TREE_PURPOSE is the default argument of the
10443 template parameter. */
10446 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10448 tree default_value
, parm_decl
;
10450 if (args
== NULL_TREE
10452 || t
== error_mark_node
)
10455 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10457 default_value
= TREE_PURPOSE (t
);
10458 parm_decl
= TREE_VALUE (t
);
10460 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10461 if (TREE_CODE (parm_decl
) == PARM_DECL
10462 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10463 parm_decl
= error_mark_node
;
10464 default_value
= tsubst_template_arg (default_value
, args
,
10465 complain
, NULL_TREE
);
10467 return build_tree_list (default_value
, parm_decl
);
10470 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10471 type T. If T is not an aggregate or enumeration type, it is
10472 handled as if by tsubst. IN_DECL is as for tsubst. If
10473 ENTERING_SCOPE is nonzero, T is the context for a template which
10474 we are presently tsubst'ing. Return the substituted value. */
10477 tsubst_aggr_type (tree t
,
10479 tsubst_flags_t complain
,
10481 int entering_scope
)
10483 if (t
== NULL_TREE
)
10486 switch (TREE_CODE (t
))
10489 if (TYPE_PTRMEMFUNC_P (t
))
10490 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10492 /* Else fall through. */
10493 case ENUMERAL_TYPE
:
10495 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10500 int saved_unevaluated_operand
;
10501 int saved_inhibit_evaluation_warnings
;
10503 /* In "sizeof(X<I>)" we need to evaluate "I". */
10504 saved_unevaluated_operand
= cp_unevaluated_operand
;
10505 cp_unevaluated_operand
= 0;
10506 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10507 c_inhibit_evaluation_warnings
= 0;
10509 /* First, determine the context for the type we are looking
10511 context
= TYPE_CONTEXT (t
);
10512 if (context
&& TYPE_P (context
))
10514 context
= tsubst_aggr_type (context
, args
, complain
,
10515 in_decl
, /*entering_scope=*/1);
10516 /* If context is a nested class inside a class template,
10517 it may still need to be instantiated (c++/33959). */
10518 context
= complete_type (context
);
10521 /* Then, figure out what arguments are appropriate for the
10522 type we are trying to find. For example, given:
10524 template <class T> struct S;
10525 template <class T, class U> void f(T, U) { S<U> su; }
10527 and supposing that we are instantiating f<int, double>,
10528 then our ARGS will be {int, double}, but, when looking up
10529 S we only want {double}. */
10530 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10531 complain
, in_decl
);
10532 if (argvec
== error_mark_node
)
10533 r
= error_mark_node
;
10536 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10537 entering_scope
, complain
);
10538 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10541 cp_unevaluated_operand
= saved_unevaluated_operand
;
10542 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10547 /* This is not a template type, so there's nothing to do. */
10551 return tsubst (t
, args
, complain
, in_decl
);
10555 /* Substitute into the default argument ARG (a default argument for
10556 FN), which has the indicated TYPE. */
10559 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10561 tree saved_class_ptr
= NULL_TREE
;
10562 tree saved_class_ref
= NULL_TREE
;
10563 int errs
= errorcount
+ sorrycount
;
10565 /* This can happen in invalid code. */
10566 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10569 /* This default argument came from a template. Instantiate the
10570 default argument here, not in tsubst. In the case of
10579 we must be careful to do name lookup in the scope of S<T>,
10580 rather than in the current class. */
10581 push_access_scope (fn
);
10582 /* The "this" pointer is not valid in a default argument. */
10585 saved_class_ptr
= current_class_ptr
;
10586 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10587 saved_class_ref
= current_class_ref
;
10588 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10591 push_deferring_access_checks(dk_no_deferred
);
10592 /* The default argument expression may cause implicitly defined
10593 member functions to be synthesized, which will result in garbage
10594 collection. We must treat this situation as if we were within
10595 the body of function so as to avoid collecting live data on the
10598 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10599 complain
, NULL_TREE
,
10600 /*integral_constant_expression_p=*/false);
10602 pop_deferring_access_checks();
10604 /* Restore the "this" pointer. */
10607 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10608 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10611 if (errorcount
+sorrycount
> errs
10612 && (complain
& tf_warning_or_error
))
10613 inform (input_location
,
10614 " when instantiating default argument for call to %D", fn
);
10616 /* Make sure the default argument is reasonable. */
10617 arg
= check_default_argument (type
, arg
, complain
);
10619 pop_access_scope (fn
);
10624 /* Substitute into all the default arguments for FN. */
10627 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10632 tmpl_args
= DECL_TI_ARGS (fn
);
10634 /* If this function is not yet instantiated, we certainly don't need
10635 its default arguments. */
10636 if (uses_template_parms (tmpl_args
))
10638 /* Don't do this again for clones. */
10639 if (DECL_CLONED_FUNCTION_P (fn
))
10642 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10644 arg
= TREE_CHAIN (arg
))
10645 if (TREE_PURPOSE (arg
))
10646 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10648 TREE_PURPOSE (arg
),
10652 /* Substitute the ARGS into the T, which is a _DECL. Return the
10653 result of the substitution. Issue error and warning messages under
10654 control of COMPLAIN. */
10657 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10659 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10660 location_t saved_loc
;
10661 tree r
= NULL_TREE
;
10663 hashval_t hash
= 0;
10665 /* Set the filename and linenumber to improve error-reporting. */
10666 saved_loc
= input_location
;
10667 input_location
= DECL_SOURCE_LOCATION (t
);
10669 switch (TREE_CODE (t
))
10671 case TEMPLATE_DECL
:
10673 /* We can get here when processing a member function template,
10674 member class template, or template template parameter. */
10675 tree decl
= DECL_TEMPLATE_RESULT (t
);
10680 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10682 /* Template template parameter is treated here. */
10683 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10684 if (new_type
== error_mark_node
)
10685 RETURN (error_mark_node
);
10686 /* If we get a real template back, return it. This can happen in
10687 the context of most_specialized_partial_spec. */
10688 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10692 DECL_CHAIN (r
) = NULL_TREE
;
10693 TREE_TYPE (r
) = new_type
;
10694 DECL_TEMPLATE_RESULT (r
)
10695 = build_decl (DECL_SOURCE_LOCATION (decl
),
10696 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10697 DECL_TEMPLATE_PARMS (r
)
10698 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10700 TYPE_NAME (new_type
) = r
;
10704 /* We might already have an instance of this template.
10705 The ARGS are for the surrounding class type, so the
10706 full args contain the tsubst'd args for the context,
10707 plus the innermost args from the template decl. */
10708 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10709 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10710 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10711 /* Because this is a template, the arguments will still be
10712 dependent, even after substitution. If
10713 PROCESSING_TEMPLATE_DECL is not set, the dependency
10714 predicates will short-circuit. */
10715 ++processing_template_decl
;
10716 full_args
= tsubst_template_args (tmpl_args
, args
,
10717 complain
, in_decl
);
10718 --processing_template_decl
;
10719 if (full_args
== error_mark_node
)
10720 RETURN (error_mark_node
);
10722 /* If this is a default template template argument,
10723 tsubst might not have changed anything. */
10724 if (full_args
== tmpl_args
)
10727 hash
= hash_tmpl_and_args (t
, full_args
);
10728 spec
= retrieve_specialization (t
, full_args
, hash
);
10729 if (spec
!= NULL_TREE
)
10735 /* Make a new template decl. It will be similar to the
10736 original, but will record the current template arguments.
10737 We also create a new function declaration, which is just
10738 like the old one, but points to this new template, rather
10739 than the old one. */
10741 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10742 DECL_CHAIN (r
) = NULL_TREE
;
10744 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10746 if (TREE_CODE (decl
) == TYPE_DECL
10747 && !TYPE_DECL_ALIAS_P (decl
))
10750 ++processing_template_decl
;
10751 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10752 --processing_template_decl
;
10753 if (new_type
== error_mark_node
)
10754 RETURN (error_mark_node
);
10756 TREE_TYPE (r
) = new_type
;
10757 /* For a partial specialization, we need to keep pointing to
10758 the primary template. */
10759 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10760 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10761 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10762 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10763 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10768 ++processing_template_decl
;
10769 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10770 --processing_template_decl
;
10771 if (new_decl
== error_mark_node
)
10772 RETURN (error_mark_node
);
10774 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10775 DECL_TI_TEMPLATE (new_decl
) = r
;
10776 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10777 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10778 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10781 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10782 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10783 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10785 /* The template parameters for this new template are all the
10786 template parameters for the old template, except the
10787 outermost level of parameters. */
10788 DECL_TEMPLATE_PARMS (r
)
10789 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10792 if (PRIMARY_TEMPLATE_P (t
))
10793 DECL_PRIMARY_TEMPLATE (r
) = r
;
10795 if (TREE_CODE (decl
) != TYPE_DECL
&& !VAR_P (decl
))
10796 /* Record this non-type partial instantiation. */
10797 register_specialization (r
, t
,
10798 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10803 case FUNCTION_DECL
:
10806 tree argvec
= NULL_TREE
;
10814 /* Nobody should be tsubst'ing into non-template functions. */
10815 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10817 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10822 /* If T is not dependent, just return it. We have to
10823 increment PROCESSING_TEMPLATE_DECL because
10824 value_dependent_expression_p assumes that nothing is
10825 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10826 ++processing_template_decl
;
10827 dependent_p
= value_dependent_expression_p (t
);
10828 --processing_template_decl
;
10832 /* Calculate the most general template of which R is a
10833 specialization, and the complete set of arguments used to
10835 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10836 argvec
= tsubst_template_args (DECL_TI_ARGS
10837 (DECL_TEMPLATE_RESULT
10838 (DECL_TI_TEMPLATE (t
))),
10839 args
, complain
, in_decl
);
10840 if (argvec
== error_mark_node
)
10841 RETURN (error_mark_node
);
10843 /* Check to see if we already have this specialization. */
10844 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10845 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10853 /* We can see more levels of arguments than parameters if
10854 there was a specialization of a member template, like
10857 template <class T> struct S { template <class U> void f(); }
10858 template <> template <class U> void S<int>::f(U);
10860 Here, we'll be substituting into the specialization,
10861 because that's where we can find the code we actually
10862 want to generate, but we'll have enough arguments for
10863 the most general template.
10865 We also deal with the peculiar case:
10867 template <class T> struct S {
10868 template <class U> friend void f();
10870 template <class U> void f() {}
10872 template void f<double>();
10874 Here, the ARGS for the instantiation of will be {int,
10875 double}. But, we only need as many ARGS as there are
10876 levels of template parameters in CODE_PATTERN. We are
10877 careful not to get fooled into reducing the ARGS in
10880 template <class T> struct S { template <class U> void f(U); }
10881 template <class T> template <> void S<T>::f(int) {}
10883 which we can spot because the pattern will be a
10884 specialization in this case. */
10885 args_depth
= TMPL_ARGS_DEPTH (args
);
10887 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10888 if (args_depth
> parms_depth
10889 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10890 args
= get_innermost_template_args (args
, parms_depth
);
10894 /* This special case arises when we have something like this:
10896 template <class T> struct S {
10897 friend void f<int>(int, double);
10900 Here, the DECL_TI_TEMPLATE for the friend declaration
10901 will be an IDENTIFIER_NODE. We are being called from
10902 tsubst_friend_function, and we want only to create a
10903 new decl (R) with appropriate types so that we can call
10904 determine_specialization. */
10905 gen_tmpl
= NULL_TREE
;
10908 if (DECL_CLASS_SCOPE_P (t
))
10910 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10914 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10915 complain
, t
, /*entering_scope=*/1);
10920 ctx
= DECL_CONTEXT (t
);
10922 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10923 if (type
== error_mark_node
)
10924 RETURN (error_mark_node
);
10926 /* If we hit excessive deduction depth, the type is bogus even if
10927 it isn't error_mark_node, so don't build a decl. */
10928 if (excessive_deduction_depth
)
10929 RETURN (error_mark_node
);
10931 /* We do NOT check for matching decls pushed separately at this
10932 point, as they may not represent instantiations of this
10933 template, and in any case are considered separate under the
10936 DECL_USE_TEMPLATE (r
) = 0;
10937 TREE_TYPE (r
) = type
;
10938 /* Clear out the mangled name and RTL for the instantiation. */
10939 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10940 SET_DECL_RTL (r
, NULL
);
10941 /* Leave DECL_INITIAL set on deleted instantiations. */
10942 if (!DECL_DELETED_FN (r
))
10943 DECL_INITIAL (r
) = NULL_TREE
;
10944 DECL_CONTEXT (r
) = ctx
;
10946 /* OpenMP UDRs have the only argument a reference to the declared
10947 type. We want to diagnose if the declared type is a reference,
10948 which is invalid, but as references to references are usually
10949 quietly merged, diagnose it here. */
10950 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10953 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10954 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10955 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10956 error_at (DECL_SOURCE_LOCATION (t
),
10957 "reference type %qT in "
10958 "%<#pragma omp declare reduction%>", argtype
);
10959 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10960 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10964 if (member
&& DECL_CONV_FN_P (r
))
10965 /* Type-conversion operator. Reconstruct the name, in
10966 case it's the name of one of the template's parameters. */
10967 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10969 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10971 DECL_RESULT (r
) = NULL_TREE
;
10973 TREE_STATIC (r
) = 0;
10974 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10975 DECL_EXTERNAL (r
) = 1;
10976 /* If this is an instantiation of a function with internal
10977 linkage, we already know what object file linkage will be
10978 assigned to the instantiation. */
10979 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10980 DECL_DEFER_OUTPUT (r
) = 0;
10981 DECL_CHAIN (r
) = NULL_TREE
;
10982 DECL_PENDING_INLINE_INFO (r
) = 0;
10983 DECL_PENDING_INLINE_P (r
) = 0;
10984 DECL_SAVED_TREE (r
) = NULL_TREE
;
10985 DECL_STRUCT_FUNCTION (r
) = NULL
;
10987 /* We'll re-clone as appropriate in instantiate_template. */
10988 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10990 /* If we aren't complaining now, return on error before we register
10991 the specialization so that we'll complain eventually. */
10992 if ((complain
& tf_error
) == 0
10993 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10994 && !grok_op_properties (r
, /*complain=*/false))
10995 RETURN (error_mark_node
);
10997 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10998 this in the special friend case mentioned above where
10999 GEN_TMPL is NULL. */
11002 DECL_TEMPLATE_INFO (r
)
11003 = build_template_info (gen_tmpl
, argvec
);
11004 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11007 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11009 /* We instantiated this while substituting into
11010 the type earlier (template/friend54.C). */
11013 /* We're not supposed to instantiate default arguments
11014 until they are called, for a template. But, for a
11017 template <class T> void f ()
11018 { extern void g(int i = T()); }
11020 we should do the substitution when the template is
11021 instantiated. We handle the member function case in
11022 instantiate_class_template since the default arguments
11023 might refer to other members of the class. */
11025 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
11026 && !uses_template_parms (argvec
))
11027 tsubst_default_arguments (r
, complain
);
11030 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
11032 /* Copy the list of befriending classes. */
11033 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
11035 friends
= &TREE_CHAIN (*friends
))
11037 *friends
= copy_node (*friends
);
11038 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
11043 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
11045 maybe_retrofit_in_chrg (r
);
11046 if (DECL_CONSTRUCTOR_P (r
))
11047 grok_ctor_properties (ctx
, r
);
11048 if (DECL_INHERITED_CTOR_BASE (r
))
11049 deduce_inheriting_ctor (r
);
11050 /* If this is an instantiation of a member template, clone it.
11051 If it isn't, that'll be handled by
11052 clone_constructors_and_destructors. */
11053 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
11054 clone_function_decl (r
, /*update_method_vec_p=*/0);
11056 else if ((complain
& tf_error
) != 0
11057 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
11058 && !grok_op_properties (r
, /*complain=*/true))
11059 RETURN (error_mark_node
);
11061 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
11062 SET_DECL_FRIEND_CONTEXT (r
,
11063 tsubst (DECL_FRIEND_CONTEXT (t
),
11064 args
, complain
, in_decl
));
11066 /* Possibly limit visibility based on template args. */
11067 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11068 if (DECL_VISIBILITY_SPECIFIED (t
))
11070 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11071 DECL_ATTRIBUTES (r
)
11072 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11074 determine_visibility (r
);
11075 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
11076 && !processing_template_decl
)
11077 defaulted_late_check (r
);
11079 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11080 args
, complain
, in_decl
);
11086 tree type
= NULL_TREE
;
11088 tree expanded_types
= NULL_TREE
;
11089 tree prev_r
= NULL_TREE
;
11090 tree first_r
= NULL_TREE
;
11092 if (DECL_PACK_P (t
))
11094 /* If there is a local specialization that isn't a
11095 parameter pack, it means that we're doing a "simple"
11096 substitution from inside tsubst_pack_expansion. Just
11097 return the local specialization (which will be a single
11099 tree spec
= retrieve_local_specialization (t
);
11101 && TREE_CODE (spec
) == PARM_DECL
11102 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
11105 /* Expand the TYPE_PACK_EXPANSION that provides the types for
11106 the parameters in this function parameter pack. */
11107 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11108 complain
, in_decl
);
11109 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11111 len
= TREE_VEC_LENGTH (expanded_types
);
11113 /* Zero-length parameter packs are boring. Just substitute
11116 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
11121 /* All we did was update the type. Make a note of that. */
11122 type
= expanded_types
;
11123 expanded_types
= NULL_TREE
;
11127 /* Loop through all of the parameters we'll build. When T is
11128 a function parameter pack, LEN is the number of expanded
11129 types in EXPANDED_TYPES; otherwise, LEN is 1. */
11131 for (i
= 0; i
< len
; ++i
)
11135 if (DECL_TEMPLATE_PARM_P (t
))
11136 SET_DECL_TEMPLATE_PARM_P (r
);
11138 if (expanded_types
)
11139 /* We're on the Ith parameter of the function parameter
11142 /* Get the Ith type. */
11143 type
= TREE_VEC_ELT (expanded_types
, i
);
11145 /* Rename the parameter to include the index. */
11147 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11150 /* We're dealing with a normal parameter. */
11151 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11153 type
= type_decays_to (type
);
11154 TREE_TYPE (r
) = type
;
11155 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11157 if (DECL_INITIAL (r
))
11159 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
11160 DECL_INITIAL (r
) = TREE_TYPE (r
);
11162 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
11163 complain
, in_decl
);
11166 DECL_CONTEXT (r
) = NULL_TREE
;
11168 if (!DECL_TEMPLATE_PARM_P (r
))
11169 DECL_ARG_TYPE (r
) = type_passed_as (type
);
11171 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11172 args
, complain
, in_decl
);
11174 /* Keep track of the first new parameter we
11175 generate. That's what will be returned to the
11180 /* Build a proper chain of parameters when substituting
11181 into a function parameter pack. */
11183 DECL_CHAIN (prev_r
) = r
;
11186 /* If cp_unevaluated_operand is set, we're just looking for a
11187 single dummy parameter, so don't keep going. */
11188 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
11189 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
11190 complain
, DECL_CHAIN (t
));
11192 /* FIRST_R contains the start of the chain we've built. */
11199 tree type
= NULL_TREE
;
11200 tree vec
= NULL_TREE
;
11201 tree expanded_types
= NULL_TREE
;
11204 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
11206 /* This field is a lambda capture pack. Return a TREE_VEC of
11207 the expanded fields to instantiate_class_template_1 and
11208 store them in the specializations hash table as a
11209 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11210 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11211 complain
, in_decl
);
11212 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11214 len
= TREE_VEC_LENGTH (expanded_types
);
11215 vec
= make_tree_vec (len
);
11219 /* All we did was update the type. Make a note of that. */
11220 type
= expanded_types
;
11221 expanded_types
= NULL_TREE
;
11225 for (int i
= 0; i
< len
; ++i
)
11228 if (expanded_types
)
11230 type
= TREE_VEC_ELT (expanded_types
, i
);
11232 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11235 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11237 if (type
== error_mark_node
)
11238 RETURN (error_mark_node
);
11239 TREE_TYPE (r
) = type
;
11240 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11242 if (DECL_C_BIT_FIELD (r
))
11243 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11244 non-bit-fields DECL_INITIAL is a non-static data member
11245 initializer, which gets deferred instantiation. */
11247 = tsubst_expr (DECL_INITIAL (t
), args
,
11249 /*integral_constant_expression_p=*/true);
11250 else if (DECL_INITIAL (t
))
11252 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11253 NSDMI in perform_member_init. Still set DECL_INITIAL
11254 so that we know there is one. */
11255 DECL_INITIAL (r
) = void_node
;
11256 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
11257 retrofit_lang_decl (r
);
11258 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
11260 /* We don't have to set DECL_CONTEXT here; it is set by
11261 finish_member_declaration. */
11262 DECL_CHAIN (r
) = NULL_TREE
;
11264 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11265 args
, complain
, in_decl
);
11268 TREE_VEC_ELT (vec
, i
) = r
;
11274 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
11275 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
11276 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
11277 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
11278 TREE_TYPE (pack
) = tpack
;
11279 register_specialization (pack
, t
, args
, false, 0);
11285 /* We reach here only for member using decls. We also need to check
11286 uses_template_parms because DECL_DEPENDENT_P is not set for a
11287 using-declaration that designates a member of the current
11288 instantiation (c++/53549). */
11289 if (DECL_DEPENDENT_P (t
)
11290 || uses_template_parms (USING_DECL_SCOPE (t
)))
11292 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
11293 complain
, in_decl
);
11294 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
11295 r
= do_class_using_decl (inst_scope
, name
);
11297 r
= error_mark_node
;
11300 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
11301 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
11307 DECL_CHAIN (r
) = NULL_TREE
;
11314 tree argvec
= NULL_TREE
;
11315 tree gen_tmpl
= NULL_TREE
;
11317 tree tmpl
= NULL_TREE
;
11319 tree type
= NULL_TREE
;
11322 if (TREE_TYPE (t
) == error_mark_node
)
11323 RETURN (error_mark_node
);
11325 if (TREE_CODE (t
) == TYPE_DECL
11326 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
11328 /* If this is the canonical decl, we don't have to
11329 mess with instantiations, and often we can't (for
11330 typename, template type parms and such). Note that
11331 TYPE_NAME is not correct for the above test if
11332 we've copied the type for a typedef. */
11333 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11334 if (type
== error_mark_node
)
11335 RETURN (error_mark_node
);
11336 r
= TYPE_NAME (type
);
11340 /* Check to see if we already have the specialization we
11343 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
11345 /* T is a static data member or namespace-scope entity.
11346 We have to substitute into namespace-scope variables
11347 (not just variable templates) because of cases like:
11349 template <class T> void f() { extern T t; }
11351 where the entity referenced is not known until
11352 instantiation time. */
11354 ctx
= DECL_CONTEXT (t
);
11355 if (DECL_CLASS_SCOPE_P (t
))
11357 ctx
= tsubst_aggr_type (ctx
, args
,
11359 in_decl
, /*entering_scope=*/1);
11360 /* If CTX is unchanged, then T is in fact the
11361 specialization we want. That situation occurs when
11362 referencing a static data member within in its own
11363 class. We can use pointer equality, rather than
11364 same_type_p, because DECL_CONTEXT is always
11366 if (ctx
== DECL_CONTEXT (t
)
11367 /* ... unless T is a member template; in which
11368 case our caller can be willing to create a
11369 specialization of that template represented
11371 && !(DECL_TI_TEMPLATE (t
)
11372 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
11378 tmpl
= DECL_TI_TEMPLATE (t
);
11379 gen_tmpl
= most_general_template (tmpl
);
11380 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11381 if (argvec
!= error_mark_node
)
11382 argvec
= (coerce_innermost_template_parms
11383 (DECL_TEMPLATE_PARMS (gen_tmpl
),
11384 argvec
, t
, complain
,
11385 /*all*/true, /*defarg*/true));
11386 if (argvec
== error_mark_node
)
11387 RETURN (error_mark_node
);
11388 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11389 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11394 /* A local variable. */
11396 /* Subsequent calls to pushdecl will fill this in. */
11398 spec
= retrieve_local_specialization (t
);
11400 /* If we already have the specialization we need, there is
11401 nothing more to do. */
11408 /* Create a new node for the specialization we need. */
11410 if (type
== NULL_TREE
)
11412 if (is_typedef_decl (t
))
11413 type
= DECL_ORIGINAL_TYPE (t
);
11415 type
= TREE_TYPE (t
);
11417 && VAR_HAD_UNKNOWN_BOUND (t
)
11418 && type
!= error_mark_node
)
11419 type
= strip_array_domain (type
);
11420 type
= tsubst (type
, args
, complain
, in_decl
);
11424 /* Even if the original location is out of scope, the
11425 newly substituted one is not. */
11426 DECL_DEAD_FOR_LOCAL (r
) = 0;
11427 DECL_INITIALIZED_P (r
) = 0;
11428 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11429 if (type
== error_mark_node
)
11430 RETURN (error_mark_node
);
11431 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11433 /* It may seem that this case cannot occur, since:
11438 declares a function, not a variable. However:
11441 template <typename T> void g() { T t; }
11442 template void g<f>();
11444 is an attempt to declare a variable with function
11446 error ("variable %qD has function type",
11447 /* R is not yet sufficiently initialized, so we
11448 just use its name. */
11450 RETURN (error_mark_node
);
11452 type
= complete_type (type
);
11453 /* Wait until cp_finish_decl to set this again, to handle
11454 circular dependency (template/instantiate6.C). */
11455 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11456 type
= check_var_type (DECL_NAME (r
), type
);
11458 if (DECL_HAS_VALUE_EXPR_P (t
))
11460 tree ve
= DECL_VALUE_EXPR (t
);
11461 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11462 /*constant_expression_p=*/false);
11463 if (REFERENCE_REF_P (ve
))
11465 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11466 ve
= TREE_OPERAND (ve
, 0);
11468 SET_DECL_VALUE_EXPR (r
, ve
);
11470 if (CP_DECL_THREAD_LOCAL_P (r
)
11471 && !processing_template_decl
)
11472 set_decl_tls_model (r
, decl_default_tls_model (r
));
11474 else if (DECL_SELF_REFERENCE_P (t
))
11475 SET_DECL_SELF_REFERENCE_P (r
);
11476 TREE_TYPE (r
) = type
;
11477 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11478 DECL_CONTEXT (r
) = ctx
;
11479 /* Clear out the mangled name and RTL for the instantiation. */
11480 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11481 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11482 SET_DECL_RTL (r
, NULL
);
11483 /* The initializer must not be expanded until it is required;
11484 see [temp.inst]. */
11485 DECL_INITIAL (r
) = NULL_TREE
;
11486 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11487 SET_DECL_RTL (r
, NULL
);
11488 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11491 /* Possibly limit visibility based on template args. */
11492 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11493 if (DECL_VISIBILITY_SPECIFIED (t
))
11495 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11496 DECL_ATTRIBUTES (r
)
11497 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11499 determine_visibility (r
);
11504 /* A static data member declaration is always marked
11505 external when it is declared in-class, even if an
11506 initializer is present. We mimic the non-template
11507 processing here. */
11508 DECL_EXTERNAL (r
) = 1;
11509 if (DECL_NAMESPACE_SCOPE_P (t
))
11510 DECL_NOT_REALLY_EXTERN (r
) = 1;
11512 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11513 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11514 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11516 else if (!cp_unevaluated_operand
)
11517 register_local_specialization (r
, t
);
11519 DECL_CHAIN (r
) = NULL_TREE
;
11521 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11523 args
, complain
, in_decl
);
11525 /* Preserve a typedef that names a type. */
11526 if (is_typedef_decl (r
))
11528 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11529 set_underlying_type (r
);
11532 layout_decl (r
, 0);
11537 gcc_unreachable ();
11542 /* Restore the file and line information. */
11543 input_location
= saved_loc
;
11548 /* Substitute into the ARG_TYPES of a function type.
11549 If END is a TREE_CHAIN, leave it and any following types
11553 tsubst_arg_types (tree arg_types
,
11556 tsubst_flags_t complain
,
11559 tree remaining_arg_types
;
11560 tree type
= NULL_TREE
;
11562 tree expanded_args
= NULL_TREE
;
11565 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11568 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11569 args
, end
, complain
, in_decl
);
11570 if (remaining_arg_types
== error_mark_node
)
11571 return error_mark_node
;
11573 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11575 /* For a pack expansion, perform substitution on the
11576 entire expression. Later on, we'll handle the arguments
11578 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11579 args
, complain
, in_decl
);
11581 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11582 /* So that we'll spin through the parameters, one by one. */
11583 i
= TREE_VEC_LENGTH (expanded_args
);
11586 /* We only partially substituted into the parameter
11587 pack. Our type is TYPE_PACK_EXPANSION. */
11588 type
= expanded_args
;
11589 expanded_args
= NULL_TREE
;
11597 type
= TREE_VEC_ELT (expanded_args
, i
);
11599 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11601 if (type
== error_mark_node
)
11602 return error_mark_node
;
11603 if (VOID_TYPE_P (type
))
11605 if (complain
& tf_error
)
11607 error ("invalid parameter type %qT", type
);
11609 error ("in declaration %q+D", in_decl
);
11611 return error_mark_node
;
11614 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11615 return error_mark_node
;
11617 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11618 top-level qualifiers as required. */
11619 type
= cv_unqualified (type_decays_to (type
));
11621 /* We do not substitute into default arguments here. The standard
11622 mandates that they be instantiated only when needed, which is
11623 done in build_over_call. */
11624 default_arg
= TREE_PURPOSE (arg_types
);
11626 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11628 /* We've instantiated a template before its default arguments
11629 have been parsed. This can happen for a nested template
11630 class, and is not an error unless we require the default
11631 argument in a call of this function. */
11632 remaining_arg_types
=
11633 tree_cons (default_arg
, type
, remaining_arg_types
);
11634 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11637 remaining_arg_types
=
11638 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11641 return remaining_arg_types
;
11644 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11645 *not* handle the exception-specification for FNTYPE, because the
11646 initial substitution of explicitly provided template parameters
11647 during argument deduction forbids substitution into the
11648 exception-specification:
11652 All references in the function type of the function template to the
11653 corresponding template parameters are replaced by the specified tem-
11654 plate argument values. If a substitution in a template parameter or
11655 in the function type of the function template results in an invalid
11656 type, type deduction fails. [Note: The equivalent substitution in
11657 exception specifications is done only when the function is instanti-
11658 ated, at which point a program is ill-formed if the substitution
11659 results in an invalid type.] */
11662 tsubst_function_type (tree t
,
11664 tsubst_flags_t complain
,
11668 tree arg_types
= NULL_TREE
;
11671 /* The TYPE_CONTEXT is not used for function/method types. */
11672 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11674 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11676 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11678 if (late_return_type_p
)
11680 /* Substitute the argument types. */
11681 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11682 complain
, in_decl
);
11683 if (arg_types
== error_mark_node
)
11684 return error_mark_node
;
11686 tree save_ccp
= current_class_ptr
;
11687 tree save_ccr
= current_class_ref
;
11688 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11689 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11690 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11693 /* DR 1207: 'this' is in scope in the trailing return type. */
11694 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11697 /* Substitute the return type. */
11698 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11702 current_class_ptr
= save_ccp
;
11703 current_class_ref
= save_ccr
;
11707 /* Substitute the return type. */
11708 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11710 if (return_type
== error_mark_node
)
11711 return error_mark_node
;
11712 /* DR 486 clarifies that creation of a function type with an
11713 invalid return type is a deduction failure. */
11714 if (TREE_CODE (return_type
) == ARRAY_TYPE
11715 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11717 if (complain
& tf_error
)
11719 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11720 error ("function returning an array");
11722 error ("function returning a function");
11724 return error_mark_node
;
11727 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11728 return error_mark_node
;
11730 if (!late_return_type_p
)
11732 /* Substitute the argument types. */
11733 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11734 complain
, in_decl
);
11735 if (arg_types
== error_mark_node
)
11736 return error_mark_node
;
11739 /* Construct a new type node and return it. */
11740 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11742 fntype
= build_function_type (return_type
, arg_types
);
11743 fntype
= apply_memfn_quals (fntype
,
11744 type_memfn_quals (t
),
11745 type_memfn_rqual (t
));
11749 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11750 /* Don't pick up extra function qualifiers from the basetype. */
11751 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11752 if (! MAYBE_CLASS_TYPE_P (r
))
11756 Type deduction may fail for any of the following
11759 -- Attempting to create "pointer to member of T" when T
11760 is not a class type. */
11761 if (complain
& tf_error
)
11762 error ("creating pointer to member function of non-class type %qT",
11764 return error_mark_node
;
11767 fntype
= build_method_type_directly (r
, return_type
,
11768 TREE_CHAIN (arg_types
));
11769 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11771 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11773 if (late_return_type_p
)
11774 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11779 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11780 ARGS into that specification, and return the substituted
11781 specification. If there is no specification, return NULL_TREE. */
11784 tsubst_exception_specification (tree fntype
,
11786 tsubst_flags_t complain
,
11793 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11794 new_specs
= NULL_TREE
;
11795 if (specs
&& TREE_PURPOSE (specs
))
11797 /* A noexcept-specifier. */
11798 tree expr
= TREE_PURPOSE (specs
);
11799 if (TREE_CODE (expr
) == INTEGER_CST
)
11803 /* Defer instantiation of noexcept-specifiers to avoid
11804 excessive instantiations (c++/49107). */
11805 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11806 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11808 /* We already partially instantiated this member template,
11809 so combine the new args with the old. */
11810 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11811 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11812 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11813 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11817 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11818 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11822 new_specs
= tsubst_copy_and_build
11823 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11824 /*integral_constant_expression_p=*/true);
11825 new_specs
= build_noexcept_spec (new_specs
, complain
);
11829 if (! TREE_VALUE (specs
))
11836 tree expanded_specs
= NULL_TREE
;
11838 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11840 /* Expand the pack expansion type. */
11841 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11845 if (expanded_specs
== error_mark_node
)
11846 return error_mark_node
;
11847 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11848 len
= TREE_VEC_LENGTH (expanded_specs
);
11851 /* We're substituting into a member template, so
11852 we got a TYPE_PACK_EXPANSION back. Add that
11853 expansion and move on. */
11854 gcc_assert (TREE_CODE (expanded_specs
)
11855 == TYPE_PACK_EXPANSION
);
11856 new_specs
= add_exception_specifier (new_specs
,
11859 specs
= TREE_CHAIN (specs
);
11864 for (i
= 0; i
< len
; ++i
)
11866 if (expanded_specs
)
11867 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11869 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11870 if (spec
== error_mark_node
)
11872 new_specs
= add_exception_specifier (new_specs
, spec
,
11876 specs
= TREE_CHAIN (specs
);
11882 /* Take the tree structure T and replace template parameters used
11883 therein with the argument vector ARGS. IN_DECL is an associated
11884 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11885 Issue error and warning messages under control of COMPLAIN. Note
11886 that we must be relatively non-tolerant of extensions here, in
11887 order to preserve conformance; if we allow substitutions that
11888 should not be allowed, we may allow argument deductions that should
11889 not succeed, and therefore report ambiguous overload situations
11890 where there are none. In theory, we could allow the substitution,
11891 but indicate that it should have failed, and allow our caller to
11892 make sure that the right thing happens, but we don't try to do this
11895 This function is used for dealing with types, decls and the like;
11896 for expressions, use tsubst_expr or tsubst_copy. */
11899 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11901 enum tree_code code
;
11902 tree type
, r
= NULL_TREE
;
11904 if (t
== NULL_TREE
|| t
== error_mark_node
11905 || t
== integer_type_node
11906 || t
== void_type_node
11907 || t
== char_type_node
11908 || t
== unknown_type_node
11909 || TREE_CODE (t
) == NAMESPACE_DECL
11910 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11914 return tsubst_decl (t
, args
, complain
);
11916 if (args
== NULL_TREE
)
11919 code
= TREE_CODE (t
);
11921 if (code
== IDENTIFIER_NODE
)
11922 type
= IDENTIFIER_TYPE_VALUE (t
);
11924 type
= TREE_TYPE (t
);
11926 gcc_assert (type
!= unknown_type_node
);
11928 /* Reuse typedefs. We need to do this to handle dependent attributes,
11929 such as attribute aligned. */
11931 && typedef_variant_p (t
))
11933 tree decl
= TYPE_NAME (t
);
11935 if (alias_template_specialization_p (t
))
11937 /* DECL represents an alias template and we want to
11939 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11940 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11941 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11943 else if (DECL_CLASS_SCOPE_P (decl
)
11944 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11945 && uses_template_parms (DECL_CONTEXT (decl
)))
11947 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11948 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11949 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11951 else if (DECL_FUNCTION_SCOPE_P (decl
)
11952 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11953 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11954 r
= retrieve_local_specialization (decl
);
11956 /* The typedef is from a non-template context. */
11962 r
= cp_build_qualified_type_real
11963 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11964 complain
| tf_ignore_bad_quals
);
11969 /* We don't have an instantiation yet, so drop the typedef. */
11970 int quals
= cp_type_quals (t
);
11971 t
= DECL_ORIGINAL_TYPE (decl
);
11972 t
= cp_build_qualified_type_real (t
, quals
,
11973 complain
| tf_ignore_bad_quals
);
11978 && code
!= TYPENAME_TYPE
11979 && code
!= TEMPLATE_TYPE_PARM
11980 && code
!= IDENTIFIER_NODE
11981 && code
!= FUNCTION_TYPE
11982 && code
!= METHOD_TYPE
)
11983 type
= tsubst (type
, args
, complain
, in_decl
);
11984 if (type
== error_mark_node
)
11985 return error_mark_node
;
11991 case ENUMERAL_TYPE
:
11992 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11993 /*entering_scope=*/0);
11996 case IDENTIFIER_NODE
:
12007 if (t
== integer_type_node
)
12010 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
12011 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
12015 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
12017 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
12018 /*integral_constant_expression_p=*/false);
12020 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
12022 if (TREE_CODE (max
) == NOP_EXPR
12023 && TREE_SIDE_EFFECTS (omax
)
12024 && !TREE_TYPE (max
))
12025 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
12027 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
12028 with TREE_SIDE_EFFECTS that indicates this is not an integral
12029 constant expression. */
12030 if (processing_template_decl
12031 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
12033 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
12034 TREE_SIDE_EFFECTS (max
) = 1;
12037 return compute_array_index_type (NULL_TREE
, max
, complain
);
12040 case TEMPLATE_TYPE_PARM
:
12041 case TEMPLATE_TEMPLATE_PARM
:
12042 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12043 case TEMPLATE_PARM_INDEX
:
12048 tree arg
= NULL_TREE
;
12052 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
12053 template_parm_level_and_index (t
, &level
, &idx
);
12055 levels
= TMPL_ARGS_DEPTH (args
);
12056 if (level
<= levels
)
12058 arg
= TMPL_ARG (args
, level
, idx
);
12060 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
12062 /* See through ARGUMENT_PACK_SELECT arguments. */
12063 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
12064 /* If the selected argument is an expansion E, that most
12065 likely means we were called from
12066 gen_elem_of_pack_expansion_instantiation during the
12067 substituting of pack an argument pack (which Ith
12068 element is a pack expansion, where I is
12069 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
12070 In this case, the Ith element resulting from this
12071 substituting is going to be a pack expansion, which
12072 pattern is the pattern of E. Let's return the
12074 gen_elem_of_pack_expansion_instantiation will
12075 build the resulting pack expansion from it. */
12076 if (PACK_EXPANSION_P (arg
))
12078 /* Make sure we aren't throwing away arg info. */
12079 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
12080 arg
= PACK_EXPANSION_PATTERN (arg
);
12085 if (arg
== error_mark_node
)
12086 return error_mark_node
;
12087 else if (arg
!= NULL_TREE
)
12089 if (ARGUMENT_PACK_P (arg
))
12090 /* If ARG is an argument pack, we don't actually want to
12091 perform a substitution here, because substitutions
12092 for argument packs are only done
12093 element-by-element. We can get to this point when
12094 substituting the type of a non-type template
12095 parameter pack, when that type actually contains
12096 template parameter packs from an outer template, e.g.,
12098 template<typename... Types> struct A {
12099 template<Types... Values> struct B { };
12103 if (code
== TEMPLATE_TYPE_PARM
)
12106 gcc_assert (TYPE_P (arg
));
12108 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
12110 return cp_build_qualified_type_real
12111 (arg
, quals
, complain
| tf_ignore_bad_quals
);
12113 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12115 /* We are processing a type constructed from a
12116 template template parameter. */
12117 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
12118 args
, complain
, in_decl
);
12119 if (argvec
== error_mark_node
)
12120 return error_mark_node
;
12122 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
12123 || TREE_CODE (arg
) == TEMPLATE_DECL
12124 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
12126 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
12127 /* Consider this code:
12129 template <template <class> class Template>
12131 template <class Arg> using Bind = Template<Arg>;
12134 template <template <class> class Template, class Arg>
12135 using Instantiate = Template<Arg>; //#0
12137 template <template <class> class Template,
12140 Instantiate<Internal<Template>::template Bind,
12143 When #1 is parsed, the
12144 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12145 parameter `Template' in #0 matches the
12146 UNBOUND_CLASS_TEMPLATE representing the argument
12147 `Internal<Template>::template Bind'; We then want
12148 to assemble the type `Bind<Argument>' that can't
12149 be fully created right now, because
12150 `Internal<Template>' not being complete, the Bind
12151 template cannot be looked up in that context. So
12152 we need to "store" `Bind<Argument>' for later
12153 when the context of Bind becomes complete. Let's
12154 store that in a TYPENAME_TYPE. */
12155 return make_typename_type (TYPE_CONTEXT (arg
),
12156 build_nt (TEMPLATE_ID_EXPR
,
12157 TYPE_IDENTIFIER (arg
),
12162 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12163 are resolving nested-types in the signature of a
12164 member function templates. Otherwise ARG is a
12165 TEMPLATE_DECL and is the real template to be
12167 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
12168 arg
= TYPE_NAME (arg
);
12170 r
= lookup_template_class (arg
,
12172 DECL_CONTEXT (arg
),
12173 /*entering_scope=*/0,
12175 return cp_build_qualified_type_real
12176 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
12179 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12180 return convert_from_reference (unshare_expr (arg
));
12184 /* This can happen during the attempted tsubst'ing in
12185 unify. This means that we don't yet have any information
12186 about the template parameter in question. */
12189 /* Early in template argument deduction substitution, we don't
12190 want to reduce the level of 'auto', or it will be confused
12191 with a normal template parm in subsequent deduction. */
12192 if (is_auto (t
) && (complain
& tf_partial
))
12195 /* If we get here, we must have been looking at a parm for a
12196 more deeply nested template. Make a new version of this
12197 template parameter, but with a lower level. */
12200 case TEMPLATE_TYPE_PARM
:
12201 case TEMPLATE_TEMPLATE_PARM
:
12202 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12203 if (cp_type_quals (t
))
12205 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
12206 r
= cp_build_qualified_type_real
12207 (r
, cp_type_quals (t
),
12208 complain
| (code
== TEMPLATE_TYPE_PARM
12209 ? tf_ignore_bad_quals
: 0));
12214 TEMPLATE_TYPE_PARM_INDEX (r
)
12215 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
12216 r
, levels
, args
, complain
);
12217 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
12218 TYPE_MAIN_VARIANT (r
) = r
;
12219 TYPE_POINTER_TO (r
) = NULL_TREE
;
12220 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
12222 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
12223 /* We have reduced the level of the template
12224 template parameter, but not the levels of its
12225 template parameters, so canonical_type_parameter
12226 will not be able to find the canonical template
12227 template parameter for this level. Thus, we
12228 require structural equality checking to compare
12229 TEMPLATE_TEMPLATE_PARMs. */
12230 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12231 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
12232 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12234 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
12236 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12238 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
12239 complain
, in_decl
);
12240 if (argvec
== error_mark_node
)
12241 return error_mark_node
;
12243 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
12244 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
12249 case TEMPLATE_PARM_INDEX
:
12250 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
12254 gcc_unreachable ();
12262 tree purpose
, value
, chain
;
12264 if (t
== void_list_node
)
12267 purpose
= TREE_PURPOSE (t
);
12270 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
12271 if (purpose
== error_mark_node
)
12272 return error_mark_node
;
12274 value
= TREE_VALUE (t
);
12277 value
= tsubst (value
, args
, complain
, in_decl
);
12278 if (value
== error_mark_node
)
12279 return error_mark_node
;
12281 chain
= TREE_CHAIN (t
);
12282 if (chain
&& chain
!= void_type_node
)
12284 chain
= tsubst (chain
, args
, complain
, in_decl
);
12285 if (chain
== error_mark_node
)
12286 return error_mark_node
;
12288 if (purpose
== TREE_PURPOSE (t
)
12289 && value
== TREE_VALUE (t
)
12290 && chain
== TREE_CHAIN (t
))
12292 return hash_tree_cons (purpose
, value
, chain
);
12296 /* We should never be tsubsting a binfo. */
12297 gcc_unreachable ();
12300 /* A vector of template arguments. */
12301 gcc_assert (!type
);
12302 return tsubst_template_args (t
, args
, complain
, in_decl
);
12305 case REFERENCE_TYPE
:
12307 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
12312 Type deduction may fail for any of the following
12315 -- Attempting to create a pointer to reference type.
12316 -- Attempting to create a reference to a reference type or
12317 a reference to void.
12319 Core issue 106 says that creating a reference to a reference
12320 during instantiation is no longer a cause for failure. We
12321 only enforce this check in strict C++98 mode. */
12322 if ((TREE_CODE (type
) == REFERENCE_TYPE
12323 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
12324 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
12326 static location_t last_loc
;
12328 /* We keep track of the last time we issued this error
12329 message to avoid spewing a ton of messages during a
12330 single bad template instantiation. */
12331 if (complain
& tf_error
12332 && last_loc
!= input_location
)
12334 if (VOID_TYPE_P (type
))
12335 error ("forming reference to void");
12336 else if (code
== POINTER_TYPE
)
12337 error ("forming pointer to reference type %qT", type
);
12339 error ("forming reference to reference type %qT", type
);
12340 last_loc
= input_location
;
12343 return error_mark_node
;
12345 else if (TREE_CODE (type
) == FUNCTION_TYPE
12346 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
12347 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12349 if (complain
& tf_error
)
12351 if (code
== POINTER_TYPE
)
12352 error ("forming pointer to qualified function type %qT",
12355 error ("forming reference to qualified function type %qT",
12358 return error_mark_node
;
12360 else if (code
== POINTER_TYPE
)
12362 r
= build_pointer_type (type
);
12363 if (TREE_CODE (type
) == METHOD_TYPE
)
12364 r
= build_ptrmemfunc_type (r
);
12366 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12367 /* In C++0x, during template argument substitution, when there is an
12368 attempt to create a reference to a reference type, reference
12369 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12371 "If a template-argument for a template-parameter T names a type
12372 that is a reference to a type A, an attempt to create the type
12373 'lvalue reference to cv T' creates the type 'lvalue reference to
12374 A,' while an attempt to create the type type rvalue reference to
12375 cv T' creates the type T"
12377 r
= cp_build_reference_type
12379 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12381 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12382 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12384 if (r
!= error_mark_node
)
12385 /* Will this ever be needed for TYPE_..._TO values? */
12392 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12393 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12397 Type deduction may fail for any of the following
12400 -- Attempting to create "pointer to member of T" when T
12401 is not a class type. */
12402 if (complain
& tf_error
)
12403 error ("creating pointer to member of non-class type %qT", r
);
12404 return error_mark_node
;
12406 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12408 if (complain
& tf_error
)
12409 error ("creating pointer to member reference type %qT", type
);
12410 return error_mark_node
;
12412 if (VOID_TYPE_P (type
))
12414 if (complain
& tf_error
)
12415 error ("creating pointer to member of type void");
12416 return error_mark_node
;
12418 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12419 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12421 /* The type of the implicit object parameter gets its
12422 cv-qualifiers from the FUNCTION_TYPE. */
12425 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12426 type_memfn_rqual (type
));
12427 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12428 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12432 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12436 case FUNCTION_TYPE
:
12441 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12442 if (fntype
== error_mark_node
)
12443 return error_mark_node
;
12445 /* Substitute the exception specification. */
12446 specs
= tsubst_exception_specification (t
, args
, complain
,
12447 in_decl
, /*defer_ok*/true);
12448 if (specs
== error_mark_node
)
12449 return error_mark_node
;
12451 fntype
= build_exception_variant (fntype
, specs
);
12456 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12457 if (domain
== error_mark_node
)
12458 return error_mark_node
;
12460 /* As an optimization, we avoid regenerating the array type if
12461 it will obviously be the same as T. */
12462 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12465 /* These checks should match the ones in create_array_type_for_decl.
12469 The deduction may fail for any of the following reasons:
12471 -- Attempting to create an array with an element type that
12472 is void, a function type, or a reference type, or [DR337]
12473 an abstract class type. */
12474 if (VOID_TYPE_P (type
)
12475 || TREE_CODE (type
) == FUNCTION_TYPE
12476 || (TREE_CODE (type
) == ARRAY_TYPE
12477 && TYPE_DOMAIN (type
) == NULL_TREE
)
12478 || TREE_CODE (type
) == REFERENCE_TYPE
)
12480 if (complain
& tf_error
)
12481 error ("creating array of %qT", type
);
12482 return error_mark_node
;
12485 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12486 return error_mark_node
;
12488 r
= build_cplus_array_type (type
, domain
);
12490 if (TYPE_USER_ALIGN (t
))
12492 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12493 TYPE_USER_ALIGN (r
) = 1;
12499 case TYPENAME_TYPE
:
12501 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12502 in_decl
, /*entering_scope=*/1);
12503 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12504 complain
, in_decl
);
12506 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12507 return error_mark_node
;
12509 if (!MAYBE_CLASS_TYPE_P (ctx
))
12511 if (complain
& tf_error
)
12512 error ("%qT is not a class, struct, or union type", ctx
);
12513 return error_mark_node
;
12515 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12517 /* Normally, make_typename_type does not require that the CTX
12518 have complete type in order to allow things like:
12520 template <class T> struct S { typename S<T>::X Y; };
12522 But, such constructs have already been resolved by this
12523 point, so here CTX really should have complete type, unless
12524 it's a partial instantiation. */
12525 ctx
= complete_type (ctx
);
12526 if (!COMPLETE_TYPE_P (ctx
))
12528 if (complain
& tf_error
)
12529 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12530 return error_mark_node
;
12534 f
= make_typename_type (ctx
, f
, typename_type
,
12535 complain
| tf_keep_type_decl
);
12536 if (f
== error_mark_node
)
12538 if (TREE_CODE (f
) == TYPE_DECL
)
12540 complain
|= tf_ignore_bad_quals
;
12544 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12546 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12548 if (complain
& tf_error
)
12549 error ("%qT resolves to %qT, which is not an enumeration type",
12552 return error_mark_node
;
12554 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12556 if (complain
& tf_error
)
12557 error ("%qT resolves to %qT, which is is not a class type",
12560 return error_mark_node
;
12564 return cp_build_qualified_type_real
12565 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12568 case UNBOUND_CLASS_TEMPLATE
:
12570 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12571 in_decl
, /*entering_scope=*/1);
12572 tree name
= TYPE_IDENTIFIER (t
);
12573 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12575 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12576 return error_mark_node
;
12579 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12580 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12587 ++cp_unevaluated_operand
;
12588 ++c_inhibit_evaluation_warnings
;
12590 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12592 /*integral_constant_expression_p=*/false);
12594 --cp_unevaluated_operand
;
12595 --c_inhibit_evaluation_warnings
;
12597 type
= finish_typeof (type
);
12598 return cp_build_qualified_type_real (type
,
12600 | cp_type_quals (type
),
12604 case DECLTYPE_TYPE
:
12608 ++cp_unevaluated_operand
;
12609 ++c_inhibit_evaluation_warnings
;
12611 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12612 complain
|tf_decltype
, in_decl
,
12613 /*function_p*/false,
12614 /*integral_constant_expression*/false);
12616 --cp_unevaluated_operand
;
12617 --c_inhibit_evaluation_warnings
;
12619 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12620 type
= lambda_capture_field_type (type
,
12621 DECLTYPE_FOR_INIT_CAPTURE (t
));
12622 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12623 type
= lambda_proxy_type (type
);
12626 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12627 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12629 /* In a template ~id could be either a complement expression
12630 or an unqualified-id naming a destructor; if instantiating
12631 it produces an expression, it's not an id-expression or
12634 type
= finish_decltype_type (type
, id
, complain
);
12636 return cp_build_qualified_type_real (type
,
12638 | cp_type_quals (type
),
12639 complain
| tf_ignore_bad_quals
);
12642 case UNDERLYING_TYPE
:
12644 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12645 complain
, in_decl
);
12646 return finish_underlying_type (type
);
12649 case TYPE_ARGUMENT_PACK
:
12650 case NONTYPE_ARGUMENT_PACK
:
12652 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12654 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12658 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12660 /* For template nontype argument packs, also substitute into
12662 if (code
== NONTYPE_ARGUMENT_PACK
)
12663 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12682 /* We should use one of the expression tsubsts for these codes. */
12683 gcc_unreachable ();
12686 sorry ("use of %qs in template", get_tree_code_name (code
));
12687 return error_mark_node
;
12691 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12692 type of the expression on the left-hand side of the "." or "->"
12696 tsubst_baselink (tree baselink
, tree object_type
,
12697 tree args
, tsubst_flags_t complain
, tree in_decl
)
12700 tree qualifying_scope
;
12703 tree template_args
= 0;
12704 bool template_id_p
= false;
12705 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12707 /* A baselink indicates a function from a base class. Both the
12708 BASELINK_ACCESS_BINFO and the base class referenced may
12709 indicate bases of the template class, rather than the
12710 instantiated class. In addition, lookups that were not
12711 ambiguous before may be ambiguous now. Therefore, we perform
12712 the lookup again. */
12713 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12714 qualifying_scope
= tsubst (qualifying_scope
, args
,
12715 complain
, in_decl
);
12716 fns
= BASELINK_FUNCTIONS (baselink
);
12717 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12718 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12720 template_id_p
= true;
12721 template_args
= TREE_OPERAND (fns
, 1);
12722 fns
= TREE_OPERAND (fns
, 0);
12724 template_args
= tsubst_template_args (template_args
, args
,
12725 complain
, in_decl
);
12727 name
= DECL_NAME (get_first_fn (fns
));
12728 if (IDENTIFIER_TYPENAME_P (name
))
12729 name
= mangle_conv_op_name_for_type (optype
);
12730 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12732 return error_mark_node
;
12734 /* If lookup found a single function, mark it as used at this
12735 point. (If it lookup found multiple functions the one selected
12736 later by overload resolution will be marked as used at that
12738 if (BASELINK_P (baselink
))
12739 fns
= BASELINK_FUNCTIONS (baselink
);
12740 if (!template_id_p
&& !really_overloaded_fn (fns
)
12741 && !mark_used (OVL_CURRENT (fns
), complain
) && !(complain
& tf_error
))
12742 return error_mark_node
;
12744 /* Add back the template arguments, if present. */
12745 if (BASELINK_P (baselink
) && template_id_p
)
12746 BASELINK_FUNCTIONS (baselink
)
12747 = build_nt (TEMPLATE_ID_EXPR
,
12748 BASELINK_FUNCTIONS (baselink
),
12750 /* Update the conversion operator type. */
12751 BASELINK_OPTYPE (baselink
) = optype
;
12754 object_type
= current_class_type
;
12757 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12763 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12764 true if the qualified-id will be a postfix-expression in-and-of
12765 itself; false if more of the postfix-expression follows the
12766 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12770 tsubst_qualified_id (tree qualified_id
, tree args
,
12771 tsubst_flags_t complain
, tree in_decl
,
12772 bool done
, bool address_p
)
12778 tree template_args
;
12779 location_t loc
= UNKNOWN_LOCATION
;
12781 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12783 /* Figure out what name to look up. */
12784 name
= TREE_OPERAND (qualified_id
, 1);
12785 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12787 is_template
= true;
12788 loc
= EXPR_LOCATION (name
);
12789 template_args
= TREE_OPERAND (name
, 1);
12791 template_args
= tsubst_template_args (template_args
, args
,
12792 complain
, in_decl
);
12793 name
= TREE_OPERAND (name
, 0);
12797 is_template
= false;
12798 template_args
= NULL_TREE
;
12801 /* Substitute into the qualifying scope. When there are no ARGS, we
12802 are just trying to simplify a non-dependent expression. In that
12803 case the qualifying scope may be dependent, and, in any case,
12804 substituting will not help. */
12805 scope
= TREE_OPERAND (qualified_id
, 0);
12808 scope
= tsubst (scope
, args
, complain
, in_decl
);
12809 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12814 if (dependent_scope_p (scope
))
12817 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12818 return build_qualified_name (NULL_TREE
, scope
, expr
,
12819 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12822 if (!BASELINK_P (name
) && !DECL_P (expr
))
12824 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12826 /* A BIT_NOT_EXPR is used to represent a destructor. */
12827 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12829 error ("qualifying type %qT does not match destructor name ~%qT",
12830 scope
, TREE_OPERAND (expr
, 0));
12831 expr
= error_mark_node
;
12834 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12835 /*is_type_p=*/0, false);
12838 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12839 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12840 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12842 if (complain
& tf_error
)
12844 error ("dependent-name %qE is parsed as a non-type, but "
12845 "instantiation yields a type", qualified_id
);
12846 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12848 return error_mark_node
;
12854 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12856 /* Remember that there was a reference to this entity. */
12857 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
12858 return error_mark_node
;
12861 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12863 if (complain
& tf_error
)
12864 qualified_name_lookup_error (scope
,
12865 TREE_OPERAND (qualified_id
, 1),
12866 expr
, input_location
);
12867 return error_mark_node
;
12871 expr
= lookup_template_function (expr
, template_args
);
12873 if (expr
== error_mark_node
&& complain
& tf_error
)
12874 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12875 expr
, input_location
);
12876 else if (TYPE_P (scope
))
12878 expr
= (adjust_result_of_qualified_name_lookup
12879 (expr
, scope
, current_nonlambda_class_type ()));
12880 expr
= (finish_qualified_id_expr
12881 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12882 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12883 /*template_arg_p=*/false, complain
));
12886 /* Expressions do not generally have reference type. */
12887 if (TREE_CODE (expr
) != SCOPE_REF
12888 /* However, if we're about to form a pointer-to-member, we just
12889 want the referenced member referenced. */
12890 && TREE_CODE (expr
) != OFFSET_REF
)
12891 expr
= convert_from_reference (expr
);
12896 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12897 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12901 tsubst_init (tree init
, tree decl
, tree args
,
12902 tsubst_flags_t complain
, tree in_decl
)
12907 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12911 /* If we had an initializer but it
12912 instantiated to nothing,
12913 value-initialize the object. This will
12914 only occur when the initializer was a
12915 pack expansion where the parameter packs
12916 used in that expansion were of length
12918 init
= build_value_init (TREE_TYPE (decl
),
12920 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12921 init
= get_target_expr_sfinae (init
, complain
);
12927 /* Like tsubst, but deals with expressions. This function just replaces
12928 template parms; to finish processing the resultant expression, use
12929 tsubst_copy_and_build or tsubst_expr. */
12932 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12934 enum tree_code code
;
12937 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12940 code
= TREE_CODE (t
);
12945 r
= retrieve_local_specialization (t
);
12947 if (r
== NULL_TREE
)
12949 /* We get here for a use of 'this' in an NSDMI. */
12950 if (DECL_NAME (t
) == this_identifier
12951 && current_function_decl
12952 && DECL_CONSTRUCTOR_P (current_function_decl
))
12953 return current_class_ptr
;
12955 /* This can happen for a parameter name used later in a function
12956 declaration (such as in a late-specified return type). Just
12957 make a dummy decl, since it's only used for its type. */
12958 gcc_assert (cp_unevaluated_operand
!= 0);
12959 r
= tsubst_decl (t
, args
, complain
);
12960 /* Give it the template pattern as its context; its true context
12961 hasn't been instantiated yet and this is good enough for
12963 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12966 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12967 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12968 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
12969 return error_mark_node
;
12977 if (DECL_TEMPLATE_PARM_P (t
))
12978 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12979 /* There is no need to substitute into namespace-scope
12981 if (DECL_NAMESPACE_SCOPE_P (t
))
12983 /* If ARGS is NULL, then T is known to be non-dependent. */
12984 if (args
== NULL_TREE
)
12985 return scalar_constant_value (t
);
12987 /* Unfortunately, we cannot just call lookup_name here.
12990 template <int I> int f() {
12992 struct S { void g() { E e = a; } };
12995 When we instantiate f<7>::S::g(), say, lookup_name is not
12996 clever enough to find f<7>::a. */
12998 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12999 /*entering_scope=*/0);
13001 for (v
= TYPE_VALUES (enum_type
);
13003 v
= TREE_CHAIN (v
))
13004 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
13005 return TREE_VALUE (v
);
13007 /* We didn't find the name. That should never happen; if
13008 name-lookup found it during preliminary parsing, we
13009 should find it again here during instantiation. */
13010 gcc_unreachable ();
13015 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
13017 /* Check for a local specialization set up by
13018 tsubst_pack_expansion. */
13019 if (tree r
= retrieve_local_specialization (t
))
13021 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
13022 r
= ARGUMENT_PACK_SELECT_ARG (r
);
13026 /* When retrieving a capture pack from a generic lambda, remove the
13027 lambda call op's own template argument list from ARGS. Only the
13028 template arguments active for the closure type should be used to
13029 retrieve the pack specialization. */
13030 if (LAMBDA_FUNCTION_P (current_function_decl
)
13031 && (template_class_depth (DECL_CONTEXT (t
))
13032 != TMPL_ARGS_DEPTH (args
)))
13033 args
= strip_innermost_template_args (args
, 1);
13035 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
13036 tsubst_decl put in the hash table. */
13037 return retrieve_specialization (t
, args
, 0);
13040 if (DECL_CONTEXT (t
))
13044 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
13045 /*entering_scope=*/1);
13046 if (ctx
!= DECL_CONTEXT (t
))
13048 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
13051 if (complain
& tf_error
)
13052 error ("using invalid field %qD", t
);
13053 return error_mark_node
;
13062 case FUNCTION_DECL
:
13063 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
13064 r
= tsubst (t
, args
, complain
, in_decl
);
13065 else if (local_variable_p (t
))
13067 r
= retrieve_local_specialization (t
);
13068 if (r
== NULL_TREE
)
13070 /* First try name lookup to find the instantiation. */
13071 r
= lookup_name (DECL_NAME (t
));
13074 /* Make sure that the one we found is the one we want. */
13075 tree ctx
= tsubst (DECL_CONTEXT (t
), args
,
13076 complain
, in_decl
);
13077 if (ctx
!= DECL_CONTEXT (r
))
13085 /* This can happen for a variable used in a
13086 late-specified return type of a local lambda, or for a
13087 local static or constant. Building a new VAR_DECL
13088 should be OK in all those cases. */
13089 r
= tsubst_decl (t
, args
, complain
);
13090 if (decl_maybe_constant_var_p (r
))
13092 /* We can't call cp_finish_decl, so handle the
13093 initializer by hand. */
13094 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
13095 complain
, in_decl
);
13096 if (!processing_template_decl
)
13097 init
= maybe_constant_init (init
);
13098 if (processing_template_decl
13099 ? potential_constant_expression (init
)
13100 : reduced_constant_expression_p (init
))
13101 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
13102 = TREE_CONSTANT (r
) = true;
13103 DECL_INITIAL (r
) = init
;
13105 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
13106 || decl_constant_var_p (r
)
13107 || errorcount
|| sorrycount
);
13108 if (!processing_template_decl
)
13110 if (TREE_STATIC (r
))
13111 rest_of_decl_compilation (r
, toplevel_bindings_p (),
13114 r
= process_outer_var_ref (r
, complain
);
13117 /* Remember this for subsequent uses. */
13118 if (local_specializations
)
13119 register_local_specialization (r
, t
);
13124 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
13125 return error_mark_node
;
13128 case NAMESPACE_DECL
:
13132 /* An OVERLOAD will always be a non-dependent overload set; an
13133 overload set from function scope will just be represented with an
13134 IDENTIFIER_NODE, and from class scope with a BASELINK. */
13135 gcc_assert (!uses_template_parms (t
));
13139 return tsubst_baselink (t
, current_nonlambda_class_type (),
13140 args
, complain
, in_decl
);
13142 case TEMPLATE_DECL
:
13143 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13144 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
13145 args
, complain
, in_decl
);
13146 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
13147 return tsubst (t
, args
, complain
, in_decl
);
13148 else if (DECL_CLASS_SCOPE_P (t
)
13149 && uses_template_parms (DECL_CONTEXT (t
)))
13151 /* Template template argument like the following example need
13154 template <template <class> class TT> struct C {};
13155 template <class T> struct D {
13156 template <class U> struct E {};
13161 We are processing the template argument `E' in #1 for
13162 the template instantiation #2. Originally, `E' is a
13163 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13164 have to substitute this with one having context `D<int>'. */
13166 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
13167 return lookup_field (context
, DECL_NAME(t
), 0, false);
13170 /* Ordinary template template argument. */
13174 case REINTERPRET_CAST_EXPR
:
13175 case CONST_CAST_EXPR
:
13176 case STATIC_CAST_EXPR
:
13177 case DYNAMIC_CAST_EXPR
:
13178 case IMPLICIT_CONV_EXPR
:
13182 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13183 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13184 return build1 (code
, type
, op0
);
13188 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
13191 tree expanded
, op
= TREE_OPERAND (t
, 0);
13194 if (SIZEOF_EXPR_TYPE_P (t
))
13195 op
= TREE_TYPE (op
);
13197 ++cp_unevaluated_operand
;
13198 ++c_inhibit_evaluation_warnings
;
13199 /* We only want to compute the number of arguments. */
13200 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
13201 --cp_unevaluated_operand
;
13202 --c_inhibit_evaluation_warnings
;
13204 if (TREE_CODE (expanded
) == TREE_VEC
)
13205 len
= TREE_VEC_LENGTH (expanded
);
13207 if (expanded
== error_mark_node
)
13208 return error_mark_node
;
13209 else if (PACK_EXPANSION_P (expanded
)
13210 || (TREE_CODE (expanded
) == TREE_VEC
13212 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
13214 if (TREE_CODE (expanded
) == TREE_VEC
)
13215 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
13217 if (TYPE_P (expanded
))
13218 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
13219 complain
& tf_error
);
13221 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
13222 complain
& tf_error
);
13225 return build_int_cst (size_type_node
, len
);
13227 if (SIZEOF_EXPR_TYPE_P (t
))
13229 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
13230 args
, complain
, in_decl
);
13231 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
13232 r
= build1 (SIZEOF_EXPR
,
13233 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
13234 SIZEOF_EXPR_TYPE_P (r
) = 1;
13241 case TRUTH_NOT_EXPR
:
13244 case UNARY_PLUS_EXPR
: /* Unary + */
13246 case AT_ENCODE_EXPR
:
13250 case REALPART_EXPR
:
13251 case IMAGPART_EXPR
:
13254 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13255 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13256 return build1 (code
, type
, op0
);
13259 case COMPONENT_REF
:
13264 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13265 name
= TREE_OPERAND (t
, 1);
13266 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
13268 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13269 complain
, in_decl
);
13270 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13272 else if (TREE_CODE (name
) == SCOPE_REF
13273 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
13275 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13276 complain
, in_decl
);
13277 name
= TREE_OPERAND (name
, 1);
13278 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13279 complain
, in_decl
);
13280 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13281 name
= build_qualified_name (/*type=*/NULL_TREE
,
13283 /*template_p=*/false);
13285 else if (BASELINK_P (name
))
13286 name
= tsubst_baselink (name
,
13287 non_reference (TREE_TYPE (object
)),
13291 name
= tsubst_copy (name
, args
, complain
, in_decl
);
13292 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
13298 case TRUNC_DIV_EXPR
:
13299 case CEIL_DIV_EXPR
:
13300 case FLOOR_DIV_EXPR
:
13301 case ROUND_DIV_EXPR
:
13302 case EXACT_DIV_EXPR
:
13306 case TRUNC_MOD_EXPR
:
13307 case FLOOR_MOD_EXPR
:
13308 case TRUTH_ANDIF_EXPR
:
13309 case TRUTH_ORIF_EXPR
:
13310 case TRUTH_AND_EXPR
:
13311 case TRUTH_OR_EXPR
:
13324 case COMPOUND_EXPR
:
13327 case PREDECREMENT_EXPR
:
13328 case PREINCREMENT_EXPR
:
13329 case POSTDECREMENT_EXPR
:
13330 case POSTINCREMENT_EXPR
:
13332 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13333 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13334 return build_nt (code
, op0
, op1
);
13339 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13340 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13341 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
13342 QUALIFIED_NAME_IS_TEMPLATE (t
));
13347 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13348 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13349 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13354 int n
= VL_EXP_OPERAND_LENGTH (t
);
13355 tree result
= build_vl_exp (CALL_EXPR
, n
);
13357 for (i
= 0; i
< n
; i
++)
13358 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13359 complain
, in_decl
);
13365 case PSEUDO_DTOR_EXPR
:
13366 case VEC_PERM_EXPR
:
13368 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13369 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13370 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13371 r
= build_nt (code
, op0
, op1
, op2
);
13372 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13378 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13379 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13380 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13381 r
= build_nt (code
, op0
, op1
, op2
);
13382 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13388 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13389 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13390 r
= build_nt (code
, op0
, op1
);
13391 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13392 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13396 case TEMPLATE_ID_EXPR
:
13398 /* Substituted template arguments */
13399 tree fn
= TREE_OPERAND (t
, 0);
13400 tree targs
= TREE_OPERAND (t
, 1);
13402 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13404 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13406 return lookup_template_function (fn
, targs
);
13411 tree purpose
, value
, chain
;
13413 if (t
== void_list_node
)
13416 purpose
= TREE_PURPOSE (t
);
13418 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13419 value
= TREE_VALUE (t
);
13421 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13422 chain
= TREE_CHAIN (t
);
13423 if (chain
&& chain
!= void_type_node
)
13424 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13425 if (purpose
== TREE_PURPOSE (t
)
13426 && value
== TREE_VALUE (t
)
13427 && chain
== TREE_CHAIN (t
))
13429 return tree_cons (purpose
, value
, chain
);
13434 case ENUMERAL_TYPE
:
13436 case TEMPLATE_TYPE_PARM
:
13437 case TEMPLATE_TEMPLATE_PARM
:
13438 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13439 case TEMPLATE_PARM_INDEX
:
13441 case REFERENCE_TYPE
:
13443 case FUNCTION_TYPE
:
13446 case TYPENAME_TYPE
:
13447 case UNBOUND_CLASS_TEMPLATE
:
13449 case DECLTYPE_TYPE
:
13451 return tsubst (t
, args
, complain
, in_decl
);
13455 /* Fall through. */
13456 case IDENTIFIER_NODE
:
13457 if (IDENTIFIER_TYPENAME_P (t
))
13459 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13460 return mangle_conv_op_name_for_type (new_type
);
13466 /* This is handled by tsubst_copy_and_build. */
13467 gcc_unreachable ();
13471 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13472 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13473 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13476 case CLEANUP_POINT_EXPR
:
13477 /* We shouldn't have built any of these during initial template
13478 generation. Instead, they should be built during instantiation
13479 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13480 gcc_unreachable ();
13484 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13485 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13486 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13487 r
= build2 (code
, type
, op0
, op1
);
13488 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13489 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
13490 && !(complain
& tf_error
))
13491 return error_mark_node
;
13495 case EXPR_PACK_EXPANSION
:
13496 error ("invalid use of pack expansion expression");
13497 return error_mark_node
;
13499 case NONTYPE_ARGUMENT_PACK
:
13500 error ("use %<...%> to expand argument pack");
13501 return error_mark_node
;
13504 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13512 /* Instantiate any typedefs in the type. */
13513 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13514 r
= fold_convert (type
, t
);
13515 gcc_assert (TREE_CODE (r
) == code
);
13520 /* These can sometimes show up in a partial instantiation, but never
13521 involve template parms. */
13522 gcc_assert (!uses_template_parms (t
));
13526 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13527 gcc_checking_assert (false);
13532 /* Helper function for tsubst_omp_clauses, used for instantiation of
13533 OMP_CLAUSE_DECL of clauses that handles also OpenMP array sections
13534 represented with TREE_LIST. */
13537 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
13540 if (TREE_CODE (decl
) == TREE_LIST
)
13543 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
13544 /*integral_constant_expression_p=*/false);
13545 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
13546 /*integral_constant_expression_p=*/false);
13547 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
13549 if (TREE_PURPOSE (decl
) == low_bound
13550 && TREE_VALUE (decl
) == length
13551 && TREE_CHAIN (decl
) == chain
)
13553 return tree_cons (low_bound
, length
, chain
);
13555 return tsubst_copy (decl
, args
, complain
, in_decl
);
13558 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13561 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13562 tree args
, tsubst_flags_t complain
, tree in_decl
)
13564 tree new_clauses
= NULL
, nc
, oc
;
13566 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13568 nc
= copy_node (oc
);
13569 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13572 switch (OMP_CLAUSE_CODE (nc
))
13574 case OMP_CLAUSE_LASTPRIVATE
:
13575 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13577 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13578 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13579 in_decl
, /*integral_constant_expression_p=*/false);
13580 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13581 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13584 case OMP_CLAUSE_PRIVATE
:
13585 case OMP_CLAUSE_SHARED
:
13586 case OMP_CLAUSE_FIRSTPRIVATE
:
13587 case OMP_CLAUSE_COPYIN
:
13588 case OMP_CLAUSE_COPYPRIVATE
:
13589 case OMP_CLAUSE_UNIFORM
:
13590 OMP_CLAUSE_DECL (nc
) = tsubst_copy (OMP_CLAUSE_DECL (oc
), args
,
13591 complain
, in_decl
);
13593 case OMP_CLAUSE_DEPEND
:
13594 case OMP_CLAUSE_FROM
:
13595 case OMP_CLAUSE_TO
:
13596 case OMP_CLAUSE_MAP
:
13597 OMP_CLAUSE_DECL (nc
)
13598 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
13601 case OMP_CLAUSE_IF
:
13602 case OMP_CLAUSE_NUM_THREADS
:
13603 case OMP_CLAUSE_SCHEDULE
:
13604 case OMP_CLAUSE_COLLAPSE
:
13605 case OMP_CLAUSE_FINAL
:
13606 case OMP_CLAUSE_DEVICE
:
13607 case OMP_CLAUSE_DIST_SCHEDULE
:
13608 case OMP_CLAUSE_NUM_TEAMS
:
13609 case OMP_CLAUSE_THREAD_LIMIT
:
13610 case OMP_CLAUSE_SAFELEN
:
13611 case OMP_CLAUSE_SIMDLEN
:
13612 OMP_CLAUSE_OPERAND (nc
, 0)
13613 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13614 in_decl
, /*integral_constant_expression_p=*/false);
13616 case OMP_CLAUSE_REDUCTION
:
13617 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13619 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13620 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13622 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13623 complain
, in_decl
);
13624 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13625 = build_qualified_name (NULL_TREE
, scope
,
13626 TREE_OPERAND (placeholder
, 1),
13630 gcc_assert (identifier_p (placeholder
));
13632 OMP_CLAUSE_DECL (nc
) = tsubst_copy (OMP_CLAUSE_DECL (oc
), args
,
13633 complain
, in_decl
);
13635 case OMP_CLAUSE_LINEAR
:
13636 case OMP_CLAUSE_ALIGNED
:
13637 OMP_CLAUSE_DECL (nc
) = tsubst_copy (OMP_CLAUSE_DECL (oc
), args
,
13638 complain
, in_decl
);
13639 OMP_CLAUSE_OPERAND (nc
, 1)
13640 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13641 in_decl
, /*integral_constant_expression_p=*/false);
13643 case OMP_CLAUSE_NOWAIT
:
13644 case OMP_CLAUSE_ORDERED
:
13645 case OMP_CLAUSE_DEFAULT
:
13646 case OMP_CLAUSE_UNTIED
:
13647 case OMP_CLAUSE_MERGEABLE
:
13648 case OMP_CLAUSE_INBRANCH
:
13649 case OMP_CLAUSE_NOTINBRANCH
:
13650 case OMP_CLAUSE_PROC_BIND
:
13651 case OMP_CLAUSE_FOR
:
13652 case OMP_CLAUSE_PARALLEL
:
13653 case OMP_CLAUSE_SECTIONS
:
13654 case OMP_CLAUSE_TASKGROUP
:
13657 gcc_unreachable ();
13661 new_clauses
= nreverse (new_clauses
);
13663 new_clauses
= finish_omp_clauses (new_clauses
);
13664 return new_clauses
;
13667 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13670 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13673 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13675 tree purpose
, value
, chain
;
13680 if (TREE_CODE (t
) != TREE_LIST
)
13681 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13682 /*function_p=*/false,
13683 /*integral_constant_expression_p=*/false);
13685 if (t
== void_list_node
)
13688 purpose
= TREE_PURPOSE (t
);
13690 purpose
= RECUR (purpose
);
13691 value
= TREE_VALUE (t
);
13694 if (TREE_CODE (value
) != LABEL_DECL
)
13695 value
= RECUR (value
);
13698 value
= lookup_label (DECL_NAME (value
));
13699 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13700 TREE_USED (value
) = 1;
13703 chain
= TREE_CHAIN (t
);
13704 if (chain
&& chain
!= void_type_node
)
13705 chain
= RECUR (chain
);
13706 return tree_cons (purpose
, value
, chain
);
13710 /* Substitute one OMP_FOR iterator. */
13713 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13714 tree condv
, tree incrv
, tree
*clauses
,
13715 tree args
, tsubst_flags_t complain
, tree in_decl
,
13716 bool integral_constant_expression_p
)
13718 #define RECUR(NODE) \
13719 tsubst_expr ((NODE), args, complain, in_decl, \
13720 integral_constant_expression_p)
13721 tree decl
, init
, cond
, incr
;
13723 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13724 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13725 decl
= TREE_OPERAND (init
, 0);
13726 init
= TREE_OPERAND (init
, 1);
13727 tree decl_expr
= NULL_TREE
;
13728 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13730 /* We need to jump through some hoops to handle declarations in the
13731 for-init-statement, since we might need to handle auto deduction,
13732 but we need to keep control of initialization. */
13734 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13735 decl
= tsubst_decl (decl
, args
, complain
);
13738 decl
= RECUR (decl
);
13739 init
= RECUR (init
);
13741 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13742 if (auto_node
&& init
)
13744 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13746 gcc_assert (!type_dependent_expression_p (decl
));
13748 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13752 /* Declare the variable, but don't let that initialize it. */
13753 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13754 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13756 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13759 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13760 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13761 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13763 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13764 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13765 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13766 NOP_EXPR
, rhs
, complain
);
13769 incr
= RECUR (incr
);
13770 TREE_VEC_ELT (declv
, i
) = decl
;
13771 TREE_VEC_ELT (initv
, i
) = init
;
13772 TREE_VEC_ELT (condv
, i
) = cond
;
13773 TREE_VEC_ELT (incrv
, i
) = incr
;
13779 /* Declare and initialize the variable. */
13786 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13788 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13789 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13790 && OMP_CLAUSE_DECL (c
) == decl
)
13792 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13793 && OMP_CLAUSE_DECL (c
) == decl
)
13794 error ("iteration variable %qD should not be firstprivate", decl
);
13795 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13796 && OMP_CLAUSE_DECL (c
) == decl
)
13797 error ("iteration variable %qD should not be reduction", decl
);
13801 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13802 OMP_CLAUSE_DECL (c
) = decl
;
13803 c
= finish_omp_clauses (c
);
13806 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13811 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13812 if (COMPARISON_CLASS_P (cond
))
13814 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13815 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13816 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13819 cond
= RECUR (cond
);
13820 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13821 switch (TREE_CODE (incr
))
13823 case PREINCREMENT_EXPR
:
13824 case PREDECREMENT_EXPR
:
13825 case POSTINCREMENT_EXPR
:
13826 case POSTDECREMENT_EXPR
:
13827 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13828 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13831 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13832 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13834 tree rhs
= TREE_OPERAND (incr
, 1);
13835 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13836 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13837 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13838 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13839 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13843 incr
= RECUR (incr
);
13846 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13847 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13849 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13850 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13851 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13852 TREE_TYPE (decl
), lhs
,
13853 RECUR (TREE_OPERAND (incr
, 2))));
13855 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13856 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13857 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13859 tree rhs
= TREE_OPERAND (incr
, 2);
13860 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13861 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13862 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13863 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13864 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13868 incr
= RECUR (incr
);
13871 incr
= RECUR (incr
);
13875 TREE_VEC_ELT (declv
, i
) = decl
;
13876 TREE_VEC_ELT (initv
, i
) = init
;
13877 TREE_VEC_ELT (condv
, i
) = cond
;
13878 TREE_VEC_ELT (incrv
, i
) = incr
;
13882 /* Like tsubst_copy for expressions, etc. but also does semantic
13886 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13887 bool integral_constant_expression_p
)
13889 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13890 #define RECUR(NODE) \
13891 tsubst_expr ((NODE), args, complain, in_decl, \
13892 integral_constant_expression_p)
13898 if (t
== NULL_TREE
|| t
== error_mark_node
)
13901 loc
= input_location
;
13902 if (EXPR_HAS_LOCATION (t
))
13903 input_location
= EXPR_LOCATION (t
);
13904 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13905 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13907 switch (TREE_CODE (t
))
13909 case STATEMENT_LIST
:
13911 tree_stmt_iterator i
;
13912 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13913 RECUR (tsi_stmt (i
));
13917 case CTOR_INITIALIZER
:
13918 finish_mem_initializers (tsubst_initializer_list
13919 (TREE_OPERAND (t
, 0), args
));
13923 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13927 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13928 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13929 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13931 finish_expr_stmt (tmp
);
13935 do_using_directive (USING_STMT_NAMESPACE (t
));
13940 tree decl
, pattern_decl
;
13943 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13944 if (TREE_CODE (decl
) == LABEL_DECL
)
13945 finish_label_decl (DECL_NAME (decl
));
13946 else if (TREE_CODE (decl
) == USING_DECL
)
13948 tree scope
= USING_DECL_SCOPE (decl
);
13949 tree name
= DECL_NAME (decl
);
13952 scope
= tsubst (scope
, args
, complain
, in_decl
);
13953 decl
= lookup_qualified_name (scope
, name
,
13954 /*is_type_p=*/false,
13955 /*complain=*/false);
13956 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13957 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13959 do_local_using_decl (decl
, scope
, name
);
13961 else if (DECL_PACK_P (decl
))
13963 /* Don't build up decls for a variadic capture proxy, we'll
13964 instantiate the elements directly as needed. */
13969 init
= DECL_INITIAL (decl
);
13970 decl
= tsubst (decl
, args
, complain
, in_decl
);
13971 if (decl
!= error_mark_node
)
13973 /* By marking the declaration as instantiated, we avoid
13974 trying to instantiate it. Since instantiate_decl can't
13975 handle local variables, and since we've already done
13976 all that needs to be done, that's the right thing to
13979 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13981 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13982 /* Anonymous aggregates are a special case. */
13983 finish_anon_union (decl
);
13984 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13986 DECL_CONTEXT (decl
) = current_function_decl
;
13987 if (DECL_NAME (decl
) == this_identifier
)
13989 tree lam
= DECL_CONTEXT (current_function_decl
);
13990 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13991 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13993 insert_capture_proxy (decl
);
13995 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13996 /* We already did a pushtag. */;
13997 else if (TREE_CODE (decl
) == FUNCTION_DECL
13998 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13999 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
14001 DECL_CONTEXT (decl
) = NULL_TREE
;
14003 DECL_CONTEXT (decl
) = current_function_decl
;
14004 cp_check_omp_declare_reduction (decl
);
14008 int const_init
= false;
14009 maybe_push_decl (decl
);
14011 && DECL_PRETTY_FUNCTION_P (decl
))
14013 /* For __PRETTY_FUNCTION__ we have to adjust the
14015 const char *const name
14016 = cxx_printable_name (current_function_decl
, 2);
14017 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
14020 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
14023 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
14025 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
14034 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
14035 RECUR (FOR_INIT_STMT (t
));
14036 finish_for_init_stmt (stmt
);
14037 tmp
= RECUR (FOR_COND (t
));
14038 finish_for_cond (tmp
, stmt
, false);
14039 tmp
= RECUR (FOR_EXPR (t
));
14040 finish_for_expr (tmp
, stmt
);
14041 RECUR (FOR_BODY (t
));
14042 finish_for_stmt (stmt
);
14045 case RANGE_FOR_STMT
:
14048 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
14049 decl
= RANGE_FOR_DECL (t
);
14050 decl
= tsubst (decl
, args
, complain
, in_decl
);
14051 maybe_push_decl (decl
);
14052 expr
= RECUR (RANGE_FOR_EXPR (t
));
14053 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
14054 RECUR (RANGE_FOR_BODY (t
));
14055 finish_for_stmt (stmt
);
14060 stmt
= begin_while_stmt ();
14061 tmp
= RECUR (WHILE_COND (t
));
14062 finish_while_stmt_cond (tmp
, stmt
, false);
14063 RECUR (WHILE_BODY (t
));
14064 finish_while_stmt (stmt
);
14068 stmt
= begin_do_stmt ();
14069 RECUR (DO_BODY (t
));
14070 finish_do_body (stmt
);
14071 tmp
= RECUR (DO_COND (t
));
14072 finish_do_stmt (tmp
, stmt
, false);
14076 stmt
= begin_if_stmt ();
14077 tmp
= RECUR (IF_COND (t
));
14078 finish_if_stmt_cond (tmp
, stmt
);
14079 RECUR (THEN_CLAUSE (t
));
14080 finish_then_clause (stmt
);
14082 if (ELSE_CLAUSE (t
))
14084 begin_else_clause (stmt
);
14085 RECUR (ELSE_CLAUSE (t
));
14086 finish_else_clause (stmt
);
14089 finish_if_stmt (stmt
);
14093 if (BIND_EXPR_BODY_BLOCK (t
))
14094 stmt
= begin_function_body ();
14096 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
14097 ? BCS_TRY_BLOCK
: 0);
14099 RECUR (BIND_EXPR_BODY (t
));
14101 if (BIND_EXPR_BODY_BLOCK (t
))
14102 finish_function_body (stmt
);
14104 finish_compound_stmt (stmt
);
14108 finish_break_stmt ();
14111 case CONTINUE_STMT
:
14112 finish_continue_stmt ();
14116 stmt
= begin_switch_stmt ();
14117 tmp
= RECUR (SWITCH_STMT_COND (t
));
14118 finish_switch_cond (tmp
, stmt
);
14119 RECUR (SWITCH_STMT_BODY (t
));
14120 finish_switch_stmt (stmt
);
14123 case CASE_LABEL_EXPR
:
14125 tree low
= RECUR (CASE_LOW (t
));
14126 tree high
= RECUR (CASE_HIGH (t
));
14127 finish_case_label (EXPR_LOCATION (t
), low
, high
);
14133 tree decl
= LABEL_EXPR_LABEL (t
);
14136 label
= finish_label_stmt (DECL_NAME (decl
));
14137 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
14138 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
14143 tmp
= GOTO_DESTINATION (t
);
14144 if (TREE_CODE (tmp
) != LABEL_DECL
)
14145 /* Computed goto's must be tsubst'd into. On the other hand,
14146 non-computed gotos must not be; the identifier in question
14147 will have no binding. */
14150 tmp
= DECL_NAME (tmp
);
14151 finish_goto_stmt (tmp
);
14156 tree string
= RECUR (ASM_STRING (t
));
14157 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
14158 complain
, in_decl
);
14159 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
14160 complain
, in_decl
);
14161 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
14162 complain
, in_decl
);
14163 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
14164 complain
, in_decl
);
14165 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
14167 tree asm_expr
= tmp
;
14168 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
14169 asm_expr
= TREE_OPERAND (asm_expr
, 0);
14170 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
14177 stmt
= begin_try_block ();
14178 RECUR (TRY_STMTS (t
));
14179 finish_cleanup_try_block (stmt
);
14180 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
14184 tree compound_stmt
= NULL_TREE
;
14186 if (FN_TRY_BLOCK_P (t
))
14187 stmt
= begin_function_try_block (&compound_stmt
);
14189 stmt
= begin_try_block ();
14191 RECUR (TRY_STMTS (t
));
14193 if (FN_TRY_BLOCK_P (t
))
14194 finish_function_try_block (stmt
);
14196 finish_try_block (stmt
);
14198 RECUR (TRY_HANDLERS (t
));
14199 if (FN_TRY_BLOCK_P (t
))
14200 finish_function_handler_sequence (stmt
, compound_stmt
);
14202 finish_handler_sequence (stmt
);
14208 tree decl
= HANDLER_PARMS (t
);
14212 decl
= tsubst (decl
, args
, complain
, in_decl
);
14213 /* Prevent instantiate_decl from trying to instantiate
14214 this variable. We've already done all that needs to be
14216 if (decl
!= error_mark_node
)
14217 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
14219 stmt
= begin_handler ();
14220 finish_handler_parms (decl
, stmt
);
14221 RECUR (HANDLER_BODY (t
));
14222 finish_handler (stmt
);
14227 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
14228 if (CLASS_TYPE_P (tmp
))
14230 /* Local classes are not independent templates; they are
14231 instantiated along with their containing function. And this
14232 way we don't have to deal with pushing out of one local class
14233 to instantiate a member of another local class. */
14235 /* Closures are handled by the LAMBDA_EXPR. */
14236 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
14237 complete_type (tmp
);
14238 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
14239 if (!DECL_ARTIFICIAL (fn
))
14240 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
14244 case STATIC_ASSERT
:
14248 ++c_inhibit_evaluation_warnings
;
14250 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
14253 /*integral_constant_expression_p=*/true);
14254 --c_inhibit_evaluation_warnings
;
14256 finish_static_assert (condition
,
14257 STATIC_ASSERT_MESSAGE (t
),
14258 STATIC_ASSERT_SOURCE_LOCATION (t
),
14259 /*member_p=*/false);
14264 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
14265 args
, complain
, in_decl
);
14266 stmt
= begin_omp_parallel ();
14267 RECUR (OMP_PARALLEL_BODY (t
));
14268 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
14269 = OMP_PARALLEL_COMBINED (t
);
14273 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
14274 args
, complain
, in_decl
);
14275 stmt
= begin_omp_task ();
14276 RECUR (OMP_TASK_BODY (t
));
14277 finish_omp_task (tmp
, stmt
);
14284 case OMP_DISTRIBUTE
:
14286 tree clauses
, body
, pre_body
;
14287 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
14288 tree incrv
= NULL_TREE
;
14291 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
14292 args
, complain
, in_decl
);
14293 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14295 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14296 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14297 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14298 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14301 stmt
= begin_omp_structured_block ();
14303 pre_body
= push_stmt_list ();
14304 RECUR (OMP_FOR_PRE_BODY (t
));
14305 pre_body
= pop_stmt_list (pre_body
);
14307 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14308 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
14309 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
14310 &clauses
, args
, complain
, in_decl
,
14311 integral_constant_expression_p
);
14313 body
= push_stmt_list ();
14314 RECUR (OMP_FOR_BODY (t
));
14315 body
= pop_stmt_list (body
);
14317 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14318 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
14319 condv
, incrv
, body
, pre_body
, clauses
);
14322 t
= make_node (TREE_CODE (t
));
14323 TREE_TYPE (t
) = void_type_node
;
14324 OMP_FOR_BODY (t
) = body
;
14325 OMP_FOR_PRE_BODY (t
) = pre_body
;
14326 OMP_FOR_CLAUSES (t
) = clauses
;
14327 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
14331 add_stmt (finish_omp_structured_block (stmt
));
14338 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14339 args
, complain
, in_decl
);
14340 stmt
= push_stmt_list ();
14341 RECUR (OMP_BODY (t
));
14342 stmt
= pop_stmt_list (stmt
);
14345 OMP_BODY (t
) = stmt
;
14346 OMP_CLAUSES (t
) = tmp
;
14350 case OMP_TARGET_DATA
:
14352 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14353 args
, complain
, in_decl
);
14354 keep_next_level (true);
14355 stmt
= begin_omp_structured_block ();
14357 RECUR (OMP_BODY (t
));
14358 stmt
= finish_omp_structured_block (stmt
);
14361 OMP_BODY (t
) = stmt
;
14362 OMP_CLAUSES (t
) = tmp
;
14366 case OMP_TARGET_UPDATE
:
14367 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
14368 args
, complain
, in_decl
);
14370 OMP_TARGET_UPDATE_CLAUSES (t
) = tmp
;
14377 case OMP_TASKGROUP
:
14379 stmt
= push_stmt_list ();
14380 RECUR (OMP_BODY (t
));
14381 stmt
= pop_stmt_list (stmt
);
14384 OMP_BODY (t
) = stmt
;
14389 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14390 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14392 tree op1
= TREE_OPERAND (t
, 1);
14393 tree rhs1
= NULL_TREE
;
14395 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14397 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14398 op1
= TREE_OPERAND (op1
, 1);
14400 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14401 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14402 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14403 NULL_TREE
, NULL_TREE
, rhs1
,
14404 OMP_ATOMIC_SEQ_CST (t
));
14408 tree op1
= TREE_OPERAND (t
, 1);
14409 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14410 tree rhs1
= NULL_TREE
;
14411 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14412 enum tree_code opcode
= NOP_EXPR
;
14413 if (code
== OMP_ATOMIC_READ
)
14415 v
= RECUR (TREE_OPERAND (op1
, 0));
14416 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14418 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14419 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14421 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14422 v
= RECUR (TREE_OPERAND (op1
, 0));
14423 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14424 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14426 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14427 op11
= TREE_OPERAND (op11
, 1);
14429 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14430 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14431 opcode
= TREE_CODE (op11
);
14432 if (opcode
== MODIFY_EXPR
)
14438 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14439 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14441 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14442 OMP_ATOMIC_SEQ_CST (t
));
14446 case TRANSACTION_EXPR
:
14449 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14450 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14452 if (TRANSACTION_EXPR_IS_STMT (t
))
14454 tree body
= TRANSACTION_EXPR_BODY (t
);
14455 tree noex
= NULL_TREE
;
14456 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14458 noex
= MUST_NOT_THROW_COND (body
);
14459 if (noex
== NULL_TREE
)
14460 noex
= boolean_true_node
;
14461 body
= TREE_OPERAND (body
, 0);
14463 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14465 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14469 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14470 RECUR (TRANSACTION_EXPR_BODY (t
)),
14477 case MUST_NOT_THROW_EXPR
:
14479 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14480 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14481 RETURN (build_must_not_throw_expr (op0
, cond
));
14484 case EXPR_PACK_EXPANSION
:
14485 error ("invalid use of pack expansion expression");
14486 RETURN (error_mark_node
);
14488 case NONTYPE_ARGUMENT_PACK
:
14489 error ("use %<...%> to expand argument pack");
14490 RETURN (error_mark_node
);
14492 case CILK_SPAWN_STMT
:
14493 cfun
->calls_cilk_spawn
= 1;
14494 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14496 case CILK_SYNC_STMT
:
14497 RETURN (build_cilk_sync ());
14499 case COMPOUND_EXPR
:
14500 tmp
= RECUR (TREE_OPERAND (t
, 0));
14501 if (tmp
== NULL_TREE
)
14502 /* If the first operand was a statement, we're done with it. */
14503 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14504 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14505 RECUR (TREE_OPERAND (t
, 1)),
14508 case ANNOTATE_EXPR
:
14509 tmp
= RECUR (TREE_OPERAND (t
, 0));
14510 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14511 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14514 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14516 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14517 /*function_p=*/false,
14518 integral_constant_expression_p
));
14521 RETURN (NULL_TREE
);
14523 input_location
= loc
;
14529 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14530 function. For description of the body see comment above
14531 cp_parser_omp_declare_reduction_exprs. */
14534 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14536 if (t
== NULL_TREE
|| t
== error_mark_node
)
14539 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14541 tree_stmt_iterator tsi
;
14544 memset (stmts
, 0, sizeof stmts
);
14545 for (i
= 0, tsi
= tsi_start (t
);
14546 i
< 7 && !tsi_end_p (tsi
);
14547 i
++, tsi_next (&tsi
))
14548 stmts
[i
] = tsi_stmt (tsi
);
14549 gcc_assert (tsi_end_p (tsi
));
14553 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14554 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14555 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14556 args
, complain
, in_decl
);
14557 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14558 args
, complain
, in_decl
);
14559 DECL_CONTEXT (omp_out
) = current_function_decl
;
14560 DECL_CONTEXT (omp_in
) = current_function_decl
;
14561 keep_next_level (true);
14562 tree block
= begin_omp_structured_block ();
14563 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14564 block
= finish_omp_structured_block (block
);
14565 block
= maybe_cleanup_point_expr_void (block
);
14566 add_decl_expr (omp_out
);
14567 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14568 TREE_NO_WARNING (omp_out
) = 1;
14569 add_decl_expr (omp_in
);
14570 finish_expr_stmt (block
);
14574 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14575 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14576 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14577 args
, complain
, in_decl
);
14578 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14579 args
, complain
, in_decl
);
14580 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14581 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14582 keep_next_level (true);
14583 tree block
= begin_omp_structured_block ();
14584 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14585 block
= finish_omp_structured_block (block
);
14586 block
= maybe_cleanup_point_expr_void (block
);
14587 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14588 add_decl_expr (omp_priv
);
14589 add_decl_expr (omp_orig
);
14590 finish_expr_stmt (block
);
14592 add_decl_expr (omp_orig
);
14596 /* T is a postfix-expression that is not being used in a function
14597 call. Return the substituted version of T. */
14600 tsubst_non_call_postfix_expression (tree t
, tree args
,
14601 tsubst_flags_t complain
,
14604 if (TREE_CODE (t
) == SCOPE_REF
)
14605 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14606 /*done=*/false, /*address_p=*/false);
14608 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14609 /*function_p=*/false,
14610 /*integral_constant_expression_p=*/false);
14615 /* Like tsubst but deals with expressions and performs semantic
14616 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14619 tsubst_copy_and_build (tree t
,
14621 tsubst_flags_t complain
,
14624 bool integral_constant_expression_p
)
14626 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14627 #define RECUR(NODE) \
14628 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14629 /*function_p=*/false, \
14630 integral_constant_expression_p)
14635 if (t
== NULL_TREE
|| t
== error_mark_node
)
14638 loc
= input_location
;
14639 if (EXPR_HAS_LOCATION (t
))
14640 input_location
= EXPR_LOCATION (t
);
14642 /* N3276 decltype magic only applies to calls at the top level or on the
14643 right side of a comma. */
14644 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14645 complain
&= ~tf_decltype
;
14647 switch (TREE_CODE (t
))
14651 /* Fall through. */
14652 case IDENTIFIER_NODE
:
14656 bool non_integral_constant_expression_p
;
14657 const char *error_msg
;
14659 if (IDENTIFIER_TYPENAME_P (t
))
14661 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14662 t
= mangle_conv_op_name_for_type (new_type
);
14665 /* Look up the name. */
14666 decl
= lookup_name (t
);
14668 /* By convention, expressions use ERROR_MARK_NODE to indicate
14669 failure, not NULL_TREE. */
14670 if (decl
== NULL_TREE
)
14671 decl
= error_mark_node
;
14673 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14675 integral_constant_expression_p
,
14676 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14677 &non_integral_constant_expression_p
,
14678 /*template_p=*/false,
14680 /*address_p=*/false,
14681 /*template_arg_p=*/false,
14686 if (!function_p
&& identifier_p (decl
))
14688 if (complain
& tf_error
)
14689 unqualified_name_lookup_error (decl
);
14690 decl
= error_mark_node
;
14695 case TEMPLATE_ID_EXPR
:
14698 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14699 tree targs
= TREE_OPERAND (t
, 1);
14702 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14704 if (TREE_CODE (templ
) == COMPONENT_REF
)
14706 object
= TREE_OPERAND (templ
, 0);
14707 templ
= TREE_OPERAND (templ
, 1);
14710 object
= NULL_TREE
;
14711 templ
= lookup_template_function (templ
, targs
);
14714 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14715 object
, templ
, NULL_TREE
));
14717 RETURN (baselink_for_fns (templ
));
14722 tree r
= RECUR (TREE_OPERAND (t
, 0));
14724 if (REFERENCE_REF_P (t
))
14726 /* A type conversion to reference type will be enclosed in
14727 such an indirect ref, but the substitution of the cast
14728 will have also added such an indirect ref. */
14729 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14730 r
= convert_from_reference (r
);
14733 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14734 complain
|decltype_flag
);
14740 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14741 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14742 RETURN (build_nop (type
, op0
));
14745 case IMPLICIT_CONV_EXPR
:
14747 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14748 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14749 int flags
= LOOKUP_IMPLICIT
;
14750 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14751 flags
= LOOKUP_NORMAL
;
14752 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14758 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14759 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14760 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14764 case REINTERPRET_CAST_EXPR
:
14765 case CONST_CAST_EXPR
:
14766 case DYNAMIC_CAST_EXPR
:
14767 case STATIC_CAST_EXPR
:
14770 tree op
, r
= NULL_TREE
;
14772 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14773 if (integral_constant_expression_p
14774 && !cast_valid_in_integral_constant_expression_p (type
))
14776 if (complain
& tf_error
)
14777 error ("a cast to a type other than an integral or "
14778 "enumeration type cannot appear in a constant-expression");
14779 RETURN (error_mark_node
);
14782 op
= RECUR (TREE_OPERAND (t
, 0));
14784 warning_sentinel
s(warn_useless_cast
);
14785 switch (TREE_CODE (t
))
14788 r
= build_functional_cast (type
, op
, complain
);
14790 case REINTERPRET_CAST_EXPR
:
14791 r
= build_reinterpret_cast (type
, op
, complain
);
14793 case CONST_CAST_EXPR
:
14794 r
= build_const_cast (type
, op
, complain
);
14796 case DYNAMIC_CAST_EXPR
:
14797 r
= build_dynamic_cast (type
, op
, complain
);
14799 case STATIC_CAST_EXPR
:
14800 r
= build_static_cast (type
, op
, complain
);
14803 gcc_unreachable ();
14809 case POSTDECREMENT_EXPR
:
14810 case POSTINCREMENT_EXPR
:
14811 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14812 args
, complain
, in_decl
);
14813 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14814 complain
|decltype_flag
));
14816 case PREDECREMENT_EXPR
:
14817 case PREINCREMENT_EXPR
:
14821 case TRUTH_NOT_EXPR
:
14822 case UNARY_PLUS_EXPR
: /* Unary + */
14823 case REALPART_EXPR
:
14824 case IMAGPART_EXPR
:
14825 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14826 RECUR (TREE_OPERAND (t
, 0)),
14827 complain
|decltype_flag
));
14829 case FIX_TRUNC_EXPR
:
14830 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14834 op1
= TREE_OPERAND (t
, 0);
14835 if (TREE_CODE (op1
) == LABEL_DECL
)
14836 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14837 EXPR_LOCATION (op1
)));
14838 if (TREE_CODE (op1
) == SCOPE_REF
)
14839 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14840 /*done=*/true, /*address_p=*/true);
14842 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14844 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14845 complain
|decltype_flag
));
14850 case TRUNC_DIV_EXPR
:
14851 case CEIL_DIV_EXPR
:
14852 case FLOOR_DIV_EXPR
:
14853 case ROUND_DIV_EXPR
:
14854 case EXACT_DIV_EXPR
:
14858 case TRUNC_MOD_EXPR
:
14859 case FLOOR_MOD_EXPR
:
14860 case TRUTH_ANDIF_EXPR
:
14861 case TRUTH_ORIF_EXPR
:
14862 case TRUTH_AND_EXPR
:
14863 case TRUTH_OR_EXPR
:
14879 warning_sentinel
s1(warn_type_limits
);
14880 warning_sentinel
s2(warn_div_by_zero
);
14881 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14882 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14883 tree r
= build_x_binary_op
14884 (input_location
, TREE_CODE (t
),
14886 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14888 : TREE_CODE (TREE_OPERAND (t
, 0))),
14890 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14892 : TREE_CODE (TREE_OPERAND (t
, 1))),
14894 complain
|decltype_flag
);
14895 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14896 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14901 case POINTER_PLUS_EXPR
:
14903 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14904 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14905 return fold_build_pointer_plus (op0
, op1
);
14909 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14910 /*address_p=*/false));
14912 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14913 args
, complain
, in_decl
);
14914 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14915 RECUR (TREE_OPERAND (t
, 1)),
14916 complain
|decltype_flag
));
14918 case ARRAY_NOTATION_REF
:
14920 tree start_index
, length
, stride
;
14921 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14922 args
, complain
, in_decl
);
14923 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14924 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14925 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14926 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14927 length
, stride
, TREE_TYPE (op1
)));
14930 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14931 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14938 op1
= TREE_OPERAND (t
, 0);
14939 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14940 op1
= TREE_TYPE (op1
);
14943 /* When there are no ARGS, we are trying to evaluate a
14944 non-dependent expression from the parser. Trying to do
14945 the substitutions may not work. */
14947 op1
= TREE_TYPE (op1
);
14951 ++cp_unevaluated_operand
;
14952 ++c_inhibit_evaluation_warnings
;
14954 op1
= tsubst (op1
, args
, complain
, in_decl
);
14956 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14957 /*function_p=*/false,
14958 /*integral_constant_expression_p=*/
14960 --cp_unevaluated_operand
;
14961 --c_inhibit_evaluation_warnings
;
14964 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14965 complain
& tf_error
);
14967 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14968 complain
& tf_error
);
14969 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14971 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14973 if (!processing_template_decl
&& TYPE_P (op1
))
14975 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14976 build1 (NOP_EXPR
, op1
, error_mark_node
));
14977 SIZEOF_EXPR_TYPE_P (r
) = 1;
14980 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14981 TREE_SIDE_EFFECTS (r
) = 0;
14982 TREE_READONLY (r
) = 1;
14984 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14989 case AT_ENCODE_EXPR
:
14991 op1
= TREE_OPERAND (t
, 0);
14992 ++cp_unevaluated_operand
;
14993 ++c_inhibit_evaluation_warnings
;
14994 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14995 /*function_p=*/false,
14996 /*integral_constant_expression_p=*/false);
14997 --cp_unevaluated_operand
;
14998 --c_inhibit_evaluation_warnings
;
14999 RETURN (objc_build_encode_expr (op1
));
15002 case NOEXCEPT_EXPR
:
15003 op1
= TREE_OPERAND (t
, 0);
15004 ++cp_unevaluated_operand
;
15005 ++c_inhibit_evaluation_warnings
;
15006 ++cp_noexcept_operand
;
15007 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
15008 /*function_p=*/false,
15009 /*integral_constant_expression_p=*/false);
15010 --cp_unevaluated_operand
;
15011 --c_inhibit_evaluation_warnings
;
15012 --cp_noexcept_operand
;
15013 RETURN (finish_noexcept_expr (op1
, complain
));
15017 warning_sentinel
s(warn_div_by_zero
);
15018 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
15019 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
15020 tree r
= build_x_modify_expr
15021 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
15022 complain
|decltype_flag
);
15023 /* TREE_NO_WARNING must be set if either the expression was
15024 parenthesized or it uses an operator such as >>= rather
15025 than plain assignment. In the former case, it was already
15026 set and must be copied. In the latter case,
15027 build_x_modify_expr sets it and it must not be reset
15029 if (TREE_NO_WARNING (t
))
15030 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
15036 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15037 args
, complain
, in_decl
);
15038 /* Remember that there was a reference to this entity. */
15040 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
15041 RETURN (error_mark_node
);
15042 RETURN (build_x_arrow (input_location
, op1
, complain
));
15046 tree placement
= RECUR (TREE_OPERAND (t
, 0));
15047 tree init
= RECUR (TREE_OPERAND (t
, 3));
15048 vec
<tree
, va_gc
> *placement_vec
;
15049 vec
<tree
, va_gc
> *init_vec
;
15052 if (placement
== NULL_TREE
)
15053 placement_vec
= NULL
;
15056 placement_vec
= make_tree_vector ();
15057 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
15058 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
15061 /* If there was an initializer in the original tree, but it
15062 instantiated to an empty list, then we should pass a
15063 non-NULL empty vector to tell build_new that it was an
15064 empty initializer() rather than no initializer. This can
15065 only happen when the initializer is a pack expansion whose
15066 parameter packs are of length zero. */
15067 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
15071 init_vec
= make_tree_vector ();
15072 if (init
== void_node
)
15073 gcc_assert (init_vec
!= NULL
);
15076 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
15077 vec_safe_push (init_vec
, TREE_VALUE (init
));
15081 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15082 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15083 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
15084 NEW_EXPR_USE_GLOBAL (t
),
15087 if (placement_vec
!= NULL
)
15088 release_tree_vector (placement_vec
);
15089 if (init_vec
!= NULL
)
15090 release_tree_vector (init_vec
);
15097 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15098 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15099 RETURN (delete_sanity (op0
, op1
,
15100 DELETE_EXPR_USE_VEC (t
),
15101 DELETE_EXPR_USE_GLOBAL (t
),
15105 case COMPOUND_EXPR
:
15107 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
15108 complain
& ~tf_decltype
, in_decl
,
15109 /*function_p=*/false,
15110 integral_constant_expression_p
);
15111 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
15113 RECUR (TREE_OPERAND (t
, 1)),
15114 complain
|decltype_flag
));
15120 vec
<tree
, va_gc
> *call_args
;
15121 unsigned int nargs
, i
;
15126 function
= CALL_EXPR_FN (t
);
15127 /* When we parsed the expression, we determined whether or
15128 not Koenig lookup should be performed. */
15129 koenig_p
= KOENIG_LOOKUP_P (t
);
15130 if (TREE_CODE (function
) == SCOPE_REF
)
15132 qualified_p
= true;
15133 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
15135 /*address_p=*/false);
15137 else if (koenig_p
&& identifier_p (function
))
15139 /* Do nothing; calling tsubst_copy_and_build on an identifier
15140 would incorrectly perform unqualified lookup again.
15142 Note that we can also have an IDENTIFIER_NODE if the earlier
15143 unqualified lookup found a member function; in that case
15144 koenig_p will be false and we do want to do the lookup
15145 again to find the instantiated member function.
15147 FIXME but doing that causes c++/15272, so we need to stop
15148 using IDENTIFIER_NODE in that situation. */
15149 qualified_p
= false;
15153 if (TREE_CODE (function
) == COMPONENT_REF
)
15155 tree op
= TREE_OPERAND (function
, 1);
15157 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
15158 || (BASELINK_P (op
)
15159 && BASELINK_QUALIFIED_P (op
)));
15162 qualified_p
= false;
15164 if (TREE_CODE (function
) == ADDR_EXPR
15165 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
15166 /* Avoid error about taking the address of a constructor. */
15167 function
= TREE_OPERAND (function
, 0);
15169 function
= tsubst_copy_and_build (function
, args
, complain
,
15172 integral_constant_expression_p
);
15174 if (BASELINK_P (function
))
15175 qualified_p
= true;
15178 nargs
= call_expr_nargs (t
);
15179 call_args
= make_tree_vector ();
15180 for (i
= 0; i
< nargs
; ++i
)
15182 tree arg
= CALL_EXPR_ARG (t
, i
);
15184 if (!PACK_EXPANSION_P (arg
))
15185 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
15188 /* Expand the pack expansion and push each entry onto
15190 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
15191 if (TREE_CODE (arg
) == TREE_VEC
)
15193 unsigned int len
, j
;
15195 len
= TREE_VEC_LENGTH (arg
);
15196 for (j
= 0; j
< len
; ++j
)
15198 tree value
= TREE_VEC_ELT (arg
, j
);
15199 if (value
!= NULL_TREE
)
15200 value
= convert_from_reference (value
);
15201 vec_safe_push (call_args
, value
);
15206 /* A partial substitution. Add one entry. */
15207 vec_safe_push (call_args
, arg
);
15212 /* We do not perform argument-dependent lookup if normal
15213 lookup finds a non-function, in accordance with the
15214 expected resolution of DR 218. */
15216 && ((is_overloaded_fn (function
)
15217 /* If lookup found a member function, the Koenig lookup is
15218 not appropriate, even if an unqualified-name was used
15219 to denote the function. */
15220 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
15221 || identifier_p (function
))
15222 /* Only do this when substitution turns a dependent call
15223 into a non-dependent call. */
15224 && type_dependent_expression_p_push (t
)
15225 && !any_type_dependent_arguments_p (call_args
))
15226 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
15228 if (identifier_p (function
)
15229 && !any_type_dependent_arguments_p (call_args
))
15231 if (koenig_p
&& (complain
& tf_warning_or_error
))
15233 /* For backwards compatibility and good diagnostics, try
15234 the unqualified lookup again if we aren't in SFINAE
15236 tree unq
= (tsubst_copy_and_build
15237 (function
, args
, complain
, in_decl
, true,
15238 integral_constant_expression_p
));
15239 if (unq
== error_mark_node
)
15240 RETURN (error_mark_node
);
15242 if (unq
!= function
)
15245 if (INDIRECT_REF_P (fn
))
15246 fn
= TREE_OPERAND (fn
, 0);
15247 if (TREE_CODE (fn
) == COMPONENT_REF
)
15248 fn
= TREE_OPERAND (fn
, 1);
15249 if (is_overloaded_fn (fn
))
15250 fn
= get_first_fn (fn
);
15251 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
15252 "%qD was not declared in this scope, "
15253 "and no declarations were found by "
15254 "argument-dependent lookup at the point "
15255 "of instantiation", function
))
15258 /* Can't say anything more. */;
15259 else if (DECL_CLASS_SCOPE_P (fn
))
15261 location_t loc
= EXPR_LOC_OR_LOC (t
,
15264 "declarations in dependent base %qT are "
15265 "not found by unqualified lookup",
15266 DECL_CLASS_CONTEXT (fn
));
15267 if (current_class_ptr
)
15269 "use %<this->%D%> instead", function
);
15272 "use %<%T::%D%> instead",
15273 current_class_name
, function
);
15276 inform (0, "%q+D declared here, later in the "
15277 "translation unit", fn
);
15282 if (identifier_p (function
))
15284 if (complain
& tf_error
)
15285 unqualified_name_lookup_error (function
);
15286 release_tree_vector (call_args
);
15287 RETURN (error_mark_node
);
15291 /* Remember that there was a reference to this entity. */
15292 if (DECL_P (function
)
15293 && !mark_used (function
, complain
) && !(complain
& tf_error
))
15294 RETURN (error_mark_node
);
15296 /* Put back tf_decltype for the actual call. */
15297 complain
|= decltype_flag
;
15299 if (TREE_CODE (function
) == OFFSET_REF
)
15300 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
15302 else if (TREE_CODE (function
) == COMPONENT_REF
)
15304 tree instance
= TREE_OPERAND (function
, 0);
15305 tree fn
= TREE_OPERAND (function
, 1);
15307 if (processing_template_decl
15308 && (type_dependent_expression_p (instance
)
15309 || (!BASELINK_P (fn
)
15310 && TREE_CODE (fn
) != FIELD_DECL
)
15311 || type_dependent_expression_p (fn
)
15312 || any_type_dependent_arguments_p (call_args
)))
15313 ret
= build_nt_call_vec (function
, call_args
);
15314 else if (!BASELINK_P (fn
))
15315 ret
= finish_call_expr (function
, &call_args
,
15316 /*disallow_virtual=*/false,
15317 /*koenig_p=*/false,
15320 ret
= (build_new_method_call
15322 &call_args
, NULL_TREE
,
15323 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
15328 ret
= finish_call_expr (function
, &call_args
,
15329 /*disallow_virtual=*/qualified_p
,
15333 release_tree_vector (call_args
);
15340 tree cond
= RECUR (TREE_OPERAND (t
, 0));
15341 tree folded_cond
= fold_non_dependent_expr (cond
);
15344 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
15346 if (integer_zerop (folded_cond
))
15348 ++c_inhibit_evaluation_warnings
;
15349 exp1
= RECUR (TREE_OPERAND (t
, 1));
15350 --c_inhibit_evaluation_warnings
;
15351 exp2
= RECUR (TREE_OPERAND (t
, 2));
15355 exp1
= RECUR (TREE_OPERAND (t
, 1));
15356 ++c_inhibit_evaluation_warnings
;
15357 exp2
= RECUR (TREE_OPERAND (t
, 2));
15358 --c_inhibit_evaluation_warnings
;
15360 cond
= folded_cond
;
15364 exp1
= RECUR (TREE_OPERAND (t
, 1));
15365 exp2
= RECUR (TREE_OPERAND (t
, 2));
15368 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
15369 cond
, exp1
, exp2
, complain
));
15372 case PSEUDO_DTOR_EXPR
:
15374 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15375 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15376 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15377 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
15383 tree purpose
, value
, chain
;
15385 if (t
== void_list_node
)
15388 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15389 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15391 /* We have pack expansions, so expand those and
15392 create a new list out of it. */
15393 tree purposevec
= NULL_TREE
;
15394 tree valuevec
= NULL_TREE
;
15398 /* Expand the argument expressions. */
15399 if (TREE_PURPOSE (t
))
15400 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15401 complain
, in_decl
);
15402 if (TREE_VALUE (t
))
15403 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15404 complain
, in_decl
);
15406 /* Build the rest of the list. */
15407 chain
= TREE_CHAIN (t
);
15408 if (chain
&& chain
!= void_type_node
)
15409 chain
= RECUR (chain
);
15411 /* Determine the number of arguments. */
15412 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15414 len
= TREE_VEC_LENGTH (purposevec
);
15415 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15417 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15418 len
= TREE_VEC_LENGTH (valuevec
);
15421 /* Since we only performed a partial substitution into
15422 the argument pack, we only RETURN (a single list
15424 if (purposevec
== TREE_PURPOSE (t
)
15425 && valuevec
== TREE_VALUE (t
)
15426 && chain
== TREE_CHAIN (t
))
15429 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15432 /* Convert the argument vectors into a TREE_LIST */
15436 /* Grab the Ith values. */
15438 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15441 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15444 /* Build the list (backwards). */
15445 chain
= tree_cons (purpose
, value
, chain
);
15451 purpose
= TREE_PURPOSE (t
);
15453 purpose
= RECUR (purpose
);
15454 value
= TREE_VALUE (t
);
15456 value
= RECUR (value
);
15457 chain
= TREE_CHAIN (t
);
15458 if (chain
&& chain
!= void_type_node
)
15459 chain
= RECUR (chain
);
15460 if (purpose
== TREE_PURPOSE (t
)
15461 && value
== TREE_VALUE (t
)
15462 && chain
== TREE_CHAIN (t
))
15464 RETURN (tree_cons (purpose
, value
, chain
));
15467 case COMPONENT_REF
:
15474 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15475 args
, complain
, in_decl
);
15476 /* Remember that there was a reference to this entity. */
15477 if (DECL_P (object
)
15478 && !mark_used (object
, complain
) && !(complain
& tf_error
))
15479 RETURN (error_mark_node
);
15480 object_type
= TREE_TYPE (object
);
15482 member
= TREE_OPERAND (t
, 1);
15483 if (BASELINK_P (member
))
15484 member
= tsubst_baselink (member
,
15485 non_reference (TREE_TYPE (object
)),
15486 args
, complain
, in_decl
);
15488 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15489 if (member
== error_mark_node
)
15490 RETURN (error_mark_node
);
15492 if (type_dependent_expression_p (object
))
15493 /* We can't do much here. */;
15494 else if (!CLASS_TYPE_P (object_type
))
15496 if (scalarish_type_p (object_type
))
15498 tree s
= NULL_TREE
;
15499 tree dtor
= member
;
15501 if (TREE_CODE (dtor
) == SCOPE_REF
)
15503 s
= TREE_OPERAND (dtor
, 0);
15504 dtor
= TREE_OPERAND (dtor
, 1);
15506 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15508 dtor
= TREE_OPERAND (dtor
, 0);
15510 RETURN (finish_pseudo_destructor_expr
15511 (object
, s
, dtor
, input_location
));
15515 else if (TREE_CODE (member
) == SCOPE_REF
15516 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15518 /* Lookup the template functions now that we know what the
15520 tree scope
= TREE_OPERAND (member
, 0);
15521 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15522 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15523 member
= lookup_qualified_name (scope
, tmpl
,
15524 /*is_type_p=*/false,
15525 /*complain=*/false);
15526 if (BASELINK_P (member
))
15528 BASELINK_FUNCTIONS (member
)
15529 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15531 member
= (adjust_result_of_qualified_name_lookup
15532 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15537 qualified_name_lookup_error (scope
, tmpl
, member
,
15539 RETURN (error_mark_node
);
15542 else if (TREE_CODE (member
) == SCOPE_REF
15543 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15544 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15546 if (complain
& tf_error
)
15548 if (TYPE_P (TREE_OPERAND (member
, 0)))
15549 error ("%qT is not a class or namespace",
15550 TREE_OPERAND (member
, 0));
15552 error ("%qD is not a class or namespace",
15553 TREE_OPERAND (member
, 0));
15555 RETURN (error_mark_node
);
15557 else if (TREE_CODE (member
) == FIELD_DECL
)
15559 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15560 if (TREE_CODE (r
) == COMPONENT_REF
)
15561 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15565 r
= finish_class_member_access_expr (object
, member
,
15566 /*template_p=*/false,
15568 if (TREE_CODE (r
) == COMPONENT_REF
)
15569 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15574 RETURN (build_throw
15575 (RECUR (TREE_OPERAND (t
, 0))));
15579 vec
<constructor_elt
, va_gc
> *n
;
15580 constructor_elt
*ce
;
15581 unsigned HOST_WIDE_INT idx
;
15582 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15583 bool process_index_p
;
15585 bool need_copy_p
= false;
15588 if (type
== error_mark_node
)
15589 RETURN (error_mark_node
);
15591 /* digest_init will do the wrong thing if we let it. */
15592 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15595 /* We do not want to process the index of aggregate
15596 initializers as they are identifier nodes which will be
15597 looked up by digest_init. */
15598 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15600 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15601 newlen
= vec_safe_length (n
);
15602 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15604 if (ce
->index
&& process_index_p
15605 /* An identifier index is looked up in the type
15606 being initialized, not the current scope. */
15607 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15608 ce
->index
= RECUR (ce
->index
);
15610 if (PACK_EXPANSION_P (ce
->value
))
15612 /* Substitute into the pack expansion. */
15613 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15616 if (ce
->value
== error_mark_node
15617 || PACK_EXPANSION_P (ce
->value
))
15619 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15620 /* Just move the argument into place. */
15621 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15624 /* Update the length of the final CONSTRUCTOR
15625 arguments vector, and note that we will need to
15627 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15628 need_copy_p
= true;
15632 ce
->value
= RECUR (ce
->value
);
15637 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15639 vec_alloc (n
, newlen
);
15640 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15642 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15644 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15645 for (i
= 0; i
< len
; ++i
)
15646 CONSTRUCTOR_APPEND_ELT (n
, 0,
15647 TREE_VEC_ELT (ce
->value
, i
));
15650 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15654 r
= build_constructor (init_list_type_node
, n
);
15655 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15657 if (TREE_HAS_CONSTRUCTOR (t
))
15658 RETURN (finish_compound_literal (type
, r
, complain
));
15660 TREE_TYPE (r
) = type
;
15666 tree operand_0
= TREE_OPERAND (t
, 0);
15667 if (TYPE_P (operand_0
))
15669 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15670 RETURN (get_typeid (operand_0
, complain
));
15674 operand_0
= RECUR (operand_0
);
15675 RETURN (build_typeid (operand_0
, complain
));
15682 else if (DECL_PACK_P (t
))
15684 /* We don't build decls for an instantiation of a
15685 variadic capture proxy, we instantiate the elements
15687 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15688 return RECUR (DECL_VALUE_EXPR (t
));
15694 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15695 /* ??? We're doing a subset of finish_id_expression here. */
15697 && !processing_template_decl
15698 && !cp_unevaluated_operand
15699 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
15700 && CP_DECL_THREAD_LOCAL_P (r
))
15702 if (tree wrap
= get_tls_wrapper_fn (r
))
15703 /* Replace an evaluated use of the thread_local variable with
15704 a call to its wrapper. */
15705 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
15707 else if (outer_automatic_var_p (r
))
15709 r
= process_outer_var_ref (r
, complain
);
15710 if (is_capture_proxy (r
))
15711 register_local_specialization (r
, t
);
15714 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15715 /* If the original type was a reference, we'll be wrapped in
15716 the appropriate INDIRECT_REF. */
15717 r
= convert_from_reference (r
);
15723 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15724 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15725 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15728 case OFFSETOF_EXPR
:
15729 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0)),
15730 EXPR_LOCATION (t
)));
15734 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15735 complain
, in_decl
);
15737 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15738 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
15739 type2
= RECUR (type2
);
15741 type2
= tsubst (type2
, args
, complain
, in_decl
);
15743 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15748 tree old_stmt_expr
= cur_stmt_expr
;
15749 tree stmt_expr
= begin_stmt_expr ();
15751 cur_stmt_expr
= stmt_expr
;
15752 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15753 integral_constant_expression_p
);
15754 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15755 cur_stmt_expr
= old_stmt_expr
;
15757 /* If the resulting list of expression statement is empty,
15758 fold it further into void_node. */
15759 if (empty_expr_stmt_p (stmt_expr
))
15760 stmt_expr
= void_node
;
15762 RETURN (stmt_expr
);
15767 tree r
= build_lambda_expr ();
15769 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15770 LAMBDA_EXPR_CLOSURE (r
) = type
;
15771 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15773 LAMBDA_EXPR_LOCATION (r
)
15774 = LAMBDA_EXPR_LOCATION (t
);
15775 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15776 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15777 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15778 LAMBDA_EXPR_DISCRIMINATOR (r
)
15779 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15780 /* For a function scope, we want to use tsubst so that we don't
15781 complain about referring to an auto function before its return
15782 type has been deduced. Otherwise, we want to use tsubst_copy so
15783 that we look up the existing field/parameter/variable rather
15784 than build a new one. */
15785 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15786 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15787 scope
= tsubst (scope
, args
, complain
, in_decl
);
15788 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15790 /* Look up the parameter we want directly, as tsubst_copy
15791 doesn't do what we need. */
15792 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15793 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15794 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15795 parm
= DECL_CHAIN (parm
);
15797 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15798 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15799 DECL_CONTEXT (scope
) = fn
;
15802 scope
= RECUR (scope
);
15803 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15804 LAMBDA_EXPR_RETURN_TYPE (r
)
15805 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15807 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15808 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15810 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15811 determine_visibility (TYPE_NAME (type
));
15812 /* Now that we know visibility, instantiate the type so we have a
15813 declaration of the op() for later calls to lambda_function. */
15814 complete_type (type
);
15816 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15818 RETURN (build_lambda_object (r
));
15822 /* We can get here for a constant initializer of non-dependent type.
15823 FIXME stop folding in cp_parser_initializer_clause. */
15825 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15830 case TRANSACTION_EXPR
:
15831 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15832 integral_constant_expression_p
));
15835 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15837 case VEC_PERM_EXPR
:
15839 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15840 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15841 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15842 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15847 /* Handle Objective-C++ constructs, if appropriate. */
15850 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15851 in_decl
, /*function_p=*/false);
15855 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15861 input_location
= loc
;
15865 /* Verify that the instantiated ARGS are valid. For type arguments,
15866 make sure that the type's linkage is ok. For non-type arguments,
15867 make sure they are constants if they are integral or enumerations.
15868 Emit an error under control of COMPLAIN, and return TRUE on error. */
15871 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15873 if (dependent_template_arg_p (t
))
15875 if (ARGUMENT_PACK_P (t
))
15877 tree vec
= ARGUMENT_PACK_ARGS (t
);
15878 int len
= TREE_VEC_LENGTH (vec
);
15879 bool result
= false;
15882 for (i
= 0; i
< len
; ++i
)
15883 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15887 else if (TYPE_P (t
))
15889 /* [basic.link]: A name with no linkage (notably, the name
15890 of a class or enumeration declared in a local scope)
15891 shall not be used to declare an entity with linkage.
15892 This implies that names with no linkage cannot be used as
15895 DR 757 relaxes this restriction for C++0x. */
15896 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15897 : no_linkage_check (t
, /*relaxed_p=*/false));
15901 /* DR 488 makes use of a type with no linkage cause
15902 type deduction to fail. */
15903 if (complain
& tf_error
)
15905 if (TYPE_ANONYMOUS_P (nt
))
15906 error ("%qT is/uses anonymous type", t
);
15908 error ("template argument for %qD uses local type %qT",
15913 /* In order to avoid all sorts of complications, we do not
15914 allow variably-modified types as template arguments. */
15915 else if (variably_modified_type_p (t
, NULL_TREE
))
15917 if (complain
& tf_error
)
15918 error ("%qT is a variably modified type", t
);
15922 /* Class template and alias template arguments should be OK. */
15923 else if (DECL_TYPE_TEMPLATE_P (t
))
15925 /* A non-type argument of integral or enumerated type must be a
15927 else if (TREE_TYPE (t
)
15928 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15929 && !REFERENCE_REF_P (t
)
15930 && !TREE_CONSTANT (t
))
15932 if (complain
& tf_error
)
15933 error ("integral expression %qE is not constant", t
);
15940 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15942 int ix
, len
= DECL_NTPARMS (tmpl
);
15943 bool result
= false;
15945 for (ix
= 0; ix
!= len
; ix
++)
15947 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15950 if (result
&& (complain
& tf_error
))
15951 error (" trying to instantiate %qD", tmpl
);
15955 /* We're out of SFINAE context now, so generate diagnostics for the access
15956 errors we saw earlier when instantiating D from TMPL and ARGS. */
15959 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15961 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15962 tree type
= TREE_TYPE (pattern
);
15963 location_t loc
= input_location
;
15965 push_access_scope (d
);
15966 push_deferring_access_checks (dk_no_deferred
);
15967 input_location
= DECL_SOURCE_LOCATION (pattern
);
15968 tsubst (type
, args
, tf_warning_or_error
, d
);
15969 input_location
= loc
;
15970 pop_deferring_access_checks ();
15971 pop_access_scope (d
);
15974 /* Instantiate the indicated variable, function, or alias template TMPL with
15975 the template arguments in TARG_PTR. */
15978 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15980 tree targ_ptr
= orig_args
;
15984 bool access_ok
= true;
15986 if (tmpl
== error_mark_node
)
15987 return error_mark_node
;
15989 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15991 /* If this function is a clone, handle it specially. */
15992 if (DECL_CLONED_FUNCTION_P (tmpl
))
15997 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15998 DECL_CLONED_FUNCTION. */
15999 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
16000 targ_ptr
, complain
);
16001 if (spec
== error_mark_node
)
16002 return error_mark_node
;
16004 /* Look for the clone. */
16005 FOR_EACH_CLONE (clone
, spec
)
16006 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
16008 /* We should always have found the clone by now. */
16009 gcc_unreachable ();
16013 if (targ_ptr
== error_mark_node
)
16014 return error_mark_node
;
16016 /* Check to see if we already have this specialization. */
16017 gen_tmpl
= most_general_template (tmpl
);
16018 if (tmpl
!= gen_tmpl
)
16019 /* The TMPL is a partial instantiation. To get a full set of
16020 arguments we must add the arguments used to perform the
16021 partial instantiation. */
16022 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
16025 /* It would be nice to avoid hashing here and then again in tsubst_decl,
16026 but it doesn't seem to be on the hot path. */
16027 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
16029 gcc_assert (tmpl
== gen_tmpl
16030 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
16032 || fndecl
== NULL_TREE
);
16034 if (spec
!= NULL_TREE
)
16036 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
16038 if (complain
& tf_error
)
16039 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
16040 return error_mark_node
;
16045 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
16047 return error_mark_node
;
16049 /* We are building a FUNCTION_DECL, during which the access of its
16050 parameters and return types have to be checked. However this
16051 FUNCTION_DECL which is the desired context for access checking
16052 is not built yet. We solve this chicken-and-egg problem by
16053 deferring all checks until we have the FUNCTION_DECL. */
16054 push_deferring_access_checks (dk_deferred
);
16056 /* Instantiation of the function happens in the context of the function
16057 template, not the context of the overload resolution we're doing. */
16058 push_to_top_level ();
16059 /* If there are dependent arguments, e.g. because we're doing partial
16060 ordering, make sure processing_template_decl stays set. */
16061 if (uses_template_parms (targ_ptr
))
16062 ++processing_template_decl
;
16063 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
16065 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
16066 complain
, gen_tmpl
, true);
16067 push_nested_class (ctx
);
16070 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
16072 if (VAR_P (pattern
))
16074 /* We need to determine if we're using a partial or explicit
16075 specialization now, because the type of the variable could be
16077 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
16078 tree elt
= most_specialized_partial_spec (tid
, complain
);
16079 if (elt
== error_mark_node
)
16080 pattern
= error_mark_node
;
16083 tmpl
= TREE_VALUE (elt
);
16084 pattern
= DECL_TEMPLATE_RESULT (tmpl
);
16085 targ_ptr
= TREE_PURPOSE (elt
);
16089 /* Substitute template parameters to obtain the specialization. */
16090 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
16091 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
16092 pop_nested_class ();
16093 pop_from_top_level ();
16095 if (fndecl
== error_mark_node
)
16097 pop_deferring_access_checks ();
16098 return error_mark_node
;
16101 /* The DECL_TI_TEMPLATE should always be the immediate parent
16102 template, not the most general template. */
16103 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
16105 /* Now we know the specialization, compute access previously
16107 push_access_scope (fndecl
);
16108 if (!perform_deferred_access_checks (complain
))
16110 pop_access_scope (fndecl
);
16111 pop_deferring_access_checks ();
16113 /* If we've just instantiated the main entry point for a function,
16114 instantiate all the alternate entry points as well. We do this
16115 by cloning the instantiation of the main entry point, not by
16116 instantiating the template clones. */
16117 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
16118 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
16122 if (!(complain
& tf_error
))
16124 /* Remember to reinstantiate when we're out of SFINAE so the user
16125 can see the errors. */
16126 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
16128 return error_mark_node
;
16133 /* Wrapper for instantiate_template_1. */
16136 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
16139 timevar_push (TV_TEMPLATE_INST
);
16140 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
16141 timevar_pop (TV_TEMPLATE_INST
);
16145 /* Instantiate the alias template TMPL with ARGS. Also push a template
16146 instantiation level, which instantiate_template doesn't do because
16147 functions and variables have sufficient context established by the
16151 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
16153 struct pending_template
*old_last_pend
= last_pending_template
;
16154 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16155 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
16156 return error_mark_node
;
16157 tree tinst
= build_tree_list (tmpl
, args
);
16158 if (!push_tinst_level (tinst
))
16161 return error_mark_node
;
16165 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
16166 args
, tmpl
, complain
,
16167 /*require_all_args=*/true,
16168 /*use_default_args=*/true);
16170 tree r
= instantiate_template (tmpl
, args
, complain
);
16171 pop_tinst_level ();
16172 /* We can't free this if a pending_template entry or last_error_tinst_level
16173 is pointing at it. */
16174 if (last_pending_template
== old_last_pend
16175 && last_error_tinst_level
== old_error_tinst
)
16181 /* PARM is a template parameter pack for FN. Returns true iff
16182 PARM is used in a deducible way in the argument list of FN. */
16185 pack_deducible_p (tree parm
, tree fn
)
16187 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
16188 for (; t
; t
= TREE_CHAIN (t
))
16190 tree type
= TREE_VALUE (t
);
16192 if (!PACK_EXPANSION_P (type
))
16194 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
16195 packs
; packs
= TREE_CHAIN (packs
))
16196 if (template_args_equal (TREE_VALUE (packs
), parm
))
16198 /* The template parameter pack is used in a function parameter
16199 pack. If this is the end of the parameter list, the
16200 template parameter pack is deducible. */
16201 if (TREE_CHAIN (t
) == void_list_node
)
16204 /* Otherwise, not. Well, it could be deduced from
16205 a non-pack parameter, but doing so would end up with
16206 a deduction mismatch, so don't bother. */
16210 /* The template parameter pack isn't used in any function parameter
16211 packs, but it might be used deeper, e.g. tuple<Args...>. */
16215 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
16216 NARGS elements of the arguments that are being used when calling
16217 it. TARGS is a vector into which the deduced template arguments
16220 Returns either a FUNCTION_DECL for the matching specialization of FN or
16221 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
16222 true, diagnostics will be printed to explain why it failed.
16224 If FN is a conversion operator, or we are trying to produce a specific
16225 specialization, RETURN_TYPE is the return type desired.
16227 The EXPLICIT_TARGS are explicit template arguments provided via a
16230 The parameter STRICT is one of:
16233 We are deducing arguments for a function call, as in
16234 [temp.deduct.call].
16237 We are deducing arguments for a conversion function, as in
16238 [temp.deduct.conv].
16241 We are deducing arguments when doing an explicit instantiation
16242 as in [temp.explicit], when determining an explicit specialization
16243 as in [temp.expl.spec], or when taking the address of a function
16244 template, as in [temp.deduct.funcaddr]. */
16247 fn_type_unification (tree fn
,
16248 tree explicit_targs
,
16251 unsigned int nargs
,
16253 unification_kind_t strict
,
16260 tree decl
= NULL_TREE
;
16261 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
16263 static int deduction_depth
;
16264 struct pending_template
*old_last_pend
= last_pending_template
;
16265 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16266 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
16268 tree r
= error_mark_node
;
16271 complain
|= tf_decltype
;
16273 /* In C++0x, it's possible to have a function template whose type depends
16274 on itself recursively. This is most obvious with decltype, but can also
16275 occur with enumeration scope (c++/48969). So we need to catch infinite
16276 recursion and reject the substitution at deduction time; this function
16277 will return error_mark_node for any repeated substitution.
16279 This also catches excessive recursion such as when f<N> depends on
16280 f<N-1> across all integers, and returns error_mark_node for all the
16281 substitutions back up to the initial one.
16283 This is, of course, not reentrant. */
16284 if (excessive_deduction_depth
)
16285 return error_mark_node
;
16286 tinst
= build_tree_list (fn
, NULL_TREE
);
16289 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
16291 fntype
= TREE_TYPE (fn
);
16292 if (explicit_targs
)
16296 The specified template arguments must match the template
16297 parameters in kind (i.e., type, nontype, template), and there
16298 must not be more arguments than there are parameters;
16299 otherwise type deduction fails.
16301 Nontype arguments must match the types of the corresponding
16302 nontype template parameters, or must be convertible to the
16303 types of the corresponding nontype parameters as specified in
16304 _temp.arg.nontype_, otherwise type deduction fails.
16306 All references in the function type of the function template
16307 to the corresponding template parameters are replaced by the
16308 specified template argument values. If a substitution in a
16309 template parameter or in the function type of the function
16310 template results in an invalid type, type deduction fails. */
16311 int i
, len
= TREE_VEC_LENGTH (tparms
);
16312 location_t loc
= input_location
;
16313 bool incomplete
= false;
16315 /* Adjust any explicit template arguments before entering the
16316 substitution context. */
16318 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
16320 /*require_all_args=*/false,
16321 /*use_default_args=*/false));
16322 if (explicit_targs
== error_mark_node
)
16325 /* Substitute the explicit args into the function type. This is
16326 necessary so that, for instance, explicitly declared function
16327 arguments can match null pointed constants. If we were given
16328 an incomplete set of explicit args, we must not do semantic
16329 processing during substitution as we could create partial
16331 for (i
= 0; i
< len
; i
++)
16333 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16334 bool parameter_pack
= false;
16335 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
16337 /* Dig out the actual parm. */
16338 if (TREE_CODE (parm
) == TYPE_DECL
16339 || TREE_CODE (parm
) == TEMPLATE_DECL
)
16341 parm
= TREE_TYPE (parm
);
16342 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
16344 else if (TREE_CODE (parm
) == PARM_DECL
)
16346 parm
= DECL_INITIAL (parm
);
16347 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
16350 if (!parameter_pack
&& targ
== NULL_TREE
)
16351 /* No explicit argument for this template parameter. */
16354 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
16356 /* Mark the argument pack as "incomplete". We could
16357 still deduce more arguments during unification.
16358 We remove this mark in type_unification_real. */
16361 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
16362 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
16363 = ARGUMENT_PACK_ARGS (targ
);
16366 /* We have some incomplete argument packs. */
16371 TREE_VALUE (tinst
) = explicit_targs
;
16372 if (!push_tinst_level (tinst
))
16374 excessive_deduction_depth
= true;
16377 processing_template_decl
+= incomplete
;
16378 input_location
= DECL_SOURCE_LOCATION (fn
);
16379 /* Ignore any access checks; we'll see them again in
16380 instantiate_template and they might have the wrong
16381 access path at this point. */
16382 push_deferring_access_checks (dk_deferred
);
16383 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
16384 complain
| tf_partial
, NULL_TREE
);
16385 pop_deferring_access_checks ();
16386 input_location
= loc
;
16387 processing_template_decl
-= incomplete
;
16388 pop_tinst_level ();
16390 if (fntype
== error_mark_node
)
16393 /* Place the explicitly specified arguments in TARGS. */
16394 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
16395 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
16398 /* Never do unification on the 'this' parameter. */
16399 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
16405 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
16406 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
16407 new_args
[0] = return_type
;
16408 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
16413 /* We allow incomplete unification without an error message here
16414 because the standard doesn't seem to explicitly prohibit it. Our
16415 callers must be ready to deal with unification failures in any
16418 TREE_VALUE (tinst
) = targs
;
16419 /* If we aren't explaining yet, push tinst context so we can see where
16420 any errors (e.g. from class instantiations triggered by instantiation
16421 of default template arguments) come from. If we are explaining, this
16422 context is redundant. */
16423 if (!explain_p
&& !push_tinst_level (tinst
))
16425 excessive_deduction_depth
= true;
16429 /* type_unification_real will pass back any access checks from default
16430 template argument substitution. */
16431 vec
<deferred_access_check
, va_gc
> *checks
;
16434 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16435 targs
, parms
, args
, nargs
, /*subr=*/0,
16436 strict
, flags
, &checks
, explain_p
);
16438 pop_tinst_level ();
16442 /* Now that we have bindings for all of the template arguments,
16443 ensure that the arguments deduced for the template template
16444 parameters have compatible template parameter lists. We cannot
16445 check this property before we have deduced all template
16446 arguments, because the template parameter types of a template
16447 template parameter might depend on prior template parameters
16448 deduced after the template template parameter. The following
16449 ill-formed example illustrates this issue:
16451 template<typename T, template<T> class C> void f(C<5>, T);
16453 template<int N> struct X {};
16456 f(X<5>(), 5l); // error: template argument deduction fails
16459 The template parameter list of 'C' depends on the template type
16460 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16461 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16462 time that we deduce 'C'. */
16463 if (!template_template_parm_bindings_ok_p
16464 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16466 unify_inconsistent_template_template_parameters (explain_p
);
16470 /* All is well so far. Now, check:
16474 When all template arguments have been deduced, all uses of
16475 template parameters in nondeduced contexts are replaced with
16476 the corresponding deduced argument values. If the
16477 substitution results in an invalid type, as described above,
16478 type deduction fails. */
16479 TREE_VALUE (tinst
) = targs
;
16480 if (!push_tinst_level (tinst
))
16482 excessive_deduction_depth
= true;
16486 /* Also collect access checks from the instantiation. */
16487 reopen_deferring_access_checks (checks
);
16489 decl
= instantiate_template (fn
, targs
, complain
);
16491 checks
= get_deferred_access_checks ();
16492 pop_deferring_access_checks ();
16494 pop_tinst_level ();
16496 if (decl
== error_mark_node
)
16499 /* Now perform any access checks encountered during substitution. */
16500 push_access_scope (decl
);
16501 ok
= perform_access_checks (checks
, complain
);
16502 pop_access_scope (decl
);
16506 /* If we're looking for an exact match, check that what we got
16507 is indeed an exact match. It might not be if some template
16508 parameters are used in non-deduced contexts. But don't check
16509 for an exact match if we have dependent template arguments;
16510 in that case we're doing partial ordering, and we already know
16511 that we have two candidates that will provide the actual type. */
16512 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16514 tree substed
= TREE_TYPE (decl
);
16518 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16520 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16521 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16522 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16524 unify_type_mismatch (explain_p
, args
[i
],
16525 TREE_VALUE (sarg
));
16534 if (excessive_deduction_depth
)
16536 if (deduction_depth
== 0)
16537 /* Reset once we're all the way out. */
16538 excessive_deduction_depth
= false;
16541 /* We can't free this if a pending_template entry or last_error_tinst_level
16542 is pointing at it. */
16543 if (last_pending_template
== old_last_pend
16544 && last_error_tinst_level
== old_error_tinst
)
16550 /* Adjust types before performing type deduction, as described in
16551 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16552 sections are symmetric. PARM is the type of a function parameter
16553 or the return type of the conversion function. ARG is the type of
16554 the argument passed to the call, or the type of the value
16555 initialized with the result of the conversion function.
16556 ARG_EXPR is the original argument expression, which may be null. */
16559 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16572 /* Swap PARM and ARG throughout the remainder of this
16573 function; the handling is precisely symmetric since PARM
16574 will initialize ARG rather than vice versa. */
16575 std::swap (parm
, arg
);
16579 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16580 too, but here handle it by stripping the reference from PARM
16581 rather than by adding it to ARG. */
16582 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16583 && TYPE_REF_IS_RVALUE (*parm
)
16584 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16585 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16586 && TREE_CODE (*arg
) == REFERENCE_TYPE
16587 && !TYPE_REF_IS_RVALUE (*arg
))
16588 *parm
= TREE_TYPE (*parm
);
16589 /* Nothing else to do in this case. */
16593 gcc_unreachable ();
16596 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16598 /* [temp.deduct.call]
16600 If P is not a reference type:
16602 --If A is an array type, the pointer type produced by the
16603 array-to-pointer standard conversion (_conv.array_) is
16604 used in place of A for type deduction; otherwise,
16606 --If A is a function type, the pointer type produced by
16607 the function-to-pointer standard conversion
16608 (_conv.func_) is used in place of A for type deduction;
16611 --If A is a cv-qualified type, the top level
16612 cv-qualifiers of A's type are ignored for type
16614 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16615 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16616 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16617 *arg
= build_pointer_type (*arg
);
16619 *arg
= TYPE_MAIN_VARIANT (*arg
);
16622 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16623 of the form T&&, where T is a template parameter, and the argument
16624 is an lvalue, T is deduced as A& */
16625 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16626 && TYPE_REF_IS_RVALUE (*parm
)
16627 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16628 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16629 && (arg_expr
? real_lvalue_p (arg_expr
)
16630 /* try_one_overload doesn't provide an arg_expr, but
16631 functions are always lvalues. */
16632 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16633 *arg
= build_reference_type (*arg
);
16635 /* [temp.deduct.call]
16637 If P is a cv-qualified type, the top level cv-qualifiers
16638 of P's type are ignored for type deduction. If P is a
16639 reference type, the type referred to by P is used for
16641 *parm
= TYPE_MAIN_VARIANT (*parm
);
16642 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16644 *parm
= TREE_TYPE (*parm
);
16645 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16648 /* DR 322. For conversion deduction, remove a reference type on parm
16649 too (which has been swapped into ARG). */
16650 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16651 *arg
= TREE_TYPE (*arg
);
16656 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16657 template which does contain any deducible template parameters; check if
16658 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16659 unify_one_argument. */
16662 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16663 int flags
, bool explain_p
)
16668 type
= TREE_TYPE (arg
);
16672 if (same_type_p (parm
, type
))
16673 return unify_success (explain_p
);
16675 if (strict
== DEDUCE_CONV
)
16677 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16678 explain_p
? tf_warning_or_error
: tf_none
))
16679 return unify_success (explain_p
);
16681 else if (strict
!= DEDUCE_EXACT
)
16683 if (can_convert_arg (parm
, type
,
16684 TYPE_P (arg
) ? NULL_TREE
: arg
,
16685 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16686 return unify_success (explain_p
);
16689 if (strict
== DEDUCE_EXACT
)
16690 return unify_type_mismatch (explain_p
, parm
, arg
);
16692 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16695 static bool uses_deducible_template_parms (tree type
);
16697 /* Returns true iff the expression EXPR is one from which a template
16698 argument can be deduced. In other words, if it's an undecorated
16699 use of a template non-type parameter. */
16702 deducible_expression (tree expr
)
16704 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16707 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16708 deducible way; that is, if it has a max value of <PARM> - 1. */
16711 deducible_array_bound (tree domain
)
16713 if (domain
== NULL_TREE
)
16716 tree max
= TYPE_MAX_VALUE (domain
);
16717 if (TREE_CODE (max
) != MINUS_EXPR
)
16720 return deducible_expression (TREE_OPERAND (max
, 0));
16723 /* Returns true iff the template arguments ARGS use a template parameter
16724 in a deducible way. */
16727 deducible_template_args (tree args
)
16729 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16732 tree elt
= TREE_VEC_ELT (args
, i
);
16733 if (ARGUMENT_PACK_P (elt
))
16734 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16737 if (PACK_EXPANSION_P (elt
))
16738 elt
= PACK_EXPANSION_PATTERN (elt
);
16739 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16741 else if (TYPE_P (elt
))
16742 deducible
= uses_deducible_template_parms (elt
);
16744 deducible
= deducible_expression (elt
);
16752 /* Returns true iff TYPE contains any deducible references to template
16753 parameters, as per 14.8.2.5. */
16756 uses_deducible_template_parms (tree type
)
16758 if (PACK_EXPANSION_P (type
))
16759 type
= PACK_EXPANSION_PATTERN (type
);
16766 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16767 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16773 if (POINTER_TYPE_P (type
))
16774 return uses_deducible_template_parms (TREE_TYPE (type
));
16776 /* T[integer-constant ]
16778 if (TREE_CODE (type
) == ARRAY_TYPE
)
16779 return (uses_deducible_template_parms (TREE_TYPE (type
))
16780 || deducible_array_bound (TYPE_DOMAIN (type
)));
16792 if (TYPE_PTRMEM_P (type
))
16793 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16794 || (uses_deducible_template_parms
16795 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16797 /* template-name <T> (where template-name refers to a class template)
16798 template-name <i> (where template-name refers to a class template) */
16799 if (CLASS_TYPE_P (type
)
16800 && CLASSTYPE_TEMPLATE_INFO (type
)
16801 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16802 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16803 (CLASSTYPE_TI_ARGS (type
)));
16808 if (TREE_CODE (type
) == FUNCTION_TYPE
16809 || TREE_CODE (type
) == METHOD_TYPE
)
16811 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16813 tree parm
= TYPE_ARG_TYPES (type
);
16814 if (TREE_CODE (type
) == METHOD_TYPE
)
16815 parm
= TREE_CHAIN (parm
);
16816 for (; parm
; parm
= TREE_CHAIN (parm
))
16817 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16824 /* Subroutine of type_unification_real and unify_pack_expansion to
16825 handle unification of a single P/A pair. Parameters are as
16826 for those functions. */
16829 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16830 int subr
, unification_kind_t strict
,
16833 tree arg_expr
= NULL_TREE
;
16836 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16837 return unify_invalid (explain_p
);
16838 if (arg
== unknown_type_node
)
16839 /* We can't deduce anything from this, but we might get all the
16840 template args from other function args. */
16841 return unify_success (explain_p
);
16843 /* Implicit conversions (Clause 4) will be performed on a function
16844 argument to convert it to the type of the corresponding function
16845 parameter if the parameter type contains no template-parameters that
16846 participate in template argument deduction. */
16847 if (strict
!= DEDUCE_EXACT
16848 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16849 /* For function parameters with no deducible template parameters,
16850 just return. We'll check non-dependent conversions later. */
16851 return unify_success (explain_p
);
16856 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16857 | UNIFY_ALLOW_MORE_CV_QUAL
16858 | UNIFY_ALLOW_DERIVED
);
16862 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16866 arg_strict
= UNIFY_ALLOW_NONE
;
16870 gcc_unreachable ();
16873 /* We only do these transformations if this is the top-level
16874 parameter_type_list in a call or declaration matching; in other
16875 situations (nested function declarators, template argument lists) we
16876 won't be comparing a type to an expression, and we don't do any type
16882 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16883 if (type_unknown_p (arg
))
16885 /* [temp.deduct.type] A template-argument can be
16886 deduced from a pointer to function or pointer
16887 to member function argument if the set of
16888 overloaded functions does not contain function
16889 templates and at most one of a set of
16890 overloaded functions provides a unique
16893 if (resolve_overloaded_unification
16894 (tparms
, targs
, parm
, arg
, strict
,
16895 arg_strict
, explain_p
))
16896 return unify_success (explain_p
);
16897 return unify_overload_resolution_failure (explain_p
, arg
);
16901 arg
= unlowered_expr_type (arg
);
16902 if (arg
== error_mark_node
)
16903 return unify_invalid (explain_p
);
16907 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16910 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16911 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
16912 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16914 /* For deduction from an init-list we need the actual list. */
16915 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16917 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16920 /* Most parms like fn_type_unification.
16922 If SUBR is 1, we're being called recursively (to unify the
16923 arguments of a function or method parameter of a function
16926 CHECKS is a pointer to a vector of access checks encountered while
16927 substituting default template arguments. */
16930 type_unification_real (tree tparms
,
16934 unsigned int xnargs
,
16936 unification_kind_t strict
,
16938 vec
<deferred_access_check
, va_gc
> **checks
,
16943 int ntparms
= TREE_VEC_LENGTH (tparms
);
16944 int saw_undeduced
= 0;
16947 unsigned int nargs
;
16950 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16951 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16952 gcc_assert (ntparms
> 0);
16954 /* Reset the number of non-defaulted template arguments contained
16956 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16964 while (parms
&& parms
!= void_list_node
16967 parm
= TREE_VALUE (parms
);
16969 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16970 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16971 /* For a function parameter pack that occurs at the end of the
16972 parameter-declaration-list, the type A of each remaining
16973 argument of the call is compared with the type P of the
16974 declarator-id of the function parameter pack. */
16977 parms
= TREE_CHAIN (parms
);
16979 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16980 /* For a function parameter pack that does not occur at the
16981 end of the parameter-declaration-list, the type of the
16982 parameter pack is a non-deduced context. */
16988 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16994 && parms
!= void_list_node
16995 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16997 /* Unify the remaining arguments with the pack expansion type. */
16999 tree parmvec
= make_tree_vec (1);
17001 /* Allocate a TREE_VEC and copy in all of the arguments */
17002 argvec
= make_tree_vec (nargs
- ia
);
17003 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
17004 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
17006 /* Copy the parameter into parmvec. */
17007 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
17008 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
17009 /*subr=*/subr
, explain_p
))
17012 /* Advance to the end of the list of parameters. */
17013 parms
= TREE_CHAIN (parms
);
17016 /* Fail if we've reached the end of the parm list, and more args
17017 are present, and the parm list isn't variadic. */
17018 if (ia
< nargs
&& parms
== void_list_node
)
17019 return unify_too_many_arguments (explain_p
, nargs
, ia
);
17020 /* Fail if parms are left and they don't have default values and
17021 they aren't all deduced as empty packs (c++/57397). This is
17022 consistent with sufficient_parms_p. */
17023 if (parms
&& parms
!= void_list_node
17024 && TREE_PURPOSE (parms
) == NULL_TREE
)
17026 unsigned int count
= nargs
;
17031 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
17034 p
= TREE_CHAIN (p
);
17036 while (p
&& p
!= void_list_node
);
17037 if (count
!= nargs
)
17038 return unify_too_few_arguments (explain_p
, ia
, count
,
17044 tsubst_flags_t complain
= (explain_p
17045 ? tf_warning_or_error
17048 for (i
= 0; i
< ntparms
; i
++)
17050 tree targ
= TREE_VEC_ELT (targs
, i
);
17051 tree tparm
= TREE_VEC_ELT (tparms
, i
);
17053 /* Clear the "incomplete" flags on all argument packs now so that
17054 substituting them into later default arguments works. */
17055 if (targ
&& ARGUMENT_PACK_P (targ
))
17057 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
17058 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
17061 if (targ
|| tparm
== error_mark_node
)
17063 tparm
= TREE_VALUE (tparm
);
17065 /* If this is an undeduced nontype parameter that depends on
17066 a type parameter, try another pass; its type may have been
17067 deduced from a later argument than the one from which
17068 this parameter can be deduced. */
17069 if (TREE_CODE (tparm
) == PARM_DECL
17070 && uses_template_parms (TREE_TYPE (tparm
))
17071 && saw_undeduced
< 2)
17077 /* Core issue #226 (C++0x) [temp.deduct]:
17079 If a template argument has not been deduced, its
17080 default template argument, if any, is used.
17082 When we are in C++98 mode, TREE_PURPOSE will either
17083 be NULL_TREE or ERROR_MARK_NODE, so we do not need
17084 to explicitly check cxx_dialect here. */
17085 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
17086 /* OK, there is a default argument. Wait until after the
17087 conversion check to do substitution. */
17090 /* If the type parameter is a parameter pack, then it will
17091 be deduced to an empty parameter pack. */
17092 if (template_parameter_pack_p (tparm
))
17096 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
17098 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
17099 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
17100 TREE_CONSTANT (arg
) = 1;
17103 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17105 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
17107 TREE_VEC_ELT (targs
, i
) = arg
;
17111 return unify_parameter_deduction_failure (explain_p
, tparm
);
17114 /* DR 1391: All parameters have args, now check non-dependent parms for
17116 if (saw_undeduced
< 2)
17117 for (ia
= 0, parms
= xparms
, args
= xargs
, nargs
= xnargs
;
17118 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
17120 parm
= TREE_VALUE (parms
);
17122 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
17123 && (!TREE_CHAIN (parms
)
17124 || TREE_CHAIN (parms
) == void_list_node
))
17125 /* For a function parameter pack that occurs at the end of the
17126 parameter-declaration-list, the type A of each remaining
17127 argument of the call is compared with the type P of the
17128 declarator-id of the function parameter pack. */
17131 parms
= TREE_CHAIN (parms
);
17133 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
17134 /* For a function parameter pack that does not occur at the
17135 end of the parameter-declaration-list, the type of the
17136 parameter pack is a non-deduced context. */
17142 if (uses_template_parms (parm
))
17144 if (check_non_deducible_conversion (parm
, arg
, strict
, flags
,
17149 /* Now substitute into the default template arguments. */
17150 for (i
= 0; i
< ntparms
; i
++)
17152 tree targ
= TREE_VEC_ELT (targs
, i
);
17153 tree tparm
= TREE_VEC_ELT (tparms
, i
);
17155 if (targ
|| tparm
== error_mark_node
)
17157 tree parm
= TREE_VALUE (tparm
);
17159 if (TREE_CODE (parm
) == PARM_DECL
17160 && uses_template_parms (TREE_TYPE (parm
))
17161 && saw_undeduced
< 2)
17164 tree arg
= TREE_PURPOSE (tparm
);
17165 reopen_deferring_access_checks (*checks
);
17166 location_t save_loc
= input_location
;
17168 input_location
= DECL_SOURCE_LOCATION (parm
);
17169 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
17170 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
17172 input_location
= save_loc
;
17173 *checks
= get_deferred_access_checks ();
17174 pop_deferring_access_checks ();
17175 if (arg
== error_mark_node
)
17179 TREE_VEC_ELT (targs
, i
) = arg
;
17180 /* The position of the first default template argument,
17181 is also the number of non-defaulted arguments in TARGS.
17183 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
17184 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
17189 if (saw_undeduced
++ == 1)
17192 #ifdef ENABLE_CHECKING
17193 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
17194 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
17197 return unify_success (explain_p
);
17200 /* Subroutine of type_unification_real. Args are like the variables
17201 at the call site. ARG is an overloaded function (or template-id);
17202 we try deducing template args from each of the overloads, and if
17203 only one succeeds, we go with that. Modifies TARGS and returns
17204 true on success. */
17207 resolve_overloaded_unification (tree tparms
,
17211 unification_kind_t strict
,
17215 tree tempargs
= copy_node (targs
);
17217 tree goodfn
= NULL_TREE
;
17220 if (TREE_CODE (arg
) == ADDR_EXPR
)
17222 arg
= TREE_OPERAND (arg
, 0);
17228 if (TREE_CODE (arg
) == COMPONENT_REF
)
17229 /* Handle `&x' where `x' is some static or non-static member
17231 arg
= TREE_OPERAND (arg
, 1);
17233 if (TREE_CODE (arg
) == OFFSET_REF
)
17234 arg
= TREE_OPERAND (arg
, 1);
17236 /* Strip baselink information. */
17237 if (BASELINK_P (arg
))
17238 arg
= BASELINK_FUNCTIONS (arg
);
17240 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
17242 /* If we got some explicit template args, we need to plug them into
17243 the affected templates before we try to unify, in case the
17244 explicit args will completely resolve the templates in question. */
17247 tree expl_subargs
= TREE_OPERAND (arg
, 1);
17248 arg
= TREE_OPERAND (arg
, 0);
17250 for (; arg
; arg
= OVL_NEXT (arg
))
17252 tree fn
= OVL_CURRENT (arg
);
17253 tree subargs
, elem
;
17255 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17258 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17259 expl_subargs
, NULL_TREE
, tf_none
,
17260 /*require_all_args=*/true,
17261 /*use_default_args=*/true);
17262 if (subargs
!= error_mark_node
17263 && !any_dependent_template_arguments_p (subargs
))
17265 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
17266 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17267 elem
, strict
, sub_strict
, addr_p
, explain_p
)
17268 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
17277 /* If no templates (or more than one) are fully resolved by the
17278 explicit arguments, this template-id is a non-deduced context; it
17279 could still be OK if we deduce all template arguments for the
17280 enclosing call through other arguments. */
17284 else if (TREE_CODE (arg
) != OVERLOAD
17285 && TREE_CODE (arg
) != FUNCTION_DECL
)
17286 /* If ARG is, for example, "(0, &f)" then its type will be unknown
17287 -- but the deduction does not succeed because the expression is
17288 not just the function on its own. */
17291 for (; arg
; arg
= OVL_NEXT (arg
))
17292 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17293 TREE_TYPE (OVL_CURRENT (arg
)),
17294 strict
, sub_strict
, addr_p
, explain_p
)
17295 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
17297 goodfn
= OVL_CURRENT (arg
);
17301 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17302 to function or pointer to member function argument if the set of
17303 overloaded functions does not contain function templates and at most
17304 one of a set of overloaded functions provides a unique match.
17306 So if we found multiple possibilities, we return success but don't
17307 deduce anything. */
17311 int i
= TREE_VEC_LENGTH (targs
);
17313 if (TREE_VEC_ELT (tempargs
, i
))
17315 tree old
= TREE_VEC_ELT (targs
, i
);
17316 tree new_
= TREE_VEC_ELT (tempargs
, i
);
17317 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
17318 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
17319 /* Don't forget explicit template arguments in a pack. */
17320 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
17321 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
17322 TREE_VEC_ELT (targs
, i
) = new_
;
17331 /* Core DR 115: In contexts where deduction is done and fails, or in
17332 contexts where deduction is not done, if a template argument list is
17333 specified and it, along with any default template arguments, identifies
17334 a single function template specialization, then the template-id is an
17335 lvalue for the function template specialization. */
17338 resolve_nondeduced_context (tree orig_expr
)
17340 tree expr
, offset
, baselink
;
17343 if (!type_unknown_p (orig_expr
))
17348 offset
= NULL_TREE
;
17349 baselink
= NULL_TREE
;
17351 if (TREE_CODE (expr
) == ADDR_EXPR
)
17353 expr
= TREE_OPERAND (expr
, 0);
17356 if (TREE_CODE (expr
) == OFFSET_REF
)
17359 expr
= TREE_OPERAND (expr
, 1);
17361 if (BASELINK_P (expr
))
17364 expr
= BASELINK_FUNCTIONS (expr
);
17367 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
17370 tree goodfn
= NULL_TREE
;
17372 /* If we got some explicit template args, we need to plug them into
17373 the affected templates before we try to unify, in case the
17374 explicit args will completely resolve the templates in question. */
17376 tree expl_subargs
= TREE_OPERAND (expr
, 1);
17377 tree arg
= TREE_OPERAND (expr
, 0);
17378 tree badfn
= NULL_TREE
;
17379 tree badargs
= NULL_TREE
;
17381 for (; arg
; arg
= OVL_NEXT (arg
))
17383 tree fn
= OVL_CURRENT (arg
);
17384 tree subargs
, elem
;
17386 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17389 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17390 expl_subargs
, NULL_TREE
, tf_none
,
17391 /*require_all_args=*/true,
17392 /*use_default_args=*/true);
17393 if (subargs
!= error_mark_node
17394 && !any_dependent_template_arguments_p (subargs
))
17396 elem
= instantiate_template (fn
, subargs
, tf_none
);
17397 if (elem
== error_mark_node
)
17402 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
17411 mark_used (goodfn
);
17414 expr
= build_baselink (BASELINK_BINFO (baselink
),
17415 BASELINK_ACCESS_BINFO (baselink
),
17416 expr
, BASELINK_OPTYPE (baselink
));
17420 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
17421 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
17424 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
17427 else if (good
== 0 && badargs
)
17428 /* There were no good options and at least one bad one, so let the
17429 user know what the problem is. */
17430 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
17435 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17436 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17437 different overloads deduce different arguments for a given parm.
17438 ADDR_P is true if the expression for which deduction is being
17439 performed was of the form "& fn" rather than simply "fn".
17441 Returns 1 on success. */
17444 try_one_overload (tree tparms
,
17449 unification_kind_t strict
,
17458 if (arg
== error_mark_node
)
17461 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17462 to function or pointer to member function argument if the set of
17463 overloaded functions does not contain function templates and at most
17464 one of a set of overloaded functions provides a unique match.
17466 So if this is a template, just return success. */
17468 if (uses_template_parms (arg
))
17471 if (TREE_CODE (arg
) == METHOD_TYPE
)
17472 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
17474 arg
= build_pointer_type (arg
);
17476 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
17478 /* We don't copy orig_targs for this because if we have already deduced
17479 some template args from previous args, unify would complain when we
17480 try to deduce a template parameter for the same argument, even though
17481 there isn't really a conflict. */
17482 nargs
= TREE_VEC_LENGTH (targs
);
17483 tempargs
= make_tree_vec (nargs
);
17485 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
17488 /* First make sure we didn't deduce anything that conflicts with
17489 explicitly specified args. */
17490 for (i
= nargs
; i
--; )
17492 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17493 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17497 else if (uses_template_parms (elt
))
17498 /* Since we're unifying against ourselves, we will fill in
17499 template args used in the function parm list with our own
17500 template parms. Discard them. */
17501 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17502 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17506 for (i
= nargs
; i
--; )
17508 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17511 TREE_VEC_ELT (targs
, i
) = elt
;
17517 /* PARM is a template class (perhaps with unbound template
17518 parameters). ARG is a fully instantiated type. If ARG can be
17519 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17520 TARGS are as for unify. */
17523 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17526 tree copy_of_targs
;
17528 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17529 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17530 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17533 /* We need to make a new template argument vector for the call to
17534 unify. If we used TARGS, we'd clutter it up with the result of
17535 the attempted unification, even if this class didn't work out.
17536 We also don't want to commit ourselves to all the unifications
17537 we've already done, since unification is supposed to be done on
17538 an argument-by-argument basis. In other words, consider the
17539 following pathological case:
17541 template <int I, int J, int K>
17544 template <int I, int J>
17545 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17547 template <int I, int J, int K>
17548 void f(S<I, J, K>, S<I, I, I>);
17557 Now, by the time we consider the unification involving `s2', we
17558 already know that we must have `f<0, 0, 0>'. But, even though
17559 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17560 because there are two ways to unify base classes of S<0, 1, 2>
17561 with S<I, I, I>. If we kept the already deduced knowledge, we
17562 would reject the possibility I=1. */
17563 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17565 /* If unification failed, we're done. */
17566 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17567 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17573 /* Given a template type PARM and a class type ARG, find the unique
17574 base type in ARG that is an instance of PARM. We do not examine
17575 ARG itself; only its base-classes. If there is not exactly one
17576 appropriate base class, return NULL_TREE. PARM may be the type of
17577 a partial specialization, as well as a plain template type. Used
17580 static enum template_base_result
17581 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17582 bool explain_p
, tree
*result
)
17584 tree rval
= NULL_TREE
;
17587 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17589 binfo
= TYPE_BINFO (complete_type (arg
));
17592 /* The type could not be completed. */
17593 *result
= NULL_TREE
;
17594 return tbr_incomplete_type
;
17597 /* Walk in inheritance graph order. The search order is not
17598 important, and this avoids multiple walks of virtual bases. */
17599 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17601 tree r
= try_class_unification (tparms
, targs
, parm
,
17602 BINFO_TYPE (binfo
), explain_p
);
17606 /* If there is more than one satisfactory baseclass, then:
17610 If they yield more than one possible deduced A, the type
17614 if (rval
&& !same_type_p (r
, rval
))
17616 *result
= NULL_TREE
;
17617 return tbr_ambiguous_baseclass
;
17625 return tbr_success
;
17628 /* Returns the level of DECL, which declares a template parameter. */
17631 template_decl_level (tree decl
)
17633 switch (TREE_CODE (decl
))
17636 case TEMPLATE_DECL
:
17637 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17640 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17643 gcc_unreachable ();
17648 /* Decide whether ARG can be unified with PARM, considering only the
17649 cv-qualifiers of each type, given STRICT as documented for unify.
17650 Returns nonzero iff the unification is OK on that basis. */
17653 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17655 int arg_quals
= cp_type_quals (arg
);
17656 int parm_quals
= cp_type_quals (parm
);
17658 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17659 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17661 /* Although a CVR qualifier is ignored when being applied to a
17662 substituted template parameter ([8.3.2]/1 for example), that
17663 does not allow us to unify "const T" with "int&" because both
17664 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17665 It is ok when we're allowing additional CV qualifiers
17666 at the outer level [14.8.2.1]/3,1st bullet. */
17667 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17668 || TREE_CODE (arg
) == FUNCTION_TYPE
17669 || TREE_CODE (arg
) == METHOD_TYPE
)
17670 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17673 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17674 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17678 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17679 && (arg_quals
& parm_quals
) != parm_quals
)
17682 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17683 && (parm_quals
& arg_quals
) != arg_quals
)
17689 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17691 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17693 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17694 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17695 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17697 *index
= TEMPLATE_TYPE_IDX (parm
);
17698 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17702 *index
= TEMPLATE_PARM_IDX (parm
);
17703 *level
= TEMPLATE_PARM_LEVEL (parm
);
17707 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17709 if (unify (TP, TA, P, A, S, EP)) \
17713 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17714 expansion at the end of PACKED_PARMS. Returns 0 if the type
17715 deduction succeeds, 1 otherwise. STRICT is the same as in
17716 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17717 call argument list. We'll need to adjust the arguments to make them
17718 types. SUBR tells us if this is from a recursive call to
17719 type_unification_real, or for comparing two template argument
17723 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17724 tree packed_args
, unification_kind_t strict
,
17725 bool subr
, bool explain_p
)
17728 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17729 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17730 tree pack
, packs
= NULL_TREE
;
17731 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17733 packed_args
= expand_template_argument_pack (packed_args
);
17735 int len
= TREE_VEC_LENGTH (packed_args
);
17737 /* Determine the parameter packs we will be deducing from the
17738 pattern, and record their current deductions. */
17739 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17740 pack
; pack
= TREE_CHAIN (pack
))
17742 tree parm_pack
= TREE_VALUE (pack
);
17745 /* Determine the index and level of this parameter pack. */
17746 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17748 /* Keep track of the parameter packs and their corresponding
17750 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17751 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17754 /* Loop through all of the arguments that have not yet been
17755 unified and unify each with the pattern. */
17756 for (i
= start
; i
< len
; i
++)
17759 bool any_explicit
= false;
17760 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17762 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17763 or the element of its argument pack at the current index if
17764 this argument was explicitly specified. */
17765 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17769 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17772 if (TREE_VALUE (pack
)
17773 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17774 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17776 any_explicit
= true;
17777 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17779 TMPL_ARG (targs
, level
, idx
) = arg
;
17782 /* If we had explicit template arguments, substitute them into the
17783 pattern before deduction. */
17786 /* Some arguments might still be unspecified or dependent. */
17788 ++processing_template_decl
;
17789 dependent
= any_dependent_template_arguments_p (targs
);
17791 --processing_template_decl
;
17792 parm
= tsubst (pattern
, targs
,
17793 explain_p
? tf_warning_or_error
: tf_none
,
17796 --processing_template_decl
;
17797 if (parm
== error_mark_node
)
17803 /* Unify the pattern with the current argument. */
17804 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17808 /* For each parameter pack, collect the deduced value. */
17809 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17812 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17814 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17815 TMPL_ARG (targs
, level
, idx
);
17819 /* Verify that the results of unification with the parameter packs
17820 produce results consistent with what we've seen before, and make
17821 the deduced argument packs available. */
17822 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17824 tree old_pack
= TREE_VALUE (pack
);
17825 tree new_args
= TREE_TYPE (pack
);
17826 int i
, len
= TREE_VEC_LENGTH (new_args
);
17828 bool nondeduced_p
= false;
17830 /* By default keep the original deduced argument pack.
17831 If necessary, more specific code is going to update the
17832 resulting deduced argument later down in this function. */
17833 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17834 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17836 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17837 actually deduce anything. */
17838 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17839 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17840 nondeduced_p
= true;
17844 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17846 /* If we had fewer function args than explicit template args,
17847 just use the explicits. */
17848 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17849 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17850 if (len
< explicit_len
)
17851 new_args
= explicit_args
;
17857 /* Build the deduced *_ARGUMENT_PACK. */
17858 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17860 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17861 TREE_TYPE (result
) =
17862 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17863 TREE_CONSTANT (result
) = 1;
17866 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17868 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17870 /* Note the deduced argument packs for this parameter
17872 TMPL_ARG (targs
, level
, idx
) = result
;
17874 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17875 && (ARGUMENT_PACK_ARGS (old_pack
)
17876 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17878 /* We only had the explicitly-provided arguments before, but
17879 now we have a complete set of arguments. */
17880 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17882 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17883 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17884 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17888 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17889 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17891 if (!comp_template_args_with_info (old_args
, new_args
,
17892 &bad_old_arg
, &bad_new_arg
))
17893 /* Inconsistent unification of this parameter pack. */
17894 return unify_parameter_pack_inconsistent (explain_p
,
17900 return unify_success (explain_p
);
17903 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17904 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17905 parameters and return value are as for unify. */
17908 unify_array_domain (tree tparms
, tree targs
,
17909 tree parm_dom
, tree arg_dom
,
17917 /* Our representation of array types uses "N - 1" as the
17918 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17919 not an integer constant. We cannot unify arbitrarily
17920 complex expressions, so we eliminate the MINUS_EXPRs
17922 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17923 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17926 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17927 parm_max
= TREE_OPERAND (parm_max
, 0);
17929 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17930 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17933 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17934 trying to unify the type of a variable with the type
17935 of a template parameter. For example:
17937 template <unsigned int N>
17938 void f (char (&) [N]);
17945 Here, the type of the ARG will be "int [g(i)]", and
17946 may be a SAVE_EXPR, etc. */
17947 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17948 return unify_vla_arg (explain_p
, arg_dom
);
17949 arg_max
= TREE_OPERAND (arg_max
, 0);
17952 /* If only one of the bounds used a MINUS_EXPR, compensate
17953 by adding one to the other bound. */
17954 if (parm_cst
&& !arg_cst
)
17955 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17959 else if (arg_cst
&& !parm_cst
)
17960 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17965 return unify (tparms
, targs
, parm_max
, arg_max
,
17966 UNIFY_ALLOW_INTEGER
, explain_p
);
17969 /* Deduce the value of template parameters. TPARMS is the (innermost)
17970 set of template parameters to a template. TARGS is the bindings
17971 for those template parameters, as determined thus far; TARGS may
17972 include template arguments for outer levels of template parameters
17973 as well. PARM is a parameter to a template function, or a
17974 subcomponent of that parameter; ARG is the corresponding argument.
17975 This function attempts to match PARM with ARG in a manner
17976 consistent with the existing assignments in TARGS. If more values
17977 are deduced, then TARGS is updated.
17979 Returns 0 if the type deduction succeeds, 1 otherwise. The
17980 parameter STRICT is a bitwise or of the following flags:
17983 Require an exact match between PARM and ARG.
17984 UNIFY_ALLOW_MORE_CV_QUAL:
17985 Allow the deduced ARG to be more cv-qualified (by qualification
17986 conversion) than ARG.
17987 UNIFY_ALLOW_LESS_CV_QUAL:
17988 Allow the deduced ARG to be less cv-qualified than ARG.
17989 UNIFY_ALLOW_DERIVED:
17990 Allow the deduced ARG to be a template base class of ARG,
17991 or a pointer to a template base class of the type pointed to by
17993 UNIFY_ALLOW_INTEGER:
17994 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17995 case for more information.
17996 UNIFY_ALLOW_OUTER_LEVEL:
17997 This is the outermost level of a deduction. Used to determine validity
17998 of qualification conversions. A valid qualification conversion must
17999 have const qualified pointers leading up to the inner type which
18000 requires additional CV quals, except at the outer level, where const
18001 is not required [conv.qual]. It would be normal to set this flag in
18002 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
18003 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
18004 This is the outermost level of a deduction, and PARM can be more CV
18005 qualified at this point.
18006 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
18007 This is the outermost level of a deduction, and PARM can be less CV
18008 qualified at this point. */
18011 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
18017 int strict_in
= strict
;
18019 /* I don't think this will do the right thing with respect to types.
18020 But the only case I've seen it in so far has been array bounds, where
18021 signedness is the only information lost, and I think that will be
18023 while (TREE_CODE (parm
) == NOP_EXPR
)
18024 parm
= TREE_OPERAND (parm
, 0);
18026 if (arg
== error_mark_node
)
18027 return unify_invalid (explain_p
);
18028 if (arg
== unknown_type_node
18029 || arg
== init_list_type_node
)
18030 /* We can't deduce anything from this, but we might get all the
18031 template args from other function args. */
18032 return unify_success (explain_p
);
18034 /* If PARM uses template parameters, then we can't bail out here,
18035 even if ARG == PARM, since we won't record unifications for the
18036 template parameters. We might need them if we're trying to
18037 figure out which of two things is more specialized. */
18038 if (arg
== parm
&& !uses_template_parms (parm
))
18039 return unify_success (explain_p
);
18041 /* Handle init lists early, so the rest of the function can assume
18042 we're dealing with a type. */
18043 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
18047 tree orig_parm
= parm
;
18049 /* Replace T with std::initializer_list<T> for deduction. */
18050 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
18051 && flag_deduce_init_list
)
18052 parm
= listify (parm
);
18054 if (!is_std_init_list (parm
)
18055 && TREE_CODE (parm
) != ARRAY_TYPE
)
18056 /* We can only deduce from an initializer list argument if the
18057 parameter is std::initializer_list or an array; otherwise this
18058 is a non-deduced context. */
18059 return unify_success (explain_p
);
18061 if (TREE_CODE (parm
) == ARRAY_TYPE
)
18062 elttype
= TREE_TYPE (parm
);
18065 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
18066 /* Deduction is defined in terms of a single type, so just punt
18067 on the (bizarre) std::initializer_list<T...>. */
18068 if (PACK_EXPANSION_P (elttype
))
18069 return unify_success (explain_p
);
18072 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
18074 int elt_strict
= strict
;
18076 if (elt
== error_mark_node
)
18077 return unify_invalid (explain_p
);
18079 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
18081 tree type
= TREE_TYPE (elt
);
18082 if (type
== error_mark_node
)
18083 return unify_invalid (explain_p
);
18084 /* It should only be possible to get here for a call. */
18085 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
18086 elt_strict
|= maybe_adjust_types_for_deduction
18087 (DEDUCE_CALL
, &elttype
, &type
, elt
);
18091 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
18095 if (TREE_CODE (parm
) == ARRAY_TYPE
18096 && deducible_array_bound (TYPE_DOMAIN (parm
)))
18098 /* Also deduce from the length of the initializer list. */
18099 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
18100 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
18101 if (idx
== error_mark_node
)
18102 return unify_invalid (explain_p
);
18103 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18107 /* If the std::initializer_list<T> deduction worked, replace the
18108 deduced A with std::initializer_list<A>. */
18109 if (orig_parm
!= parm
)
18111 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
18112 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18113 targ
= listify (targ
);
18114 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
18116 return unify_success (explain_p
);
18119 /* Immediately reject some pairs that won't unify because of
18120 cv-qualification mismatches. */
18121 if (TREE_CODE (arg
) == TREE_CODE (parm
)
18123 /* It is the elements of the array which hold the cv quals of an array
18124 type, and the elements might be template type parms. We'll check
18125 when we recurse. */
18126 && TREE_CODE (arg
) != ARRAY_TYPE
18127 /* We check the cv-qualifiers when unifying with template type
18128 parameters below. We want to allow ARG `const T' to unify with
18129 PARM `T' for example, when computing which of two templates
18130 is more specialized, for example. */
18131 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
18132 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
18133 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18135 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
18136 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
18137 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
18138 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
18139 strict
&= ~UNIFY_ALLOW_DERIVED
;
18140 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
18141 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
18143 switch (TREE_CODE (parm
))
18145 case TYPENAME_TYPE
:
18147 case UNBOUND_CLASS_TEMPLATE
:
18148 /* In a type which contains a nested-name-specifier, template
18149 argument values cannot be deduced for template parameters used
18150 within the nested-name-specifier. */
18151 return unify_success (explain_p
);
18153 case TEMPLATE_TYPE_PARM
:
18154 case TEMPLATE_TEMPLATE_PARM
:
18155 case BOUND_TEMPLATE_TEMPLATE_PARM
:
18156 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18157 if (error_operand_p (tparm
))
18158 return unify_invalid (explain_p
);
18160 if (TEMPLATE_TYPE_LEVEL (parm
)
18161 != template_decl_level (tparm
))
18162 /* The PARM is not one we're trying to unify. Just check
18163 to see if it matches ARG. */
18165 if (TREE_CODE (arg
) == TREE_CODE (parm
)
18166 && (is_auto (parm
) ? is_auto (arg
)
18167 : same_type_p (parm
, arg
)))
18168 return unify_success (explain_p
);
18170 return unify_type_mismatch (explain_p
, parm
, arg
);
18172 idx
= TEMPLATE_TYPE_IDX (parm
);
18173 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18174 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
18175 if (error_operand_p (tparm
))
18176 return unify_invalid (explain_p
);
18178 /* Check for mixed types and values. */
18179 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
18180 && TREE_CODE (tparm
) != TYPE_DECL
)
18181 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18182 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
18183 gcc_unreachable ();
18185 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18187 /* ARG must be constructed from a template class or a template
18188 template parameter. */
18189 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
18190 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
18191 return unify_template_deduction_failure (explain_p
, parm
, arg
);
18193 tree parmvec
= TYPE_TI_ARGS (parm
);
18194 /* An alias template name is never deduced. */
18195 if (TYPE_ALIAS_P (arg
))
18196 arg
= strip_typedefs (arg
);
18197 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
18198 tree full_argvec
= add_to_template_args (targs
, argvec
);
18200 = DECL_INNERMOST_TEMPLATE_PARMS
18201 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
18203 int parm_variadic_p
= 0;
18205 /* The resolution to DR150 makes clear that default
18206 arguments for an N-argument may not be used to bind T
18207 to a template template parameter with fewer than N
18208 parameters. It is not safe to permit the binding of
18209 default arguments as an extension, as that may change
18210 the meaning of a conforming program. Consider:
18212 struct Dense { static const unsigned int dim = 1; };
18214 template <template <typename> class View,
18216 void operator+(float, View<Block> const&);
18218 template <typename Block,
18219 unsigned int Dim = Block::dim>
18220 struct Lvalue_proxy { operator float() const; };
18224 Lvalue_proxy<Dense> p;
18229 Here, if Lvalue_proxy is permitted to bind to View, then
18230 the global operator+ will be used; if they are not, the
18231 Lvalue_proxy will be converted to float. */
18232 if (coerce_template_parms (parm_parms
,
18234 TYPE_TI_TEMPLATE (parm
),
18236 ? tf_warning_or_error
18238 /*require_all_args=*/true,
18239 /*use_default_args=*/false)
18240 == error_mark_node
)
18243 /* Deduce arguments T, i from TT<T> or TT<i>.
18244 We check each element of PARMVEC and ARGVEC individually
18245 rather than the whole TREE_VEC since they can have
18246 different number of elements. */
18248 parmvec
= expand_template_argument_pack (parmvec
);
18249 argvec
= expand_template_argument_pack (argvec
);
18251 len
= TREE_VEC_LENGTH (parmvec
);
18253 /* Check if the parameters end in a pack, making them
18256 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
18257 parm_variadic_p
= 1;
18259 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18260 /* If the template argument list of P contains a pack
18261 expansion that is not the last template argument, the
18262 entire template argument list is a non-deduced
18264 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
18265 return unify_success (explain_p
);
18267 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
18268 return unify_too_few_arguments (explain_p
,
18269 TREE_VEC_LENGTH (argvec
), len
);
18271 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18273 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18274 TREE_VEC_ELT (parmvec
, i
),
18275 TREE_VEC_ELT (argvec
, i
),
18276 UNIFY_ALLOW_NONE
, explain_p
);
18279 if (parm_variadic_p
18280 && unify_pack_expansion (tparms
, targs
,
18283 /*subr=*/true, explain_p
))
18286 arg
= TYPE_TI_TEMPLATE (arg
);
18288 /* Fall through to deduce template name. */
18291 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18292 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18294 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
18296 /* Simple cases: Value already set, does match or doesn't. */
18297 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
18298 return unify_success (explain_p
);
18300 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18304 /* If PARM is `const T' and ARG is only `int', we don't have
18305 a match unless we are allowing additional qualification.
18306 If ARG is `const int' and PARM is just `T' that's OK;
18307 that binds `const int' to `T'. */
18308 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
18310 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18312 /* Consider the case where ARG is `const volatile int' and
18313 PARM is `const T'. Then, T should be `volatile int'. */
18314 arg
= cp_build_qualified_type_real
18315 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
18316 if (arg
== error_mark_node
)
18317 return unify_invalid (explain_p
);
18319 /* Simple cases: Value already set, does match or doesn't. */
18320 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
18321 return unify_success (explain_p
);
18323 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18325 /* Make sure that ARG is not a variable-sized array. (Note
18326 that were talking about variable-sized arrays (like
18327 `int[n]'), rather than arrays of unknown size (like
18328 `int[]').) We'll get very confused by such a type since
18329 the bound of the array is not constant, and therefore
18330 not mangleable. Besides, such types are not allowed in
18331 ISO C++, so we can do as we please here. We do allow
18332 them for 'auto' deduction, since that isn't ABI-exposed. */
18333 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
18334 return unify_vla_arg (explain_p
, arg
);
18336 /* Strip typedefs as in convert_template_argument. */
18337 arg
= canonicalize_type_argument (arg
, tf_none
);
18340 /* If ARG is a parameter pack or an expansion, we cannot unify
18341 against it unless PARM is also a parameter pack. */
18342 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18343 && !template_parameter_pack_p (parm
))
18344 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18346 /* If the argument deduction results is a METHOD_TYPE,
18347 then there is a problem.
18348 METHOD_TYPE doesn't map to any real C++ type the result of
18349 the deduction can not be of that type. */
18350 if (TREE_CODE (arg
) == METHOD_TYPE
)
18351 return unify_method_type_error (explain_p
, arg
);
18353 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18354 return unify_success (explain_p
);
18356 case TEMPLATE_PARM_INDEX
:
18357 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18358 if (error_operand_p (tparm
))
18359 return unify_invalid (explain_p
);
18361 if (TEMPLATE_PARM_LEVEL (parm
)
18362 != template_decl_level (tparm
))
18364 /* The PARM is not one we're trying to unify. Just check
18365 to see if it matches ARG. */
18366 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
18367 && cp_tree_equal (parm
, arg
));
18369 unify_expression_unequal (explain_p
, parm
, arg
);
18373 idx
= TEMPLATE_PARM_IDX (parm
);
18374 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18378 int x
= !cp_tree_equal (targ
, arg
);
18380 unify_inconsistency (explain_p
, parm
, targ
, arg
);
18384 /* [temp.deduct.type] If, in the declaration of a function template
18385 with a non-type template-parameter, the non-type
18386 template-parameter is used in an expression in the function
18387 parameter-list and, if the corresponding template-argument is
18388 deduced, the template-argument type shall match the type of the
18389 template-parameter exactly, except that a template-argument
18390 deduced from an array bound may be of any integral type.
18391 The non-type parameter might use already deduced type parameters. */
18392 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
18393 if (!TREE_TYPE (arg
))
18394 /* Template-parameter dependent expression. Just accept it for now.
18395 It will later be processed in convert_template_argument. */
18397 else if (same_type_p (TREE_TYPE (arg
), tparm
))
18399 else if ((strict
& UNIFY_ALLOW_INTEGER
)
18400 && CP_INTEGRAL_TYPE_P (tparm
))
18401 /* Convert the ARG to the type of PARM; the deduced non-type
18402 template argument must exactly match the types of the
18403 corresponding parameter. */
18404 arg
= fold (build_nop (tparm
, arg
));
18405 else if (uses_template_parms (tparm
))
18406 /* We haven't deduced the type of this parameter yet. Try again
18408 return unify_success (explain_p
);
18410 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
18412 /* If ARG is a parameter pack or an expansion, we cannot unify
18413 against it unless PARM is also a parameter pack. */
18414 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18415 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
18416 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18419 bool removed_attr
= false;
18420 arg
= strip_typedefs_expr (arg
, &removed_attr
);
18422 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18423 return unify_success (explain_p
);
18427 /* A pointer-to-member constant can be unified only with
18428 another constant. */
18429 if (TREE_CODE (arg
) != PTRMEM_CST
)
18430 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
18432 /* Just unify the class member. It would be useless (and possibly
18433 wrong, depending on the strict flags) to unify also
18434 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18435 arg refer to the same variable, even if through different
18436 classes. For instance:
18438 struct A { int x; };
18441 Unification of &A::x and &B::x must succeed. */
18442 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
18443 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
18448 if (!TYPE_PTR_P (arg
))
18449 return unify_type_mismatch (explain_p
, parm
, arg
);
18451 /* [temp.deduct.call]
18453 A can be another pointer or pointer to member type that can
18454 be converted to the deduced A via a qualification
18455 conversion (_conv.qual_).
18457 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18458 This will allow for additional cv-qualification of the
18459 pointed-to types if appropriate. */
18461 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
18462 /* The derived-to-base conversion only persists through one
18463 level of pointers. */
18464 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
18466 return unify (tparms
, targs
, TREE_TYPE (parm
),
18467 TREE_TYPE (arg
), strict
, explain_p
);
18470 case REFERENCE_TYPE
:
18471 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
18472 return unify_type_mismatch (explain_p
, parm
, arg
);
18473 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18474 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18477 if (TREE_CODE (arg
) != ARRAY_TYPE
)
18478 return unify_type_mismatch (explain_p
, parm
, arg
);
18479 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
18480 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
18481 return unify_type_mismatch (explain_p
, parm
, arg
);
18482 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18483 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18484 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
18485 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18486 TYPE_DOMAIN (arg
), explain_p
);
18487 return unify_success (explain_p
);
18494 case ENUMERAL_TYPE
:
18497 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18498 return unify_type_mismatch (explain_p
, parm
, arg
);
18500 /* We have already checked cv-qualification at the top of the
18502 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
18503 return unify_type_mismatch (explain_p
, parm
, arg
);
18505 /* As far as unification is concerned, this wins. Later checks
18506 will invalidate it if necessary. */
18507 return unify_success (explain_p
);
18509 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18510 /* Type INTEGER_CST can come from ordinary constant template args. */
18512 while (TREE_CODE (arg
) == NOP_EXPR
)
18513 arg
= TREE_OPERAND (arg
, 0);
18515 if (TREE_CODE (arg
) != INTEGER_CST
)
18516 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18517 return (tree_int_cst_equal (parm
, arg
)
18518 ? unify_success (explain_p
)
18519 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18523 int i
, len
, argslen
;
18524 int parm_variadic_p
= 0;
18526 if (TREE_CODE (arg
) != TREE_VEC
)
18527 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18529 len
= TREE_VEC_LENGTH (parm
);
18530 argslen
= TREE_VEC_LENGTH (arg
);
18532 /* Check for pack expansions in the parameters. */
18533 for (i
= 0; i
< len
; ++i
)
18535 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18538 /* We can unify against something with a trailing
18540 parm_variadic_p
= 1;
18542 /* [temp.deduct.type]/9: If the template argument list of
18543 P contains a pack expansion that is not the last
18544 template argument, the entire template argument list
18545 is a non-deduced context. */
18546 return unify_success (explain_p
);
18550 /* If we don't have enough arguments to satisfy the parameters
18551 (not counting the pack expression at the end), or we have
18552 too many arguments for a parameter list that doesn't end in
18553 a pack expression, we can't unify. */
18554 if (parm_variadic_p
18555 ? argslen
< len
- parm_variadic_p
18557 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18559 /* Unify all of the parameters that precede the (optional)
18560 pack expression. */
18561 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18563 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18564 TREE_VEC_ELT (parm
, i
),
18565 TREE_VEC_ELT (arg
, i
),
18566 UNIFY_ALLOW_NONE
, explain_p
);
18568 if (parm_variadic_p
)
18569 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18571 /*subr=*/true, explain_p
);
18572 return unify_success (explain_p
);
18577 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18578 return unify_type_mismatch (explain_p
, parm
, arg
);
18580 if (TYPE_PTRMEMFUNC_P (parm
))
18582 if (!TYPE_PTRMEMFUNC_P (arg
))
18583 return unify_type_mismatch (explain_p
, parm
, arg
);
18585 return unify (tparms
, targs
,
18586 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18587 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18588 strict
, explain_p
);
18590 else if (TYPE_PTRMEMFUNC_P (arg
))
18591 return unify_type_mismatch (explain_p
, parm
, arg
);
18593 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18595 tree t
= NULL_TREE
;
18597 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18599 /* First, we try to unify the PARM and ARG directly. */
18600 t
= try_class_unification (tparms
, targs
,
18601 parm
, arg
, explain_p
);
18605 /* Fallback to the special case allowed in
18606 [temp.deduct.call]:
18608 If P is a class, and P has the form
18609 template-id, then A can be a derived class of
18610 the deduced A. Likewise, if P is a pointer to
18611 a class of the form template-id, A can be a
18612 pointer to a derived class pointed to by the
18614 enum template_base_result r
;
18615 r
= get_template_base (tparms
, targs
, parm
, arg
,
18619 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18622 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18623 && (CLASSTYPE_TI_TEMPLATE (parm
)
18624 == CLASSTYPE_TI_TEMPLATE (arg
)))
18625 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18626 Then, we should unify `int' and `U'. */
18629 /* There's no chance of unification succeeding. */
18630 return unify_type_mismatch (explain_p
, parm
, arg
);
18632 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18633 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18635 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18636 return unify_type_mismatch (explain_p
, parm
, arg
);
18637 return unify_success (explain_p
);
18640 case FUNCTION_TYPE
:
18642 unsigned int nargs
;
18647 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18648 return unify_type_mismatch (explain_p
, parm
, arg
);
18650 /* CV qualifications for methods can never be deduced, they must
18651 match exactly. We need to check them explicitly here,
18652 because type_unification_real treats them as any other
18653 cv-qualified parameter. */
18654 if (TREE_CODE (parm
) == METHOD_TYPE
18655 && (!check_cv_quals_for_unify
18657 class_of_this_parm (arg
),
18658 class_of_this_parm (parm
))))
18659 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18661 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18662 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18664 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18665 args
= XALLOCAVEC (tree
, nargs
);
18666 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18667 a
!= NULL_TREE
&& a
!= void_list_node
;
18668 a
= TREE_CHAIN (a
), ++i
)
18669 args
[i
] = TREE_VALUE (a
);
18672 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18673 args
, nargs
, 1, DEDUCE_EXACT
,
18674 LOOKUP_NORMAL
, NULL
, explain_p
);
18678 /* Unify a pointer to member with a pointer to member function, which
18679 deduces the type of the member as a function type. */
18680 if (TYPE_PTRMEMFUNC_P (arg
))
18682 /* Check top-level cv qualifiers */
18683 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18684 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18686 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18687 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18688 UNIFY_ALLOW_NONE
, explain_p
);
18690 /* Determine the type of the function we are unifying against. */
18691 tree fntype
= static_fn_type (arg
);
18693 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18696 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18697 return unify_type_mismatch (explain_p
, parm
, arg
);
18698 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18699 TYPE_OFFSET_BASETYPE (arg
),
18700 UNIFY_ALLOW_NONE
, explain_p
);
18701 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18702 strict
, explain_p
);
18705 if (DECL_TEMPLATE_PARM_P (parm
))
18706 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18707 if (arg
!= scalar_constant_value (parm
))
18708 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18709 return unify_success (explain_p
);
18712 case TEMPLATE_DECL
:
18713 /* Matched cases are handled by the ARG == PARM test above. */
18714 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18717 /* A non-type template parameter that is a variable should be a
18718 an integral constant, in which case, it whould have been
18719 folded into its (constant) value. So we should not be getting
18720 a variable here. */
18721 gcc_unreachable ();
18723 case TYPE_ARGUMENT_PACK
:
18724 case NONTYPE_ARGUMENT_PACK
:
18725 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18726 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18729 case DECLTYPE_TYPE
:
18730 case UNDERLYING_TYPE
:
18731 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18732 or UNDERLYING_TYPE nodes. */
18733 return unify_success (explain_p
);
18736 /* Unification fails if we hit an error node. */
18737 return unify_invalid (explain_p
);
18740 if (REFERENCE_REF_P (parm
))
18742 if (REFERENCE_REF_P (arg
))
18743 arg
= TREE_OPERAND (arg
, 0);
18744 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18745 strict
, explain_p
);
18750 /* An unresolved overload is a nondeduced context. */
18751 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18752 return unify_success (explain_p
);
18753 gcc_assert (EXPR_P (parm
));
18755 /* We must be looking at an expression. This can happen with
18759 void foo(S<I>, S<I + 2>);
18761 This is a "nondeduced context":
18765 The nondeduced contexts are:
18767 --A type that is a template-id in which one or more of
18768 the template-arguments is an expression that references
18769 a template-parameter.
18771 In these cases, we assume deduction succeeded, but don't
18772 actually infer any unifications. */
18774 if (!uses_template_parms (parm
)
18775 && !template_args_equal (parm
, arg
))
18776 return unify_expression_unequal (explain_p
, parm
, arg
);
18778 return unify_success (explain_p
);
18781 #undef RECUR_AND_CHECK_FAILURE
18783 /* Note that DECL can be defined in this translation unit, if
18787 mark_definable (tree decl
)
18790 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18791 FOR_EACH_CLONE (clone
, decl
)
18792 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18795 /* Called if RESULT is explicitly instantiated, or is a member of an
18796 explicitly instantiated class. */
18799 mark_decl_instantiated (tree result
, int extern_p
)
18801 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18803 /* If this entity has already been written out, it's too late to
18804 make any modifications. */
18805 if (TREE_ASM_WRITTEN (result
))
18808 /* For anonymous namespace we don't need to do anything. */
18809 if (decl_anon_ns_mem_p (result
))
18811 gcc_assert (!TREE_PUBLIC (result
));
18815 if (TREE_CODE (result
) != FUNCTION_DECL
)
18816 /* The TREE_PUBLIC flag for function declarations will have been
18817 set correctly by tsubst. */
18818 TREE_PUBLIC (result
) = 1;
18820 /* This might have been set by an earlier implicit instantiation. */
18821 DECL_COMDAT (result
) = 0;
18824 DECL_NOT_REALLY_EXTERN (result
) = 0;
18827 mark_definable (result
);
18828 mark_needed (result
);
18829 /* Always make artificials weak. */
18830 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18831 comdat_linkage (result
);
18832 /* For WIN32 we also want to put explicit instantiations in
18833 linkonce sections. */
18834 else if (TREE_PUBLIC (result
))
18835 maybe_make_one_only (result
);
18838 /* If EXTERN_P, then this function will not be emitted -- unless
18839 followed by an explicit instantiation, at which point its linkage
18840 will be adjusted. If !EXTERN_P, then this function will be
18841 emitted here. In neither circumstance do we want
18842 import_export_decl to adjust the linkage. */
18843 DECL_INTERFACE_KNOWN (result
) = 1;
18846 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18847 important template arguments. If any are missing, we check whether
18848 they're important by using error_mark_node for substituting into any
18849 args that were used for partial ordering (the ones between ARGS and END)
18850 and seeing if it bubbles up. */
18853 check_undeduced_parms (tree targs
, tree args
, tree end
)
18855 bool found
= false;
18857 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18858 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18861 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18865 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18866 if (substed
== error_mark_node
)
18872 /* Given two function templates PAT1 and PAT2, return:
18874 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18875 -1 if PAT2 is more specialized than PAT1.
18876 0 if neither is more specialized.
18878 LEN indicates the number of parameters we should consider
18879 (defaulted parameters should not be considered).
18881 The 1998 std underspecified function template partial ordering, and
18882 DR214 addresses the issue. We take pairs of arguments, one from
18883 each of the templates, and deduce them against each other. One of
18884 the templates will be more specialized if all the *other*
18885 template's arguments deduce against its arguments and at least one
18886 of its arguments *does* *not* deduce against the other template's
18887 corresponding argument. Deduction is done as for class templates.
18888 The arguments used in deduction have reference and top level cv
18889 qualifiers removed. Iff both arguments were originally reference
18890 types *and* deduction succeeds in both directions, an lvalue reference
18891 wins against an rvalue reference and otherwise the template
18892 with the more cv-qualified argument wins for that pairing (if
18893 neither is more cv-qualified, they both are equal). Unlike regular
18894 deduction, after all the arguments have been deduced in this way,
18895 we do *not* verify the deduced template argument values can be
18896 substituted into non-deduced contexts.
18898 The logic can be a bit confusing here, because we look at deduce1 and
18899 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18900 can find template arguments for pat1 to make arg1 look like arg2, that
18901 means that arg2 is at least as specialized as arg1. */
18904 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18906 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18907 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18908 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18909 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18910 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18911 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18912 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18913 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18914 tree origs1
, origs2
;
18915 bool lose1
= false;
18916 bool lose2
= false;
18918 /* Remove the this parameter from non-static member functions. If
18919 one is a non-static member function and the other is not a static
18920 member function, remove the first parameter from that function
18921 also. This situation occurs for operator functions where we
18922 locate both a member function (with this pointer) and non-member
18923 operator (with explicit first operand). */
18924 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18926 len
--; /* LEN is the number of significant arguments for DECL1 */
18927 args1
= TREE_CHAIN (args1
);
18928 if (!DECL_STATIC_FUNCTION_P (decl2
))
18929 args2
= TREE_CHAIN (args2
);
18931 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18933 args2
= TREE_CHAIN (args2
);
18934 if (!DECL_STATIC_FUNCTION_P (decl1
))
18937 args1
= TREE_CHAIN (args1
);
18941 /* If only one is a conversion operator, they are unordered. */
18942 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18945 /* Consider the return type for a conversion function */
18946 if (DECL_CONV_FN_P (decl1
))
18948 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18949 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18953 processing_template_decl
++;
18959 /* Stop when an ellipsis is seen. */
18960 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18962 tree arg1
= TREE_VALUE (args1
);
18963 tree arg2
= TREE_VALUE (args2
);
18964 int deduce1
, deduce2
;
18970 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18971 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18973 /* When both arguments are pack expansions, we need only
18974 unify the patterns themselves. */
18975 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18976 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18978 /* This is the last comparison we need to do. */
18982 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18984 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18985 arg1
= TREE_TYPE (arg1
);
18986 quals1
= cp_type_quals (arg1
);
18989 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18991 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18992 arg2
= TREE_TYPE (arg2
);
18993 quals2
= cp_type_quals (arg2
);
18996 arg1
= TYPE_MAIN_VARIANT (arg1
);
18997 arg2
= TYPE_MAIN_VARIANT (arg2
);
18999 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
19001 int i
, len2
= list_length (args2
);
19002 tree parmvec
= make_tree_vec (1);
19003 tree argvec
= make_tree_vec (len2
);
19006 /* Setup the parameter vector, which contains only ARG1. */
19007 TREE_VEC_ELT (parmvec
, 0) = arg1
;
19009 /* Setup the argument vector, which contains the remaining
19011 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
19012 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
19014 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
19015 argvec
, DEDUCE_EXACT
,
19016 /*subr=*/true, /*explain_p=*/false)
19019 /* We cannot deduce in the other direction, because ARG1 is
19020 a pack expansion but ARG2 is not. */
19023 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
19025 int i
, len1
= list_length (args1
);
19026 tree parmvec
= make_tree_vec (1);
19027 tree argvec
= make_tree_vec (len1
);
19030 /* Setup the parameter vector, which contains only ARG1. */
19031 TREE_VEC_ELT (parmvec
, 0) = arg2
;
19033 /* Setup the argument vector, which contains the remaining
19035 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
19036 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
19038 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
19039 argvec
, DEDUCE_EXACT
,
19040 /*subr=*/true, /*explain_p=*/false)
19043 /* We cannot deduce in the other direction, because ARG2 is
19044 a pack expansion but ARG1 is not.*/
19050 /* The normal case, where neither argument is a pack
19052 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
19053 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
19055 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
19056 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
19060 /* If we couldn't deduce arguments for tparms1 to make arg1 match
19061 arg2, then arg2 is not as specialized as arg1. */
19067 /* "If, for a given type, deduction succeeds in both directions
19068 (i.e., the types are identical after the transformations above)
19069 and both P and A were reference types (before being replaced with
19070 the type referred to above):
19071 - if the type from the argument template was an lvalue reference and
19072 the type from the parameter template was not, the argument type is
19073 considered to be more specialized than the other; otherwise,
19074 - if the type from the argument template is more cv-qualified
19075 than the type from the parameter template (as described above),
19076 the argument type is considered to be more specialized than the other;
19078 - neither type is more specialized than the other." */
19080 if (deduce1
&& deduce2
)
19082 if (ref1
&& ref2
&& ref1
!= ref2
)
19089 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
19091 if ((quals1
& quals2
) == quals2
)
19093 if ((quals1
& quals2
) == quals1
)
19098 if (lose1
&& lose2
)
19099 /* We've failed to deduce something in either direction.
19100 These must be unordered. */
19103 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
19104 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
19105 /* We have already processed all of the arguments in our
19106 handing of the pack expansion type. */
19109 args1
= TREE_CHAIN (args1
);
19110 args2
= TREE_CHAIN (args2
);
19113 /* "In most cases, all template parameters must have values in order for
19114 deduction to succeed, but for partial ordering purposes a template
19115 parameter may remain without a value provided it is not used in the
19116 types being used for partial ordering."
19118 Thus, if we are missing any of the targs1 we need to substitute into
19119 origs1, then pat2 is not as specialized as pat1. This can happen when
19120 there is a nondeduced context. */
19121 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
19123 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
19126 processing_template_decl
--;
19128 /* All things being equal, if the next argument is a pack expansion
19129 for one function but not for the other, prefer the
19130 non-variadic function. FIXME this is bogus; see c++/41958. */
19132 && args1
&& TREE_VALUE (args1
)
19133 && args2
&& TREE_VALUE (args2
))
19135 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
19136 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
19139 if (lose1
== lose2
)
19147 /* Determine which of two partial specializations of TMPL is more
19150 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
19151 to the first partial specialization. The TREE_PURPOSE is the
19152 innermost set of template parameters for the partial
19153 specialization. PAT2 is similar, but for the second template.
19155 Return 1 if the first partial specialization is more specialized;
19156 -1 if the second is more specialized; 0 if neither is more
19159 See [temp.class.order] for information about determining which of
19160 two templates is more specialized. */
19163 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
19167 bool any_deductions
= false;
19169 tree tmpl1
= TREE_VALUE (pat1
);
19170 tree tmpl2
= TREE_VALUE (pat2
);
19171 tree parms1
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl1
);
19172 tree parms2
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl2
);
19173 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
19174 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
19176 /* Just like what happens for functions, if we are ordering between
19177 different template specializations, we may encounter dependent
19178 types in the arguments, and we need our dependency check functions
19179 to behave correctly. */
19180 ++processing_template_decl
;
19181 targs
= get_partial_spec_bindings (tmpl
, parms1
, specargs1
, specargs2
);
19185 any_deductions
= true;
19188 targs
= get_partial_spec_bindings (tmpl
, parms2
, specargs2
, specargs1
);
19192 any_deductions
= true;
19194 --processing_template_decl
;
19196 /* In the case of a tie where at least one of the templates
19197 has a parameter pack at the end, the template with the most
19198 non-packed parameters wins. */
19201 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
19202 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
19204 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
19205 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
19206 int len1
= TREE_VEC_LENGTH (args1
);
19207 int len2
= TREE_VEC_LENGTH (args2
);
19209 /* We don't count the pack expansion at the end. */
19210 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
19212 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
19217 else if (len1
< len2
)
19224 /* Return the template arguments that will produce the function signature
19225 DECL from the function template FN, with the explicit template
19226 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
19227 also match. Return NULL_TREE if no satisfactory arguments could be
19231 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
19233 int ntparms
= DECL_NTPARMS (fn
);
19234 tree targs
= make_tree_vec (ntparms
);
19235 tree decl_type
= TREE_TYPE (decl
);
19236 tree decl_arg_types
;
19238 unsigned int nargs
, ix
;
19241 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
19243 /* Never do unification on the 'this' parameter. */
19244 decl_arg_types
= skip_artificial_parms_for (decl
,
19245 TYPE_ARG_TYPES (decl_type
));
19247 nargs
= list_length (decl_arg_types
);
19248 args
= XALLOCAVEC (tree
, nargs
);
19249 for (arg
= decl_arg_types
, ix
= 0;
19250 arg
!= NULL_TREE
&& arg
!= void_list_node
;
19251 arg
= TREE_CHAIN (arg
), ++ix
)
19252 args
[ix
] = TREE_VALUE (arg
);
19254 if (fn_type_unification (fn
, explicit_args
, targs
,
19256 (check_rettype
|| DECL_CONV_FN_P (fn
)
19257 ? TREE_TYPE (decl_type
) : NULL_TREE
),
19258 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
19260 == error_mark_node
)
19266 /* Return the innermost template arguments that, when applied to a partial
19267 specialization of TMPL whose innermost template parameters are
19268 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
19271 For example, suppose we have:
19273 template <class T, class U> struct S {};
19274 template <class T> struct S<T*, int> {};
19276 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
19277 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
19278 int}. The resulting vector will be {double}, indicating that `T'
19279 is bound to `double'. */
19282 get_partial_spec_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
19284 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
19286 tree innermost_deduced_args
;
19288 innermost_deduced_args
= make_tree_vec (ntparms
);
19289 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19291 deduced_args
= copy_node (args
);
19292 SET_TMPL_ARGS_LEVEL (deduced_args
,
19293 TMPL_ARGS_DEPTH (deduced_args
),
19294 innermost_deduced_args
);
19297 deduced_args
= innermost_deduced_args
;
19299 if (unify (tparms
, deduced_args
,
19300 INNERMOST_TEMPLATE_ARGS (spec_args
),
19301 INNERMOST_TEMPLATE_ARGS (args
),
19302 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
19305 for (i
= 0; i
< ntparms
; ++i
)
19306 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
19309 /* Verify that nondeduced template arguments agree with the type
19310 obtained from argument deduction.
19314 struct A { typedef int X; };
19315 template <class T, class U> struct C {};
19316 template <class T> struct C<T, typename T::X> {};
19318 Then with the instantiation `C<A, int>', we can deduce that
19319 `T' is `A' but unify () does not check whether `typename T::X'
19321 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
19322 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19324 tf_none
, false, false);
19325 if (spec_args
== error_mark_node
19326 /* We only need to check the innermost arguments; the other
19327 arguments will always agree. */
19328 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
19329 INNERMOST_TEMPLATE_ARGS (args
)))
19332 /* Now that we have bindings for all of the template arguments,
19333 ensure that the arguments deduced for the template template
19334 parameters have compatible template parameter lists. See the use
19335 of template_template_parm_bindings_ok_p in fn_type_unification
19336 for more information. */
19337 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
19340 return deduced_args
;
19343 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19344 Return the TREE_LIST node with the most specialized template, if
19345 any. If there is no most specialized template, the error_mark_node
19348 Note that this function does not look at, or modify, the
19349 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19350 returned is one of the elements of INSTANTIATIONS, callers may
19351 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19352 and retrieve it from the value returned. */
19355 most_specialized_instantiation (tree templates
)
19359 ++processing_template_decl
;
19362 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
19366 if (get_bindings (TREE_VALUE (champ
),
19367 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19368 NULL_TREE
, /*check_ret=*/true))
19371 if (get_bindings (TREE_VALUE (fn
),
19372 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19373 NULL_TREE
, /*check_ret=*/true))
19380 /* Equally specialized, move to next function. If there
19381 is no next function, nothing's most specialized. */
19382 fn
= TREE_CHAIN (fn
);
19390 /* Now verify that champ is better than everything earlier in the
19391 instantiation list. */
19392 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
19393 if (get_bindings (TREE_VALUE (champ
),
19394 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19395 NULL_TREE
, /*check_ret=*/true)
19396 || !get_bindings (TREE_VALUE (fn
),
19397 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19398 NULL_TREE
, /*check_ret=*/true))
19404 processing_template_decl
--;
19407 return error_mark_node
;
19412 /* If DECL is a specialization of some template, return the most
19413 general such template. Otherwise, returns NULL_TREE.
19415 For example, given:
19417 template <class T> struct S { template <class U> void f(U); };
19419 if TMPL is `template <class U> void S<int>::f(U)' this will return
19420 the full template. This function will not trace past partial
19421 specializations, however. For example, given in addition:
19423 template <class T> struct S<T*> { template <class U> void f(U); };
19425 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19426 `template <class T> template <class U> S<T*>::f(U)'. */
19429 most_general_template (tree decl
)
19431 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19433 if (tree tinfo
= get_template_info (decl
))
19434 decl
= TI_TEMPLATE (tinfo
);
19435 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19436 template friend, or a FIELD_DECL for a capture pack. */
19437 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19441 /* Look for more and more general templates. */
19442 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
19444 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19445 (See cp-tree.h for details.) */
19446 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
19449 if (CLASS_TYPE_P (TREE_TYPE (decl
))
19450 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
19451 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
19454 /* Stop if we run into an explicitly specialized class template. */
19455 if (!DECL_NAMESPACE_SCOPE_P (decl
)
19456 && DECL_CONTEXT (decl
)
19457 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
19460 decl
= DECL_TI_TEMPLATE (decl
);
19466 /* Return the most specialized of the template partial specializations
19467 which can produce TARGET, a specialization of some class or variable
19468 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
19469 a TEMPLATE_DECL node corresponding to the partial specialization, while
19470 the TREE_PURPOSE is the set of template arguments that must be
19471 substituted into the template pattern in order to generate TARGET.
19473 If the choice of partial specialization is ambiguous, a diagnostic
19474 is issued, and the error_mark_node is returned. If there are no
19475 partial specializations matching TARGET, then NULL_TREE is
19476 returned, indicating that the primary template should be used. */
19479 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
19481 tree list
= NULL_TREE
;
19486 tree outer_args
= NULL_TREE
;
19489 if (TYPE_P (target
))
19491 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
19492 tmpl
= TI_TEMPLATE (tinfo
);
19493 args
= TI_ARGS (tinfo
);
19495 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
19497 tmpl
= TREE_OPERAND (target
, 0);
19498 args
= TREE_OPERAND (target
, 1);
19500 else if (VAR_P (target
))
19502 tree tinfo
= DECL_TEMPLATE_INFO (target
);
19503 tmpl
= TI_TEMPLATE (tinfo
);
19504 args
= TI_ARGS (tinfo
);
19507 gcc_unreachable ();
19509 tree main_tmpl
= most_general_template (tmpl
);
19511 /* For determining which partial specialization to use, only the
19512 innermost args are interesting. */
19513 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19515 outer_args
= strip_innermost_template_args (args
, 1);
19516 args
= INNERMOST_TEMPLATE_ARGS (args
);
19519 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
19521 tree partial_spec_args
;
19523 tree spec_tmpl
= TREE_VALUE (t
);
19525 partial_spec_args
= TREE_PURPOSE (t
);
19527 ++processing_template_decl
;
19531 /* Discard the outer levels of args, and then substitute in the
19532 template args from the enclosing class. */
19533 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19534 partial_spec_args
= tsubst_template_args
19535 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19537 /* And the same for the partial specialization TEMPLATE_DECL. */
19538 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19541 partial_spec_args
=
19542 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19545 /*require_all_args=*/true,
19546 /*use_default_args=*/true);
19548 --processing_template_decl
;
19550 if (partial_spec_args
== error_mark_node
)
19551 return error_mark_node
;
19552 if (spec_tmpl
== error_mark_node
)
19553 return error_mark_node
;
19555 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19556 spec_args
= get_partial_spec_bindings (tmpl
, parms
,
19562 spec_args
= add_to_template_args (outer_args
, spec_args
);
19563 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
19564 TREE_TYPE (list
) = TREE_TYPE (t
);
19571 ambiguous_p
= false;
19574 t
= TREE_CHAIN (t
);
19575 for (; t
; t
= TREE_CHAIN (t
))
19577 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19584 t
= TREE_CHAIN (t
);
19587 ambiguous_p
= true;
19596 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19598 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19601 ambiguous_p
= true;
19609 char *spaces
= NULL
;
19610 if (!(complain
& tf_error
))
19611 return error_mark_node
;
19612 if (TYPE_P (target
))
19613 error ("ambiguous template instantiation for %q#T", target
);
19615 error ("ambiguous template instantiation for %q#D", target
);
19616 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19617 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19619 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
19620 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
19621 "%s %#S", spaces
? spaces
: str
, subst
);
19622 spaces
= spaces
? spaces
: get_spaces (str
);
19625 return error_mark_node
;
19631 /* Explicitly instantiate DECL. */
19634 do_decl_instantiation (tree decl
, tree storage
)
19636 tree result
= NULL_TREE
;
19639 if (!decl
|| decl
== error_mark_node
)
19640 /* An error occurred, for which grokdeclarator has already issued
19641 an appropriate message. */
19643 else if (! DECL_LANG_SPECIFIC (decl
))
19645 error ("explicit instantiation of non-template %q#D", decl
);
19649 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
19650 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
19652 if (VAR_P (decl
) && !var_templ
)
19654 /* There is an asymmetry here in the way VAR_DECLs and
19655 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19656 the latter, the DECL we get back will be marked as a
19657 template instantiation, and the appropriate
19658 DECL_TEMPLATE_INFO will be set up. This does not happen for
19659 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19660 should handle VAR_DECLs as it currently handles
19662 if (!DECL_CLASS_SCOPE_P (decl
))
19664 error ("%qD is not a static data member of a class template", decl
);
19667 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19668 if (!result
|| !VAR_P (result
))
19670 error ("no matching template for %qD found", decl
);
19673 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19675 error ("type %qT for explicit instantiation %qD does not match "
19676 "declared type %qT", TREE_TYPE (result
), decl
,
19681 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
19683 error ("explicit instantiation of %q#D", decl
);
19689 /* Check for various error cases. Note that if the explicit
19690 instantiation is valid the RESULT will currently be marked as an
19691 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19692 until we get here. */
19694 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19696 /* DR 259 [temp.spec].
19698 Both an explicit instantiation and a declaration of an explicit
19699 specialization shall not appear in a program unless the explicit
19700 instantiation follows a declaration of the explicit specialization.
19702 For a given set of template parameters, if an explicit
19703 instantiation of a template appears after a declaration of an
19704 explicit specialization for that template, the explicit
19705 instantiation has no effect. */
19708 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19712 No program shall explicitly instantiate any template more
19715 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19716 the first instantiation was `extern' and the second is not,
19717 and EXTERN_P for the opposite case. */
19718 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19719 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19720 /* If an "extern" explicit instantiation follows an ordinary
19721 explicit instantiation, the template is instantiated. */
19725 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19727 error ("no matching template for %qD found", result
);
19730 else if (!DECL_TEMPLATE_INFO (result
))
19732 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19736 if (storage
== NULL_TREE
)
19738 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19740 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19741 pedwarn (input_location
, OPT_Wpedantic
,
19742 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19747 error ("storage class %qD applied to template instantiation", storage
);
19749 check_explicit_instantiation_namespace (result
);
19750 mark_decl_instantiated (result
, extern_p
);
19752 instantiate_decl (result
, /*defer_ok=*/1,
19753 /*expl_inst_class_mem_p=*/false);
19757 mark_class_instantiated (tree t
, int extern_p
)
19759 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19760 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19761 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19762 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19765 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19766 rest_of_type_compilation (t
, 1);
19770 /* Called from do_type_instantiation through binding_table_foreach to
19771 do recursive instantiation for the type bound in ENTRY. */
19773 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19775 tree storage
= *(tree
*) data
;
19777 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19778 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19779 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19782 /* Called from do_type_instantiation to instantiate a member
19783 (a member function or a static member variable) of an
19784 explicitly instantiated class template. */
19786 instantiate_class_member (tree decl
, int extern_p
)
19788 mark_decl_instantiated (decl
, extern_p
);
19790 instantiate_decl (decl
, /*defer_ok=*/1,
19791 /*expl_inst_class_mem_p=*/true);
19794 /* Perform an explicit instantiation of template class T. STORAGE, if
19795 non-null, is the RID for extern, inline or static. COMPLAIN is
19796 nonzero if this is called from the parser, zero if called recursively,
19797 since the standard is unclear (as detailed below). */
19800 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19805 int previous_instantiation_extern_p
= 0;
19807 if (TREE_CODE (t
) == TYPE_DECL
)
19810 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19813 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19815 error ("explicit instantiation of non-class template %qD", tmpl
);
19817 error ("explicit instantiation of non-template type %qT", t
);
19823 if (!COMPLETE_TYPE_P (t
))
19825 if (complain
& tf_error
)
19826 error ("explicit instantiation of %q#T before definition of template",
19831 if (storage
!= NULL_TREE
)
19833 if (!in_system_header_at (input_location
))
19835 if (storage
== ridpointers
[(int) RID_EXTERN
])
19837 if (cxx_dialect
== cxx98
)
19838 pedwarn (input_location
, OPT_Wpedantic
,
19839 "ISO C++ 1998 forbids the use of %<extern%> on "
19840 "explicit instantiations");
19843 pedwarn (input_location
, OPT_Wpedantic
,
19844 "ISO C++ forbids the use of %qE"
19845 " on explicit instantiations", storage
);
19848 if (storage
== ridpointers
[(int) RID_INLINE
])
19850 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19852 else if (storage
== ridpointers
[(int) RID_STATIC
])
19856 error ("storage class %qD applied to template instantiation",
19862 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19864 /* DR 259 [temp.spec].
19866 Both an explicit instantiation and a declaration of an explicit
19867 specialization shall not appear in a program unless the explicit
19868 instantiation follows a declaration of the explicit specialization.
19870 For a given set of template parameters, if an explicit
19871 instantiation of a template appears after a declaration of an
19872 explicit specialization for that template, the explicit
19873 instantiation has no effect. */
19876 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19880 No program shall explicitly instantiate any template more
19883 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19884 instantiation was `extern'. If EXTERN_P then the second is.
19885 These cases are OK. */
19886 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19888 if (!previous_instantiation_extern_p
&& !extern_p
19889 && (complain
& tf_error
))
19890 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19892 /* If we've already instantiated the template, just return now. */
19893 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19897 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19898 mark_class_instantiated (t
, extern_p
);
19906 /* In contrast to implicit instantiation, where only the
19907 declarations, and not the definitions, of members are
19908 instantiated, we have here:
19912 The explicit instantiation of a class template specialization
19913 implies the instantiation of all of its members not
19914 previously explicitly specialized in the translation unit
19915 containing the explicit instantiation.
19917 Of course, we can't instantiate member template classes, since
19918 we don't have any arguments for them. Note that the standard
19919 is unclear on whether the instantiation of the members are
19920 *explicit* instantiations or not. However, the most natural
19921 interpretation is that it should be an explicit instantiation. */
19924 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19925 if (TREE_CODE (tmp
) == FUNCTION_DECL
19926 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19927 instantiate_class_member (tmp
, extern_p
);
19929 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19930 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19931 instantiate_class_member (tmp
, extern_p
);
19933 if (CLASSTYPE_NESTED_UTDS (t
))
19934 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19935 bt_instantiate_type_proc
, &storage
);
19939 /* Given a function DECL, which is a specialization of TMPL, modify
19940 DECL to be a re-instantiation of TMPL with the same template
19941 arguments. TMPL should be the template into which tsubst'ing
19942 should occur for DECL, not the most general template.
19944 One reason for doing this is a scenario like this:
19947 void f(const T&, int i);
19949 void g() { f(3, 7); }
19952 void f(const T& t, const int i) { }
19954 Note that when the template is first instantiated, with
19955 instantiate_template, the resulting DECL will have no name for the
19956 first parameter, and the wrong type for the second. So, when we go
19957 to instantiate the DECL, we regenerate it. */
19960 regenerate_decl_from_template (tree decl
, tree tmpl
)
19962 /* The arguments used to instantiate DECL, from the most general
19967 args
= DECL_TI_ARGS (decl
);
19968 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19970 /* Make sure that we can see identifiers, and compute access
19972 push_access_scope (decl
);
19974 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19982 args_depth
= TMPL_ARGS_DEPTH (args
);
19983 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19984 if (args_depth
> parms_depth
)
19985 args
= get_innermost_template_args (args
, parms_depth
);
19987 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19988 args
, tf_error
, NULL_TREE
,
19989 /*defer_ok*/false);
19990 if (specs
&& specs
!= error_mark_node
)
19991 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19994 /* Merge parameter declarations. */
19995 decl_parm
= skip_artificial_parms_for (decl
,
19996 DECL_ARGUMENTS (decl
));
19998 = skip_artificial_parms_for (code_pattern
,
19999 DECL_ARGUMENTS (code_pattern
));
20000 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
20005 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
20006 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
20007 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
20009 parm_type
= type_decays_to (parm_type
);
20010 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
20011 TREE_TYPE (decl_parm
) = parm_type
;
20012 attributes
= DECL_ATTRIBUTES (pattern_parm
);
20013 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
20015 DECL_ATTRIBUTES (decl_parm
) = attributes
;
20016 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
20018 decl_parm
= DECL_CHAIN (decl_parm
);
20019 pattern_parm
= DECL_CHAIN (pattern_parm
);
20021 /* Merge any parameters that match with the function parameter
20023 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
20026 tree expanded_types
;
20027 /* Expand the TYPE_PACK_EXPANSION that provides the types for
20028 the parameters in this function parameter pack. */
20029 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
20030 args
, tf_error
, NULL_TREE
);
20031 len
= TREE_VEC_LENGTH (expanded_types
);
20032 for (i
= 0; i
< len
; i
++)
20037 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
20038 /* Rename the parameter to include the index. */
20039 DECL_NAME (decl_parm
) =
20040 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
20041 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
20042 parm_type
= type_decays_to (parm_type
);
20043 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
20044 TREE_TYPE (decl_parm
) = parm_type
;
20045 attributes
= DECL_ATTRIBUTES (pattern_parm
);
20046 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
20048 DECL_ATTRIBUTES (decl_parm
) = attributes
;
20049 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
20051 decl_parm
= DECL_CHAIN (decl_parm
);
20054 /* Merge additional specifiers from the CODE_PATTERN. */
20055 if (DECL_DECLARED_INLINE_P (code_pattern
)
20056 && !DECL_DECLARED_INLINE_P (decl
))
20057 DECL_DECLARED_INLINE_P (decl
) = 1;
20059 else if (VAR_P (decl
))
20061 DECL_INITIAL (decl
) =
20062 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
20063 tf_error
, DECL_TI_TEMPLATE (decl
),
20064 /*integral_constant_expression_p=*/false);
20065 if (VAR_HAD_UNKNOWN_BOUND (decl
))
20066 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
20067 tf_error
, DECL_TI_TEMPLATE (decl
));
20070 gcc_unreachable ();
20072 pop_access_scope (decl
);
20075 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
20076 substituted to get DECL. */
20079 template_for_substitution (tree decl
)
20081 tree tmpl
= DECL_TI_TEMPLATE (decl
);
20083 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
20084 for the instantiation. This is not always the most general
20085 template. Consider, for example:
20088 struct S { template <class U> void f();
20089 template <> void f<int>(); };
20091 and an instantiation of S<double>::f<int>. We want TD to be the
20092 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
20093 while (/* An instantiation cannot have a definition, so we need a
20094 more general template. */
20095 DECL_TEMPLATE_INSTANTIATION (tmpl
)
20096 /* We must also deal with friend templates. Given:
20098 template <class T> struct S {
20099 template <class U> friend void f() {};
20102 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
20103 so far as the language is concerned, but that's still
20104 where we get the pattern for the instantiation from. On
20105 other hand, if the definition comes outside the class, say:
20107 template <class T> struct S {
20108 template <class U> friend void f();
20110 template <class U> friend void f() {}
20112 we don't need to look any further. That's what the check for
20113 DECL_INITIAL is for. */
20114 || (TREE_CODE (decl
) == FUNCTION_DECL
20115 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
20116 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
20118 /* The present template, TD, should not be a definition. If it
20119 were a definition, we should be using it! Note that we
20120 cannot restructure the loop to just keep going until we find
20121 a template with a definition, since that might go too far if
20122 a specialization was declared, but not defined. */
20124 /* Fetch the more general template. */
20125 tmpl
= DECL_TI_TEMPLATE (tmpl
);
20131 /* Returns true if we need to instantiate this template instance even if we
20132 know we aren't going to emit it.. */
20135 always_instantiate_p (tree decl
)
20137 /* We always instantiate inline functions so that we can inline them. An
20138 explicit instantiation declaration prohibits implicit instantiation of
20139 non-inline functions. With high levels of optimization, we would
20140 normally inline non-inline functions -- but we're not allowed to do
20141 that for "extern template" functions. Therefore, we check
20142 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
20143 return ((TREE_CODE (decl
) == FUNCTION_DECL
20144 && (DECL_DECLARED_INLINE_P (decl
)
20145 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
20146 /* And we need to instantiate static data members so that
20147 their initializers are available in integral constant
20150 && decl_maybe_constant_var_p (decl
)));
20153 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
20154 instantiate it now, modifying TREE_TYPE (fn). */
20157 maybe_instantiate_noexcept (tree fn
)
20159 tree fntype
, spec
, noex
, clone
;
20161 /* Don't instantiate a noexcept-specification from template context. */
20162 if (processing_template_decl
)
20165 if (DECL_CLONED_FUNCTION_P (fn
))
20166 fn
= DECL_CLONED_FUNCTION (fn
);
20167 fntype
= TREE_TYPE (fn
);
20168 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
20170 if (!spec
|| !TREE_PURPOSE (spec
))
20173 noex
= TREE_PURPOSE (spec
);
20175 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
20177 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
20178 spec
= get_defaulted_eh_spec (fn
);
20179 else if (push_tinst_level (fn
))
20181 push_access_scope (fn
);
20182 push_deferring_access_checks (dk_no_deferred
);
20183 input_location
= DECL_SOURCE_LOCATION (fn
);
20184 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
20185 DEFERRED_NOEXCEPT_ARGS (noex
),
20186 tf_warning_or_error
, fn
,
20187 /*function_p=*/false,
20188 /*integral_constant_expression_p=*/true);
20189 pop_deferring_access_checks ();
20190 pop_access_scope (fn
);
20191 pop_tinst_level ();
20192 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
20193 if (spec
== error_mark_node
)
20194 spec
= noexcept_false_spec
;
20197 spec
= noexcept_false_spec
;
20199 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
20202 FOR_EACH_CLONE (clone
, fn
)
20204 if (TREE_TYPE (clone
) == fntype
)
20205 TREE_TYPE (clone
) = TREE_TYPE (fn
);
20207 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
20211 /* Produce the definition of D, a _DECL generated from a template. If
20212 DEFER_OK is nonzero, then we don't have to actually do the
20213 instantiation now; we just have to do it sometime. Normally it is
20214 an error if this is an explicit instantiation but D is undefined.
20215 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
20216 explicitly instantiated class template. */
20219 instantiate_decl (tree d
, int defer_ok
,
20220 bool expl_inst_class_mem_p
)
20222 tree tmpl
= DECL_TI_TEMPLATE (d
);
20229 bool pattern_defined
;
20230 location_t saved_loc
= input_location
;
20231 int saved_unevaluated_operand
= cp_unevaluated_operand
;
20232 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
20238 /* This function should only be used to instantiate templates for
20239 functions and static member variables. */
20240 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
20242 /* Variables are never deferred; if instantiation is required, they
20243 are instantiated right away. That allows for better code in the
20244 case that an expression refers to the value of the variable --
20245 if the variable has a constant value the referring expression can
20246 take advantage of that fact. */
20248 || DECL_DECLARED_CONSTEXPR_P (d
))
20251 /* Don't instantiate cloned functions. Instead, instantiate the
20252 functions they cloned. */
20253 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
20254 d
= DECL_CLONED_FUNCTION (d
);
20256 if (DECL_TEMPLATE_INSTANTIATED (d
)
20257 || (TREE_CODE (d
) == FUNCTION_DECL
20258 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
20259 || DECL_TEMPLATE_SPECIALIZATION (d
))
20260 /* D has already been instantiated or explicitly specialized, so
20261 there's nothing for us to do here.
20263 It might seem reasonable to check whether or not D is an explicit
20264 instantiation, and, if so, stop here. But when an explicit
20265 instantiation is deferred until the end of the compilation,
20266 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
20267 the instantiation. */
20270 /* Check to see whether we know that this template will be
20271 instantiated in some other file, as with "extern template"
20273 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
20275 /* In general, we do not instantiate such templates. */
20276 if (external_p
&& !always_instantiate_p (d
))
20279 gen_tmpl
= most_general_template (tmpl
);
20280 gen_args
= DECL_TI_ARGS (d
);
20282 if (tmpl
!= gen_tmpl
)
20283 /* We should already have the extra args. */
20284 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
20285 == TMPL_ARGS_DEPTH (gen_args
));
20286 /* And what's in the hash table should match D. */
20287 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
20288 || spec
== NULL_TREE
);
20290 /* This needs to happen before any tsubsting. */
20291 if (! push_tinst_level (d
))
20294 timevar_push (TV_TEMPLATE_INST
);
20296 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
20297 for the instantiation. */
20298 td
= template_for_substitution (d
);
20299 code_pattern
= DECL_TEMPLATE_RESULT (td
);
20301 /* We should never be trying to instantiate a member of a class
20302 template or partial specialization. */
20303 gcc_assert (d
!= code_pattern
);
20305 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
20306 || DECL_TEMPLATE_SPECIALIZATION (td
))
20307 /* In the case of a friend template whose definition is provided
20308 outside the class, we may have too many arguments. Drop the
20309 ones we don't need. The same is true for specializations. */
20310 args
= get_innermost_template_args
20311 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
20315 if (TREE_CODE (d
) == FUNCTION_DECL
)
20317 deleted_p
= DECL_DELETED_FN (code_pattern
);
20318 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
20319 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
20325 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
20328 /* We may be in the middle of deferred access check. Disable it now. */
20329 push_deferring_access_checks (dk_no_deferred
);
20331 /* Unless an explicit instantiation directive has already determined
20332 the linkage of D, remember that a definition is available for
20334 if (pattern_defined
20335 && !DECL_INTERFACE_KNOWN (d
)
20336 && !DECL_NOT_REALLY_EXTERN (d
))
20337 mark_definable (d
);
20339 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
20340 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
20341 input_location
= DECL_SOURCE_LOCATION (d
);
20343 /* If D is a member of an explicitly instantiated class template,
20344 and no definition is available, treat it like an implicit
20346 if (!pattern_defined
&& expl_inst_class_mem_p
20347 && DECL_EXPLICIT_INSTANTIATION (d
))
20349 /* Leave linkage flags alone on instantiations with anonymous
20351 if (TREE_PUBLIC (d
))
20353 DECL_NOT_REALLY_EXTERN (d
) = 0;
20354 DECL_INTERFACE_KNOWN (d
) = 0;
20356 SET_DECL_IMPLICIT_INSTANTIATION (d
);
20359 /* Defer all other templates, unless we have been explicitly
20360 forbidden from doing so. */
20361 if (/* If there is no definition, we cannot instantiate the
20364 /* If it's OK to postpone instantiation, do so. */
20366 /* If this is a static data member that will be defined
20367 elsewhere, we don't want to instantiate the entire data
20368 member, but we do want to instantiate the initializer so that
20369 we can substitute that elsewhere. */
20370 || (external_p
&& VAR_P (d
))
20371 /* Handle here a deleted function too, avoid generating
20372 its body (c++/61080). */
20375 /* The definition of the static data member is now required so
20376 we must substitute the initializer. */
20378 && !DECL_INITIAL (d
)
20379 && DECL_INITIAL (code_pattern
))
20383 bool const_init
= false;
20384 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20386 ns
= decl_namespace_context (d
);
20387 push_nested_namespace (ns
);
20389 push_nested_class (DECL_CONTEXT (d
));
20390 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
20392 tf_warning_or_error
, NULL_TREE
,
20393 /*integral_constant_expression_p=*/false);
20394 /* If instantiating the initializer involved instantiating this
20395 again, don't call cp_finish_decl twice. */
20396 if (!DECL_INITIAL (d
))
20398 /* Make sure the initializer is still constant, in case of
20399 circular dependency (template/instantiate6.C). */
20401 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20402 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
20403 /*asmspec_tree=*/NULL_TREE
,
20404 LOOKUP_ONLYCONVERTING
);
20407 pop_nested_class ();
20408 pop_nested_namespace (ns
);
20411 /* We restore the source position here because it's used by
20412 add_pending_template. */
20413 input_location
= saved_loc
;
20415 if (at_eof
&& !pattern_defined
20416 && DECL_EXPLICIT_INSTANTIATION (d
)
20417 && DECL_NOT_REALLY_EXTERN (d
))
20420 The definition of a non-exported function template, a
20421 non-exported member function template, or a non-exported
20422 member function or static data member of a class template
20423 shall be present in every translation unit in which it is
20424 explicitly instantiated. */
20425 permerror (input_location
, "explicit instantiation of %qD "
20426 "but no definition available", d
);
20428 /* If we're in unevaluated context, we just wanted to get the
20429 constant value; this isn't an odr use, so don't queue
20430 a full instantiation. */
20431 if (cp_unevaluated_operand
!= 0)
20433 /* ??? Historically, we have instantiated inline functions, even
20434 when marked as "extern template". */
20435 if (!(external_p
&& VAR_P (d
)))
20436 add_pending_template (d
);
20439 /* Tell the repository that D is available in this translation unit
20440 -- and see if it is supposed to be instantiated here. */
20441 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
20443 /* In a PCH file, despite the fact that the repository hasn't
20444 requested instantiation in the PCH it is still possible that
20445 an instantiation will be required in a file that includes the
20448 add_pending_template (d
);
20449 /* Instantiate inline functions so that the inliner can do its
20450 job, even though we'll not be emitting a copy of this
20452 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
20456 fn_context
= decl_function_context (d
);
20457 nested
= (current_function_decl
!= NULL_TREE
);
20459 push_to_top_level ();
20463 push_function_context ();
20464 cp_unevaluated_operand
= 0;
20465 c_inhibit_evaluation_warnings
= 0;
20468 /* Mark D as instantiated so that recursive calls to
20469 instantiate_decl do not try to instantiate it again. */
20470 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
20472 /* Regenerate the declaration in case the template has been modified
20473 by a subsequent redeclaration. */
20474 regenerate_decl_from_template (d
, td
);
20476 /* We already set the file and line above. Reset them now in case
20477 they changed as a result of calling regenerate_decl_from_template. */
20478 input_location
= DECL_SOURCE_LOCATION (d
);
20483 bool const_init
= false;
20485 /* Clear out DECL_RTL; whatever was there before may not be right
20486 since we've reset the type of the declaration. */
20487 SET_DECL_RTL (d
, NULL
);
20488 DECL_IN_AGGR_P (d
) = 0;
20490 /* The initializer is placed in DECL_INITIAL by
20491 regenerate_decl_from_template so we don't need to
20492 push/pop_access_scope again here. Pull it out so that
20493 cp_finish_decl can process it. */
20494 init
= DECL_INITIAL (d
);
20495 DECL_INITIAL (d
) = NULL_TREE
;
20496 DECL_INITIALIZED_P (d
) = 0;
20498 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20499 initializer. That function will defer actual emission until
20500 we have a chance to determine linkage. */
20501 DECL_EXTERNAL (d
) = 0;
20503 /* Enter the scope of D so that access-checking works correctly. */
20504 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20506 push_nested_class (DECL_CONTEXT (d
));
20508 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20509 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
20512 pop_nested_class ();
20514 if (variable_template_p (td
))
20515 note_variable_template_instantiation (d
);
20517 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
20518 synthesize_method (d
);
20519 else if (TREE_CODE (d
) == FUNCTION_DECL
)
20521 hash_map
<tree
, tree
> *saved_local_specializations
;
20525 tree block
= NULL_TREE
;
20527 /* Save away the current list, in case we are instantiating one
20528 template from within the body of another. */
20529 saved_local_specializations
= local_specializations
;
20531 /* Set up the list of local specializations. */
20532 local_specializations
= new hash_map
<tree
, tree
>;
20534 /* Set up context. */
20535 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20536 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20537 block
= push_stmt_list ();
20539 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
20541 /* Some typedefs referenced from within the template code need to be
20542 access checked at template instantiation time, i.e now. These
20543 types were added to the template at parsing time. Let's get those
20544 and perform the access checks then. */
20545 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20548 /* Create substitution entries for the parameters. */
20549 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20550 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20551 spec_parm
= DECL_ARGUMENTS (d
);
20552 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20554 register_local_specialization (spec_parm
, tmpl_parm
);
20555 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20556 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20558 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20560 if (!DECL_PACK_P (tmpl_parm
))
20562 register_local_specialization (spec_parm
, tmpl_parm
);
20563 spec_parm
= DECL_CHAIN (spec_parm
);
20567 /* Register the (value) argument pack as a specialization of
20568 TMPL_PARM, then move on. */
20569 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20570 register_local_specialization (argpack
, tmpl_parm
);
20573 gcc_assert (!spec_parm
);
20575 /* Substitute into the body of the function. */
20576 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20577 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20578 tf_warning_or_error
, tmpl
);
20581 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20582 tf_warning_or_error
, tmpl
,
20583 /*integral_constant_expression_p=*/false);
20585 /* Set the current input_location to the end of the function
20586 so that finish_function knows where we are. */
20588 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20590 /* Remember if we saw an infinite loop in the template. */
20591 current_function_infinite_loop
20592 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20595 /* We don't need the local specializations any more. */
20596 delete local_specializations
;
20597 local_specializations
= saved_local_specializations
;
20599 /* Finish the function. */
20600 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20601 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20602 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20605 d
= finish_function (0);
20606 expand_or_defer_fn (d
);
20609 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20610 cp_check_omp_declare_reduction (d
);
20613 /* We're not deferring instantiation any more. */
20614 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20617 pop_from_top_level ();
20619 pop_function_context ();
20622 input_location
= saved_loc
;
20623 cp_unevaluated_operand
= saved_unevaluated_operand
;
20624 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20625 pop_deferring_access_checks ();
20626 pop_tinst_level ();
20628 timevar_pop (TV_TEMPLATE_INST
);
20633 /* Run through the list of templates that we wish we could
20634 instantiate, and instantiate any we can. RETRIES is the
20635 number of times we retry pending template instantiation. */
20638 instantiate_pending_templates (int retries
)
20641 location_t saved_loc
= input_location
;
20643 /* Instantiating templates may trigger vtable generation. This in turn
20644 may require further template instantiations. We place a limit here
20645 to avoid infinite loop. */
20646 if (pending_templates
&& retries
>= max_tinst_depth
)
20648 tree decl
= pending_templates
->tinst
->decl
;
20650 fatal_error (input_location
,
20651 "template instantiation depth exceeds maximum of %d"
20652 " instantiating %q+D, possibly from virtual table generation"
20653 " (use -ftemplate-depth= to increase the maximum)",
20654 max_tinst_depth
, decl
);
20655 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20656 /* Pretend that we defined it. */
20657 DECL_INITIAL (decl
) = error_mark_node
;
20663 struct pending_template
**t
= &pending_templates
;
20664 struct pending_template
*last
= NULL
;
20668 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20669 bool complete
= false;
20671 if (TYPE_P (instantiation
))
20675 if (!COMPLETE_TYPE_P (instantiation
))
20677 instantiate_class_template (instantiation
);
20678 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20679 for (fn
= TYPE_METHODS (instantiation
);
20681 fn
= TREE_CHAIN (fn
))
20682 if (! DECL_ARTIFICIAL (fn
))
20683 instantiate_decl (fn
,
20685 /*expl_inst_class_mem_p=*/false);
20686 if (COMPLETE_TYPE_P (instantiation
))
20690 complete
= COMPLETE_TYPE_P (instantiation
);
20694 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20695 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20698 = instantiate_decl (instantiation
,
20700 /*expl_inst_class_mem_p=*/false);
20701 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20705 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20706 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20710 /* If INSTANTIATION has been instantiated, then we don't
20711 need to consider it again in the future. */
20719 current_tinst_level
= NULL
;
20721 last_pending_template
= last
;
20723 while (reconsider
);
20725 input_location
= saved_loc
;
20728 /* Substitute ARGVEC into T, which is a list of initializers for
20729 either base class or a non-static data member. The TREE_PURPOSEs
20730 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20731 instantiate_decl. */
20734 tsubst_initializer_list (tree t
, tree argvec
)
20736 tree inits
= NULL_TREE
;
20738 for (; t
; t
= TREE_CHAIN (t
))
20742 tree expanded_bases
= NULL_TREE
;
20743 tree expanded_arguments
= NULL_TREE
;
20746 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20751 /* Expand the base class expansion type into separate base
20753 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20754 tf_warning_or_error
,
20756 if (expanded_bases
== error_mark_node
)
20759 /* We'll be building separate TREE_LISTs of arguments for
20761 len
= TREE_VEC_LENGTH (expanded_bases
);
20762 expanded_arguments
= make_tree_vec (len
);
20763 for (i
= 0; i
< len
; i
++)
20764 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20766 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20767 expand each argument in the TREE_VALUE of t. */
20768 expr
= make_node (EXPR_PACK_EXPANSION
);
20769 PACK_EXPANSION_LOCAL_P (expr
) = true;
20770 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20771 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20773 if (TREE_VALUE (t
) == void_type_node
)
20774 /* VOID_TYPE_NODE is used to indicate
20775 value-initialization. */
20777 for (i
= 0; i
< len
; i
++)
20778 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20782 /* Substitute parameter packs into each argument in the
20784 in_base_initializer
= 1;
20785 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20787 tree expanded_exprs
;
20789 /* Expand the argument. */
20790 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20792 = tsubst_pack_expansion (expr
, argvec
,
20793 tf_warning_or_error
,
20795 if (expanded_exprs
== error_mark_node
)
20798 /* Prepend each of the expanded expressions to the
20799 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20800 for (i
= 0; i
< len
; i
++)
20802 TREE_VEC_ELT (expanded_arguments
, i
) =
20803 tree_cons (NULL_TREE
,
20804 TREE_VEC_ELT (expanded_exprs
, i
),
20805 TREE_VEC_ELT (expanded_arguments
, i
));
20808 in_base_initializer
= 0;
20810 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20811 since we built them backwards. */
20812 for (i
= 0; i
< len
; i
++)
20814 TREE_VEC_ELT (expanded_arguments
, i
) =
20815 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20820 for (i
= 0; i
< len
; ++i
)
20822 if (expanded_bases
)
20824 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20825 decl
= expand_member_init (decl
);
20826 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20831 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20832 tf_warning_or_error
, NULL_TREE
);
20834 decl
= expand_member_init (decl
);
20835 if (decl
&& !DECL_P (decl
))
20836 in_base_initializer
= 1;
20838 init
= TREE_VALUE (t
);
20840 if (init
!= void_type_node
)
20841 init
= tsubst_expr (init
, argvec
,
20842 tf_warning_or_error
, NULL_TREE
,
20843 /*integral_constant_expression_p=*/false);
20844 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20845 /* If we had an initializer but it instantiated to nothing,
20846 value-initialize the object. This will only occur when
20847 the initializer was a pack expansion where the parameter
20848 packs used in that expansion were of length zero. */
20849 init
= void_type_node
;
20850 in_base_initializer
= 0;
20855 init
= build_tree_list (decl
, init
);
20856 TREE_CHAIN (init
) = inits
;
20864 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20867 set_current_access_from_decl (tree decl
)
20869 if (TREE_PRIVATE (decl
))
20870 current_access_specifier
= access_private_node
;
20871 else if (TREE_PROTECTED (decl
))
20872 current_access_specifier
= access_protected_node
;
20874 current_access_specifier
= access_public_node
;
20877 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20878 is the instantiation (which should have been created with
20879 start_enum) and ARGS are the template arguments to use. */
20882 tsubst_enum (tree tag
, tree newtag
, tree args
)
20886 if (SCOPED_ENUM_P (newtag
))
20887 begin_scope (sk_scoped_enum
, newtag
);
20889 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20894 decl
= TREE_VALUE (e
);
20895 /* Note that in a template enum, the TREE_VALUE is the
20896 CONST_DECL, not the corresponding INTEGER_CST. */
20897 value
= tsubst_expr (DECL_INITIAL (decl
),
20898 args
, tf_warning_or_error
, NULL_TREE
,
20899 /*integral_constant_expression_p=*/true);
20901 /* Give this enumeration constant the correct access. */
20902 set_current_access_from_decl (decl
);
20904 /* Actually build the enumerator itself. Here we're assuming that
20905 enumerators can't have dependent attributes. */
20906 build_enumerator (DECL_NAME (decl
), value
, newtag
,
20907 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
20910 if (SCOPED_ENUM_P (newtag
))
20913 finish_enum_value_list (newtag
);
20914 finish_enum (newtag
);
20916 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20917 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20920 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20921 its type -- but without substituting the innermost set of template
20922 arguments. So, innermost set of template parameters will appear in
20926 get_mostly_instantiated_function_type (tree decl
)
20928 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
20929 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
20932 /* Return truthvalue if we're processing a template different from
20933 the last one involved in diagnostics. */
20935 problematic_instantiation_changed (void)
20937 return current_tinst_level
!= last_error_tinst_level
;
20940 /* Remember current template involved in diagnostics. */
20942 record_last_problematic_instantiation (void)
20944 last_error_tinst_level
= current_tinst_level
;
20947 struct tinst_level
*
20948 current_instantiation (void)
20950 return current_tinst_level
;
20953 /* Return TRUE if current_function_decl is being instantiated, false
20957 instantiating_current_function_p (void)
20959 return (current_instantiation ()
20960 && current_instantiation ()->decl
== current_function_decl
);
20963 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20964 type. Return zero for ok, nonzero for disallowed. Issue error and
20965 warning messages under control of COMPLAIN. */
20968 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20970 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20972 else if (POINTER_TYPE_P (type
))
20974 else if (TYPE_PTRMEM_P (type
))
20976 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20978 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20980 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20982 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20985 if (complain
& tf_error
)
20987 if (type
== error_mark_node
)
20988 inform (input_location
, "invalid template non-type parameter");
20990 error ("%q#T is not a valid type for a template non-type parameter",
20996 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20997 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
21000 dependent_type_p_r (tree type
)
21006 A type is dependent if it is:
21008 -- a template parameter. Template template parameters are types
21009 for us (since TYPE_P holds true for them) so we handle
21011 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
21012 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
21014 /* -- a qualified-id with a nested-name-specifier which contains a
21015 class-name that names a dependent type or whose unqualified-id
21016 names a dependent type. */
21017 if (TREE_CODE (type
) == TYPENAME_TYPE
)
21020 /* An alias template specialization can be dependent even if the
21021 resulting type is not. */
21022 if (dependent_alias_template_spec_p (type
))
21025 /* -- a cv-qualified type where the cv-unqualified type is
21027 No code is necessary for this bullet; the code below handles
21028 cv-qualified types, and we don't want to strip aliases with
21029 TYPE_MAIN_VARIANT because of DR 1558. */
21030 /* -- a compound type constructed from any dependent type. */
21031 if (TYPE_PTRMEM_P (type
))
21032 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
21033 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
21035 else if (TYPE_PTR_P (type
)
21036 || TREE_CODE (type
) == REFERENCE_TYPE
)
21037 return dependent_type_p (TREE_TYPE (type
));
21038 else if (TREE_CODE (type
) == FUNCTION_TYPE
21039 || TREE_CODE (type
) == METHOD_TYPE
)
21043 if (dependent_type_p (TREE_TYPE (type
)))
21045 for (arg_type
= TYPE_ARG_TYPES (type
);
21047 arg_type
= TREE_CHAIN (arg_type
))
21048 if (dependent_type_p (TREE_VALUE (arg_type
)))
21052 /* -- an array type constructed from any dependent type or whose
21053 size is specified by a constant expression that is
21056 We checked for type- and value-dependence of the bounds in
21057 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
21058 if (TREE_CODE (type
) == ARRAY_TYPE
)
21060 if (TYPE_DOMAIN (type
)
21061 && dependent_type_p (TYPE_DOMAIN (type
)))
21063 return dependent_type_p (TREE_TYPE (type
));
21066 /* -- a template-id in which either the template name is a template
21068 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21070 /* ... or any of the template arguments is a dependent type or
21071 an expression that is type-dependent or value-dependent. */
21072 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
21073 && (any_dependent_template_arguments_p
21074 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
21077 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
21078 dependent; if the argument of the `typeof' expression is not
21079 type-dependent, then it should already been have resolved. */
21080 if (TREE_CODE (type
) == TYPEOF_TYPE
21081 || TREE_CODE (type
) == DECLTYPE_TYPE
21082 || TREE_CODE (type
) == UNDERLYING_TYPE
)
21085 /* A template argument pack is dependent if any of its packed
21087 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
21089 tree args
= ARGUMENT_PACK_ARGS (type
);
21090 int i
, len
= TREE_VEC_LENGTH (args
);
21091 for (i
= 0; i
< len
; ++i
)
21092 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21096 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
21097 be template parameters. */
21098 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
21101 /* The standard does not specifically mention types that are local
21102 to template functions or local classes, but they should be
21103 considered dependent too. For example:
21105 template <int I> void f() {
21110 The size of `E' cannot be known until the value of `I' has been
21111 determined. Therefore, `E' must be considered dependent. */
21112 scope
= TYPE_CONTEXT (type
);
21113 if (scope
&& TYPE_P (scope
))
21114 return dependent_type_p (scope
);
21115 /* Don't use type_dependent_expression_p here, as it can lead
21116 to infinite recursion trying to determine whether a lambda
21117 nested in a lambda is dependent (c++/47687). */
21118 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
21119 && DECL_LANG_SPECIFIC (scope
)
21120 && DECL_TEMPLATE_INFO (scope
)
21121 && (any_dependent_template_arguments_p
21122 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
21125 /* Other types are non-dependent. */
21129 /* Returns TRUE if TYPE is dependent, in the sense of
21130 [temp.dep.type]. Note that a NULL type is considered dependent. */
21133 dependent_type_p (tree type
)
21135 /* If there are no template parameters in scope, then there can't be
21136 any dependent types. */
21137 if (!processing_template_decl
)
21139 /* If we are not processing a template, then nobody should be
21140 providing us with a dependent type. */
21142 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
21146 /* If the type is NULL, we have not computed a type for the entity
21147 in question; in that case, the type is dependent. */
21151 /* Erroneous types can be considered non-dependent. */
21152 if (type
== error_mark_node
)
21155 /* If we have not already computed the appropriate value for TYPE,
21157 if (!TYPE_DEPENDENT_P_VALID (type
))
21159 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
21160 TYPE_DEPENDENT_P_VALID (type
) = 1;
21163 return TYPE_DEPENDENT_P (type
);
21166 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
21167 lookup. In other words, a dependent type that is not the current
21171 dependent_scope_p (tree scope
)
21173 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
21174 && !currently_open_class (scope
));
21177 /* T is a SCOPE_REF; return whether we need to consider it
21178 instantiation-dependent so that we can check access at instantiation
21179 time even though we know which member it resolves to. */
21182 instantiation_dependent_scope_ref_p (tree t
)
21184 if (DECL_P (TREE_OPERAND (t
, 1))
21185 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
21186 && accessible_in_template_p (TREE_OPERAND (t
, 0),
21187 TREE_OPERAND (t
, 1)))
21193 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
21194 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
21197 /* Note that this predicate is not appropriate for general expressions;
21198 only constant expressions (that satisfy potential_constant_expression)
21199 can be tested for value dependence. */
21202 value_dependent_expression_p (tree expression
)
21204 if (!processing_template_decl
)
21207 /* A name declared with a dependent type. */
21208 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
21211 switch (TREE_CODE (expression
))
21213 case IDENTIFIER_NODE
:
21214 /* A name that has not been looked up -- must be dependent. */
21217 case TEMPLATE_PARM_INDEX
:
21218 /* A non-type template parm. */
21222 /* A non-type template parm. */
21223 if (DECL_TEMPLATE_PARM_P (expression
))
21225 return value_dependent_expression_p (DECL_INITIAL (expression
));
21228 /* A constant with literal type and is initialized
21229 with an expression that is value-dependent.
21231 Note that a non-dependent parenthesized initializer will have
21232 already been replaced with its constant value, so if we see
21233 a TREE_LIST it must be dependent. */
21234 if (DECL_INITIAL (expression
)
21235 && decl_constant_var_p (expression
)
21236 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
21237 /* cp_finish_decl doesn't fold reference initializers. */
21238 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
21239 || value_dependent_expression_p (DECL_INITIAL (expression
))))
21243 case DYNAMIC_CAST_EXPR
:
21244 case STATIC_CAST_EXPR
:
21245 case CONST_CAST_EXPR
:
21246 case REINTERPRET_CAST_EXPR
:
21248 /* These expressions are value-dependent if the type to which
21249 the cast occurs is dependent or the expression being casted
21250 is value-dependent. */
21252 tree type
= TREE_TYPE (expression
);
21254 if (dependent_type_p (type
))
21257 /* A functional cast has a list of operands. */
21258 expression
= TREE_OPERAND (expression
, 0);
21261 /* If there are no operands, it must be an expression such
21262 as "int()". This should not happen for aggregate types
21263 because it would form non-constant expressions. */
21264 gcc_assert (cxx_dialect
>= cxx11
21265 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
21270 if (TREE_CODE (expression
) == TREE_LIST
)
21271 return any_value_dependent_elements_p (expression
);
21273 return value_dependent_expression_p (expression
);
21277 if (SIZEOF_EXPR_TYPE_P (expression
))
21278 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
21282 /* A `sizeof' expression is value-dependent if the operand is
21283 type-dependent or is a pack expansion. */
21284 expression
= TREE_OPERAND (expression
, 0);
21285 if (PACK_EXPANSION_P (expression
))
21287 else if (TYPE_P (expression
))
21288 return dependent_type_p (expression
);
21289 return instantiation_dependent_expression_p (expression
);
21291 case AT_ENCODE_EXPR
:
21292 /* An 'encode' expression is value-dependent if the operand is
21294 expression
= TREE_OPERAND (expression
, 0);
21295 return dependent_type_p (expression
);
21297 case NOEXCEPT_EXPR
:
21298 expression
= TREE_OPERAND (expression
, 0);
21299 return instantiation_dependent_expression_p (expression
);
21302 /* All instantiation-dependent expressions should also be considered
21303 value-dependent. */
21304 return instantiation_dependent_scope_ref_p (expression
);
21306 case COMPONENT_REF
:
21307 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
21308 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
21310 case NONTYPE_ARGUMENT_PACK
:
21311 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
21312 is value-dependent. */
21314 tree values
= ARGUMENT_PACK_ARGS (expression
);
21315 int i
, len
= TREE_VEC_LENGTH (values
);
21317 for (i
= 0; i
< len
; ++i
)
21318 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
21326 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
21327 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
21328 || (type2
? dependent_type_p (type2
) : false));
21332 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21333 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
21336 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21337 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
21341 tree op
= TREE_OPERAND (expression
, 0);
21342 return (value_dependent_expression_p (op
)
21343 || has_value_dependent_address (op
));
21348 tree fn
= get_callee_fndecl (expression
);
21350 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
21352 nargs
= call_expr_nargs (expression
);
21353 for (i
= 0; i
< nargs
; ++i
)
21355 tree op
= CALL_EXPR_ARG (expression
, i
);
21356 /* In a call to a constexpr member function, look through the
21357 implicit ADDR_EXPR on the object argument so that it doesn't
21358 cause the call to be considered value-dependent. We also
21359 look through it in potential_constant_expression. */
21360 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
21361 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
21362 && TREE_CODE (op
) == ADDR_EXPR
)
21363 op
= TREE_OPERAND (op
, 0);
21364 if (value_dependent_expression_p (op
))
21370 case TEMPLATE_ID_EXPR
:
21371 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21373 return type_dependent_expression_p (expression
);
21379 if (dependent_type_p (TREE_TYPE (expression
)))
21381 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
21382 if (value_dependent_expression_p (val
))
21388 /* Treat a GNU statement expression as dependent to avoid crashing
21389 under instantiate_non_dependent_expr; it can't be constant. */
21393 /* A constant expression is value-dependent if any subexpression is
21394 value-dependent. */
21395 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
21397 case tcc_reference
:
21399 case tcc_comparison
:
21401 case tcc_expression
:
21404 int i
, len
= cp_tree_operand_length (expression
);
21406 for (i
= 0; i
< len
; i
++)
21408 tree t
= TREE_OPERAND (expression
, i
);
21410 /* In some cases, some of the operands may be missing.l
21411 (For example, in the case of PREDECREMENT_EXPR, the
21412 amount to increment by may be missing.) That doesn't
21413 make the expression dependent. */
21414 if (t
&& value_dependent_expression_p (t
))
21425 /* The expression is not value-dependent. */
21429 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21430 [temp.dep.expr]. Note that an expression with no type is
21431 considered dependent. Other parts of the compiler arrange for an
21432 expression with type-dependent subexpressions to have no type, so
21433 this function doesn't have to be fully recursive. */
21436 type_dependent_expression_p (tree expression
)
21438 if (!processing_template_decl
)
21441 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
21444 /* An unresolved name is always dependent. */
21445 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
21448 /* Some expression forms are never type-dependent. */
21449 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
21450 || TREE_CODE (expression
) == SIZEOF_EXPR
21451 || TREE_CODE (expression
) == ALIGNOF_EXPR
21452 || TREE_CODE (expression
) == AT_ENCODE_EXPR
21453 || TREE_CODE (expression
) == NOEXCEPT_EXPR
21454 || TREE_CODE (expression
) == TRAIT_EXPR
21455 || TREE_CODE (expression
) == TYPEID_EXPR
21456 || TREE_CODE (expression
) == DELETE_EXPR
21457 || TREE_CODE (expression
) == VEC_DELETE_EXPR
21458 || TREE_CODE (expression
) == THROW_EXPR
)
21461 /* The types of these expressions depends only on the type to which
21462 the cast occurs. */
21463 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
21464 || TREE_CODE (expression
) == STATIC_CAST_EXPR
21465 || TREE_CODE (expression
) == CONST_CAST_EXPR
21466 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
21467 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
21468 || TREE_CODE (expression
) == CAST_EXPR
)
21469 return dependent_type_p (TREE_TYPE (expression
));
21471 /* The types of these expressions depends only on the type created
21472 by the expression. */
21473 if (TREE_CODE (expression
) == NEW_EXPR
21474 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
21476 /* For NEW_EXPR tree nodes created inside a template, either
21477 the object type itself or a TREE_LIST may appear as the
21479 tree type
= TREE_OPERAND (expression
, 1);
21480 if (TREE_CODE (type
) == TREE_LIST
)
21481 /* This is an array type. We need to check array dimensions
21483 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
21484 || value_dependent_expression_p
21485 (TREE_OPERAND (TREE_VALUE (type
), 1));
21487 return dependent_type_p (type
);
21490 if (TREE_CODE (expression
) == SCOPE_REF
)
21492 tree scope
= TREE_OPERAND (expression
, 0);
21493 tree name
= TREE_OPERAND (expression
, 1);
21495 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21496 contains an identifier associated by name lookup with one or more
21497 declarations declared with a dependent type, or...a
21498 nested-name-specifier or qualified-id that names a member of an
21499 unknown specialization. */
21500 return (type_dependent_expression_p (name
)
21501 || dependent_scope_p (scope
));
21504 if (TREE_CODE (expression
) == FUNCTION_DECL
21505 && DECL_LANG_SPECIFIC (expression
)
21506 && DECL_TEMPLATE_INFO (expression
)
21507 && (any_dependent_template_arguments_p
21508 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
21511 if (TREE_CODE (expression
) == TEMPLATE_DECL
21512 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
21515 if (TREE_CODE (expression
) == STMT_EXPR
)
21516 expression
= stmt_expr_value_expr (expression
);
21518 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21523 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21525 if (type_dependent_expression_p (elt
))
21531 /* A static data member of the current instantiation with incomplete
21532 array type is type-dependent, as the definition and specializations
21533 can have different bounds. */
21534 if (VAR_P (expression
)
21535 && DECL_CLASS_SCOPE_P (expression
)
21536 && dependent_type_p (DECL_CONTEXT (expression
))
21537 && VAR_HAD_UNKNOWN_BOUND (expression
))
21540 /* An array of unknown bound depending on a variadic parameter, eg:
21542 template<typename... Args>
21543 void foo (Args... args)
21545 int arr[] = { args... };
21548 template<int... vals>
21551 int arr[] = { vals... };
21554 If the array has no length and has an initializer, it must be that
21555 we couldn't determine its length in cp_complete_array_type because
21556 it is dependent. */
21557 if (VAR_P (expression
)
21558 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21559 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21560 && DECL_INITIAL (expression
))
21563 /* A variable template specialization is type-dependent if it has any
21564 dependent template arguments. */
21565 if (VAR_P (expression
)
21566 && DECL_LANG_SPECIFIC (expression
)
21567 && DECL_TEMPLATE_INFO (expression
)
21568 && variable_template_p (DECL_TI_TEMPLATE (expression
)))
21569 return any_dependent_template_arguments_p (DECL_TI_ARGS (expression
));
21571 /* Always dependent, on the number of arguments if nothing else. */
21572 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21575 if (TREE_TYPE (expression
) == unknown_type_node
)
21577 if (TREE_CODE (expression
) == ADDR_EXPR
)
21578 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21579 if (TREE_CODE (expression
) == COMPONENT_REF
21580 || TREE_CODE (expression
) == OFFSET_REF
)
21582 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21584 expression
= TREE_OPERAND (expression
, 1);
21585 if (identifier_p (expression
))
21588 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21589 if (TREE_CODE (expression
) == SCOPE_REF
)
21592 if (BASELINK_P (expression
))
21594 if (BASELINK_OPTYPE (expression
)
21595 && dependent_type_p (BASELINK_OPTYPE (expression
)))
21597 expression
= BASELINK_FUNCTIONS (expression
);
21600 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21602 if (any_dependent_template_arguments_p
21603 (TREE_OPERAND (expression
, 1)))
21605 expression
= TREE_OPERAND (expression
, 0);
21607 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21608 || TREE_CODE (expression
) == FUNCTION_DECL
);
21612 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21614 expression
= OVL_NEXT (expression
);
21619 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21621 return (dependent_type_p (TREE_TYPE (expression
)));
21624 /* walk_tree callback function for instantiation_dependent_expression_p,
21625 below. Returns non-zero if a dependent subexpression is found. */
21628 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21633 /* We don't have to worry about decltype currently because decltype
21634 of an instantiation-dependent expr is a dependent type. This
21635 might change depending on the resolution of DR 1172. */
21636 *walk_subtrees
= false;
21639 enum tree_code code
= TREE_CODE (*tp
);
21642 /* Don't treat an argument list as dependent just because it has no
21650 /* A constant with a dependent initializer is dependent. */
21651 if (value_dependent_expression_p (*tp
))
21655 case TEMPLATE_PARM_INDEX
:
21658 /* Handle expressions with type operands. */
21662 case AT_ENCODE_EXPR
:
21664 tree op
= TREE_OPERAND (*tp
, 0);
21665 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21666 op
= TREE_TYPE (op
);
21669 if (dependent_type_p (op
))
21673 *walk_subtrees
= false;
21681 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21682 || (TRAIT_EXPR_TYPE2 (*tp
)
21683 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21685 *walk_subtrees
= false;
21688 case COMPONENT_REF
:
21689 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21690 /* In a template, finish_class_member_access_expr creates a
21691 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21692 type-dependent, so that we can check access control at
21693 instantiation time (PR 42277). See also Core issue 1273. */
21698 if (instantiation_dependent_scope_ref_p (*tp
))
21703 /* Treat statement-expressions as dependent. */
21711 if (type_dependent_expression_p (*tp
))
21717 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21718 sense defined by the ABI:
21720 "An expression is instantiation-dependent if it is type-dependent
21721 or value-dependent, or it has a subexpression that is type-dependent
21722 or value-dependent." */
21725 instantiation_dependent_expression_p (tree expression
)
21729 if (!processing_template_decl
)
21732 if (expression
== error_mark_node
)
21735 result
= cp_walk_tree_without_duplicates (&expression
,
21736 instantiation_dependent_r
, NULL
);
21737 return result
!= NULL_TREE
;
21740 /* Like type_dependent_expression_p, but it also works while not processing
21741 a template definition, i.e. during substitution or mangling. */
21744 type_dependent_expression_p_push (tree expr
)
21747 ++processing_template_decl
;
21748 b
= type_dependent_expression_p (expr
);
21749 --processing_template_decl
;
21753 /* Returns TRUE if ARGS contains a type-dependent expression. */
21756 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21761 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21763 if (type_dependent_expression_p (arg
))
21769 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21770 expressions) contains any type-dependent expressions. */
21773 any_type_dependent_elements_p (const_tree list
)
21775 for (; list
; list
= TREE_CHAIN (list
))
21776 if (type_dependent_expression_p (TREE_VALUE (list
)))
21782 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21783 expressions) contains any value-dependent expressions. */
21786 any_value_dependent_elements_p (const_tree list
)
21788 for (; list
; list
= TREE_CHAIN (list
))
21789 if (value_dependent_expression_p (TREE_VALUE (list
)))
21795 /* Returns TRUE if the ARG (a template argument) is dependent. */
21798 dependent_template_arg_p (tree arg
)
21800 if (!processing_template_decl
)
21803 /* Assume a template argument that was wrongly written by the user
21804 is dependent. This is consistent with what
21805 any_dependent_template_arguments_p [that calls this function]
21807 if (!arg
|| arg
== error_mark_node
)
21810 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21811 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21813 if (TREE_CODE (arg
) == TEMPLATE_DECL
21814 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21815 return dependent_template_p (arg
);
21816 else if (ARGUMENT_PACK_P (arg
))
21818 tree args
= ARGUMENT_PACK_ARGS (arg
);
21819 int i
, len
= TREE_VEC_LENGTH (args
);
21820 for (i
= 0; i
< len
; ++i
)
21822 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21828 else if (TYPE_P (arg
))
21829 return dependent_type_p (arg
);
21831 return (type_dependent_expression_p (arg
)
21832 || value_dependent_expression_p (arg
));
21835 /* Returns true if ARGS (a collection of template arguments) contains
21836 any types that require structural equality testing. */
21839 any_template_arguments_need_structural_equality_p (tree args
)
21846 if (args
== error_mark_node
)
21849 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21851 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21852 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21854 tree arg
= TREE_VEC_ELT (level
, j
);
21855 tree packed_args
= NULL_TREE
;
21858 if (ARGUMENT_PACK_P (arg
))
21860 /* Look inside the argument pack. */
21861 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21862 len
= TREE_VEC_LENGTH (packed_args
);
21865 for (k
= 0; k
< len
; ++k
)
21868 arg
= TREE_VEC_ELT (packed_args
, k
);
21870 if (error_operand_p (arg
))
21872 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21874 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21876 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21877 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21886 /* Returns true if ARGS (a collection of template arguments) contains
21887 any dependent arguments. */
21890 any_dependent_template_arguments_p (const_tree args
)
21897 if (args
== error_mark_node
)
21900 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21902 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21903 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21904 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21911 /* Returns TRUE if the template TMPL is dependent. */
21914 dependent_template_p (tree tmpl
)
21916 if (TREE_CODE (tmpl
) == OVERLOAD
)
21920 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21922 tmpl
= OVL_NEXT (tmpl
);
21927 /* Template template parameters are dependent. */
21928 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21929 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21931 /* So are names that have not been looked up. */
21932 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21934 /* So are member templates of dependent classes. */
21935 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21936 return dependent_type_p (DECL_CONTEXT (tmpl
));
21940 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21943 dependent_template_id_p (tree tmpl
, tree args
)
21945 return (dependent_template_p (tmpl
)
21946 || any_dependent_template_arguments_p (args
));
21949 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21953 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21957 if (!processing_template_decl
)
21960 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21962 tree decl
= TREE_VEC_ELT (declv
, i
);
21963 tree init
= TREE_VEC_ELT (initv
, i
);
21964 tree cond
= TREE_VEC_ELT (condv
, i
);
21965 tree incr
= TREE_VEC_ELT (incrv
, i
);
21967 if (type_dependent_expression_p (decl
))
21970 if (init
&& type_dependent_expression_p (init
))
21973 if (type_dependent_expression_p (cond
))
21976 if (COMPARISON_CLASS_P (cond
)
21977 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21978 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21981 if (TREE_CODE (incr
) == MODOP_EXPR
)
21983 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21984 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21987 else if (type_dependent_expression_p (incr
))
21989 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21991 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21993 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21995 tree t
= TREE_OPERAND (incr
, 1);
21996 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21997 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
22006 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
22007 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
22008 no such TYPE can be found. Note that this function peers inside
22009 uninstantiated templates and therefore should be used only in
22010 extremely limited situations. ONLY_CURRENT_P restricts this
22011 peering to the currently open classes hierarchy (which is required
22012 when comparing types). */
22015 resolve_typename_type (tree type
, bool only_current_p
)
22024 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
22026 scope
= TYPE_CONTEXT (type
);
22027 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
22028 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
22029 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
22030 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
22031 identifier of the TYPENAME_TYPE anymore.
22032 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
22033 TYPENAME_TYPE instead, we avoid messing up with a possible
22034 typedef variant case. */
22035 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
22037 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
22038 it first before we can figure out what NAME refers to. */
22039 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
22041 if (TYPENAME_IS_RESOLVING_P (scope
))
22042 /* Given a class template A with a dependent base with nested type C,
22043 typedef typename A::C::C C will land us here, as trying to resolve
22044 the initial A::C leads to the local C typedef, which leads back to
22045 A::C::C. So we break the recursion now. */
22048 scope
= resolve_typename_type (scope
, only_current_p
);
22050 /* If we don't know what SCOPE refers to, then we cannot resolve the
22052 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
22054 /* If the SCOPE is a template type parameter, we have no way of
22055 resolving the name. */
22056 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
22058 /* If the SCOPE is not the current instantiation, there's no reason
22059 to look inside it. */
22060 if (only_current_p
&& !currently_open_class (scope
))
22062 /* If this is a typedef, we don't want to look inside (c++/11987). */
22063 if (typedef_variant_p (type
))
22065 /* If SCOPE isn't the template itself, it will not have a valid
22066 TYPE_FIELDS list. */
22067 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
22068 /* scope is either the template itself or a compatible instantiation
22069 like X<T>, so look up the name in the original template. */
22070 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
22072 /* scope is a partial instantiation, so we can't do the lookup or we
22073 will lose the template arguments. */
22075 /* Enter the SCOPE so that name lookup will be resolved as if we
22076 were in the class definition. In particular, SCOPE will no
22077 longer be considered a dependent type. */
22078 pushed_scope
= push_scope (scope
);
22079 /* Look up the declaration. */
22080 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
22081 tf_warning_or_error
);
22083 result
= NULL_TREE
;
22085 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
22086 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
22089 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
22090 && TREE_CODE (decl
) == TYPE_DECL
)
22092 result
= TREE_TYPE (decl
);
22093 if (result
== error_mark_node
)
22094 result
= NULL_TREE
;
22096 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
22097 && DECL_CLASS_TEMPLATE_P (decl
))
22101 /* Obtain the template and the arguments. */
22102 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
22103 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
22104 /* Instantiate the template. */
22105 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
22106 /*entering_scope=*/0,
22107 tf_error
| tf_user
);
22108 if (result
== error_mark_node
)
22109 result
= NULL_TREE
;
22112 /* Leave the SCOPE. */
22114 pop_scope (pushed_scope
);
22116 /* If we failed to resolve it, return the original typename. */
22120 /* If lookup found a typename type, resolve that too. */
22121 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
22123 /* Ill-formed programs can cause infinite recursion here, so we
22124 must catch that. */
22125 TYPENAME_IS_RESOLVING_P (type
) = 1;
22126 result
= resolve_typename_type (result
, only_current_p
);
22127 TYPENAME_IS_RESOLVING_P (type
) = 0;
22130 /* Qualify the resulting type. */
22131 quals
= cp_type_quals (type
);
22133 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
22138 /* EXPR is an expression which is not type-dependent. Return a proxy
22139 for EXPR that can be used to compute the types of larger
22140 expressions containing EXPR. */
22143 build_non_dependent_expr (tree expr
)
22147 #ifdef ENABLE_CHECKING
22148 /* Try to get a constant value for all non-dependent expressions in
22149 order to expose bugs in *_dependent_expression_p and constexpr. */
22150 if (cxx_dialect
>= cxx11
)
22151 fold_non_dependent_expr (expr
);
22154 /* Preserve OVERLOADs; the functions must be available to resolve
22157 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
22158 inner_expr
= stmt_expr_value_expr (inner_expr
);
22159 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
22160 inner_expr
= TREE_OPERAND (inner_expr
, 0);
22161 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
22162 inner_expr
= TREE_OPERAND (inner_expr
, 1);
22163 if (is_overloaded_fn (inner_expr
)
22164 || TREE_CODE (inner_expr
) == OFFSET_REF
)
22166 /* There is no need to return a proxy for a variable. */
22169 /* Preserve string constants; conversions from string constants to
22170 "char *" are allowed, even though normally a "const char *"
22171 cannot be used to initialize a "char *". */
22172 if (TREE_CODE (expr
) == STRING_CST
)
22174 /* Preserve void and arithmetic constants, as an optimization -- there is no
22175 reason to create a new node. */
22176 if (TREE_CODE (expr
) == VOID_CST
22177 || TREE_CODE (expr
) == INTEGER_CST
22178 || TREE_CODE (expr
) == REAL_CST
)
22180 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
22181 There is at least one place where we want to know that a
22182 particular expression is a throw-expression: when checking a ?:
22183 expression, there are special rules if the second or third
22184 argument is a throw-expression. */
22185 if (TREE_CODE (expr
) == THROW_EXPR
)
22188 /* Don't wrap an initializer list, we need to be able to look inside. */
22189 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
22192 /* Don't wrap a dummy object, we need to be able to test for it. */
22193 if (is_dummy_object (expr
))
22196 if (TREE_CODE (expr
) == COND_EXPR
)
22197 return build3 (COND_EXPR
,
22199 TREE_OPERAND (expr
, 0),
22200 (TREE_OPERAND (expr
, 1)
22201 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
22202 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
22203 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
22204 if (TREE_CODE (expr
) == COMPOUND_EXPR
22205 && !COMPOUND_EXPR_OVERLOADED (expr
))
22206 return build2 (COMPOUND_EXPR
,
22208 TREE_OPERAND (expr
, 0),
22209 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
22211 /* If the type is unknown, it can't really be non-dependent */
22212 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
22214 /* Otherwise, build a NON_DEPENDENT_EXPR. */
22215 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
22218 /* ARGS is a vector of expressions as arguments to a function call.
22219 Replace the arguments with equivalent non-dependent expressions.
22220 This modifies ARGS in place. */
22223 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
22228 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
22230 tree newarg
= build_non_dependent_expr (arg
);
22232 (*args
)[ix
] = newarg
;
22236 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
22237 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
22241 make_auto_1 (tree name
)
22243 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
22244 TYPE_NAME (au
) = build_decl (input_location
,
22245 TYPE_DECL
, name
, au
);
22246 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
22247 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
22248 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
22249 TYPE_NAME (au
), NULL_TREE
);
22250 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
22251 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
22252 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
22258 make_decltype_auto (void)
22260 return make_auto_1 (get_identifier ("decltype(auto)"));
22266 return make_auto_1 (get_identifier ("auto"));
22269 /* Given type ARG, return std::initializer_list<ARG>. */
22274 tree std_init_list
= namespace_binding
22275 (get_identifier ("initializer_list"), std_node
);
22277 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
22279 error ("deducing from brace-enclosed initializer list requires "
22280 "#include <initializer_list>");
22281 return error_mark_node
;
22283 argvec
= make_tree_vec (1);
22284 TREE_VEC_ELT (argvec
, 0) = arg
;
22285 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
22286 NULL_TREE
, 0, tf_warning_or_error
);
22289 /* Replace auto in TYPE with std::initializer_list<auto>. */
22292 listify_autos (tree type
, tree auto_node
)
22294 tree init_auto
= listify (auto_node
);
22295 tree argvec
= make_tree_vec (1);
22296 TREE_VEC_ELT (argvec
, 0) = init_auto
;
22297 if (processing_template_decl
)
22298 argvec
= add_to_template_args (current_template_args (), argvec
);
22299 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22302 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
22303 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
22306 do_auto_deduction (tree type
, tree init
, tree auto_node
)
22310 if (init
== error_mark_node
)
22311 return error_mark_node
;
22313 if (type_dependent_expression_p (init
))
22314 /* Defining a subset of type-dependent expressions that we can deduce
22315 from ahead of time isn't worth the trouble. */
22318 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
22319 with either a new invented type template parameter U or, if the
22320 initializer is a braced-init-list (8.5.4), with
22321 std::initializer_list<U>. */
22322 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
22324 if (!DIRECT_LIST_INIT_P (init
))
22325 type
= listify_autos (type
, auto_node
);
22326 else if (CONSTRUCTOR_NELTS (init
) == 1)
22327 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
22330 if (permerror (input_location
, "direct-list-initialization of "
22331 "%<auto%> requires exactly one element"))
22332 inform (input_location
,
22333 "for deduction to %<std::initializer_list%>, use copy-"
22334 "list-initialization (i.e. add %<=%> before the %<{%>)");
22335 type
= listify_autos (type
, auto_node
);
22339 init
= resolve_nondeduced_context (init
);
22341 targs
= make_tree_vec (1);
22342 if (AUTO_IS_DECLTYPE (auto_node
))
22344 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
22345 && !REF_PARENTHESIZED_P (init
)));
22346 TREE_VEC_ELT (targs
, 0)
22347 = finish_decltype_type (init
, id
, tf_warning_or_error
);
22348 if (type
!= auto_node
)
22350 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
22351 return error_mark_node
;
22356 tree parms
= build_tree_list (NULL_TREE
, type
);
22357 tree tparms
= make_tree_vec (1);
22360 TREE_VEC_ELT (tparms
, 0)
22361 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
22362 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
22363 DEDUCE_CALL
, LOOKUP_NORMAL
,
22364 NULL
, /*explain_p=*/false);
22367 if (processing_template_decl
)
22368 /* Try again at instantiation time. */
22370 if (type
&& type
!= error_mark_node
)
22371 /* If type is error_mark_node a diagnostic must have been
22372 emitted by now. Also, having a mention to '<type error>'
22373 in the diagnostic is not really useful to the user. */
22375 if (cfun
&& auto_node
== current_function_auto_return_pattern
22376 && LAMBDA_FUNCTION_P (current_function_decl
))
22377 error ("unable to deduce lambda return type from %qE", init
);
22379 error ("unable to deduce %qT from %qE", type
, init
);
22381 return error_mark_node
;
22385 /* If the list of declarators contains more than one declarator, the type
22386 of each declared variable is determined as described above. If the
22387 type deduced for the template parameter U is not the same in each
22388 deduction, the program is ill-formed. */
22389 if (TREE_TYPE (auto_node
)
22390 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
22392 if (cfun
&& auto_node
== current_function_auto_return_pattern
22393 && LAMBDA_FUNCTION_P (current_function_decl
))
22394 error ("inconsistent types %qT and %qT deduced for "
22395 "lambda return type", TREE_TYPE (auto_node
),
22396 TREE_VEC_ELT (targs
, 0));
22398 error ("inconsistent deduction for %qT: %qT and then %qT",
22399 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
22400 return error_mark_node
;
22402 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
22404 if (processing_template_decl
)
22405 targs
= add_to_template_args (current_template_args (), targs
);
22406 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
22409 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22413 splice_late_return_type (tree type
, tree late_return_type
)
22417 if (late_return_type
== NULL_TREE
)
22419 argvec
= make_tree_vec (1);
22420 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
22421 if (processing_template_parmlist
)
22422 /* For a late-specified return type in a template type-parameter, we
22423 need to add a dummy argument level for its parmlist. */
22424 argvec
= add_to_template_args
22425 (make_tree_vec (processing_template_parmlist
), argvec
);
22426 if (current_template_parms
)
22427 argvec
= add_to_template_args (current_template_args (), argvec
);
22428 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22431 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22432 'decltype(auto)'. */
22435 is_auto (const_tree type
)
22437 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
22438 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
22439 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
22445 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22446 a use of `auto'. Returns NULL_TREE otherwise. */
22449 type_uses_auto (tree type
)
22451 return find_type_usage (type
, is_auto
);
22454 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22455 'decltype(auto)' or a concept. */
22458 is_auto_or_concept (const_tree type
)
22460 return is_auto (type
); // or concept
22463 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22464 a concept identifier) iff TYPE contains a use of a generic type. Returns
22465 NULL_TREE otherwise. */
22468 type_uses_auto_or_concept (tree type
)
22470 return find_type_usage (type
, is_auto_or_concept
);
22474 /* For a given template T, return the vector of typedefs referenced
22475 in T for which access check is needed at T instantiation time.
22476 T is either a FUNCTION_DECL or a RECORD_TYPE.
22477 Those typedefs were added to T by the function
22478 append_type_to_template_for_access_check. */
22480 vec
<qualified_typedef_usage_t
, va_gc
> *
22481 get_types_needing_access_check (tree t
)
22484 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
22486 if (!t
|| t
== error_mark_node
)
22489 if (!(ti
= get_template_info (t
)))
22492 if (CLASS_TYPE_P (t
)
22493 || TREE_CODE (t
) == FUNCTION_DECL
)
22495 if (!TI_TEMPLATE (ti
))
22498 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
22504 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22505 tied to T. That list of typedefs will be access checked at
22506 T instantiation time.
22507 T is either a FUNCTION_DECL or a RECORD_TYPE.
22508 TYPE_DECL is a TYPE_DECL node representing a typedef.
22509 SCOPE is the scope through which TYPE_DECL is accessed.
22510 LOCATION is the location of the usage point of TYPE_DECL.
22512 This function is a subroutine of
22513 append_type_to_template_for_access_check. */
22516 append_type_to_template_for_access_check_1 (tree t
,
22519 location_t location
)
22521 qualified_typedef_usage_t typedef_usage
;
22524 if (!t
|| t
== error_mark_node
)
22527 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
22528 || CLASS_TYPE_P (t
))
22530 && TREE_CODE (type_decl
) == TYPE_DECL
22533 if (!(ti
= get_template_info (t
)))
22536 gcc_assert (TI_TEMPLATE (ti
));
22538 typedef_usage
.typedef_decl
= type_decl
;
22539 typedef_usage
.context
= scope
;
22540 typedef_usage
.locus
= location
;
22542 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22545 /* Append TYPE_DECL to the template TEMPL.
22546 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22547 At TEMPL instanciation time, TYPE_DECL will be checked to see
22548 if it can be accessed through SCOPE.
22549 LOCATION is the location of the usage point of TYPE_DECL.
22551 e.g. consider the following code snippet:
22558 template<class U> struct S
22560 C::myint mi; // <-- usage point of the typedef C::myint
22565 At S<char> instantiation time, we need to check the access of C::myint
22566 In other words, we need to check the access of the myint typedef through
22567 the C scope. For that purpose, this function will add the myint typedef
22568 and the scope C through which its being accessed to a list of typedefs
22569 tied to the template S. That list will be walked at template instantiation
22570 time and access check performed on each typedefs it contains.
22571 Note that this particular code snippet should yield an error because
22572 myint is private to C. */
22575 append_type_to_template_for_access_check (tree templ
,
22578 location_t location
)
22580 qualified_typedef_usage_t
*iter
;
22583 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22585 /* Make sure we don't append the type to the template twice. */
22586 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22587 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22590 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22594 /* Convert the generic type parameters in PARM that match the types given in the
22595 range [START_IDX, END_IDX) from the current_template_parms into generic type
22599 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22601 tree current
= current_template_parms
;
22602 int depth
= TMPL_PARMS_DEPTH (current
);
22603 current
= INNERMOST_TEMPLATE_PARMS (current
);
22604 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22606 for (int i
= 0; i
< start_idx
; ++i
)
22607 TREE_VEC_ELT (replacement
, i
)
22608 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22610 for (int i
= start_idx
; i
< end_idx
; ++i
)
22612 /* Create a distinct parameter pack type from the current parm and add it
22613 to the replacement args to tsubst below into the generic function
22616 tree o
= TREE_TYPE (TREE_VALUE
22617 (TREE_VEC_ELT (current
, i
)));
22618 tree t
= copy_type (o
);
22619 TEMPLATE_TYPE_PARM_INDEX (t
)
22620 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22622 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22623 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22624 TYPE_MAIN_VARIANT (t
) = t
;
22625 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22626 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22627 TREE_VEC_ELT (replacement
, i
) = t
;
22628 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22631 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22632 TREE_VEC_ELT (replacement
, i
)
22633 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22635 /* If there are more levels then build up the replacement with the outer
22638 replacement
= add_to_template_args (template_parms_to_args
22639 (TREE_CHAIN (current_template_parms
)),
22642 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22646 /* Set up the hash tables for template instantiations. */
22649 init_template_processing (void)
22651 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22652 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22655 /* Print stats about the template hash tables for -fstats. */
22658 print_template_statistics (void)
22660 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22661 "%f collisions\n", (long) decl_specializations
->size (),
22662 (long) decl_specializations
->elements (),
22663 decl_specializations
->collisions ());
22664 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22665 "%f collisions\n", (long) type_specializations
->size (),
22666 (long) type_specializations
->elements (),
22667 type_specializations
->collisions ());
22670 #include "gt-cp-pt.h"