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
&& TREE_CODE (decl
) != VAR_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 (TREE_CODE (decl
) == VAR_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
)))
4774 || (TREE_CODE (decl
) == VAR_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
&& TREE_CODE (decl
) != VAR_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 (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
11471 set_decl_tls_model (r
, decl_tls_model (t
));
11473 else if (DECL_SELF_REFERENCE_P (t
))
11474 SET_DECL_SELF_REFERENCE_P (r
);
11475 TREE_TYPE (r
) = type
;
11476 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11477 DECL_CONTEXT (r
) = ctx
;
11478 /* Clear out the mangled name and RTL for the instantiation. */
11479 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11480 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11481 SET_DECL_RTL (r
, NULL
);
11482 /* The initializer must not be expanded until it is required;
11483 see [temp.inst]. */
11484 DECL_INITIAL (r
) = NULL_TREE
;
11485 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11486 SET_DECL_RTL (r
, NULL
);
11487 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11490 /* Possibly limit visibility based on template args. */
11491 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11492 if (DECL_VISIBILITY_SPECIFIED (t
))
11494 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11495 DECL_ATTRIBUTES (r
)
11496 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11498 determine_visibility (r
);
11503 /* A static data member declaration is always marked
11504 external when it is declared in-class, even if an
11505 initializer is present. We mimic the non-template
11506 processing here. */
11507 DECL_EXTERNAL (r
) = 1;
11508 if (DECL_NAMESPACE_SCOPE_P (t
))
11509 DECL_NOT_REALLY_EXTERN (r
) = 1;
11511 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11512 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11513 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11515 else if (!cp_unevaluated_operand
)
11516 register_local_specialization (r
, t
);
11518 DECL_CHAIN (r
) = NULL_TREE
;
11520 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11522 args
, complain
, in_decl
);
11524 /* Preserve a typedef that names a type. */
11525 if (is_typedef_decl (r
))
11527 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11528 set_underlying_type (r
);
11531 layout_decl (r
, 0);
11536 gcc_unreachable ();
11541 /* Restore the file and line information. */
11542 input_location
= saved_loc
;
11547 /* Substitute into the ARG_TYPES of a function type.
11548 If END is a TREE_CHAIN, leave it and any following types
11552 tsubst_arg_types (tree arg_types
,
11555 tsubst_flags_t complain
,
11558 tree remaining_arg_types
;
11559 tree type
= NULL_TREE
;
11561 tree expanded_args
= NULL_TREE
;
11564 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11567 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11568 args
, end
, complain
, in_decl
);
11569 if (remaining_arg_types
== error_mark_node
)
11570 return error_mark_node
;
11572 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11574 /* For a pack expansion, perform substitution on the
11575 entire expression. Later on, we'll handle the arguments
11577 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11578 args
, complain
, in_decl
);
11580 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11581 /* So that we'll spin through the parameters, one by one. */
11582 i
= TREE_VEC_LENGTH (expanded_args
);
11585 /* We only partially substituted into the parameter
11586 pack. Our type is TYPE_PACK_EXPANSION. */
11587 type
= expanded_args
;
11588 expanded_args
= NULL_TREE
;
11596 type
= TREE_VEC_ELT (expanded_args
, i
);
11598 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11600 if (type
== error_mark_node
)
11601 return error_mark_node
;
11602 if (VOID_TYPE_P (type
))
11604 if (complain
& tf_error
)
11606 error ("invalid parameter type %qT", type
);
11608 error ("in declaration %q+D", in_decl
);
11610 return error_mark_node
;
11613 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11614 return error_mark_node
;
11616 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11617 top-level qualifiers as required. */
11618 type
= cv_unqualified (type_decays_to (type
));
11620 /* We do not substitute into default arguments here. The standard
11621 mandates that they be instantiated only when needed, which is
11622 done in build_over_call. */
11623 default_arg
= TREE_PURPOSE (arg_types
);
11625 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11627 /* We've instantiated a template before its default arguments
11628 have been parsed. This can happen for a nested template
11629 class, and is not an error unless we require the default
11630 argument in a call of this function. */
11631 remaining_arg_types
=
11632 tree_cons (default_arg
, type
, remaining_arg_types
);
11633 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11636 remaining_arg_types
=
11637 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11640 return remaining_arg_types
;
11643 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11644 *not* handle the exception-specification for FNTYPE, because the
11645 initial substitution of explicitly provided template parameters
11646 during argument deduction forbids substitution into the
11647 exception-specification:
11651 All references in the function type of the function template to the
11652 corresponding template parameters are replaced by the specified tem-
11653 plate argument values. If a substitution in a template parameter or
11654 in the function type of the function template results in an invalid
11655 type, type deduction fails. [Note: The equivalent substitution in
11656 exception specifications is done only when the function is instanti-
11657 ated, at which point a program is ill-formed if the substitution
11658 results in an invalid type.] */
11661 tsubst_function_type (tree t
,
11663 tsubst_flags_t complain
,
11667 tree arg_types
= NULL_TREE
;
11670 /* The TYPE_CONTEXT is not used for function/method types. */
11671 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11673 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11675 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11677 if (late_return_type_p
)
11679 /* Substitute the argument types. */
11680 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11681 complain
, in_decl
);
11682 if (arg_types
== error_mark_node
)
11683 return error_mark_node
;
11685 tree save_ccp
= current_class_ptr
;
11686 tree save_ccr
= current_class_ref
;
11687 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11688 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11689 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11692 /* DR 1207: 'this' is in scope in the trailing return type. */
11693 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11696 /* Substitute the return type. */
11697 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11701 current_class_ptr
= save_ccp
;
11702 current_class_ref
= save_ccr
;
11706 /* Substitute the return type. */
11707 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11709 if (return_type
== error_mark_node
)
11710 return error_mark_node
;
11711 /* DR 486 clarifies that creation of a function type with an
11712 invalid return type is a deduction failure. */
11713 if (TREE_CODE (return_type
) == ARRAY_TYPE
11714 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11716 if (complain
& tf_error
)
11718 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11719 error ("function returning an array");
11721 error ("function returning a function");
11723 return error_mark_node
;
11726 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11727 return error_mark_node
;
11729 if (!late_return_type_p
)
11731 /* Substitute the argument types. */
11732 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11733 complain
, in_decl
);
11734 if (arg_types
== error_mark_node
)
11735 return error_mark_node
;
11738 /* Construct a new type node and return it. */
11739 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11741 fntype
= build_function_type (return_type
, arg_types
);
11742 fntype
= apply_memfn_quals (fntype
,
11743 type_memfn_quals (t
),
11744 type_memfn_rqual (t
));
11748 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11749 /* Don't pick up extra function qualifiers from the basetype. */
11750 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11751 if (! MAYBE_CLASS_TYPE_P (r
))
11755 Type deduction may fail for any of the following
11758 -- Attempting to create "pointer to member of T" when T
11759 is not a class type. */
11760 if (complain
& tf_error
)
11761 error ("creating pointer to member function of non-class type %qT",
11763 return error_mark_node
;
11766 fntype
= build_method_type_directly (r
, return_type
,
11767 TREE_CHAIN (arg_types
));
11768 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11770 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11772 if (late_return_type_p
)
11773 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11778 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11779 ARGS into that specification, and return the substituted
11780 specification. If there is no specification, return NULL_TREE. */
11783 tsubst_exception_specification (tree fntype
,
11785 tsubst_flags_t complain
,
11792 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11793 new_specs
= NULL_TREE
;
11794 if (specs
&& TREE_PURPOSE (specs
))
11796 /* A noexcept-specifier. */
11797 tree expr
= TREE_PURPOSE (specs
);
11798 if (TREE_CODE (expr
) == INTEGER_CST
)
11802 /* Defer instantiation of noexcept-specifiers to avoid
11803 excessive instantiations (c++/49107). */
11804 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11805 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11807 /* We already partially instantiated this member template,
11808 so combine the new args with the old. */
11809 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11810 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11811 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11812 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11816 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11817 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11821 new_specs
= tsubst_copy_and_build
11822 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11823 /*integral_constant_expression_p=*/true);
11824 new_specs
= build_noexcept_spec (new_specs
, complain
);
11828 if (! TREE_VALUE (specs
))
11835 tree expanded_specs
= NULL_TREE
;
11837 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11839 /* Expand the pack expansion type. */
11840 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11844 if (expanded_specs
== error_mark_node
)
11845 return error_mark_node
;
11846 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11847 len
= TREE_VEC_LENGTH (expanded_specs
);
11850 /* We're substituting into a member template, so
11851 we got a TYPE_PACK_EXPANSION back. Add that
11852 expansion and move on. */
11853 gcc_assert (TREE_CODE (expanded_specs
)
11854 == TYPE_PACK_EXPANSION
);
11855 new_specs
= add_exception_specifier (new_specs
,
11858 specs
= TREE_CHAIN (specs
);
11863 for (i
= 0; i
< len
; ++i
)
11865 if (expanded_specs
)
11866 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11868 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11869 if (spec
== error_mark_node
)
11871 new_specs
= add_exception_specifier (new_specs
, spec
,
11875 specs
= TREE_CHAIN (specs
);
11881 /* Take the tree structure T and replace template parameters used
11882 therein with the argument vector ARGS. IN_DECL is an associated
11883 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11884 Issue error and warning messages under control of COMPLAIN. Note
11885 that we must be relatively non-tolerant of extensions here, in
11886 order to preserve conformance; if we allow substitutions that
11887 should not be allowed, we may allow argument deductions that should
11888 not succeed, and therefore report ambiguous overload situations
11889 where there are none. In theory, we could allow the substitution,
11890 but indicate that it should have failed, and allow our caller to
11891 make sure that the right thing happens, but we don't try to do this
11894 This function is used for dealing with types, decls and the like;
11895 for expressions, use tsubst_expr or tsubst_copy. */
11898 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11900 enum tree_code code
;
11901 tree type
, r
= NULL_TREE
;
11903 if (t
== NULL_TREE
|| t
== error_mark_node
11904 || t
== integer_type_node
11905 || t
== void_type_node
11906 || t
== char_type_node
11907 || t
== unknown_type_node
11908 || TREE_CODE (t
) == NAMESPACE_DECL
11909 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11913 return tsubst_decl (t
, args
, complain
);
11915 if (args
== NULL_TREE
)
11918 code
= TREE_CODE (t
);
11920 if (code
== IDENTIFIER_NODE
)
11921 type
= IDENTIFIER_TYPE_VALUE (t
);
11923 type
= TREE_TYPE (t
);
11925 gcc_assert (type
!= unknown_type_node
);
11927 /* Reuse typedefs. We need to do this to handle dependent attributes,
11928 such as attribute aligned. */
11930 && typedef_variant_p (t
))
11932 tree decl
= TYPE_NAME (t
);
11934 if (alias_template_specialization_p (t
))
11936 /* DECL represents an alias template and we want to
11938 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11939 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11940 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11942 else if (DECL_CLASS_SCOPE_P (decl
)
11943 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11944 && uses_template_parms (DECL_CONTEXT (decl
)))
11946 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11947 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11948 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11950 else if (DECL_FUNCTION_SCOPE_P (decl
)
11951 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11952 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11953 r
= retrieve_local_specialization (decl
);
11955 /* The typedef is from a non-template context. */
11961 r
= cp_build_qualified_type_real
11962 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11963 complain
| tf_ignore_bad_quals
);
11968 /* We don't have an instantiation yet, so drop the typedef. */
11969 int quals
= cp_type_quals (t
);
11970 t
= DECL_ORIGINAL_TYPE (decl
);
11971 t
= cp_build_qualified_type_real (t
, quals
,
11972 complain
| tf_ignore_bad_quals
);
11977 && code
!= TYPENAME_TYPE
11978 && code
!= TEMPLATE_TYPE_PARM
11979 && code
!= IDENTIFIER_NODE
11980 && code
!= FUNCTION_TYPE
11981 && code
!= METHOD_TYPE
)
11982 type
= tsubst (type
, args
, complain
, in_decl
);
11983 if (type
== error_mark_node
)
11984 return error_mark_node
;
11990 case ENUMERAL_TYPE
:
11991 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11992 /*entering_scope=*/0);
11995 case IDENTIFIER_NODE
:
12006 if (t
== integer_type_node
)
12009 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
12010 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
12014 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
12016 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
12017 /*integral_constant_expression_p=*/false);
12019 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
12021 if (TREE_CODE (max
) == NOP_EXPR
12022 && TREE_SIDE_EFFECTS (omax
)
12023 && !TREE_TYPE (max
))
12024 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
12026 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
12027 with TREE_SIDE_EFFECTS that indicates this is not an integral
12028 constant expression. */
12029 if (processing_template_decl
12030 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
12032 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
12033 TREE_SIDE_EFFECTS (max
) = 1;
12036 return compute_array_index_type (NULL_TREE
, max
, complain
);
12039 case TEMPLATE_TYPE_PARM
:
12040 case TEMPLATE_TEMPLATE_PARM
:
12041 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12042 case TEMPLATE_PARM_INDEX
:
12047 tree arg
= NULL_TREE
;
12051 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
12052 template_parm_level_and_index (t
, &level
, &idx
);
12054 levels
= TMPL_ARGS_DEPTH (args
);
12055 if (level
<= levels
)
12057 arg
= TMPL_ARG (args
, level
, idx
);
12059 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
12061 /* See through ARGUMENT_PACK_SELECT arguments. */
12062 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
12063 /* If the selected argument is an expansion E, that most
12064 likely means we were called from
12065 gen_elem_of_pack_expansion_instantiation during the
12066 substituting of pack an argument pack (which Ith
12067 element is a pack expansion, where I is
12068 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
12069 In this case, the Ith element resulting from this
12070 substituting is going to be a pack expansion, which
12071 pattern is the pattern of E. Let's return the
12073 gen_elem_of_pack_expansion_instantiation will
12074 build the resulting pack expansion from it. */
12075 if (PACK_EXPANSION_P (arg
))
12077 /* Make sure we aren't throwing away arg info. */
12078 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
12079 arg
= PACK_EXPANSION_PATTERN (arg
);
12084 if (arg
== error_mark_node
)
12085 return error_mark_node
;
12086 else if (arg
!= NULL_TREE
)
12088 if (ARGUMENT_PACK_P (arg
))
12089 /* If ARG is an argument pack, we don't actually want to
12090 perform a substitution here, because substitutions
12091 for argument packs are only done
12092 element-by-element. We can get to this point when
12093 substituting the type of a non-type template
12094 parameter pack, when that type actually contains
12095 template parameter packs from an outer template, e.g.,
12097 template<typename... Types> struct A {
12098 template<Types... Values> struct B { };
12102 if (code
== TEMPLATE_TYPE_PARM
)
12105 gcc_assert (TYPE_P (arg
));
12107 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
12109 return cp_build_qualified_type_real
12110 (arg
, quals
, complain
| tf_ignore_bad_quals
);
12112 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12114 /* We are processing a type constructed from a
12115 template template parameter. */
12116 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
12117 args
, complain
, in_decl
);
12118 if (argvec
== error_mark_node
)
12119 return error_mark_node
;
12121 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
12122 || TREE_CODE (arg
) == TEMPLATE_DECL
12123 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
12125 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
12126 /* Consider this code:
12128 template <template <class> class Template>
12130 template <class Arg> using Bind = Template<Arg>;
12133 template <template <class> class Template, class Arg>
12134 using Instantiate = Template<Arg>; //#0
12136 template <template <class> class Template,
12139 Instantiate<Internal<Template>::template Bind,
12142 When #1 is parsed, the
12143 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12144 parameter `Template' in #0 matches the
12145 UNBOUND_CLASS_TEMPLATE representing the argument
12146 `Internal<Template>::template Bind'; We then want
12147 to assemble the type `Bind<Argument>' that can't
12148 be fully created right now, because
12149 `Internal<Template>' not being complete, the Bind
12150 template cannot be looked up in that context. So
12151 we need to "store" `Bind<Argument>' for later
12152 when the context of Bind becomes complete. Let's
12153 store that in a TYPENAME_TYPE. */
12154 return make_typename_type (TYPE_CONTEXT (arg
),
12155 build_nt (TEMPLATE_ID_EXPR
,
12156 TYPE_IDENTIFIER (arg
),
12161 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12162 are resolving nested-types in the signature of a
12163 member function templates. Otherwise ARG is a
12164 TEMPLATE_DECL and is the real template to be
12166 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
12167 arg
= TYPE_NAME (arg
);
12169 r
= lookup_template_class (arg
,
12171 DECL_CONTEXT (arg
),
12172 /*entering_scope=*/0,
12174 return cp_build_qualified_type_real
12175 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
12178 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12179 return convert_from_reference (unshare_expr (arg
));
12183 /* This can happen during the attempted tsubst'ing in
12184 unify. This means that we don't yet have any information
12185 about the template parameter in question. */
12188 /* Early in template argument deduction substitution, we don't
12189 want to reduce the level of 'auto', or it will be confused
12190 with a normal template parm in subsequent deduction. */
12191 if (is_auto (t
) && (complain
& tf_partial
))
12194 /* If we get here, we must have been looking at a parm for a
12195 more deeply nested template. Make a new version of this
12196 template parameter, but with a lower level. */
12199 case TEMPLATE_TYPE_PARM
:
12200 case TEMPLATE_TEMPLATE_PARM
:
12201 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12202 if (cp_type_quals (t
))
12204 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
12205 r
= cp_build_qualified_type_real
12206 (r
, cp_type_quals (t
),
12207 complain
| (code
== TEMPLATE_TYPE_PARM
12208 ? tf_ignore_bad_quals
: 0));
12213 TEMPLATE_TYPE_PARM_INDEX (r
)
12214 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
12215 r
, levels
, args
, complain
);
12216 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
12217 TYPE_MAIN_VARIANT (r
) = r
;
12218 TYPE_POINTER_TO (r
) = NULL_TREE
;
12219 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
12221 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
12222 /* We have reduced the level of the template
12223 template parameter, but not the levels of its
12224 template parameters, so canonical_type_parameter
12225 will not be able to find the canonical template
12226 template parameter for this level. Thus, we
12227 require structural equality checking to compare
12228 TEMPLATE_TEMPLATE_PARMs. */
12229 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12230 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
12231 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12233 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
12235 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12237 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
12238 complain
, in_decl
);
12239 if (argvec
== error_mark_node
)
12240 return error_mark_node
;
12242 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
12243 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
12248 case TEMPLATE_PARM_INDEX
:
12249 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
12253 gcc_unreachable ();
12261 tree purpose
, value
, chain
;
12263 if (t
== void_list_node
)
12266 purpose
= TREE_PURPOSE (t
);
12269 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
12270 if (purpose
== error_mark_node
)
12271 return error_mark_node
;
12273 value
= TREE_VALUE (t
);
12276 value
= tsubst (value
, args
, complain
, in_decl
);
12277 if (value
== error_mark_node
)
12278 return error_mark_node
;
12280 chain
= TREE_CHAIN (t
);
12281 if (chain
&& chain
!= void_type_node
)
12283 chain
= tsubst (chain
, args
, complain
, in_decl
);
12284 if (chain
== error_mark_node
)
12285 return error_mark_node
;
12287 if (purpose
== TREE_PURPOSE (t
)
12288 && value
== TREE_VALUE (t
)
12289 && chain
== TREE_CHAIN (t
))
12291 return hash_tree_cons (purpose
, value
, chain
);
12295 /* We should never be tsubsting a binfo. */
12296 gcc_unreachable ();
12299 /* A vector of template arguments. */
12300 gcc_assert (!type
);
12301 return tsubst_template_args (t
, args
, complain
, in_decl
);
12304 case REFERENCE_TYPE
:
12306 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
12311 Type deduction may fail for any of the following
12314 -- Attempting to create a pointer to reference type.
12315 -- Attempting to create a reference to a reference type or
12316 a reference to void.
12318 Core issue 106 says that creating a reference to a reference
12319 during instantiation is no longer a cause for failure. We
12320 only enforce this check in strict C++98 mode. */
12321 if ((TREE_CODE (type
) == REFERENCE_TYPE
12322 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
12323 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
12325 static location_t last_loc
;
12327 /* We keep track of the last time we issued this error
12328 message to avoid spewing a ton of messages during a
12329 single bad template instantiation. */
12330 if (complain
& tf_error
12331 && last_loc
!= input_location
)
12333 if (VOID_TYPE_P (type
))
12334 error ("forming reference to void");
12335 else if (code
== POINTER_TYPE
)
12336 error ("forming pointer to reference type %qT", type
);
12338 error ("forming reference to reference type %qT", type
);
12339 last_loc
= input_location
;
12342 return error_mark_node
;
12344 else if (TREE_CODE (type
) == FUNCTION_TYPE
12345 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
12346 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12348 if (complain
& tf_error
)
12350 if (code
== POINTER_TYPE
)
12351 error ("forming pointer to qualified function type %qT",
12354 error ("forming reference to qualified function type %qT",
12357 return error_mark_node
;
12359 else if (code
== POINTER_TYPE
)
12361 r
= build_pointer_type (type
);
12362 if (TREE_CODE (type
) == METHOD_TYPE
)
12363 r
= build_ptrmemfunc_type (r
);
12365 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12366 /* In C++0x, during template argument substitution, when there is an
12367 attempt to create a reference to a reference type, reference
12368 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12370 "If a template-argument for a template-parameter T names a type
12371 that is a reference to a type A, an attempt to create the type
12372 'lvalue reference to cv T' creates the type 'lvalue reference to
12373 A,' while an attempt to create the type type rvalue reference to
12374 cv T' creates the type T"
12376 r
= cp_build_reference_type
12378 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12380 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12381 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12383 if (r
!= error_mark_node
)
12384 /* Will this ever be needed for TYPE_..._TO values? */
12391 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12392 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12396 Type deduction may fail for any of the following
12399 -- Attempting to create "pointer to member of T" when T
12400 is not a class type. */
12401 if (complain
& tf_error
)
12402 error ("creating pointer to member of non-class type %qT", r
);
12403 return error_mark_node
;
12405 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12407 if (complain
& tf_error
)
12408 error ("creating pointer to member reference type %qT", type
);
12409 return error_mark_node
;
12411 if (VOID_TYPE_P (type
))
12413 if (complain
& tf_error
)
12414 error ("creating pointer to member of type void");
12415 return error_mark_node
;
12417 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12418 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12420 /* The type of the implicit object parameter gets its
12421 cv-qualifiers from the FUNCTION_TYPE. */
12424 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12425 type_memfn_rqual (type
));
12426 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12427 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12431 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12435 case FUNCTION_TYPE
:
12440 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12441 if (fntype
== error_mark_node
)
12442 return error_mark_node
;
12444 /* Substitute the exception specification. */
12445 specs
= tsubst_exception_specification (t
, args
, complain
,
12446 in_decl
, /*defer_ok*/true);
12447 if (specs
== error_mark_node
)
12448 return error_mark_node
;
12450 fntype
= build_exception_variant (fntype
, specs
);
12455 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12456 if (domain
== error_mark_node
)
12457 return error_mark_node
;
12459 /* As an optimization, we avoid regenerating the array type if
12460 it will obviously be the same as T. */
12461 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12464 /* These checks should match the ones in create_array_type_for_decl.
12468 The deduction may fail for any of the following reasons:
12470 -- Attempting to create an array with an element type that
12471 is void, a function type, or a reference type, or [DR337]
12472 an abstract class type. */
12473 if (VOID_TYPE_P (type
)
12474 || TREE_CODE (type
) == FUNCTION_TYPE
12475 || (TREE_CODE (type
) == ARRAY_TYPE
12476 && TYPE_DOMAIN (type
) == NULL_TREE
)
12477 || TREE_CODE (type
) == REFERENCE_TYPE
)
12479 if (complain
& tf_error
)
12480 error ("creating array of %qT", type
);
12481 return error_mark_node
;
12484 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12485 return error_mark_node
;
12487 r
= build_cplus_array_type (type
, domain
);
12489 if (TYPE_USER_ALIGN (t
))
12491 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12492 TYPE_USER_ALIGN (r
) = 1;
12498 case TYPENAME_TYPE
:
12500 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12501 in_decl
, /*entering_scope=*/1);
12502 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12503 complain
, in_decl
);
12505 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12506 return error_mark_node
;
12508 if (!MAYBE_CLASS_TYPE_P (ctx
))
12510 if (complain
& tf_error
)
12511 error ("%qT is not a class, struct, or union type", ctx
);
12512 return error_mark_node
;
12514 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12516 /* Normally, make_typename_type does not require that the CTX
12517 have complete type in order to allow things like:
12519 template <class T> struct S { typename S<T>::X Y; };
12521 But, such constructs have already been resolved by this
12522 point, so here CTX really should have complete type, unless
12523 it's a partial instantiation. */
12524 ctx
= complete_type (ctx
);
12525 if (!COMPLETE_TYPE_P (ctx
))
12527 if (complain
& tf_error
)
12528 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12529 return error_mark_node
;
12533 f
= make_typename_type (ctx
, f
, typename_type
,
12534 complain
| tf_keep_type_decl
);
12535 if (f
== error_mark_node
)
12537 if (TREE_CODE (f
) == TYPE_DECL
)
12539 complain
|= tf_ignore_bad_quals
;
12543 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12545 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12547 if (complain
& tf_error
)
12548 error ("%qT resolves to %qT, which is not an enumeration type",
12551 return error_mark_node
;
12553 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12555 if (complain
& tf_error
)
12556 error ("%qT resolves to %qT, which is is not a class type",
12559 return error_mark_node
;
12563 return cp_build_qualified_type_real
12564 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12567 case UNBOUND_CLASS_TEMPLATE
:
12569 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12570 in_decl
, /*entering_scope=*/1);
12571 tree name
= TYPE_IDENTIFIER (t
);
12572 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12574 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12575 return error_mark_node
;
12578 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12579 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12586 ++cp_unevaluated_operand
;
12587 ++c_inhibit_evaluation_warnings
;
12589 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12591 /*integral_constant_expression_p=*/false);
12593 --cp_unevaluated_operand
;
12594 --c_inhibit_evaluation_warnings
;
12596 type
= finish_typeof (type
);
12597 return cp_build_qualified_type_real (type
,
12599 | cp_type_quals (type
),
12603 case DECLTYPE_TYPE
:
12607 ++cp_unevaluated_operand
;
12608 ++c_inhibit_evaluation_warnings
;
12610 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12611 complain
|tf_decltype
, in_decl
,
12612 /*function_p*/false,
12613 /*integral_constant_expression*/false);
12615 --cp_unevaluated_operand
;
12616 --c_inhibit_evaluation_warnings
;
12618 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12619 type
= lambda_capture_field_type (type
,
12620 DECLTYPE_FOR_INIT_CAPTURE (t
));
12621 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12622 type
= lambda_proxy_type (type
);
12625 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12626 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12628 /* In a template ~id could be either a complement expression
12629 or an unqualified-id naming a destructor; if instantiating
12630 it produces an expression, it's not an id-expression or
12633 type
= finish_decltype_type (type
, id
, complain
);
12635 return cp_build_qualified_type_real (type
,
12637 | cp_type_quals (type
),
12638 complain
| tf_ignore_bad_quals
);
12641 case UNDERLYING_TYPE
:
12643 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12644 complain
, in_decl
);
12645 return finish_underlying_type (type
);
12648 case TYPE_ARGUMENT_PACK
:
12649 case NONTYPE_ARGUMENT_PACK
:
12651 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12653 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12657 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12659 /* For template nontype argument packs, also substitute into
12661 if (code
== NONTYPE_ARGUMENT_PACK
)
12662 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12681 /* We should use one of the expression tsubsts for these codes. */
12682 gcc_unreachable ();
12685 sorry ("use of %qs in template", get_tree_code_name (code
));
12686 return error_mark_node
;
12690 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12691 type of the expression on the left-hand side of the "." or "->"
12695 tsubst_baselink (tree baselink
, tree object_type
,
12696 tree args
, tsubst_flags_t complain
, tree in_decl
)
12699 tree qualifying_scope
;
12702 tree template_args
= 0;
12703 bool template_id_p
= false;
12704 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12706 /* A baselink indicates a function from a base class. Both the
12707 BASELINK_ACCESS_BINFO and the base class referenced may
12708 indicate bases of the template class, rather than the
12709 instantiated class. In addition, lookups that were not
12710 ambiguous before may be ambiguous now. Therefore, we perform
12711 the lookup again. */
12712 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12713 qualifying_scope
= tsubst (qualifying_scope
, args
,
12714 complain
, in_decl
);
12715 fns
= BASELINK_FUNCTIONS (baselink
);
12716 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12717 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12719 template_id_p
= true;
12720 template_args
= TREE_OPERAND (fns
, 1);
12721 fns
= TREE_OPERAND (fns
, 0);
12723 template_args
= tsubst_template_args (template_args
, args
,
12724 complain
, in_decl
);
12726 name
= DECL_NAME (get_first_fn (fns
));
12727 if (IDENTIFIER_TYPENAME_P (name
))
12728 name
= mangle_conv_op_name_for_type (optype
);
12729 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12731 return error_mark_node
;
12733 /* If lookup found a single function, mark it as used at this
12734 point. (If it lookup found multiple functions the one selected
12735 later by overload resolution will be marked as used at that
12737 if (BASELINK_P (baselink
))
12738 fns
= BASELINK_FUNCTIONS (baselink
);
12739 if (!template_id_p
&& !really_overloaded_fn (fns
)
12740 && !mark_used (OVL_CURRENT (fns
), complain
) && !(complain
& tf_error
))
12741 return error_mark_node
;
12743 /* Add back the template arguments, if present. */
12744 if (BASELINK_P (baselink
) && template_id_p
)
12745 BASELINK_FUNCTIONS (baselink
)
12746 = build_nt (TEMPLATE_ID_EXPR
,
12747 BASELINK_FUNCTIONS (baselink
),
12749 /* Update the conversion operator type. */
12750 BASELINK_OPTYPE (baselink
) = optype
;
12753 object_type
= current_class_type
;
12756 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12762 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12763 true if the qualified-id will be a postfix-expression in-and-of
12764 itself; false if more of the postfix-expression follows the
12765 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12769 tsubst_qualified_id (tree qualified_id
, tree args
,
12770 tsubst_flags_t complain
, tree in_decl
,
12771 bool done
, bool address_p
)
12777 tree template_args
;
12778 location_t loc
= UNKNOWN_LOCATION
;
12780 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12782 /* Figure out what name to look up. */
12783 name
= TREE_OPERAND (qualified_id
, 1);
12784 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12786 is_template
= true;
12787 loc
= EXPR_LOCATION (name
);
12788 template_args
= TREE_OPERAND (name
, 1);
12790 template_args
= tsubst_template_args (template_args
, args
,
12791 complain
, in_decl
);
12792 name
= TREE_OPERAND (name
, 0);
12796 is_template
= false;
12797 template_args
= NULL_TREE
;
12800 /* Substitute into the qualifying scope. When there are no ARGS, we
12801 are just trying to simplify a non-dependent expression. In that
12802 case the qualifying scope may be dependent, and, in any case,
12803 substituting will not help. */
12804 scope
= TREE_OPERAND (qualified_id
, 0);
12807 scope
= tsubst (scope
, args
, complain
, in_decl
);
12808 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12813 if (dependent_scope_p (scope
))
12816 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12817 return build_qualified_name (NULL_TREE
, scope
, expr
,
12818 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12821 if (!BASELINK_P (name
) && !DECL_P (expr
))
12823 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12825 /* A BIT_NOT_EXPR is used to represent a destructor. */
12826 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12828 error ("qualifying type %qT does not match destructor name ~%qT",
12829 scope
, TREE_OPERAND (expr
, 0));
12830 expr
= error_mark_node
;
12833 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12834 /*is_type_p=*/0, false);
12837 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12838 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12839 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12841 if (complain
& tf_error
)
12843 error ("dependent-name %qE is parsed as a non-type, but "
12844 "instantiation yields a type", qualified_id
);
12845 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12847 return error_mark_node
;
12853 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12855 /* Remember that there was a reference to this entity. */
12856 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
12857 return error_mark_node
;
12860 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12862 if (complain
& tf_error
)
12863 qualified_name_lookup_error (scope
,
12864 TREE_OPERAND (qualified_id
, 1),
12865 expr
, input_location
);
12866 return error_mark_node
;
12870 expr
= lookup_template_function (expr
, template_args
);
12872 if (expr
== error_mark_node
&& complain
& tf_error
)
12873 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12874 expr
, input_location
);
12875 else if (TYPE_P (scope
))
12877 expr
= (adjust_result_of_qualified_name_lookup
12878 (expr
, scope
, current_nonlambda_class_type ()));
12879 expr
= (finish_qualified_id_expr
12880 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12881 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12882 /*template_arg_p=*/false, complain
));
12885 /* Expressions do not generally have reference type. */
12886 if (TREE_CODE (expr
) != SCOPE_REF
12887 /* However, if we're about to form a pointer-to-member, we just
12888 want the referenced member referenced. */
12889 && TREE_CODE (expr
) != OFFSET_REF
)
12890 expr
= convert_from_reference (expr
);
12895 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12896 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12900 tsubst_init (tree init
, tree decl
, tree args
,
12901 tsubst_flags_t complain
, tree in_decl
)
12906 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12910 /* If we had an initializer but it
12911 instantiated to nothing,
12912 value-initialize the object. This will
12913 only occur when the initializer was a
12914 pack expansion where the parameter packs
12915 used in that expansion were of length
12917 init
= build_value_init (TREE_TYPE (decl
),
12919 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12920 init
= get_target_expr_sfinae (init
, complain
);
12926 /* Like tsubst, but deals with expressions. This function just replaces
12927 template parms; to finish processing the resultant expression, use
12928 tsubst_copy_and_build or tsubst_expr. */
12931 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12933 enum tree_code code
;
12936 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12939 code
= TREE_CODE (t
);
12944 r
= retrieve_local_specialization (t
);
12946 if (r
== NULL_TREE
)
12948 /* We get here for a use of 'this' in an NSDMI. */
12949 if (DECL_NAME (t
) == this_identifier
12950 && current_function_decl
12951 && DECL_CONSTRUCTOR_P (current_function_decl
))
12952 return current_class_ptr
;
12954 /* This can happen for a parameter name used later in a function
12955 declaration (such as in a late-specified return type). Just
12956 make a dummy decl, since it's only used for its type. */
12957 gcc_assert (cp_unevaluated_operand
!= 0);
12958 r
= tsubst_decl (t
, args
, complain
);
12959 /* Give it the template pattern as its context; its true context
12960 hasn't been instantiated yet and this is good enough for
12962 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12965 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12966 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12967 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
12968 return error_mark_node
;
12976 if (DECL_TEMPLATE_PARM_P (t
))
12977 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12978 /* There is no need to substitute into namespace-scope
12980 if (DECL_NAMESPACE_SCOPE_P (t
))
12982 /* If ARGS is NULL, then T is known to be non-dependent. */
12983 if (args
== NULL_TREE
)
12984 return scalar_constant_value (t
);
12986 /* Unfortunately, we cannot just call lookup_name here.
12989 template <int I> int f() {
12991 struct S { void g() { E e = a; } };
12994 When we instantiate f<7>::S::g(), say, lookup_name is not
12995 clever enough to find f<7>::a. */
12997 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12998 /*entering_scope=*/0);
13000 for (v
= TYPE_VALUES (enum_type
);
13002 v
= TREE_CHAIN (v
))
13003 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
13004 return TREE_VALUE (v
);
13006 /* We didn't find the name. That should never happen; if
13007 name-lookup found it during preliminary parsing, we
13008 should find it again here during instantiation. */
13009 gcc_unreachable ();
13014 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
13016 /* Check for a local specialization set up by
13017 tsubst_pack_expansion. */
13018 if (tree r
= retrieve_local_specialization (t
))
13020 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
13021 r
= ARGUMENT_PACK_SELECT_ARG (r
);
13025 /* When retrieving a capture pack from a generic lambda, remove the
13026 lambda call op's own template argument list from ARGS. Only the
13027 template arguments active for the closure type should be used to
13028 retrieve the pack specialization. */
13029 if (LAMBDA_FUNCTION_P (current_function_decl
)
13030 && (template_class_depth (DECL_CONTEXT (t
))
13031 != TMPL_ARGS_DEPTH (args
)))
13032 args
= strip_innermost_template_args (args
, 1);
13034 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
13035 tsubst_decl put in the hash table. */
13036 return retrieve_specialization (t
, args
, 0);
13039 if (DECL_CONTEXT (t
))
13043 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
13044 /*entering_scope=*/1);
13045 if (ctx
!= DECL_CONTEXT (t
))
13047 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
13050 if (complain
& tf_error
)
13051 error ("using invalid field %qD", t
);
13052 return error_mark_node
;
13061 case FUNCTION_DECL
:
13062 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
13063 r
= tsubst (t
, args
, complain
, in_decl
);
13064 else if (local_variable_p (t
))
13066 r
= retrieve_local_specialization (t
);
13067 if (r
== NULL_TREE
)
13069 /* First try name lookup to find the instantiation. */
13070 r
= lookup_name (DECL_NAME (t
));
13073 /* Make sure that the one we found is the one we want. */
13074 tree ctx
= tsubst (DECL_CONTEXT (t
), args
,
13075 complain
, in_decl
);
13076 if (ctx
!= DECL_CONTEXT (r
))
13084 /* This can happen for a variable used in a
13085 late-specified return type of a local lambda, or for a
13086 local static or constant. Building a new VAR_DECL
13087 should be OK in all those cases. */
13088 r
= tsubst_decl (t
, args
, complain
);
13089 if (decl_maybe_constant_var_p (r
))
13091 /* We can't call cp_finish_decl, so handle the
13092 initializer by hand. */
13093 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
13094 complain
, in_decl
);
13095 if (!processing_template_decl
)
13096 init
= maybe_constant_init (init
);
13097 if (processing_template_decl
13098 ? potential_constant_expression (init
)
13099 : reduced_constant_expression_p (init
))
13100 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
13101 = TREE_CONSTANT (r
) = true;
13102 DECL_INITIAL (r
) = init
;
13104 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
13105 || decl_constant_var_p (r
)
13106 || errorcount
|| sorrycount
);
13107 if (!processing_template_decl
)
13109 if (TREE_STATIC (r
))
13110 rest_of_decl_compilation (r
, toplevel_bindings_p (),
13113 r
= process_outer_var_ref (r
, complain
);
13116 /* Remember this for subsequent uses. */
13117 if (local_specializations
)
13118 register_local_specialization (r
, t
);
13123 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
13124 return error_mark_node
;
13127 case NAMESPACE_DECL
:
13131 /* An OVERLOAD will always be a non-dependent overload set; an
13132 overload set from function scope will just be represented with an
13133 IDENTIFIER_NODE, and from class scope with a BASELINK. */
13134 gcc_assert (!uses_template_parms (t
));
13138 return tsubst_baselink (t
, current_nonlambda_class_type (),
13139 args
, complain
, in_decl
);
13141 case TEMPLATE_DECL
:
13142 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13143 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
13144 args
, complain
, in_decl
);
13145 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
13146 return tsubst (t
, args
, complain
, in_decl
);
13147 else if (DECL_CLASS_SCOPE_P (t
)
13148 && uses_template_parms (DECL_CONTEXT (t
)))
13150 /* Template template argument like the following example need
13153 template <template <class> class TT> struct C {};
13154 template <class T> struct D {
13155 template <class U> struct E {};
13160 We are processing the template argument `E' in #1 for
13161 the template instantiation #2. Originally, `E' is a
13162 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13163 have to substitute this with one having context `D<int>'. */
13165 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
13166 return lookup_field (context
, DECL_NAME(t
), 0, false);
13169 /* Ordinary template template argument. */
13173 case REINTERPRET_CAST_EXPR
:
13174 case CONST_CAST_EXPR
:
13175 case STATIC_CAST_EXPR
:
13176 case DYNAMIC_CAST_EXPR
:
13177 case IMPLICIT_CONV_EXPR
:
13181 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13182 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13183 return build1 (code
, type
, op0
);
13187 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
13190 tree expanded
, op
= TREE_OPERAND (t
, 0);
13193 if (SIZEOF_EXPR_TYPE_P (t
))
13194 op
= TREE_TYPE (op
);
13196 ++cp_unevaluated_operand
;
13197 ++c_inhibit_evaluation_warnings
;
13198 /* We only want to compute the number of arguments. */
13199 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
13200 --cp_unevaluated_operand
;
13201 --c_inhibit_evaluation_warnings
;
13203 if (TREE_CODE (expanded
) == TREE_VEC
)
13204 len
= TREE_VEC_LENGTH (expanded
);
13206 if (expanded
== error_mark_node
)
13207 return error_mark_node
;
13208 else if (PACK_EXPANSION_P (expanded
)
13209 || (TREE_CODE (expanded
) == TREE_VEC
13211 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
13213 if (TREE_CODE (expanded
) == TREE_VEC
)
13214 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
13216 if (TYPE_P (expanded
))
13217 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
13218 complain
& tf_error
);
13220 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
13221 complain
& tf_error
);
13224 return build_int_cst (size_type_node
, len
);
13226 if (SIZEOF_EXPR_TYPE_P (t
))
13228 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
13229 args
, complain
, in_decl
);
13230 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
13231 r
= build1 (SIZEOF_EXPR
,
13232 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
13233 SIZEOF_EXPR_TYPE_P (r
) = 1;
13240 case TRUTH_NOT_EXPR
:
13243 case UNARY_PLUS_EXPR
: /* Unary + */
13245 case AT_ENCODE_EXPR
:
13249 case REALPART_EXPR
:
13250 case IMAGPART_EXPR
:
13253 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13254 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13255 return build1 (code
, type
, op0
);
13258 case COMPONENT_REF
:
13263 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13264 name
= TREE_OPERAND (t
, 1);
13265 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
13267 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13268 complain
, in_decl
);
13269 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13271 else if (TREE_CODE (name
) == SCOPE_REF
13272 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
13274 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13275 complain
, in_decl
);
13276 name
= TREE_OPERAND (name
, 1);
13277 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13278 complain
, in_decl
);
13279 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13280 name
= build_qualified_name (/*type=*/NULL_TREE
,
13282 /*template_p=*/false);
13284 else if (BASELINK_P (name
))
13285 name
= tsubst_baselink (name
,
13286 non_reference (TREE_TYPE (object
)),
13290 name
= tsubst_copy (name
, args
, complain
, in_decl
);
13291 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
13297 case TRUNC_DIV_EXPR
:
13298 case CEIL_DIV_EXPR
:
13299 case FLOOR_DIV_EXPR
:
13300 case ROUND_DIV_EXPR
:
13301 case EXACT_DIV_EXPR
:
13305 case TRUNC_MOD_EXPR
:
13306 case FLOOR_MOD_EXPR
:
13307 case TRUTH_ANDIF_EXPR
:
13308 case TRUTH_ORIF_EXPR
:
13309 case TRUTH_AND_EXPR
:
13310 case TRUTH_OR_EXPR
:
13323 case COMPOUND_EXPR
:
13326 case PREDECREMENT_EXPR
:
13327 case PREINCREMENT_EXPR
:
13328 case POSTDECREMENT_EXPR
:
13329 case POSTINCREMENT_EXPR
:
13331 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13332 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13333 return build_nt (code
, op0
, op1
);
13338 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13339 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13340 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
13341 QUALIFIED_NAME_IS_TEMPLATE (t
));
13346 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13347 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13348 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13353 int n
= VL_EXP_OPERAND_LENGTH (t
);
13354 tree result
= build_vl_exp (CALL_EXPR
, n
);
13356 for (i
= 0; i
< n
; i
++)
13357 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13358 complain
, in_decl
);
13364 case PSEUDO_DTOR_EXPR
:
13365 case VEC_PERM_EXPR
:
13367 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13368 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13369 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13370 r
= build_nt (code
, op0
, op1
, op2
);
13371 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13377 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13378 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13379 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13380 r
= build_nt (code
, op0
, op1
, op2
);
13381 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13387 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13388 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13389 r
= build_nt (code
, op0
, op1
);
13390 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13391 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13395 case TEMPLATE_ID_EXPR
:
13397 /* Substituted template arguments */
13398 tree fn
= TREE_OPERAND (t
, 0);
13399 tree targs
= TREE_OPERAND (t
, 1);
13401 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13403 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13405 return lookup_template_function (fn
, targs
);
13410 tree purpose
, value
, chain
;
13412 if (t
== void_list_node
)
13415 purpose
= TREE_PURPOSE (t
);
13417 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13418 value
= TREE_VALUE (t
);
13420 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13421 chain
= TREE_CHAIN (t
);
13422 if (chain
&& chain
!= void_type_node
)
13423 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13424 if (purpose
== TREE_PURPOSE (t
)
13425 && value
== TREE_VALUE (t
)
13426 && chain
== TREE_CHAIN (t
))
13428 return tree_cons (purpose
, value
, chain
);
13433 case ENUMERAL_TYPE
:
13435 case TEMPLATE_TYPE_PARM
:
13436 case TEMPLATE_TEMPLATE_PARM
:
13437 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13438 case TEMPLATE_PARM_INDEX
:
13440 case REFERENCE_TYPE
:
13442 case FUNCTION_TYPE
:
13445 case TYPENAME_TYPE
:
13446 case UNBOUND_CLASS_TEMPLATE
:
13448 case DECLTYPE_TYPE
:
13450 return tsubst (t
, args
, complain
, in_decl
);
13454 /* Fall through. */
13455 case IDENTIFIER_NODE
:
13456 if (IDENTIFIER_TYPENAME_P (t
))
13458 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13459 return mangle_conv_op_name_for_type (new_type
);
13465 /* This is handled by tsubst_copy_and_build. */
13466 gcc_unreachable ();
13470 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13471 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13472 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13475 case CLEANUP_POINT_EXPR
:
13476 /* We shouldn't have built any of these during initial template
13477 generation. Instead, they should be built during instantiation
13478 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13479 gcc_unreachable ();
13483 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13484 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13485 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13486 r
= build2 (code
, type
, op0
, op1
);
13487 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13488 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
13489 && !(complain
& tf_error
))
13490 return error_mark_node
;
13494 case EXPR_PACK_EXPANSION
:
13495 error ("invalid use of pack expansion expression");
13496 return error_mark_node
;
13498 case NONTYPE_ARGUMENT_PACK
:
13499 error ("use %<...%> to expand argument pack");
13500 return error_mark_node
;
13503 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13511 /* Instantiate any typedefs in the type. */
13512 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13513 r
= fold_convert (type
, t
);
13514 gcc_assert (TREE_CODE (r
) == code
);
13519 /* These can sometimes show up in a partial instantiation, but never
13520 involve template parms. */
13521 gcc_assert (!uses_template_parms (t
));
13525 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13526 gcc_checking_assert (false);
13531 /* Helper function for tsubst_omp_clauses, used for instantiation of
13532 OMP_CLAUSE_DECL of clauses that handles also OpenMP array sections
13533 represented with TREE_LIST. */
13536 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
13539 if (TREE_CODE (decl
) == TREE_LIST
)
13542 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
13543 /*integral_constant_expression_p=*/false);
13544 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
13545 /*integral_constant_expression_p=*/false);
13546 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
13548 if (TREE_PURPOSE (decl
) == low_bound
13549 && TREE_VALUE (decl
) == length
13550 && TREE_CHAIN (decl
) == chain
)
13552 return tree_cons (low_bound
, length
, chain
);
13554 return tsubst_copy (decl
, args
, complain
, in_decl
);
13557 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13560 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13561 tree args
, tsubst_flags_t complain
, tree in_decl
)
13563 tree new_clauses
= NULL
, nc
, oc
;
13565 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13567 nc
= copy_node (oc
);
13568 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13571 switch (OMP_CLAUSE_CODE (nc
))
13573 case OMP_CLAUSE_LASTPRIVATE
:
13574 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13576 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13577 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13578 in_decl
, /*integral_constant_expression_p=*/false);
13579 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13580 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13583 case OMP_CLAUSE_PRIVATE
:
13584 case OMP_CLAUSE_SHARED
:
13585 case OMP_CLAUSE_FIRSTPRIVATE
:
13586 case OMP_CLAUSE_COPYIN
:
13587 case OMP_CLAUSE_COPYPRIVATE
:
13588 case OMP_CLAUSE_UNIFORM
:
13589 OMP_CLAUSE_DECL (nc
) = tsubst_copy (OMP_CLAUSE_DECL (oc
), args
,
13590 complain
, in_decl
);
13592 case OMP_CLAUSE_DEPEND
:
13593 case OMP_CLAUSE_FROM
:
13594 case OMP_CLAUSE_TO
:
13595 case OMP_CLAUSE_MAP
:
13596 OMP_CLAUSE_DECL (nc
)
13597 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
13600 case OMP_CLAUSE_IF
:
13601 case OMP_CLAUSE_NUM_THREADS
:
13602 case OMP_CLAUSE_SCHEDULE
:
13603 case OMP_CLAUSE_COLLAPSE
:
13604 case OMP_CLAUSE_FINAL
:
13605 case OMP_CLAUSE_DEVICE
:
13606 case OMP_CLAUSE_DIST_SCHEDULE
:
13607 case OMP_CLAUSE_NUM_TEAMS
:
13608 case OMP_CLAUSE_THREAD_LIMIT
:
13609 case OMP_CLAUSE_SAFELEN
:
13610 case OMP_CLAUSE_SIMDLEN
:
13611 OMP_CLAUSE_OPERAND (nc
, 0)
13612 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13613 in_decl
, /*integral_constant_expression_p=*/false);
13615 case OMP_CLAUSE_REDUCTION
:
13616 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13618 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13619 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13621 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13622 complain
, in_decl
);
13623 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13624 = build_qualified_name (NULL_TREE
, scope
,
13625 TREE_OPERAND (placeholder
, 1),
13629 gcc_assert (identifier_p (placeholder
));
13631 OMP_CLAUSE_DECL (nc
) = tsubst_copy (OMP_CLAUSE_DECL (oc
), args
,
13632 complain
, in_decl
);
13634 case OMP_CLAUSE_LINEAR
:
13635 case OMP_CLAUSE_ALIGNED
:
13636 OMP_CLAUSE_DECL (nc
) = tsubst_copy (OMP_CLAUSE_DECL (oc
), args
,
13637 complain
, in_decl
);
13638 OMP_CLAUSE_OPERAND (nc
, 1)
13639 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13640 in_decl
, /*integral_constant_expression_p=*/false);
13642 case OMP_CLAUSE_NOWAIT
:
13643 case OMP_CLAUSE_ORDERED
:
13644 case OMP_CLAUSE_DEFAULT
:
13645 case OMP_CLAUSE_UNTIED
:
13646 case OMP_CLAUSE_MERGEABLE
:
13647 case OMP_CLAUSE_INBRANCH
:
13648 case OMP_CLAUSE_NOTINBRANCH
:
13649 case OMP_CLAUSE_PROC_BIND
:
13650 case OMP_CLAUSE_FOR
:
13651 case OMP_CLAUSE_PARALLEL
:
13652 case OMP_CLAUSE_SECTIONS
:
13653 case OMP_CLAUSE_TASKGROUP
:
13656 gcc_unreachable ();
13660 new_clauses
= nreverse (new_clauses
);
13662 new_clauses
= finish_omp_clauses (new_clauses
);
13663 return new_clauses
;
13666 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13669 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13672 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13674 tree purpose
, value
, chain
;
13679 if (TREE_CODE (t
) != TREE_LIST
)
13680 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13681 /*function_p=*/false,
13682 /*integral_constant_expression_p=*/false);
13684 if (t
== void_list_node
)
13687 purpose
= TREE_PURPOSE (t
);
13689 purpose
= RECUR (purpose
);
13690 value
= TREE_VALUE (t
);
13693 if (TREE_CODE (value
) != LABEL_DECL
)
13694 value
= RECUR (value
);
13697 value
= lookup_label (DECL_NAME (value
));
13698 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13699 TREE_USED (value
) = 1;
13702 chain
= TREE_CHAIN (t
);
13703 if (chain
&& chain
!= void_type_node
)
13704 chain
= RECUR (chain
);
13705 return tree_cons (purpose
, value
, chain
);
13709 /* Substitute one OMP_FOR iterator. */
13712 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13713 tree condv
, tree incrv
, tree
*clauses
,
13714 tree args
, tsubst_flags_t complain
, tree in_decl
,
13715 bool integral_constant_expression_p
)
13717 #define RECUR(NODE) \
13718 tsubst_expr ((NODE), args, complain, in_decl, \
13719 integral_constant_expression_p)
13720 tree decl
, init
, cond
, incr
;
13722 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13723 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13724 decl
= TREE_OPERAND (init
, 0);
13725 init
= TREE_OPERAND (init
, 1);
13726 tree decl_expr
= NULL_TREE
;
13727 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13729 /* We need to jump through some hoops to handle declarations in the
13730 for-init-statement, since we might need to handle auto deduction,
13731 but we need to keep control of initialization. */
13733 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13734 decl
= tsubst_decl (decl
, args
, complain
);
13737 decl
= RECUR (decl
);
13738 init
= RECUR (init
);
13740 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13741 if (auto_node
&& init
)
13743 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13745 gcc_assert (!type_dependent_expression_p (decl
));
13747 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13751 /* Declare the variable, but don't let that initialize it. */
13752 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13753 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13755 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13758 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13759 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13760 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13762 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13763 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13764 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13765 NOP_EXPR
, rhs
, complain
);
13768 incr
= RECUR (incr
);
13769 TREE_VEC_ELT (declv
, i
) = decl
;
13770 TREE_VEC_ELT (initv
, i
) = init
;
13771 TREE_VEC_ELT (condv
, i
) = cond
;
13772 TREE_VEC_ELT (incrv
, i
) = incr
;
13778 /* Declare and initialize the variable. */
13785 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13787 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13788 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13789 && OMP_CLAUSE_DECL (c
) == decl
)
13791 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13792 && OMP_CLAUSE_DECL (c
) == decl
)
13793 error ("iteration variable %qD should not be firstprivate", decl
);
13794 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13795 && OMP_CLAUSE_DECL (c
) == decl
)
13796 error ("iteration variable %qD should not be reduction", decl
);
13800 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13801 OMP_CLAUSE_DECL (c
) = decl
;
13802 c
= finish_omp_clauses (c
);
13805 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13810 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13811 if (COMPARISON_CLASS_P (cond
))
13813 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13814 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13815 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13818 cond
= RECUR (cond
);
13819 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13820 switch (TREE_CODE (incr
))
13822 case PREINCREMENT_EXPR
:
13823 case PREDECREMENT_EXPR
:
13824 case POSTINCREMENT_EXPR
:
13825 case POSTDECREMENT_EXPR
:
13826 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13827 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13830 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13831 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13833 tree rhs
= TREE_OPERAND (incr
, 1);
13834 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13835 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13836 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13837 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13838 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13842 incr
= RECUR (incr
);
13845 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13846 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13848 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13849 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13850 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13851 TREE_TYPE (decl
), lhs
,
13852 RECUR (TREE_OPERAND (incr
, 2))));
13854 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13855 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13856 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13858 tree rhs
= TREE_OPERAND (incr
, 2);
13859 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13860 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13861 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13862 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13863 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13867 incr
= RECUR (incr
);
13870 incr
= RECUR (incr
);
13874 TREE_VEC_ELT (declv
, i
) = decl
;
13875 TREE_VEC_ELT (initv
, i
) = init
;
13876 TREE_VEC_ELT (condv
, i
) = cond
;
13877 TREE_VEC_ELT (incrv
, i
) = incr
;
13881 /* Like tsubst_copy for expressions, etc. but also does semantic
13885 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13886 bool integral_constant_expression_p
)
13888 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13889 #define RECUR(NODE) \
13890 tsubst_expr ((NODE), args, complain, in_decl, \
13891 integral_constant_expression_p)
13897 if (t
== NULL_TREE
|| t
== error_mark_node
)
13900 loc
= input_location
;
13901 if (EXPR_HAS_LOCATION (t
))
13902 input_location
= EXPR_LOCATION (t
);
13903 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13904 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13906 switch (TREE_CODE (t
))
13908 case STATEMENT_LIST
:
13910 tree_stmt_iterator i
;
13911 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13912 RECUR (tsi_stmt (i
));
13916 case CTOR_INITIALIZER
:
13917 finish_mem_initializers (tsubst_initializer_list
13918 (TREE_OPERAND (t
, 0), args
));
13922 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13926 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13927 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13928 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13930 finish_expr_stmt (tmp
);
13934 do_using_directive (USING_STMT_NAMESPACE (t
));
13939 tree decl
, pattern_decl
;
13942 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13943 if (TREE_CODE (decl
) == LABEL_DECL
)
13944 finish_label_decl (DECL_NAME (decl
));
13945 else if (TREE_CODE (decl
) == USING_DECL
)
13947 tree scope
= USING_DECL_SCOPE (decl
);
13948 tree name
= DECL_NAME (decl
);
13951 scope
= tsubst (scope
, args
, complain
, in_decl
);
13952 decl
= lookup_qualified_name (scope
, name
,
13953 /*is_type_p=*/false,
13954 /*complain=*/false);
13955 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13956 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13958 do_local_using_decl (decl
, scope
, name
);
13960 else if (DECL_PACK_P (decl
))
13962 /* Don't build up decls for a variadic capture proxy, we'll
13963 instantiate the elements directly as needed. */
13968 init
= DECL_INITIAL (decl
);
13969 decl
= tsubst (decl
, args
, complain
, in_decl
);
13970 if (decl
!= error_mark_node
)
13972 /* By marking the declaration as instantiated, we avoid
13973 trying to instantiate it. Since instantiate_decl can't
13974 handle local variables, and since we've already done
13975 all that needs to be done, that's the right thing to
13978 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13980 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13981 /* Anonymous aggregates are a special case. */
13982 finish_anon_union (decl
);
13983 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13985 DECL_CONTEXT (decl
) = current_function_decl
;
13986 if (DECL_NAME (decl
) == this_identifier
)
13988 tree lam
= DECL_CONTEXT (current_function_decl
);
13989 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13990 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13992 insert_capture_proxy (decl
);
13994 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13995 /* We already did a pushtag. */;
13996 else if (TREE_CODE (decl
) == FUNCTION_DECL
13997 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13998 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
14000 DECL_CONTEXT (decl
) = NULL_TREE
;
14002 DECL_CONTEXT (decl
) = current_function_decl
;
14003 cp_check_omp_declare_reduction (decl
);
14007 int const_init
= false;
14008 maybe_push_decl (decl
);
14010 && DECL_PRETTY_FUNCTION_P (decl
))
14012 /* For __PRETTY_FUNCTION__ we have to adjust the
14014 const char *const name
14015 = cxx_printable_name (current_function_decl
, 2);
14016 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
14019 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
14022 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
14024 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
14033 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
14034 RECUR (FOR_INIT_STMT (t
));
14035 finish_for_init_stmt (stmt
);
14036 tmp
= RECUR (FOR_COND (t
));
14037 finish_for_cond (tmp
, stmt
, false);
14038 tmp
= RECUR (FOR_EXPR (t
));
14039 finish_for_expr (tmp
, stmt
);
14040 RECUR (FOR_BODY (t
));
14041 finish_for_stmt (stmt
);
14044 case RANGE_FOR_STMT
:
14047 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
14048 decl
= RANGE_FOR_DECL (t
);
14049 decl
= tsubst (decl
, args
, complain
, in_decl
);
14050 maybe_push_decl (decl
);
14051 expr
= RECUR (RANGE_FOR_EXPR (t
));
14052 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
14053 RECUR (RANGE_FOR_BODY (t
));
14054 finish_for_stmt (stmt
);
14059 stmt
= begin_while_stmt ();
14060 tmp
= RECUR (WHILE_COND (t
));
14061 finish_while_stmt_cond (tmp
, stmt
, false);
14062 RECUR (WHILE_BODY (t
));
14063 finish_while_stmt (stmt
);
14067 stmt
= begin_do_stmt ();
14068 RECUR (DO_BODY (t
));
14069 finish_do_body (stmt
);
14070 tmp
= RECUR (DO_COND (t
));
14071 finish_do_stmt (tmp
, stmt
, false);
14075 stmt
= begin_if_stmt ();
14076 tmp
= RECUR (IF_COND (t
));
14077 finish_if_stmt_cond (tmp
, stmt
);
14078 RECUR (THEN_CLAUSE (t
));
14079 finish_then_clause (stmt
);
14081 if (ELSE_CLAUSE (t
))
14083 begin_else_clause (stmt
);
14084 RECUR (ELSE_CLAUSE (t
));
14085 finish_else_clause (stmt
);
14088 finish_if_stmt (stmt
);
14092 if (BIND_EXPR_BODY_BLOCK (t
))
14093 stmt
= begin_function_body ();
14095 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
14096 ? BCS_TRY_BLOCK
: 0);
14098 RECUR (BIND_EXPR_BODY (t
));
14100 if (BIND_EXPR_BODY_BLOCK (t
))
14101 finish_function_body (stmt
);
14103 finish_compound_stmt (stmt
);
14107 finish_break_stmt ();
14110 case CONTINUE_STMT
:
14111 finish_continue_stmt ();
14115 stmt
= begin_switch_stmt ();
14116 tmp
= RECUR (SWITCH_STMT_COND (t
));
14117 finish_switch_cond (tmp
, stmt
);
14118 RECUR (SWITCH_STMT_BODY (t
));
14119 finish_switch_stmt (stmt
);
14122 case CASE_LABEL_EXPR
:
14124 tree low
= RECUR (CASE_LOW (t
));
14125 tree high
= RECUR (CASE_HIGH (t
));
14126 finish_case_label (EXPR_LOCATION (t
), low
, high
);
14132 tree decl
= LABEL_EXPR_LABEL (t
);
14135 label
= finish_label_stmt (DECL_NAME (decl
));
14136 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
14137 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
14142 tmp
= GOTO_DESTINATION (t
);
14143 if (TREE_CODE (tmp
) != LABEL_DECL
)
14144 /* Computed goto's must be tsubst'd into. On the other hand,
14145 non-computed gotos must not be; the identifier in question
14146 will have no binding. */
14149 tmp
= DECL_NAME (tmp
);
14150 finish_goto_stmt (tmp
);
14155 tree string
= RECUR (ASM_STRING (t
));
14156 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
14157 complain
, in_decl
);
14158 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
14159 complain
, in_decl
);
14160 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
14161 complain
, in_decl
);
14162 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
14163 complain
, in_decl
);
14164 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
14166 tree asm_expr
= tmp
;
14167 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
14168 asm_expr
= TREE_OPERAND (asm_expr
, 0);
14169 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
14176 stmt
= begin_try_block ();
14177 RECUR (TRY_STMTS (t
));
14178 finish_cleanup_try_block (stmt
);
14179 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
14183 tree compound_stmt
= NULL_TREE
;
14185 if (FN_TRY_BLOCK_P (t
))
14186 stmt
= begin_function_try_block (&compound_stmt
);
14188 stmt
= begin_try_block ();
14190 RECUR (TRY_STMTS (t
));
14192 if (FN_TRY_BLOCK_P (t
))
14193 finish_function_try_block (stmt
);
14195 finish_try_block (stmt
);
14197 RECUR (TRY_HANDLERS (t
));
14198 if (FN_TRY_BLOCK_P (t
))
14199 finish_function_handler_sequence (stmt
, compound_stmt
);
14201 finish_handler_sequence (stmt
);
14207 tree decl
= HANDLER_PARMS (t
);
14211 decl
= tsubst (decl
, args
, complain
, in_decl
);
14212 /* Prevent instantiate_decl from trying to instantiate
14213 this variable. We've already done all that needs to be
14215 if (decl
!= error_mark_node
)
14216 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
14218 stmt
= begin_handler ();
14219 finish_handler_parms (decl
, stmt
);
14220 RECUR (HANDLER_BODY (t
));
14221 finish_handler (stmt
);
14226 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
14227 if (CLASS_TYPE_P (tmp
))
14229 /* Local classes are not independent templates; they are
14230 instantiated along with their containing function. And this
14231 way we don't have to deal with pushing out of one local class
14232 to instantiate a member of another local class. */
14234 /* Closures are handled by the LAMBDA_EXPR. */
14235 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
14236 complete_type (tmp
);
14237 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
14238 if (!DECL_ARTIFICIAL (fn
))
14239 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
14243 case STATIC_ASSERT
:
14247 ++c_inhibit_evaluation_warnings
;
14249 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
14252 /*integral_constant_expression_p=*/true);
14253 --c_inhibit_evaluation_warnings
;
14255 finish_static_assert (condition
,
14256 STATIC_ASSERT_MESSAGE (t
),
14257 STATIC_ASSERT_SOURCE_LOCATION (t
),
14258 /*member_p=*/false);
14263 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
14264 args
, complain
, in_decl
);
14265 stmt
= begin_omp_parallel ();
14266 RECUR (OMP_PARALLEL_BODY (t
));
14267 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
14268 = OMP_PARALLEL_COMBINED (t
);
14272 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
14273 args
, complain
, in_decl
);
14274 stmt
= begin_omp_task ();
14275 RECUR (OMP_TASK_BODY (t
));
14276 finish_omp_task (tmp
, stmt
);
14283 case OMP_DISTRIBUTE
:
14285 tree clauses
, body
, pre_body
;
14286 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
14287 tree incrv
= NULL_TREE
;
14290 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
14291 args
, complain
, in_decl
);
14292 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14294 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14295 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14296 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14297 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14300 stmt
= begin_omp_structured_block ();
14302 pre_body
= push_stmt_list ();
14303 RECUR (OMP_FOR_PRE_BODY (t
));
14304 pre_body
= pop_stmt_list (pre_body
);
14306 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14307 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
14308 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
14309 &clauses
, args
, complain
, in_decl
,
14310 integral_constant_expression_p
);
14312 body
= push_stmt_list ();
14313 RECUR (OMP_FOR_BODY (t
));
14314 body
= pop_stmt_list (body
);
14316 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14317 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
14318 condv
, incrv
, body
, pre_body
, clauses
);
14321 t
= make_node (TREE_CODE (t
));
14322 TREE_TYPE (t
) = void_type_node
;
14323 OMP_FOR_BODY (t
) = body
;
14324 OMP_FOR_PRE_BODY (t
) = pre_body
;
14325 OMP_FOR_CLAUSES (t
) = clauses
;
14326 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
14330 add_stmt (finish_omp_structured_block (stmt
));
14337 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14338 args
, complain
, in_decl
);
14339 stmt
= push_stmt_list ();
14340 RECUR (OMP_BODY (t
));
14341 stmt
= pop_stmt_list (stmt
);
14344 OMP_BODY (t
) = stmt
;
14345 OMP_CLAUSES (t
) = tmp
;
14349 case OMP_TARGET_DATA
:
14351 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14352 args
, complain
, in_decl
);
14353 keep_next_level (true);
14354 stmt
= begin_omp_structured_block ();
14356 RECUR (OMP_BODY (t
));
14357 stmt
= finish_omp_structured_block (stmt
);
14360 OMP_BODY (t
) = stmt
;
14361 OMP_CLAUSES (t
) = tmp
;
14365 case OMP_TARGET_UPDATE
:
14366 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
14367 args
, complain
, in_decl
);
14369 OMP_TARGET_UPDATE_CLAUSES (t
) = tmp
;
14376 case OMP_TASKGROUP
:
14378 stmt
= push_stmt_list ();
14379 RECUR (OMP_BODY (t
));
14380 stmt
= pop_stmt_list (stmt
);
14383 OMP_BODY (t
) = stmt
;
14388 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14389 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14391 tree op1
= TREE_OPERAND (t
, 1);
14392 tree rhs1
= NULL_TREE
;
14394 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14396 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14397 op1
= TREE_OPERAND (op1
, 1);
14399 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14400 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14401 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14402 NULL_TREE
, NULL_TREE
, rhs1
,
14403 OMP_ATOMIC_SEQ_CST (t
));
14407 tree op1
= TREE_OPERAND (t
, 1);
14408 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14409 tree rhs1
= NULL_TREE
;
14410 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14411 enum tree_code opcode
= NOP_EXPR
;
14412 if (code
== OMP_ATOMIC_READ
)
14414 v
= RECUR (TREE_OPERAND (op1
, 0));
14415 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14417 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14418 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14420 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14421 v
= RECUR (TREE_OPERAND (op1
, 0));
14422 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14423 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14425 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14426 op11
= TREE_OPERAND (op11
, 1);
14428 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14429 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14430 opcode
= TREE_CODE (op11
);
14431 if (opcode
== MODIFY_EXPR
)
14437 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14438 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14440 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14441 OMP_ATOMIC_SEQ_CST (t
));
14445 case TRANSACTION_EXPR
:
14448 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14449 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14451 if (TRANSACTION_EXPR_IS_STMT (t
))
14453 tree body
= TRANSACTION_EXPR_BODY (t
);
14454 tree noex
= NULL_TREE
;
14455 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14457 noex
= MUST_NOT_THROW_COND (body
);
14458 if (noex
== NULL_TREE
)
14459 noex
= boolean_true_node
;
14460 body
= TREE_OPERAND (body
, 0);
14462 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14464 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14468 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14469 RECUR (TRANSACTION_EXPR_BODY (t
)),
14476 case MUST_NOT_THROW_EXPR
:
14478 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14479 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14480 RETURN (build_must_not_throw_expr (op0
, cond
));
14483 case EXPR_PACK_EXPANSION
:
14484 error ("invalid use of pack expansion expression");
14485 RETURN (error_mark_node
);
14487 case NONTYPE_ARGUMENT_PACK
:
14488 error ("use %<...%> to expand argument pack");
14489 RETURN (error_mark_node
);
14491 case CILK_SPAWN_STMT
:
14492 cfun
->calls_cilk_spawn
= 1;
14493 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14495 case CILK_SYNC_STMT
:
14496 RETURN (build_cilk_sync ());
14498 case COMPOUND_EXPR
:
14499 tmp
= RECUR (TREE_OPERAND (t
, 0));
14500 if (tmp
== NULL_TREE
)
14501 /* If the first operand was a statement, we're done with it. */
14502 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14503 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14504 RECUR (TREE_OPERAND (t
, 1)),
14507 case ANNOTATE_EXPR
:
14508 tmp
= RECUR (TREE_OPERAND (t
, 0));
14509 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14510 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14513 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14515 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14516 /*function_p=*/false,
14517 integral_constant_expression_p
));
14520 RETURN (NULL_TREE
);
14522 input_location
= loc
;
14528 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14529 function. For description of the body see comment above
14530 cp_parser_omp_declare_reduction_exprs. */
14533 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14535 if (t
== NULL_TREE
|| t
== error_mark_node
)
14538 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14540 tree_stmt_iterator tsi
;
14543 memset (stmts
, 0, sizeof stmts
);
14544 for (i
= 0, tsi
= tsi_start (t
);
14545 i
< 7 && !tsi_end_p (tsi
);
14546 i
++, tsi_next (&tsi
))
14547 stmts
[i
] = tsi_stmt (tsi
);
14548 gcc_assert (tsi_end_p (tsi
));
14552 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14553 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14554 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14555 args
, complain
, in_decl
);
14556 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14557 args
, complain
, in_decl
);
14558 DECL_CONTEXT (omp_out
) = current_function_decl
;
14559 DECL_CONTEXT (omp_in
) = current_function_decl
;
14560 keep_next_level (true);
14561 tree block
= begin_omp_structured_block ();
14562 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14563 block
= finish_omp_structured_block (block
);
14564 block
= maybe_cleanup_point_expr_void (block
);
14565 add_decl_expr (omp_out
);
14566 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14567 TREE_NO_WARNING (omp_out
) = 1;
14568 add_decl_expr (omp_in
);
14569 finish_expr_stmt (block
);
14573 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14574 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14575 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14576 args
, complain
, in_decl
);
14577 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14578 args
, complain
, in_decl
);
14579 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14580 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14581 keep_next_level (true);
14582 tree block
= begin_omp_structured_block ();
14583 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14584 block
= finish_omp_structured_block (block
);
14585 block
= maybe_cleanup_point_expr_void (block
);
14586 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14587 add_decl_expr (omp_priv
);
14588 add_decl_expr (omp_orig
);
14589 finish_expr_stmt (block
);
14591 add_decl_expr (omp_orig
);
14595 /* T is a postfix-expression that is not being used in a function
14596 call. Return the substituted version of T. */
14599 tsubst_non_call_postfix_expression (tree t
, tree args
,
14600 tsubst_flags_t complain
,
14603 if (TREE_CODE (t
) == SCOPE_REF
)
14604 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14605 /*done=*/false, /*address_p=*/false);
14607 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14608 /*function_p=*/false,
14609 /*integral_constant_expression_p=*/false);
14614 /* Like tsubst but deals with expressions and performs semantic
14615 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14618 tsubst_copy_and_build (tree t
,
14620 tsubst_flags_t complain
,
14623 bool integral_constant_expression_p
)
14625 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14626 #define RECUR(NODE) \
14627 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14628 /*function_p=*/false, \
14629 integral_constant_expression_p)
14634 if (t
== NULL_TREE
|| t
== error_mark_node
)
14637 loc
= input_location
;
14638 if (EXPR_HAS_LOCATION (t
))
14639 input_location
= EXPR_LOCATION (t
);
14641 /* N3276 decltype magic only applies to calls at the top level or on the
14642 right side of a comma. */
14643 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14644 complain
&= ~tf_decltype
;
14646 switch (TREE_CODE (t
))
14650 /* Fall through. */
14651 case IDENTIFIER_NODE
:
14655 bool non_integral_constant_expression_p
;
14656 const char *error_msg
;
14658 if (IDENTIFIER_TYPENAME_P (t
))
14660 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14661 t
= mangle_conv_op_name_for_type (new_type
);
14664 /* Look up the name. */
14665 decl
= lookup_name (t
);
14667 /* By convention, expressions use ERROR_MARK_NODE to indicate
14668 failure, not NULL_TREE. */
14669 if (decl
== NULL_TREE
)
14670 decl
= error_mark_node
;
14672 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14674 integral_constant_expression_p
,
14675 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14676 &non_integral_constant_expression_p
,
14677 /*template_p=*/false,
14679 /*address_p=*/false,
14680 /*template_arg_p=*/false,
14685 if (!function_p
&& identifier_p (decl
))
14687 if (complain
& tf_error
)
14688 unqualified_name_lookup_error (decl
);
14689 decl
= error_mark_node
;
14694 case TEMPLATE_ID_EXPR
:
14697 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14698 tree targs
= TREE_OPERAND (t
, 1);
14701 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14703 if (TREE_CODE (templ
) == COMPONENT_REF
)
14705 object
= TREE_OPERAND (templ
, 0);
14706 templ
= TREE_OPERAND (templ
, 1);
14709 object
= NULL_TREE
;
14710 templ
= lookup_template_function (templ
, targs
);
14713 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14714 object
, templ
, NULL_TREE
));
14716 RETURN (baselink_for_fns (templ
));
14721 tree r
= RECUR (TREE_OPERAND (t
, 0));
14723 if (REFERENCE_REF_P (t
))
14725 /* A type conversion to reference type will be enclosed in
14726 such an indirect ref, but the substitution of the cast
14727 will have also added such an indirect ref. */
14728 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14729 r
= convert_from_reference (r
);
14732 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14733 complain
|decltype_flag
);
14739 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14740 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14741 RETURN (build_nop (type
, op0
));
14744 case IMPLICIT_CONV_EXPR
:
14746 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14747 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14748 int flags
= LOOKUP_IMPLICIT
;
14749 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14750 flags
= LOOKUP_NORMAL
;
14751 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14757 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14758 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14759 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14763 case REINTERPRET_CAST_EXPR
:
14764 case CONST_CAST_EXPR
:
14765 case DYNAMIC_CAST_EXPR
:
14766 case STATIC_CAST_EXPR
:
14769 tree op
, r
= NULL_TREE
;
14771 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14772 if (integral_constant_expression_p
14773 && !cast_valid_in_integral_constant_expression_p (type
))
14775 if (complain
& tf_error
)
14776 error ("a cast to a type other than an integral or "
14777 "enumeration type cannot appear in a constant-expression");
14778 RETURN (error_mark_node
);
14781 op
= RECUR (TREE_OPERAND (t
, 0));
14783 warning_sentinel
s(warn_useless_cast
);
14784 switch (TREE_CODE (t
))
14787 r
= build_functional_cast (type
, op
, complain
);
14789 case REINTERPRET_CAST_EXPR
:
14790 r
= build_reinterpret_cast (type
, op
, complain
);
14792 case CONST_CAST_EXPR
:
14793 r
= build_const_cast (type
, op
, complain
);
14795 case DYNAMIC_CAST_EXPR
:
14796 r
= build_dynamic_cast (type
, op
, complain
);
14798 case STATIC_CAST_EXPR
:
14799 r
= build_static_cast (type
, op
, complain
);
14802 gcc_unreachable ();
14808 case POSTDECREMENT_EXPR
:
14809 case POSTINCREMENT_EXPR
:
14810 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14811 args
, complain
, in_decl
);
14812 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14813 complain
|decltype_flag
));
14815 case PREDECREMENT_EXPR
:
14816 case PREINCREMENT_EXPR
:
14820 case TRUTH_NOT_EXPR
:
14821 case UNARY_PLUS_EXPR
: /* Unary + */
14822 case REALPART_EXPR
:
14823 case IMAGPART_EXPR
:
14824 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14825 RECUR (TREE_OPERAND (t
, 0)),
14826 complain
|decltype_flag
));
14828 case FIX_TRUNC_EXPR
:
14829 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14833 op1
= TREE_OPERAND (t
, 0);
14834 if (TREE_CODE (op1
) == LABEL_DECL
)
14835 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14836 EXPR_LOCATION (op1
)));
14837 if (TREE_CODE (op1
) == SCOPE_REF
)
14838 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14839 /*done=*/true, /*address_p=*/true);
14841 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14843 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14844 complain
|decltype_flag
));
14849 case TRUNC_DIV_EXPR
:
14850 case CEIL_DIV_EXPR
:
14851 case FLOOR_DIV_EXPR
:
14852 case ROUND_DIV_EXPR
:
14853 case EXACT_DIV_EXPR
:
14857 case TRUNC_MOD_EXPR
:
14858 case FLOOR_MOD_EXPR
:
14859 case TRUTH_ANDIF_EXPR
:
14860 case TRUTH_ORIF_EXPR
:
14861 case TRUTH_AND_EXPR
:
14862 case TRUTH_OR_EXPR
:
14878 warning_sentinel
s1(warn_type_limits
);
14879 warning_sentinel
s2(warn_div_by_zero
);
14880 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14881 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14882 tree r
= build_x_binary_op
14883 (input_location
, TREE_CODE (t
),
14885 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14887 : TREE_CODE (TREE_OPERAND (t
, 0))),
14889 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14891 : TREE_CODE (TREE_OPERAND (t
, 1))),
14893 complain
|decltype_flag
);
14894 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14895 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14900 case POINTER_PLUS_EXPR
:
14902 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14903 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14904 return fold_build_pointer_plus (op0
, op1
);
14908 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14909 /*address_p=*/false));
14911 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14912 args
, complain
, in_decl
);
14913 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14914 RECUR (TREE_OPERAND (t
, 1)),
14915 complain
|decltype_flag
));
14917 case ARRAY_NOTATION_REF
:
14919 tree start_index
, length
, stride
;
14920 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14921 args
, complain
, in_decl
);
14922 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14923 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14924 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14925 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14926 length
, stride
, TREE_TYPE (op1
)));
14929 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14930 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14937 op1
= TREE_OPERAND (t
, 0);
14938 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14939 op1
= TREE_TYPE (op1
);
14942 /* When there are no ARGS, we are trying to evaluate a
14943 non-dependent expression from the parser. Trying to do
14944 the substitutions may not work. */
14946 op1
= TREE_TYPE (op1
);
14950 ++cp_unevaluated_operand
;
14951 ++c_inhibit_evaluation_warnings
;
14953 op1
= tsubst (op1
, args
, complain
, in_decl
);
14955 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14956 /*function_p=*/false,
14957 /*integral_constant_expression_p=*/
14959 --cp_unevaluated_operand
;
14960 --c_inhibit_evaluation_warnings
;
14963 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14964 complain
& tf_error
);
14966 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14967 complain
& tf_error
);
14968 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14970 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14972 if (!processing_template_decl
&& TYPE_P (op1
))
14974 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14975 build1 (NOP_EXPR
, op1
, error_mark_node
));
14976 SIZEOF_EXPR_TYPE_P (r
) = 1;
14979 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14980 TREE_SIDE_EFFECTS (r
) = 0;
14981 TREE_READONLY (r
) = 1;
14983 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14988 case AT_ENCODE_EXPR
:
14990 op1
= TREE_OPERAND (t
, 0);
14991 ++cp_unevaluated_operand
;
14992 ++c_inhibit_evaluation_warnings
;
14993 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14994 /*function_p=*/false,
14995 /*integral_constant_expression_p=*/false);
14996 --cp_unevaluated_operand
;
14997 --c_inhibit_evaluation_warnings
;
14998 RETURN (objc_build_encode_expr (op1
));
15001 case NOEXCEPT_EXPR
:
15002 op1
= TREE_OPERAND (t
, 0);
15003 ++cp_unevaluated_operand
;
15004 ++c_inhibit_evaluation_warnings
;
15005 ++cp_noexcept_operand
;
15006 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
15007 /*function_p=*/false,
15008 /*integral_constant_expression_p=*/false);
15009 --cp_unevaluated_operand
;
15010 --c_inhibit_evaluation_warnings
;
15011 --cp_noexcept_operand
;
15012 RETURN (finish_noexcept_expr (op1
, complain
));
15016 warning_sentinel
s(warn_div_by_zero
);
15017 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
15018 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
15019 tree r
= build_x_modify_expr
15020 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
15021 complain
|decltype_flag
);
15022 /* TREE_NO_WARNING must be set if either the expression was
15023 parenthesized or it uses an operator such as >>= rather
15024 than plain assignment. In the former case, it was already
15025 set and must be copied. In the latter case,
15026 build_x_modify_expr sets it and it must not be reset
15028 if (TREE_NO_WARNING (t
))
15029 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
15035 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15036 args
, complain
, in_decl
);
15037 /* Remember that there was a reference to this entity. */
15039 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
15040 RETURN (error_mark_node
);
15041 RETURN (build_x_arrow (input_location
, op1
, complain
));
15045 tree placement
= RECUR (TREE_OPERAND (t
, 0));
15046 tree init
= RECUR (TREE_OPERAND (t
, 3));
15047 vec
<tree
, va_gc
> *placement_vec
;
15048 vec
<tree
, va_gc
> *init_vec
;
15051 if (placement
== NULL_TREE
)
15052 placement_vec
= NULL
;
15055 placement_vec
= make_tree_vector ();
15056 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
15057 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
15060 /* If there was an initializer in the original tree, but it
15061 instantiated to an empty list, then we should pass a
15062 non-NULL empty vector to tell build_new that it was an
15063 empty initializer() rather than no initializer. This can
15064 only happen when the initializer is a pack expansion whose
15065 parameter packs are of length zero. */
15066 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
15070 init_vec
= make_tree_vector ();
15071 if (init
== void_node
)
15072 gcc_assert (init_vec
!= NULL
);
15075 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
15076 vec_safe_push (init_vec
, TREE_VALUE (init
));
15080 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15081 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15082 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
15083 NEW_EXPR_USE_GLOBAL (t
),
15086 if (placement_vec
!= NULL
)
15087 release_tree_vector (placement_vec
);
15088 if (init_vec
!= NULL
)
15089 release_tree_vector (init_vec
);
15096 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15097 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15098 RETURN (delete_sanity (op0
, op1
,
15099 DELETE_EXPR_USE_VEC (t
),
15100 DELETE_EXPR_USE_GLOBAL (t
),
15104 case COMPOUND_EXPR
:
15106 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
15107 complain
& ~tf_decltype
, in_decl
,
15108 /*function_p=*/false,
15109 integral_constant_expression_p
);
15110 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
15112 RECUR (TREE_OPERAND (t
, 1)),
15113 complain
|decltype_flag
));
15119 vec
<tree
, va_gc
> *call_args
;
15120 unsigned int nargs
, i
;
15125 function
= CALL_EXPR_FN (t
);
15126 /* When we parsed the expression, we determined whether or
15127 not Koenig lookup should be performed. */
15128 koenig_p
= KOENIG_LOOKUP_P (t
);
15129 if (TREE_CODE (function
) == SCOPE_REF
)
15131 qualified_p
= true;
15132 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
15134 /*address_p=*/false);
15136 else if (koenig_p
&& identifier_p (function
))
15138 /* Do nothing; calling tsubst_copy_and_build on an identifier
15139 would incorrectly perform unqualified lookup again.
15141 Note that we can also have an IDENTIFIER_NODE if the earlier
15142 unqualified lookup found a member function; in that case
15143 koenig_p will be false and we do want to do the lookup
15144 again to find the instantiated member function.
15146 FIXME but doing that causes c++/15272, so we need to stop
15147 using IDENTIFIER_NODE in that situation. */
15148 qualified_p
= false;
15152 if (TREE_CODE (function
) == COMPONENT_REF
)
15154 tree op
= TREE_OPERAND (function
, 1);
15156 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
15157 || (BASELINK_P (op
)
15158 && BASELINK_QUALIFIED_P (op
)));
15161 qualified_p
= false;
15163 if (TREE_CODE (function
) == ADDR_EXPR
15164 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
15165 /* Avoid error about taking the address of a constructor. */
15166 function
= TREE_OPERAND (function
, 0);
15168 function
= tsubst_copy_and_build (function
, args
, complain
,
15171 integral_constant_expression_p
);
15173 if (BASELINK_P (function
))
15174 qualified_p
= true;
15177 nargs
= call_expr_nargs (t
);
15178 call_args
= make_tree_vector ();
15179 for (i
= 0; i
< nargs
; ++i
)
15181 tree arg
= CALL_EXPR_ARG (t
, i
);
15183 if (!PACK_EXPANSION_P (arg
))
15184 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
15187 /* Expand the pack expansion and push each entry onto
15189 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
15190 if (TREE_CODE (arg
) == TREE_VEC
)
15192 unsigned int len
, j
;
15194 len
= TREE_VEC_LENGTH (arg
);
15195 for (j
= 0; j
< len
; ++j
)
15197 tree value
= TREE_VEC_ELT (arg
, j
);
15198 if (value
!= NULL_TREE
)
15199 value
= convert_from_reference (value
);
15200 vec_safe_push (call_args
, value
);
15205 /* A partial substitution. Add one entry. */
15206 vec_safe_push (call_args
, arg
);
15211 /* We do not perform argument-dependent lookup if normal
15212 lookup finds a non-function, in accordance with the
15213 expected resolution of DR 218. */
15215 && ((is_overloaded_fn (function
)
15216 /* If lookup found a member function, the Koenig lookup is
15217 not appropriate, even if an unqualified-name was used
15218 to denote the function. */
15219 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
15220 || identifier_p (function
))
15221 /* Only do this when substitution turns a dependent call
15222 into a non-dependent call. */
15223 && type_dependent_expression_p_push (t
)
15224 && !any_type_dependent_arguments_p (call_args
))
15225 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
15227 if (identifier_p (function
)
15228 && !any_type_dependent_arguments_p (call_args
))
15230 if (koenig_p
&& (complain
& tf_warning_or_error
))
15232 /* For backwards compatibility and good diagnostics, try
15233 the unqualified lookup again if we aren't in SFINAE
15235 tree unq
= (tsubst_copy_and_build
15236 (function
, args
, complain
, in_decl
, true,
15237 integral_constant_expression_p
));
15238 if (unq
== error_mark_node
)
15239 RETURN (error_mark_node
);
15241 if (unq
!= function
)
15244 if (INDIRECT_REF_P (fn
))
15245 fn
= TREE_OPERAND (fn
, 0);
15246 if (TREE_CODE (fn
) == COMPONENT_REF
)
15247 fn
= TREE_OPERAND (fn
, 1);
15248 if (is_overloaded_fn (fn
))
15249 fn
= get_first_fn (fn
);
15250 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
15251 "%qD was not declared in this scope, "
15252 "and no declarations were found by "
15253 "argument-dependent lookup at the point "
15254 "of instantiation", function
))
15257 /* Can't say anything more. */;
15258 else if (DECL_CLASS_SCOPE_P (fn
))
15260 location_t loc
= EXPR_LOC_OR_LOC (t
,
15263 "declarations in dependent base %qT are "
15264 "not found by unqualified lookup",
15265 DECL_CLASS_CONTEXT (fn
));
15266 if (current_class_ptr
)
15268 "use %<this->%D%> instead", function
);
15271 "use %<%T::%D%> instead",
15272 current_class_name
, function
);
15275 inform (0, "%q+D declared here, later in the "
15276 "translation unit", fn
);
15281 if (identifier_p (function
))
15283 if (complain
& tf_error
)
15284 unqualified_name_lookup_error (function
);
15285 release_tree_vector (call_args
);
15286 RETURN (error_mark_node
);
15290 /* Remember that there was a reference to this entity. */
15291 if (DECL_P (function
)
15292 && !mark_used (function
, complain
) && !(complain
& tf_error
))
15293 RETURN (error_mark_node
);
15295 /* Put back tf_decltype for the actual call. */
15296 complain
|= decltype_flag
;
15298 if (TREE_CODE (function
) == OFFSET_REF
)
15299 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
15301 else if (TREE_CODE (function
) == COMPONENT_REF
)
15303 tree instance
= TREE_OPERAND (function
, 0);
15304 tree fn
= TREE_OPERAND (function
, 1);
15306 if (processing_template_decl
15307 && (type_dependent_expression_p (instance
)
15308 || (!BASELINK_P (fn
)
15309 && TREE_CODE (fn
) != FIELD_DECL
)
15310 || type_dependent_expression_p (fn
)
15311 || any_type_dependent_arguments_p (call_args
)))
15312 ret
= build_nt_call_vec (function
, call_args
);
15313 else if (!BASELINK_P (fn
))
15314 ret
= finish_call_expr (function
, &call_args
,
15315 /*disallow_virtual=*/false,
15316 /*koenig_p=*/false,
15319 ret
= (build_new_method_call
15321 &call_args
, NULL_TREE
,
15322 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
15327 ret
= finish_call_expr (function
, &call_args
,
15328 /*disallow_virtual=*/qualified_p
,
15332 release_tree_vector (call_args
);
15339 tree cond
= RECUR (TREE_OPERAND (t
, 0));
15340 tree folded_cond
= fold_non_dependent_expr (cond
);
15343 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
15345 if (integer_zerop (folded_cond
))
15347 ++c_inhibit_evaluation_warnings
;
15348 exp1
= RECUR (TREE_OPERAND (t
, 1));
15349 --c_inhibit_evaluation_warnings
;
15350 exp2
= RECUR (TREE_OPERAND (t
, 2));
15354 exp1
= RECUR (TREE_OPERAND (t
, 1));
15355 ++c_inhibit_evaluation_warnings
;
15356 exp2
= RECUR (TREE_OPERAND (t
, 2));
15357 --c_inhibit_evaluation_warnings
;
15359 cond
= folded_cond
;
15363 exp1
= RECUR (TREE_OPERAND (t
, 1));
15364 exp2
= RECUR (TREE_OPERAND (t
, 2));
15367 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
15368 cond
, exp1
, exp2
, complain
));
15371 case PSEUDO_DTOR_EXPR
:
15373 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15374 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15375 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15376 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
15382 tree purpose
, value
, chain
;
15384 if (t
== void_list_node
)
15387 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15388 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15390 /* We have pack expansions, so expand those and
15391 create a new list out of it. */
15392 tree purposevec
= NULL_TREE
;
15393 tree valuevec
= NULL_TREE
;
15397 /* Expand the argument expressions. */
15398 if (TREE_PURPOSE (t
))
15399 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15400 complain
, in_decl
);
15401 if (TREE_VALUE (t
))
15402 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15403 complain
, in_decl
);
15405 /* Build the rest of the list. */
15406 chain
= TREE_CHAIN (t
);
15407 if (chain
&& chain
!= void_type_node
)
15408 chain
= RECUR (chain
);
15410 /* Determine the number of arguments. */
15411 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15413 len
= TREE_VEC_LENGTH (purposevec
);
15414 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15416 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15417 len
= TREE_VEC_LENGTH (valuevec
);
15420 /* Since we only performed a partial substitution into
15421 the argument pack, we only RETURN (a single list
15423 if (purposevec
== TREE_PURPOSE (t
)
15424 && valuevec
== TREE_VALUE (t
)
15425 && chain
== TREE_CHAIN (t
))
15428 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15431 /* Convert the argument vectors into a TREE_LIST */
15435 /* Grab the Ith values. */
15437 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15440 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15443 /* Build the list (backwards). */
15444 chain
= tree_cons (purpose
, value
, chain
);
15450 purpose
= TREE_PURPOSE (t
);
15452 purpose
= RECUR (purpose
);
15453 value
= TREE_VALUE (t
);
15455 value
= RECUR (value
);
15456 chain
= TREE_CHAIN (t
);
15457 if (chain
&& chain
!= void_type_node
)
15458 chain
= RECUR (chain
);
15459 if (purpose
== TREE_PURPOSE (t
)
15460 && value
== TREE_VALUE (t
)
15461 && chain
== TREE_CHAIN (t
))
15463 RETURN (tree_cons (purpose
, value
, chain
));
15466 case COMPONENT_REF
:
15473 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15474 args
, complain
, in_decl
);
15475 /* Remember that there was a reference to this entity. */
15476 if (DECL_P (object
)
15477 && !mark_used (object
, complain
) && !(complain
& tf_error
))
15478 RETURN (error_mark_node
);
15479 object_type
= TREE_TYPE (object
);
15481 member
= TREE_OPERAND (t
, 1);
15482 if (BASELINK_P (member
))
15483 member
= tsubst_baselink (member
,
15484 non_reference (TREE_TYPE (object
)),
15485 args
, complain
, in_decl
);
15487 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15488 if (member
== error_mark_node
)
15489 RETURN (error_mark_node
);
15491 if (type_dependent_expression_p (object
))
15492 /* We can't do much here. */;
15493 else if (!CLASS_TYPE_P (object_type
))
15495 if (scalarish_type_p (object_type
))
15497 tree s
= NULL_TREE
;
15498 tree dtor
= member
;
15500 if (TREE_CODE (dtor
) == SCOPE_REF
)
15502 s
= TREE_OPERAND (dtor
, 0);
15503 dtor
= TREE_OPERAND (dtor
, 1);
15505 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15507 dtor
= TREE_OPERAND (dtor
, 0);
15509 RETURN (finish_pseudo_destructor_expr
15510 (object
, s
, dtor
, input_location
));
15514 else if (TREE_CODE (member
) == SCOPE_REF
15515 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15517 /* Lookup the template functions now that we know what the
15519 tree scope
= TREE_OPERAND (member
, 0);
15520 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15521 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15522 member
= lookup_qualified_name (scope
, tmpl
,
15523 /*is_type_p=*/false,
15524 /*complain=*/false);
15525 if (BASELINK_P (member
))
15527 BASELINK_FUNCTIONS (member
)
15528 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15530 member
= (adjust_result_of_qualified_name_lookup
15531 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15536 qualified_name_lookup_error (scope
, tmpl
, member
,
15538 RETURN (error_mark_node
);
15541 else if (TREE_CODE (member
) == SCOPE_REF
15542 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15543 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15545 if (complain
& tf_error
)
15547 if (TYPE_P (TREE_OPERAND (member
, 0)))
15548 error ("%qT is not a class or namespace",
15549 TREE_OPERAND (member
, 0));
15551 error ("%qD is not a class or namespace",
15552 TREE_OPERAND (member
, 0));
15554 RETURN (error_mark_node
);
15556 else if (TREE_CODE (member
) == FIELD_DECL
)
15558 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15559 if (TREE_CODE (r
) == COMPONENT_REF
)
15560 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15564 r
= finish_class_member_access_expr (object
, member
,
15565 /*template_p=*/false,
15567 if (TREE_CODE (r
) == COMPONENT_REF
)
15568 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15573 RETURN (build_throw
15574 (RECUR (TREE_OPERAND (t
, 0))));
15578 vec
<constructor_elt
, va_gc
> *n
;
15579 constructor_elt
*ce
;
15580 unsigned HOST_WIDE_INT idx
;
15581 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15582 bool process_index_p
;
15584 bool need_copy_p
= false;
15587 if (type
== error_mark_node
)
15588 RETURN (error_mark_node
);
15590 /* digest_init will do the wrong thing if we let it. */
15591 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15594 /* We do not want to process the index of aggregate
15595 initializers as they are identifier nodes which will be
15596 looked up by digest_init. */
15597 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15599 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15600 newlen
= vec_safe_length (n
);
15601 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15603 if (ce
->index
&& process_index_p
15604 /* An identifier index is looked up in the type
15605 being initialized, not the current scope. */
15606 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15607 ce
->index
= RECUR (ce
->index
);
15609 if (PACK_EXPANSION_P (ce
->value
))
15611 /* Substitute into the pack expansion. */
15612 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15615 if (ce
->value
== error_mark_node
15616 || PACK_EXPANSION_P (ce
->value
))
15618 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15619 /* Just move the argument into place. */
15620 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15623 /* Update the length of the final CONSTRUCTOR
15624 arguments vector, and note that we will need to
15626 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15627 need_copy_p
= true;
15631 ce
->value
= RECUR (ce
->value
);
15636 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15638 vec_alloc (n
, newlen
);
15639 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15641 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15643 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15644 for (i
= 0; i
< len
; ++i
)
15645 CONSTRUCTOR_APPEND_ELT (n
, 0,
15646 TREE_VEC_ELT (ce
->value
, i
));
15649 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15653 r
= build_constructor (init_list_type_node
, n
);
15654 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15656 if (TREE_HAS_CONSTRUCTOR (t
))
15657 RETURN (finish_compound_literal (type
, r
, complain
));
15659 TREE_TYPE (r
) = type
;
15665 tree operand_0
= TREE_OPERAND (t
, 0);
15666 if (TYPE_P (operand_0
))
15668 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15669 RETURN (get_typeid (operand_0
, complain
));
15673 operand_0
= RECUR (operand_0
);
15674 RETURN (build_typeid (operand_0
, complain
));
15681 else if (DECL_PACK_P (t
))
15683 /* We don't build decls for an instantiation of a
15684 variadic capture proxy, we instantiate the elements
15686 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15687 return RECUR (DECL_VALUE_EXPR (t
));
15693 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15694 /* ??? We're doing a subset of finish_id_expression here. */
15696 && !processing_template_decl
15697 && !cp_unevaluated_operand
15698 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
15699 && DECL_THREAD_LOCAL_P (r
))
15701 if (tree wrap
= get_tls_wrapper_fn (r
))
15702 /* Replace an evaluated use of the thread_local variable with
15703 a call to its wrapper. */
15704 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
15706 else if (outer_automatic_var_p (r
))
15708 r
= process_outer_var_ref (r
, complain
);
15709 if (is_capture_proxy (r
))
15710 register_local_specialization (r
, t
);
15713 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15714 /* If the original type was a reference, we'll be wrapped in
15715 the appropriate INDIRECT_REF. */
15716 r
= convert_from_reference (r
);
15722 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15723 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15724 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15727 case OFFSETOF_EXPR
:
15728 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0)),
15729 EXPR_LOCATION (t
)));
15733 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15734 complain
, in_decl
);
15736 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15737 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
15738 type2
= RECUR (type2
);
15740 type2
= tsubst (type2
, args
, complain
, in_decl
);
15742 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15747 tree old_stmt_expr
= cur_stmt_expr
;
15748 tree stmt_expr
= begin_stmt_expr ();
15750 cur_stmt_expr
= stmt_expr
;
15751 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15752 integral_constant_expression_p
);
15753 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15754 cur_stmt_expr
= old_stmt_expr
;
15756 /* If the resulting list of expression statement is empty,
15757 fold it further into void_node. */
15758 if (empty_expr_stmt_p (stmt_expr
))
15759 stmt_expr
= void_node
;
15761 RETURN (stmt_expr
);
15766 tree r
= build_lambda_expr ();
15768 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15769 LAMBDA_EXPR_CLOSURE (r
) = type
;
15770 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15772 LAMBDA_EXPR_LOCATION (r
)
15773 = LAMBDA_EXPR_LOCATION (t
);
15774 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15775 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15776 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15777 LAMBDA_EXPR_DISCRIMINATOR (r
)
15778 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15779 /* For a function scope, we want to use tsubst so that we don't
15780 complain about referring to an auto function before its return
15781 type has been deduced. Otherwise, we want to use tsubst_copy so
15782 that we look up the existing field/parameter/variable rather
15783 than build a new one. */
15784 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15785 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15786 scope
= tsubst (scope
, args
, complain
, in_decl
);
15787 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15789 /* Look up the parameter we want directly, as tsubst_copy
15790 doesn't do what we need. */
15791 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15792 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15793 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15794 parm
= DECL_CHAIN (parm
);
15796 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15797 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15798 DECL_CONTEXT (scope
) = fn
;
15801 scope
= RECUR (scope
);
15802 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15803 LAMBDA_EXPR_RETURN_TYPE (r
)
15804 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15806 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15807 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15809 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15810 determine_visibility (TYPE_NAME (type
));
15811 /* Now that we know visibility, instantiate the type so we have a
15812 declaration of the op() for later calls to lambda_function. */
15813 complete_type (type
);
15815 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15817 RETURN (build_lambda_object (r
));
15821 /* We can get here for a constant initializer of non-dependent type.
15822 FIXME stop folding in cp_parser_initializer_clause. */
15824 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15829 case TRANSACTION_EXPR
:
15830 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15831 integral_constant_expression_p
));
15834 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15836 case VEC_PERM_EXPR
:
15838 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15839 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15840 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15841 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15846 /* Handle Objective-C++ constructs, if appropriate. */
15849 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15850 in_decl
, /*function_p=*/false);
15854 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15860 input_location
= loc
;
15864 /* Verify that the instantiated ARGS are valid. For type arguments,
15865 make sure that the type's linkage is ok. For non-type arguments,
15866 make sure they are constants if they are integral or enumerations.
15867 Emit an error under control of COMPLAIN, and return TRUE on error. */
15870 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15872 if (dependent_template_arg_p (t
))
15874 if (ARGUMENT_PACK_P (t
))
15876 tree vec
= ARGUMENT_PACK_ARGS (t
);
15877 int len
= TREE_VEC_LENGTH (vec
);
15878 bool result
= false;
15881 for (i
= 0; i
< len
; ++i
)
15882 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15886 else if (TYPE_P (t
))
15888 /* [basic.link]: A name with no linkage (notably, the name
15889 of a class or enumeration declared in a local scope)
15890 shall not be used to declare an entity with linkage.
15891 This implies that names with no linkage cannot be used as
15894 DR 757 relaxes this restriction for C++0x. */
15895 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15896 : no_linkage_check (t
, /*relaxed_p=*/false));
15900 /* DR 488 makes use of a type with no linkage cause
15901 type deduction to fail. */
15902 if (complain
& tf_error
)
15904 if (TYPE_ANONYMOUS_P (nt
))
15905 error ("%qT is/uses anonymous type", t
);
15907 error ("template argument for %qD uses local type %qT",
15912 /* In order to avoid all sorts of complications, we do not
15913 allow variably-modified types as template arguments. */
15914 else if (variably_modified_type_p (t
, NULL_TREE
))
15916 if (complain
& tf_error
)
15917 error ("%qT is a variably modified type", t
);
15921 /* Class template and alias template arguments should be OK. */
15922 else if (DECL_TYPE_TEMPLATE_P (t
))
15924 /* A non-type argument of integral or enumerated type must be a
15926 else if (TREE_TYPE (t
)
15927 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15928 && !REFERENCE_REF_P (t
)
15929 && !TREE_CONSTANT (t
))
15931 if (complain
& tf_error
)
15932 error ("integral expression %qE is not constant", t
);
15939 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15941 int ix
, len
= DECL_NTPARMS (tmpl
);
15942 bool result
= false;
15944 for (ix
= 0; ix
!= len
; ix
++)
15946 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15949 if (result
&& (complain
& tf_error
))
15950 error (" trying to instantiate %qD", tmpl
);
15954 /* We're out of SFINAE context now, so generate diagnostics for the access
15955 errors we saw earlier when instantiating D from TMPL and ARGS. */
15958 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15960 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15961 tree type
= TREE_TYPE (pattern
);
15962 location_t loc
= input_location
;
15964 push_access_scope (d
);
15965 push_deferring_access_checks (dk_no_deferred
);
15966 input_location
= DECL_SOURCE_LOCATION (pattern
);
15967 tsubst (type
, args
, tf_warning_or_error
, d
);
15968 input_location
= loc
;
15969 pop_deferring_access_checks ();
15970 pop_access_scope (d
);
15973 /* Instantiate the indicated variable, function, or alias template TMPL with
15974 the template arguments in TARG_PTR. */
15977 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15979 tree targ_ptr
= orig_args
;
15983 bool access_ok
= true;
15985 if (tmpl
== error_mark_node
)
15986 return error_mark_node
;
15988 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15990 /* If this function is a clone, handle it specially. */
15991 if (DECL_CLONED_FUNCTION_P (tmpl
))
15996 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15997 DECL_CLONED_FUNCTION. */
15998 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15999 targ_ptr
, complain
);
16000 if (spec
== error_mark_node
)
16001 return error_mark_node
;
16003 /* Look for the clone. */
16004 FOR_EACH_CLONE (clone
, spec
)
16005 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
16007 /* We should always have found the clone by now. */
16008 gcc_unreachable ();
16012 if (targ_ptr
== error_mark_node
)
16013 return error_mark_node
;
16015 /* Check to see if we already have this specialization. */
16016 gen_tmpl
= most_general_template (tmpl
);
16017 if (tmpl
!= gen_tmpl
)
16018 /* The TMPL is a partial instantiation. To get a full set of
16019 arguments we must add the arguments used to perform the
16020 partial instantiation. */
16021 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
16024 /* It would be nice to avoid hashing here and then again in tsubst_decl,
16025 but it doesn't seem to be on the hot path. */
16026 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
16028 gcc_assert (tmpl
== gen_tmpl
16029 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
16031 || fndecl
== NULL_TREE
);
16033 if (spec
!= NULL_TREE
)
16035 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
16037 if (complain
& tf_error
)
16038 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
16039 return error_mark_node
;
16044 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
16046 return error_mark_node
;
16048 /* We are building a FUNCTION_DECL, during which the access of its
16049 parameters and return types have to be checked. However this
16050 FUNCTION_DECL which is the desired context for access checking
16051 is not built yet. We solve this chicken-and-egg problem by
16052 deferring all checks until we have the FUNCTION_DECL. */
16053 push_deferring_access_checks (dk_deferred
);
16055 /* Instantiation of the function happens in the context of the function
16056 template, not the context of the overload resolution we're doing. */
16057 push_to_top_level ();
16058 /* If there are dependent arguments, e.g. because we're doing partial
16059 ordering, make sure processing_template_decl stays set. */
16060 if (uses_template_parms (targ_ptr
))
16061 ++processing_template_decl
;
16062 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
16064 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
16065 complain
, gen_tmpl
, true);
16066 push_nested_class (ctx
);
16069 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
16071 if (VAR_P (pattern
))
16073 /* We need to determine if we're using a partial or explicit
16074 specialization now, because the type of the variable could be
16076 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
16077 tree elt
= most_specialized_partial_spec (tid
, complain
);
16078 if (elt
== error_mark_node
)
16079 pattern
= error_mark_node
;
16082 tmpl
= TREE_VALUE (elt
);
16083 pattern
= DECL_TEMPLATE_RESULT (tmpl
);
16084 targ_ptr
= TREE_PURPOSE (elt
);
16088 /* Substitute template parameters to obtain the specialization. */
16089 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
16090 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
16091 pop_nested_class ();
16092 pop_from_top_level ();
16094 if (fndecl
== error_mark_node
)
16096 pop_deferring_access_checks ();
16097 return error_mark_node
;
16100 /* The DECL_TI_TEMPLATE should always be the immediate parent
16101 template, not the most general template. */
16102 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
16104 /* Now we know the specialization, compute access previously
16106 push_access_scope (fndecl
);
16107 if (!perform_deferred_access_checks (complain
))
16109 pop_access_scope (fndecl
);
16110 pop_deferring_access_checks ();
16112 /* If we've just instantiated the main entry point for a function,
16113 instantiate all the alternate entry points as well. We do this
16114 by cloning the instantiation of the main entry point, not by
16115 instantiating the template clones. */
16116 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
16117 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
16121 if (!(complain
& tf_error
))
16123 /* Remember to reinstantiate when we're out of SFINAE so the user
16124 can see the errors. */
16125 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
16127 return error_mark_node
;
16132 /* Wrapper for instantiate_template_1. */
16135 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
16138 timevar_push (TV_TEMPLATE_INST
);
16139 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
16140 timevar_pop (TV_TEMPLATE_INST
);
16144 /* Instantiate the alias template TMPL with ARGS. Also push a template
16145 instantiation level, which instantiate_template doesn't do because
16146 functions and variables have sufficient context established by the
16150 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
16152 struct pending_template
*old_last_pend
= last_pending_template
;
16153 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16154 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
16155 return error_mark_node
;
16156 tree tinst
= build_tree_list (tmpl
, args
);
16157 if (!push_tinst_level (tinst
))
16160 return error_mark_node
;
16164 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
16165 args
, tmpl
, complain
,
16166 /*require_all_args=*/true,
16167 /*use_default_args=*/true);
16169 tree r
= instantiate_template (tmpl
, args
, complain
);
16170 pop_tinst_level ();
16171 /* We can't free this if a pending_template entry or last_error_tinst_level
16172 is pointing at it. */
16173 if (last_pending_template
== old_last_pend
16174 && last_error_tinst_level
== old_error_tinst
)
16180 /* PARM is a template parameter pack for FN. Returns true iff
16181 PARM is used in a deducible way in the argument list of FN. */
16184 pack_deducible_p (tree parm
, tree fn
)
16186 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
16187 for (; t
; t
= TREE_CHAIN (t
))
16189 tree type
= TREE_VALUE (t
);
16191 if (!PACK_EXPANSION_P (type
))
16193 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
16194 packs
; packs
= TREE_CHAIN (packs
))
16195 if (template_args_equal (TREE_VALUE (packs
), parm
))
16197 /* The template parameter pack is used in a function parameter
16198 pack. If this is the end of the parameter list, the
16199 template parameter pack is deducible. */
16200 if (TREE_CHAIN (t
) == void_list_node
)
16203 /* Otherwise, not. Well, it could be deduced from
16204 a non-pack parameter, but doing so would end up with
16205 a deduction mismatch, so don't bother. */
16209 /* The template parameter pack isn't used in any function parameter
16210 packs, but it might be used deeper, e.g. tuple<Args...>. */
16214 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
16215 NARGS elements of the arguments that are being used when calling
16216 it. TARGS is a vector into which the deduced template arguments
16219 Returns either a FUNCTION_DECL for the matching specialization of FN or
16220 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
16221 true, diagnostics will be printed to explain why it failed.
16223 If FN is a conversion operator, or we are trying to produce a specific
16224 specialization, RETURN_TYPE is the return type desired.
16226 The EXPLICIT_TARGS are explicit template arguments provided via a
16229 The parameter STRICT is one of:
16232 We are deducing arguments for a function call, as in
16233 [temp.deduct.call].
16236 We are deducing arguments for a conversion function, as in
16237 [temp.deduct.conv].
16240 We are deducing arguments when doing an explicit instantiation
16241 as in [temp.explicit], when determining an explicit specialization
16242 as in [temp.expl.spec], or when taking the address of a function
16243 template, as in [temp.deduct.funcaddr]. */
16246 fn_type_unification (tree fn
,
16247 tree explicit_targs
,
16250 unsigned int nargs
,
16252 unification_kind_t strict
,
16259 tree decl
= NULL_TREE
;
16260 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
16262 static int deduction_depth
;
16263 struct pending_template
*old_last_pend
= last_pending_template
;
16264 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16265 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
16267 tree r
= error_mark_node
;
16270 complain
|= tf_decltype
;
16272 /* In C++0x, it's possible to have a function template whose type depends
16273 on itself recursively. This is most obvious with decltype, but can also
16274 occur with enumeration scope (c++/48969). So we need to catch infinite
16275 recursion and reject the substitution at deduction time; this function
16276 will return error_mark_node for any repeated substitution.
16278 This also catches excessive recursion such as when f<N> depends on
16279 f<N-1> across all integers, and returns error_mark_node for all the
16280 substitutions back up to the initial one.
16282 This is, of course, not reentrant. */
16283 if (excessive_deduction_depth
)
16284 return error_mark_node
;
16285 tinst
= build_tree_list (fn
, NULL_TREE
);
16288 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
16290 fntype
= TREE_TYPE (fn
);
16291 if (explicit_targs
)
16295 The specified template arguments must match the template
16296 parameters in kind (i.e., type, nontype, template), and there
16297 must not be more arguments than there are parameters;
16298 otherwise type deduction fails.
16300 Nontype arguments must match the types of the corresponding
16301 nontype template parameters, or must be convertible to the
16302 types of the corresponding nontype parameters as specified in
16303 _temp.arg.nontype_, otherwise type deduction fails.
16305 All references in the function type of the function template
16306 to the corresponding template parameters are replaced by the
16307 specified template argument values. If a substitution in a
16308 template parameter or in the function type of the function
16309 template results in an invalid type, type deduction fails. */
16310 int i
, len
= TREE_VEC_LENGTH (tparms
);
16311 location_t loc
= input_location
;
16312 bool incomplete
= false;
16314 /* Adjust any explicit template arguments before entering the
16315 substitution context. */
16317 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
16319 /*require_all_args=*/false,
16320 /*use_default_args=*/false));
16321 if (explicit_targs
== error_mark_node
)
16324 /* Substitute the explicit args into the function type. This is
16325 necessary so that, for instance, explicitly declared function
16326 arguments can match null pointed constants. If we were given
16327 an incomplete set of explicit args, we must not do semantic
16328 processing during substitution as we could create partial
16330 for (i
= 0; i
< len
; i
++)
16332 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16333 bool parameter_pack
= false;
16334 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
16336 /* Dig out the actual parm. */
16337 if (TREE_CODE (parm
) == TYPE_DECL
16338 || TREE_CODE (parm
) == TEMPLATE_DECL
)
16340 parm
= TREE_TYPE (parm
);
16341 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
16343 else if (TREE_CODE (parm
) == PARM_DECL
)
16345 parm
= DECL_INITIAL (parm
);
16346 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
16349 if (!parameter_pack
&& targ
== NULL_TREE
)
16350 /* No explicit argument for this template parameter. */
16353 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
16355 /* Mark the argument pack as "incomplete". We could
16356 still deduce more arguments during unification.
16357 We remove this mark in type_unification_real. */
16360 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
16361 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
16362 = ARGUMENT_PACK_ARGS (targ
);
16365 /* We have some incomplete argument packs. */
16370 TREE_VALUE (tinst
) = explicit_targs
;
16371 if (!push_tinst_level (tinst
))
16373 excessive_deduction_depth
= true;
16376 processing_template_decl
+= incomplete
;
16377 input_location
= DECL_SOURCE_LOCATION (fn
);
16378 /* Ignore any access checks; we'll see them again in
16379 instantiate_template and they might have the wrong
16380 access path at this point. */
16381 push_deferring_access_checks (dk_deferred
);
16382 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
16383 complain
| tf_partial
, NULL_TREE
);
16384 pop_deferring_access_checks ();
16385 input_location
= loc
;
16386 processing_template_decl
-= incomplete
;
16387 pop_tinst_level ();
16389 if (fntype
== error_mark_node
)
16392 /* Place the explicitly specified arguments in TARGS. */
16393 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
16394 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
16397 /* Never do unification on the 'this' parameter. */
16398 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
16404 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
16405 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
16406 new_args
[0] = return_type
;
16407 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
16412 /* We allow incomplete unification without an error message here
16413 because the standard doesn't seem to explicitly prohibit it. Our
16414 callers must be ready to deal with unification failures in any
16417 TREE_VALUE (tinst
) = targs
;
16418 /* If we aren't explaining yet, push tinst context so we can see where
16419 any errors (e.g. from class instantiations triggered by instantiation
16420 of default template arguments) come from. If we are explaining, this
16421 context is redundant. */
16422 if (!explain_p
&& !push_tinst_level (tinst
))
16424 excessive_deduction_depth
= true;
16428 /* type_unification_real will pass back any access checks from default
16429 template argument substitution. */
16430 vec
<deferred_access_check
, va_gc
> *checks
;
16433 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16434 targs
, parms
, args
, nargs
, /*subr=*/0,
16435 strict
, flags
, &checks
, explain_p
);
16437 pop_tinst_level ();
16441 /* Now that we have bindings for all of the template arguments,
16442 ensure that the arguments deduced for the template template
16443 parameters have compatible template parameter lists. We cannot
16444 check this property before we have deduced all template
16445 arguments, because the template parameter types of a template
16446 template parameter might depend on prior template parameters
16447 deduced after the template template parameter. The following
16448 ill-formed example illustrates this issue:
16450 template<typename T, template<T> class C> void f(C<5>, T);
16452 template<int N> struct X {};
16455 f(X<5>(), 5l); // error: template argument deduction fails
16458 The template parameter list of 'C' depends on the template type
16459 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16460 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16461 time that we deduce 'C'. */
16462 if (!template_template_parm_bindings_ok_p
16463 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16465 unify_inconsistent_template_template_parameters (explain_p
);
16469 /* All is well so far. Now, check:
16473 When all template arguments have been deduced, all uses of
16474 template parameters in nondeduced contexts are replaced with
16475 the corresponding deduced argument values. If the
16476 substitution results in an invalid type, as described above,
16477 type deduction fails. */
16478 TREE_VALUE (tinst
) = targs
;
16479 if (!push_tinst_level (tinst
))
16481 excessive_deduction_depth
= true;
16485 /* Also collect access checks from the instantiation. */
16486 reopen_deferring_access_checks (checks
);
16488 decl
= instantiate_template (fn
, targs
, complain
);
16490 checks
= get_deferred_access_checks ();
16491 pop_deferring_access_checks ();
16493 pop_tinst_level ();
16495 if (decl
== error_mark_node
)
16498 /* Now perform any access checks encountered during substitution. */
16499 push_access_scope (decl
);
16500 ok
= perform_access_checks (checks
, complain
);
16501 pop_access_scope (decl
);
16505 /* If we're looking for an exact match, check that what we got
16506 is indeed an exact match. It might not be if some template
16507 parameters are used in non-deduced contexts. But don't check
16508 for an exact match if we have dependent template arguments;
16509 in that case we're doing partial ordering, and we already know
16510 that we have two candidates that will provide the actual type. */
16511 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16513 tree substed
= TREE_TYPE (decl
);
16517 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16519 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16520 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16521 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16523 unify_type_mismatch (explain_p
, args
[i
],
16524 TREE_VALUE (sarg
));
16533 if (excessive_deduction_depth
)
16535 if (deduction_depth
== 0)
16536 /* Reset once we're all the way out. */
16537 excessive_deduction_depth
= false;
16540 /* We can't free this if a pending_template entry or last_error_tinst_level
16541 is pointing at it. */
16542 if (last_pending_template
== old_last_pend
16543 && last_error_tinst_level
== old_error_tinst
)
16549 /* Adjust types before performing type deduction, as described in
16550 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16551 sections are symmetric. PARM is the type of a function parameter
16552 or the return type of the conversion function. ARG is the type of
16553 the argument passed to the call, or the type of the value
16554 initialized with the result of the conversion function.
16555 ARG_EXPR is the original argument expression, which may be null. */
16558 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16571 /* Swap PARM and ARG throughout the remainder of this
16572 function; the handling is precisely symmetric since PARM
16573 will initialize ARG rather than vice versa. */
16574 std::swap (parm
, arg
);
16578 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16579 too, but here handle it by stripping the reference from PARM
16580 rather than by adding it to ARG. */
16581 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16582 && TYPE_REF_IS_RVALUE (*parm
)
16583 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16584 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16585 && TREE_CODE (*arg
) == REFERENCE_TYPE
16586 && !TYPE_REF_IS_RVALUE (*arg
))
16587 *parm
= TREE_TYPE (*parm
);
16588 /* Nothing else to do in this case. */
16592 gcc_unreachable ();
16595 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16597 /* [temp.deduct.call]
16599 If P is not a reference type:
16601 --If A is an array type, the pointer type produced by the
16602 array-to-pointer standard conversion (_conv.array_) is
16603 used in place of A for type deduction; otherwise,
16605 --If A is a function type, the pointer type produced by
16606 the function-to-pointer standard conversion
16607 (_conv.func_) is used in place of A for type deduction;
16610 --If A is a cv-qualified type, the top level
16611 cv-qualifiers of A's type are ignored for type
16613 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16614 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16615 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16616 *arg
= build_pointer_type (*arg
);
16618 *arg
= TYPE_MAIN_VARIANT (*arg
);
16621 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16622 of the form T&&, where T is a template parameter, and the argument
16623 is an lvalue, T is deduced as A& */
16624 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16625 && TYPE_REF_IS_RVALUE (*parm
)
16626 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16627 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16628 && (arg_expr
? real_lvalue_p (arg_expr
)
16629 /* try_one_overload doesn't provide an arg_expr, but
16630 functions are always lvalues. */
16631 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16632 *arg
= build_reference_type (*arg
);
16634 /* [temp.deduct.call]
16636 If P is a cv-qualified type, the top level cv-qualifiers
16637 of P's type are ignored for type deduction. If P is a
16638 reference type, the type referred to by P is used for
16640 *parm
= TYPE_MAIN_VARIANT (*parm
);
16641 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16643 *parm
= TREE_TYPE (*parm
);
16644 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16647 /* DR 322. For conversion deduction, remove a reference type on parm
16648 too (which has been swapped into ARG). */
16649 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16650 *arg
= TREE_TYPE (*arg
);
16655 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16656 template which does contain any deducible template parameters; check if
16657 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16658 unify_one_argument. */
16661 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16662 int flags
, bool explain_p
)
16667 type
= TREE_TYPE (arg
);
16671 if (same_type_p (parm
, type
))
16672 return unify_success (explain_p
);
16674 if (strict
== DEDUCE_CONV
)
16676 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16677 explain_p
? tf_warning_or_error
: tf_none
))
16678 return unify_success (explain_p
);
16680 else if (strict
!= DEDUCE_EXACT
)
16682 if (can_convert_arg (parm
, type
,
16683 TYPE_P (arg
) ? NULL_TREE
: arg
,
16684 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16685 return unify_success (explain_p
);
16688 if (strict
== DEDUCE_EXACT
)
16689 return unify_type_mismatch (explain_p
, parm
, arg
);
16691 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16694 static bool uses_deducible_template_parms (tree type
);
16696 /* Returns true iff the expression EXPR is one from which a template
16697 argument can be deduced. In other words, if it's an undecorated
16698 use of a template non-type parameter. */
16701 deducible_expression (tree expr
)
16703 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16706 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16707 deducible way; that is, if it has a max value of <PARM> - 1. */
16710 deducible_array_bound (tree domain
)
16712 if (domain
== NULL_TREE
)
16715 tree max
= TYPE_MAX_VALUE (domain
);
16716 if (TREE_CODE (max
) != MINUS_EXPR
)
16719 return deducible_expression (TREE_OPERAND (max
, 0));
16722 /* Returns true iff the template arguments ARGS use a template parameter
16723 in a deducible way. */
16726 deducible_template_args (tree args
)
16728 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16731 tree elt
= TREE_VEC_ELT (args
, i
);
16732 if (ARGUMENT_PACK_P (elt
))
16733 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16736 if (PACK_EXPANSION_P (elt
))
16737 elt
= PACK_EXPANSION_PATTERN (elt
);
16738 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16740 else if (TYPE_P (elt
))
16741 deducible
= uses_deducible_template_parms (elt
);
16743 deducible
= deducible_expression (elt
);
16751 /* Returns true iff TYPE contains any deducible references to template
16752 parameters, as per 14.8.2.5. */
16755 uses_deducible_template_parms (tree type
)
16757 if (PACK_EXPANSION_P (type
))
16758 type
= PACK_EXPANSION_PATTERN (type
);
16765 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16766 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16772 if (POINTER_TYPE_P (type
))
16773 return uses_deducible_template_parms (TREE_TYPE (type
));
16775 /* T[integer-constant ]
16777 if (TREE_CODE (type
) == ARRAY_TYPE
)
16778 return (uses_deducible_template_parms (TREE_TYPE (type
))
16779 || deducible_array_bound (TYPE_DOMAIN (type
)));
16791 if (TYPE_PTRMEM_P (type
))
16792 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16793 || (uses_deducible_template_parms
16794 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16796 /* template-name <T> (where template-name refers to a class template)
16797 template-name <i> (where template-name refers to a class template) */
16798 if (CLASS_TYPE_P (type
)
16799 && CLASSTYPE_TEMPLATE_INFO (type
)
16800 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16801 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16802 (CLASSTYPE_TI_ARGS (type
)));
16807 if (TREE_CODE (type
) == FUNCTION_TYPE
16808 || TREE_CODE (type
) == METHOD_TYPE
)
16810 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16812 tree parm
= TYPE_ARG_TYPES (type
);
16813 if (TREE_CODE (type
) == METHOD_TYPE
)
16814 parm
= TREE_CHAIN (parm
);
16815 for (; parm
; parm
= TREE_CHAIN (parm
))
16816 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16823 /* Subroutine of type_unification_real and unify_pack_expansion to
16824 handle unification of a single P/A pair. Parameters are as
16825 for those functions. */
16828 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16829 int subr
, unification_kind_t strict
,
16832 tree arg_expr
= NULL_TREE
;
16835 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16836 return unify_invalid (explain_p
);
16837 if (arg
== unknown_type_node
)
16838 /* We can't deduce anything from this, but we might get all the
16839 template args from other function args. */
16840 return unify_success (explain_p
);
16842 /* Implicit conversions (Clause 4) will be performed on a function
16843 argument to convert it to the type of the corresponding function
16844 parameter if the parameter type contains no template-parameters that
16845 participate in template argument deduction. */
16846 if (strict
!= DEDUCE_EXACT
16847 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16848 /* For function parameters with no deducible template parameters,
16849 just return. We'll check non-dependent conversions later. */
16850 return unify_success (explain_p
);
16855 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16856 | UNIFY_ALLOW_MORE_CV_QUAL
16857 | UNIFY_ALLOW_DERIVED
);
16861 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16865 arg_strict
= UNIFY_ALLOW_NONE
;
16869 gcc_unreachable ();
16872 /* We only do these transformations if this is the top-level
16873 parameter_type_list in a call or declaration matching; in other
16874 situations (nested function declarators, template argument lists) we
16875 won't be comparing a type to an expression, and we don't do any type
16881 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16882 if (type_unknown_p (arg
))
16884 /* [temp.deduct.type] A template-argument can be
16885 deduced from a pointer to function or pointer
16886 to member function argument if the set of
16887 overloaded functions does not contain function
16888 templates and at most one of a set of
16889 overloaded functions provides a unique
16892 if (resolve_overloaded_unification
16893 (tparms
, targs
, parm
, arg
, strict
,
16894 arg_strict
, explain_p
))
16895 return unify_success (explain_p
);
16896 return unify_overload_resolution_failure (explain_p
, arg
);
16900 arg
= unlowered_expr_type (arg
);
16901 if (arg
== error_mark_node
)
16902 return unify_invalid (explain_p
);
16906 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16909 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16910 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
16911 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16913 /* For deduction from an init-list we need the actual list. */
16914 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16916 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16919 /* Most parms like fn_type_unification.
16921 If SUBR is 1, we're being called recursively (to unify the
16922 arguments of a function or method parameter of a function
16925 CHECKS is a pointer to a vector of access checks encountered while
16926 substituting default template arguments. */
16929 type_unification_real (tree tparms
,
16933 unsigned int xnargs
,
16935 unification_kind_t strict
,
16937 vec
<deferred_access_check
, va_gc
> **checks
,
16942 int ntparms
= TREE_VEC_LENGTH (tparms
);
16943 int saw_undeduced
= 0;
16946 unsigned int nargs
;
16949 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16950 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16951 gcc_assert (ntparms
> 0);
16953 /* Reset the number of non-defaulted template arguments contained
16955 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16963 while (parms
&& parms
!= void_list_node
16966 parm
= TREE_VALUE (parms
);
16968 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16969 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16970 /* For a function parameter pack that occurs at the end of the
16971 parameter-declaration-list, the type A of each remaining
16972 argument of the call is compared with the type P of the
16973 declarator-id of the function parameter pack. */
16976 parms
= TREE_CHAIN (parms
);
16978 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16979 /* For a function parameter pack that does not occur at the
16980 end of the parameter-declaration-list, the type of the
16981 parameter pack is a non-deduced context. */
16987 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16993 && parms
!= void_list_node
16994 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16996 /* Unify the remaining arguments with the pack expansion type. */
16998 tree parmvec
= make_tree_vec (1);
17000 /* Allocate a TREE_VEC and copy in all of the arguments */
17001 argvec
= make_tree_vec (nargs
- ia
);
17002 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
17003 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
17005 /* Copy the parameter into parmvec. */
17006 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
17007 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
17008 /*subr=*/subr
, explain_p
))
17011 /* Advance to the end of the list of parameters. */
17012 parms
= TREE_CHAIN (parms
);
17015 /* Fail if we've reached the end of the parm list, and more args
17016 are present, and the parm list isn't variadic. */
17017 if (ia
< nargs
&& parms
== void_list_node
)
17018 return unify_too_many_arguments (explain_p
, nargs
, ia
);
17019 /* Fail if parms are left and they don't have default values and
17020 they aren't all deduced as empty packs (c++/57397). This is
17021 consistent with sufficient_parms_p. */
17022 if (parms
&& parms
!= void_list_node
17023 && TREE_PURPOSE (parms
) == NULL_TREE
)
17025 unsigned int count
= nargs
;
17030 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
17033 p
= TREE_CHAIN (p
);
17035 while (p
&& p
!= void_list_node
);
17036 if (count
!= nargs
)
17037 return unify_too_few_arguments (explain_p
, ia
, count
,
17043 tsubst_flags_t complain
= (explain_p
17044 ? tf_warning_or_error
17047 for (i
= 0; i
< ntparms
; i
++)
17049 tree targ
= TREE_VEC_ELT (targs
, i
);
17050 tree tparm
= TREE_VEC_ELT (tparms
, i
);
17052 /* Clear the "incomplete" flags on all argument packs now so that
17053 substituting them into later default arguments works. */
17054 if (targ
&& ARGUMENT_PACK_P (targ
))
17056 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
17057 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
17060 if (targ
|| tparm
== error_mark_node
)
17062 tparm
= TREE_VALUE (tparm
);
17064 /* If this is an undeduced nontype parameter that depends on
17065 a type parameter, try another pass; its type may have been
17066 deduced from a later argument than the one from which
17067 this parameter can be deduced. */
17068 if (TREE_CODE (tparm
) == PARM_DECL
17069 && uses_template_parms (TREE_TYPE (tparm
))
17070 && saw_undeduced
< 2)
17076 /* Core issue #226 (C++0x) [temp.deduct]:
17078 If a template argument has not been deduced, its
17079 default template argument, if any, is used.
17081 When we are in C++98 mode, TREE_PURPOSE will either
17082 be NULL_TREE or ERROR_MARK_NODE, so we do not need
17083 to explicitly check cxx_dialect here. */
17084 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
17085 /* OK, there is a default argument. Wait until after the
17086 conversion check to do substitution. */
17089 /* If the type parameter is a parameter pack, then it will
17090 be deduced to an empty parameter pack. */
17091 if (template_parameter_pack_p (tparm
))
17095 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
17097 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
17098 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
17099 TREE_CONSTANT (arg
) = 1;
17102 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17104 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
17106 TREE_VEC_ELT (targs
, i
) = arg
;
17110 return unify_parameter_deduction_failure (explain_p
, tparm
);
17113 /* DR 1391: All parameters have args, now check non-dependent parms for
17115 if (saw_undeduced
< 2)
17116 for (ia
= 0, parms
= xparms
, args
= xargs
, nargs
= xnargs
;
17117 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
17119 parm
= TREE_VALUE (parms
);
17121 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
17122 && (!TREE_CHAIN (parms
)
17123 || TREE_CHAIN (parms
) == void_list_node
))
17124 /* For a function parameter pack that occurs at the end of the
17125 parameter-declaration-list, the type A of each remaining
17126 argument of the call is compared with the type P of the
17127 declarator-id of the function parameter pack. */
17130 parms
= TREE_CHAIN (parms
);
17132 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
17133 /* For a function parameter pack that does not occur at the
17134 end of the parameter-declaration-list, the type of the
17135 parameter pack is a non-deduced context. */
17141 if (uses_template_parms (parm
))
17143 if (check_non_deducible_conversion (parm
, arg
, strict
, flags
,
17148 /* Now substitute into the default template arguments. */
17149 for (i
= 0; i
< ntparms
; i
++)
17151 tree targ
= TREE_VEC_ELT (targs
, i
);
17152 tree tparm
= TREE_VEC_ELT (tparms
, i
);
17154 if (targ
|| tparm
== error_mark_node
)
17156 tree parm
= TREE_VALUE (tparm
);
17158 if (TREE_CODE (parm
) == PARM_DECL
17159 && uses_template_parms (TREE_TYPE (parm
))
17160 && saw_undeduced
< 2)
17163 tree arg
= TREE_PURPOSE (tparm
);
17164 reopen_deferring_access_checks (*checks
);
17165 location_t save_loc
= input_location
;
17167 input_location
= DECL_SOURCE_LOCATION (parm
);
17168 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
17169 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
17171 input_location
= save_loc
;
17172 *checks
= get_deferred_access_checks ();
17173 pop_deferring_access_checks ();
17174 if (arg
== error_mark_node
)
17178 TREE_VEC_ELT (targs
, i
) = arg
;
17179 /* The position of the first default template argument,
17180 is also the number of non-defaulted arguments in TARGS.
17182 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
17183 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
17188 if (saw_undeduced
++ == 1)
17191 #ifdef ENABLE_CHECKING
17192 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
17193 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
17196 return unify_success (explain_p
);
17199 /* Subroutine of type_unification_real. Args are like the variables
17200 at the call site. ARG is an overloaded function (or template-id);
17201 we try deducing template args from each of the overloads, and if
17202 only one succeeds, we go with that. Modifies TARGS and returns
17203 true on success. */
17206 resolve_overloaded_unification (tree tparms
,
17210 unification_kind_t strict
,
17214 tree tempargs
= copy_node (targs
);
17216 tree goodfn
= NULL_TREE
;
17219 if (TREE_CODE (arg
) == ADDR_EXPR
)
17221 arg
= TREE_OPERAND (arg
, 0);
17227 if (TREE_CODE (arg
) == COMPONENT_REF
)
17228 /* Handle `&x' where `x' is some static or non-static member
17230 arg
= TREE_OPERAND (arg
, 1);
17232 if (TREE_CODE (arg
) == OFFSET_REF
)
17233 arg
= TREE_OPERAND (arg
, 1);
17235 /* Strip baselink information. */
17236 if (BASELINK_P (arg
))
17237 arg
= BASELINK_FUNCTIONS (arg
);
17239 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
17241 /* If we got some explicit template args, we need to plug them into
17242 the affected templates before we try to unify, in case the
17243 explicit args will completely resolve the templates in question. */
17246 tree expl_subargs
= TREE_OPERAND (arg
, 1);
17247 arg
= TREE_OPERAND (arg
, 0);
17249 for (; arg
; arg
= OVL_NEXT (arg
))
17251 tree fn
= OVL_CURRENT (arg
);
17252 tree subargs
, elem
;
17254 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17257 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17258 expl_subargs
, NULL_TREE
, tf_none
,
17259 /*require_all_args=*/true,
17260 /*use_default_args=*/true);
17261 if (subargs
!= error_mark_node
17262 && !any_dependent_template_arguments_p (subargs
))
17264 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
17265 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17266 elem
, strict
, sub_strict
, addr_p
, explain_p
)
17267 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
17276 /* If no templates (or more than one) are fully resolved by the
17277 explicit arguments, this template-id is a non-deduced context; it
17278 could still be OK if we deduce all template arguments for the
17279 enclosing call through other arguments. */
17283 else if (TREE_CODE (arg
) != OVERLOAD
17284 && TREE_CODE (arg
) != FUNCTION_DECL
)
17285 /* If ARG is, for example, "(0, &f)" then its type will be unknown
17286 -- but the deduction does not succeed because the expression is
17287 not just the function on its own. */
17290 for (; arg
; arg
= OVL_NEXT (arg
))
17291 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17292 TREE_TYPE (OVL_CURRENT (arg
)),
17293 strict
, sub_strict
, addr_p
, explain_p
)
17294 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
17296 goodfn
= OVL_CURRENT (arg
);
17300 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17301 to function or pointer to member function argument if the set of
17302 overloaded functions does not contain function templates and at most
17303 one of a set of overloaded functions provides a unique match.
17305 So if we found multiple possibilities, we return success but don't
17306 deduce anything. */
17310 int i
= TREE_VEC_LENGTH (targs
);
17312 if (TREE_VEC_ELT (tempargs
, i
))
17314 tree old
= TREE_VEC_ELT (targs
, i
);
17315 tree new_
= TREE_VEC_ELT (tempargs
, i
);
17316 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
17317 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
17318 /* Don't forget explicit template arguments in a pack. */
17319 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
17320 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
17321 TREE_VEC_ELT (targs
, i
) = new_
;
17330 /* Core DR 115: In contexts where deduction is done and fails, or in
17331 contexts where deduction is not done, if a template argument list is
17332 specified and it, along with any default template arguments, identifies
17333 a single function template specialization, then the template-id is an
17334 lvalue for the function template specialization. */
17337 resolve_nondeduced_context (tree orig_expr
)
17339 tree expr
, offset
, baselink
;
17342 if (!type_unknown_p (orig_expr
))
17347 offset
= NULL_TREE
;
17348 baselink
= NULL_TREE
;
17350 if (TREE_CODE (expr
) == ADDR_EXPR
)
17352 expr
= TREE_OPERAND (expr
, 0);
17355 if (TREE_CODE (expr
) == OFFSET_REF
)
17358 expr
= TREE_OPERAND (expr
, 1);
17360 if (BASELINK_P (expr
))
17363 expr
= BASELINK_FUNCTIONS (expr
);
17366 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
17369 tree goodfn
= NULL_TREE
;
17371 /* If we got some explicit template args, we need to plug them into
17372 the affected templates before we try to unify, in case the
17373 explicit args will completely resolve the templates in question. */
17375 tree expl_subargs
= TREE_OPERAND (expr
, 1);
17376 tree arg
= TREE_OPERAND (expr
, 0);
17377 tree badfn
= NULL_TREE
;
17378 tree badargs
= NULL_TREE
;
17380 for (; arg
; arg
= OVL_NEXT (arg
))
17382 tree fn
= OVL_CURRENT (arg
);
17383 tree subargs
, elem
;
17385 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17388 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17389 expl_subargs
, NULL_TREE
, tf_none
,
17390 /*require_all_args=*/true,
17391 /*use_default_args=*/true);
17392 if (subargs
!= error_mark_node
17393 && !any_dependent_template_arguments_p (subargs
))
17395 elem
= instantiate_template (fn
, subargs
, tf_none
);
17396 if (elem
== error_mark_node
)
17401 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
17410 mark_used (goodfn
);
17413 expr
= build_baselink (BASELINK_BINFO (baselink
),
17414 BASELINK_ACCESS_BINFO (baselink
),
17415 expr
, BASELINK_OPTYPE (baselink
));
17419 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
17420 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
17423 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
17426 else if (good
== 0 && badargs
)
17427 /* There were no good options and at least one bad one, so let the
17428 user know what the problem is. */
17429 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
17434 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17435 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17436 different overloads deduce different arguments for a given parm.
17437 ADDR_P is true if the expression for which deduction is being
17438 performed was of the form "& fn" rather than simply "fn".
17440 Returns 1 on success. */
17443 try_one_overload (tree tparms
,
17448 unification_kind_t strict
,
17457 if (arg
== error_mark_node
)
17460 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17461 to function or pointer to member function argument if the set of
17462 overloaded functions does not contain function templates and at most
17463 one of a set of overloaded functions provides a unique match.
17465 So if this is a template, just return success. */
17467 if (uses_template_parms (arg
))
17470 if (TREE_CODE (arg
) == METHOD_TYPE
)
17471 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
17473 arg
= build_pointer_type (arg
);
17475 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
17477 /* We don't copy orig_targs for this because if we have already deduced
17478 some template args from previous args, unify would complain when we
17479 try to deduce a template parameter for the same argument, even though
17480 there isn't really a conflict. */
17481 nargs
= TREE_VEC_LENGTH (targs
);
17482 tempargs
= make_tree_vec (nargs
);
17484 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
17487 /* First make sure we didn't deduce anything that conflicts with
17488 explicitly specified args. */
17489 for (i
= nargs
; i
--; )
17491 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17492 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17496 else if (uses_template_parms (elt
))
17497 /* Since we're unifying against ourselves, we will fill in
17498 template args used in the function parm list with our own
17499 template parms. Discard them. */
17500 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17501 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17505 for (i
= nargs
; i
--; )
17507 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17510 TREE_VEC_ELT (targs
, i
) = elt
;
17516 /* PARM is a template class (perhaps with unbound template
17517 parameters). ARG is a fully instantiated type. If ARG can be
17518 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17519 TARGS are as for unify. */
17522 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17525 tree copy_of_targs
;
17527 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17528 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17529 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17532 /* We need to make a new template argument vector for the call to
17533 unify. If we used TARGS, we'd clutter it up with the result of
17534 the attempted unification, even if this class didn't work out.
17535 We also don't want to commit ourselves to all the unifications
17536 we've already done, since unification is supposed to be done on
17537 an argument-by-argument basis. In other words, consider the
17538 following pathological case:
17540 template <int I, int J, int K>
17543 template <int I, int J>
17544 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17546 template <int I, int J, int K>
17547 void f(S<I, J, K>, S<I, I, I>);
17556 Now, by the time we consider the unification involving `s2', we
17557 already know that we must have `f<0, 0, 0>'. But, even though
17558 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17559 because there are two ways to unify base classes of S<0, 1, 2>
17560 with S<I, I, I>. If we kept the already deduced knowledge, we
17561 would reject the possibility I=1. */
17562 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17564 /* If unification failed, we're done. */
17565 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17566 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17572 /* Given a template type PARM and a class type ARG, find the unique
17573 base type in ARG that is an instance of PARM. We do not examine
17574 ARG itself; only its base-classes. If there is not exactly one
17575 appropriate base class, return NULL_TREE. PARM may be the type of
17576 a partial specialization, as well as a plain template type. Used
17579 static enum template_base_result
17580 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17581 bool explain_p
, tree
*result
)
17583 tree rval
= NULL_TREE
;
17586 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17588 binfo
= TYPE_BINFO (complete_type (arg
));
17591 /* The type could not be completed. */
17592 *result
= NULL_TREE
;
17593 return tbr_incomplete_type
;
17596 /* Walk in inheritance graph order. The search order is not
17597 important, and this avoids multiple walks of virtual bases. */
17598 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17600 tree r
= try_class_unification (tparms
, targs
, parm
,
17601 BINFO_TYPE (binfo
), explain_p
);
17605 /* If there is more than one satisfactory baseclass, then:
17609 If they yield more than one possible deduced A, the type
17613 if (rval
&& !same_type_p (r
, rval
))
17615 *result
= NULL_TREE
;
17616 return tbr_ambiguous_baseclass
;
17624 return tbr_success
;
17627 /* Returns the level of DECL, which declares a template parameter. */
17630 template_decl_level (tree decl
)
17632 switch (TREE_CODE (decl
))
17635 case TEMPLATE_DECL
:
17636 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17639 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17642 gcc_unreachable ();
17647 /* Decide whether ARG can be unified with PARM, considering only the
17648 cv-qualifiers of each type, given STRICT as documented for unify.
17649 Returns nonzero iff the unification is OK on that basis. */
17652 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17654 int arg_quals
= cp_type_quals (arg
);
17655 int parm_quals
= cp_type_quals (parm
);
17657 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17658 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17660 /* Although a CVR qualifier is ignored when being applied to a
17661 substituted template parameter ([8.3.2]/1 for example), that
17662 does not allow us to unify "const T" with "int&" because both
17663 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17664 It is ok when we're allowing additional CV qualifiers
17665 at the outer level [14.8.2.1]/3,1st bullet. */
17666 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17667 || TREE_CODE (arg
) == FUNCTION_TYPE
17668 || TREE_CODE (arg
) == METHOD_TYPE
)
17669 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17672 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17673 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17677 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17678 && (arg_quals
& parm_quals
) != parm_quals
)
17681 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17682 && (parm_quals
& arg_quals
) != arg_quals
)
17688 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17690 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17692 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17693 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17694 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17696 *index
= TEMPLATE_TYPE_IDX (parm
);
17697 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17701 *index
= TEMPLATE_PARM_IDX (parm
);
17702 *level
= TEMPLATE_PARM_LEVEL (parm
);
17706 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17708 if (unify (TP, TA, P, A, S, EP)) \
17712 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17713 expansion at the end of PACKED_PARMS. Returns 0 if the type
17714 deduction succeeds, 1 otherwise. STRICT is the same as in
17715 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17716 call argument list. We'll need to adjust the arguments to make them
17717 types. SUBR tells us if this is from a recursive call to
17718 type_unification_real, or for comparing two template argument
17722 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17723 tree packed_args
, unification_kind_t strict
,
17724 bool subr
, bool explain_p
)
17727 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17728 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17729 tree pack
, packs
= NULL_TREE
;
17730 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17732 packed_args
= expand_template_argument_pack (packed_args
);
17734 int len
= TREE_VEC_LENGTH (packed_args
);
17736 /* Determine the parameter packs we will be deducing from the
17737 pattern, and record their current deductions. */
17738 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17739 pack
; pack
= TREE_CHAIN (pack
))
17741 tree parm_pack
= TREE_VALUE (pack
);
17744 /* Determine the index and level of this parameter pack. */
17745 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17747 /* Keep track of the parameter packs and their corresponding
17749 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17750 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17753 /* Loop through all of the arguments that have not yet been
17754 unified and unify each with the pattern. */
17755 for (i
= start
; i
< len
; i
++)
17758 bool any_explicit
= false;
17759 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17761 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17762 or the element of its argument pack at the current index if
17763 this argument was explicitly specified. */
17764 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17768 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17771 if (TREE_VALUE (pack
)
17772 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17773 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17775 any_explicit
= true;
17776 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17778 TMPL_ARG (targs
, level
, idx
) = arg
;
17781 /* If we had explicit template arguments, substitute them into the
17782 pattern before deduction. */
17785 /* Some arguments might still be unspecified or dependent. */
17787 ++processing_template_decl
;
17788 dependent
= any_dependent_template_arguments_p (targs
);
17790 --processing_template_decl
;
17791 parm
= tsubst (pattern
, targs
,
17792 explain_p
? tf_warning_or_error
: tf_none
,
17795 --processing_template_decl
;
17796 if (parm
== error_mark_node
)
17802 /* Unify the pattern with the current argument. */
17803 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17807 /* For each parameter pack, collect the deduced value. */
17808 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17811 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17813 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17814 TMPL_ARG (targs
, level
, idx
);
17818 /* Verify that the results of unification with the parameter packs
17819 produce results consistent with what we've seen before, and make
17820 the deduced argument packs available. */
17821 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17823 tree old_pack
= TREE_VALUE (pack
);
17824 tree new_args
= TREE_TYPE (pack
);
17825 int i
, len
= TREE_VEC_LENGTH (new_args
);
17827 bool nondeduced_p
= false;
17829 /* By default keep the original deduced argument pack.
17830 If necessary, more specific code is going to update the
17831 resulting deduced argument later down in this function. */
17832 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17833 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17835 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17836 actually deduce anything. */
17837 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17838 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17839 nondeduced_p
= true;
17843 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17845 /* If we had fewer function args than explicit template args,
17846 just use the explicits. */
17847 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17848 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17849 if (len
< explicit_len
)
17850 new_args
= explicit_args
;
17856 /* Build the deduced *_ARGUMENT_PACK. */
17857 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17859 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17860 TREE_TYPE (result
) =
17861 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17862 TREE_CONSTANT (result
) = 1;
17865 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17867 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17869 /* Note the deduced argument packs for this parameter
17871 TMPL_ARG (targs
, level
, idx
) = result
;
17873 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17874 && (ARGUMENT_PACK_ARGS (old_pack
)
17875 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17877 /* We only had the explicitly-provided arguments before, but
17878 now we have a complete set of arguments. */
17879 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17881 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17882 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17883 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17887 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17888 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17890 if (!comp_template_args_with_info (old_args
, new_args
,
17891 &bad_old_arg
, &bad_new_arg
))
17892 /* Inconsistent unification of this parameter pack. */
17893 return unify_parameter_pack_inconsistent (explain_p
,
17899 return unify_success (explain_p
);
17902 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17903 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17904 parameters and return value are as for unify. */
17907 unify_array_domain (tree tparms
, tree targs
,
17908 tree parm_dom
, tree arg_dom
,
17916 /* Our representation of array types uses "N - 1" as the
17917 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17918 not an integer constant. We cannot unify arbitrarily
17919 complex expressions, so we eliminate the MINUS_EXPRs
17921 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17922 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17925 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17926 parm_max
= TREE_OPERAND (parm_max
, 0);
17928 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17929 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17932 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17933 trying to unify the type of a variable with the type
17934 of a template parameter. For example:
17936 template <unsigned int N>
17937 void f (char (&) [N]);
17944 Here, the type of the ARG will be "int [g(i)]", and
17945 may be a SAVE_EXPR, etc. */
17946 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17947 return unify_vla_arg (explain_p
, arg_dom
);
17948 arg_max
= TREE_OPERAND (arg_max
, 0);
17951 /* If only one of the bounds used a MINUS_EXPR, compensate
17952 by adding one to the other bound. */
17953 if (parm_cst
&& !arg_cst
)
17954 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17958 else if (arg_cst
&& !parm_cst
)
17959 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17964 return unify (tparms
, targs
, parm_max
, arg_max
,
17965 UNIFY_ALLOW_INTEGER
, explain_p
);
17968 /* Deduce the value of template parameters. TPARMS is the (innermost)
17969 set of template parameters to a template. TARGS is the bindings
17970 for those template parameters, as determined thus far; TARGS may
17971 include template arguments for outer levels of template parameters
17972 as well. PARM is a parameter to a template function, or a
17973 subcomponent of that parameter; ARG is the corresponding argument.
17974 This function attempts to match PARM with ARG in a manner
17975 consistent with the existing assignments in TARGS. If more values
17976 are deduced, then TARGS is updated.
17978 Returns 0 if the type deduction succeeds, 1 otherwise. The
17979 parameter STRICT is a bitwise or of the following flags:
17982 Require an exact match between PARM and ARG.
17983 UNIFY_ALLOW_MORE_CV_QUAL:
17984 Allow the deduced ARG to be more cv-qualified (by qualification
17985 conversion) than ARG.
17986 UNIFY_ALLOW_LESS_CV_QUAL:
17987 Allow the deduced ARG to be less cv-qualified than ARG.
17988 UNIFY_ALLOW_DERIVED:
17989 Allow the deduced ARG to be a template base class of ARG,
17990 or a pointer to a template base class of the type pointed to by
17992 UNIFY_ALLOW_INTEGER:
17993 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17994 case for more information.
17995 UNIFY_ALLOW_OUTER_LEVEL:
17996 This is the outermost level of a deduction. Used to determine validity
17997 of qualification conversions. A valid qualification conversion must
17998 have const qualified pointers leading up to the inner type which
17999 requires additional CV quals, except at the outer level, where const
18000 is not required [conv.qual]. It would be normal to set this flag in
18001 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
18002 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
18003 This is the outermost level of a deduction, and PARM can be more CV
18004 qualified at this point.
18005 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
18006 This is the outermost level of a deduction, and PARM can be less CV
18007 qualified at this point. */
18010 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
18016 int strict_in
= strict
;
18018 /* I don't think this will do the right thing with respect to types.
18019 But the only case I've seen it in so far has been array bounds, where
18020 signedness is the only information lost, and I think that will be
18022 while (TREE_CODE (parm
) == NOP_EXPR
)
18023 parm
= TREE_OPERAND (parm
, 0);
18025 if (arg
== error_mark_node
)
18026 return unify_invalid (explain_p
);
18027 if (arg
== unknown_type_node
18028 || arg
== init_list_type_node
)
18029 /* We can't deduce anything from this, but we might get all the
18030 template args from other function args. */
18031 return unify_success (explain_p
);
18033 /* If PARM uses template parameters, then we can't bail out here,
18034 even if ARG == PARM, since we won't record unifications for the
18035 template parameters. We might need them if we're trying to
18036 figure out which of two things is more specialized. */
18037 if (arg
== parm
&& !uses_template_parms (parm
))
18038 return unify_success (explain_p
);
18040 /* Handle init lists early, so the rest of the function can assume
18041 we're dealing with a type. */
18042 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
18046 tree orig_parm
= parm
;
18048 /* Replace T with std::initializer_list<T> for deduction. */
18049 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
18050 && flag_deduce_init_list
)
18051 parm
= listify (parm
);
18053 if (!is_std_init_list (parm
)
18054 && TREE_CODE (parm
) != ARRAY_TYPE
)
18055 /* We can only deduce from an initializer list argument if the
18056 parameter is std::initializer_list or an array; otherwise this
18057 is a non-deduced context. */
18058 return unify_success (explain_p
);
18060 if (TREE_CODE (parm
) == ARRAY_TYPE
)
18061 elttype
= TREE_TYPE (parm
);
18064 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
18065 /* Deduction is defined in terms of a single type, so just punt
18066 on the (bizarre) std::initializer_list<T...>. */
18067 if (PACK_EXPANSION_P (elttype
))
18068 return unify_success (explain_p
);
18071 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
18073 int elt_strict
= strict
;
18075 if (elt
== error_mark_node
)
18076 return unify_invalid (explain_p
);
18078 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
18080 tree type
= TREE_TYPE (elt
);
18081 if (type
== error_mark_node
)
18082 return unify_invalid (explain_p
);
18083 /* It should only be possible to get here for a call. */
18084 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
18085 elt_strict
|= maybe_adjust_types_for_deduction
18086 (DEDUCE_CALL
, &elttype
, &type
, elt
);
18090 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
18094 if (TREE_CODE (parm
) == ARRAY_TYPE
18095 && deducible_array_bound (TYPE_DOMAIN (parm
)))
18097 /* Also deduce from the length of the initializer list. */
18098 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
18099 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
18100 if (idx
== error_mark_node
)
18101 return unify_invalid (explain_p
);
18102 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18106 /* If the std::initializer_list<T> deduction worked, replace the
18107 deduced A with std::initializer_list<A>. */
18108 if (orig_parm
!= parm
)
18110 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
18111 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18112 targ
= listify (targ
);
18113 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
18115 return unify_success (explain_p
);
18118 /* Immediately reject some pairs that won't unify because of
18119 cv-qualification mismatches. */
18120 if (TREE_CODE (arg
) == TREE_CODE (parm
)
18122 /* It is the elements of the array which hold the cv quals of an array
18123 type, and the elements might be template type parms. We'll check
18124 when we recurse. */
18125 && TREE_CODE (arg
) != ARRAY_TYPE
18126 /* We check the cv-qualifiers when unifying with template type
18127 parameters below. We want to allow ARG `const T' to unify with
18128 PARM `T' for example, when computing which of two templates
18129 is more specialized, for example. */
18130 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
18131 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
18132 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18134 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
18135 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
18136 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
18137 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
18138 strict
&= ~UNIFY_ALLOW_DERIVED
;
18139 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
18140 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
18142 switch (TREE_CODE (parm
))
18144 case TYPENAME_TYPE
:
18146 case UNBOUND_CLASS_TEMPLATE
:
18147 /* In a type which contains a nested-name-specifier, template
18148 argument values cannot be deduced for template parameters used
18149 within the nested-name-specifier. */
18150 return unify_success (explain_p
);
18152 case TEMPLATE_TYPE_PARM
:
18153 case TEMPLATE_TEMPLATE_PARM
:
18154 case BOUND_TEMPLATE_TEMPLATE_PARM
:
18155 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18156 if (error_operand_p (tparm
))
18157 return unify_invalid (explain_p
);
18159 if (TEMPLATE_TYPE_LEVEL (parm
)
18160 != template_decl_level (tparm
))
18161 /* The PARM is not one we're trying to unify. Just check
18162 to see if it matches ARG. */
18164 if (TREE_CODE (arg
) == TREE_CODE (parm
)
18165 && (is_auto (parm
) ? is_auto (arg
)
18166 : same_type_p (parm
, arg
)))
18167 return unify_success (explain_p
);
18169 return unify_type_mismatch (explain_p
, parm
, arg
);
18171 idx
= TEMPLATE_TYPE_IDX (parm
);
18172 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18173 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
18174 if (error_operand_p (tparm
))
18175 return unify_invalid (explain_p
);
18177 /* Check for mixed types and values. */
18178 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
18179 && TREE_CODE (tparm
) != TYPE_DECL
)
18180 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18181 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
18182 gcc_unreachable ();
18184 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18186 /* ARG must be constructed from a template class or a template
18187 template parameter. */
18188 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
18189 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
18190 return unify_template_deduction_failure (explain_p
, parm
, arg
);
18192 tree parmvec
= TYPE_TI_ARGS (parm
);
18193 /* An alias template name is never deduced. */
18194 if (TYPE_ALIAS_P (arg
))
18195 arg
= strip_typedefs (arg
);
18196 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
18197 tree full_argvec
= add_to_template_args (targs
, argvec
);
18199 = DECL_INNERMOST_TEMPLATE_PARMS
18200 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
18202 int parm_variadic_p
= 0;
18204 /* The resolution to DR150 makes clear that default
18205 arguments for an N-argument may not be used to bind T
18206 to a template template parameter with fewer than N
18207 parameters. It is not safe to permit the binding of
18208 default arguments as an extension, as that may change
18209 the meaning of a conforming program. Consider:
18211 struct Dense { static const unsigned int dim = 1; };
18213 template <template <typename> class View,
18215 void operator+(float, View<Block> const&);
18217 template <typename Block,
18218 unsigned int Dim = Block::dim>
18219 struct Lvalue_proxy { operator float() const; };
18223 Lvalue_proxy<Dense> p;
18228 Here, if Lvalue_proxy is permitted to bind to View, then
18229 the global operator+ will be used; if they are not, the
18230 Lvalue_proxy will be converted to float. */
18231 if (coerce_template_parms (parm_parms
,
18233 TYPE_TI_TEMPLATE (parm
),
18235 ? tf_warning_or_error
18237 /*require_all_args=*/true,
18238 /*use_default_args=*/false)
18239 == error_mark_node
)
18242 /* Deduce arguments T, i from TT<T> or TT<i>.
18243 We check each element of PARMVEC and ARGVEC individually
18244 rather than the whole TREE_VEC since they can have
18245 different number of elements. */
18247 parmvec
= expand_template_argument_pack (parmvec
);
18248 argvec
= expand_template_argument_pack (argvec
);
18250 len
= TREE_VEC_LENGTH (parmvec
);
18252 /* Check if the parameters end in a pack, making them
18255 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
18256 parm_variadic_p
= 1;
18258 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18259 /* If the template argument list of P contains a pack
18260 expansion that is not the last template argument, the
18261 entire template argument list is a non-deduced
18263 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
18264 return unify_success (explain_p
);
18266 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
18267 return unify_too_few_arguments (explain_p
,
18268 TREE_VEC_LENGTH (argvec
), len
);
18270 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18272 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18273 TREE_VEC_ELT (parmvec
, i
),
18274 TREE_VEC_ELT (argvec
, i
),
18275 UNIFY_ALLOW_NONE
, explain_p
);
18278 if (parm_variadic_p
18279 && unify_pack_expansion (tparms
, targs
,
18282 /*subr=*/true, explain_p
))
18285 arg
= TYPE_TI_TEMPLATE (arg
);
18287 /* Fall through to deduce template name. */
18290 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18291 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18293 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
18295 /* Simple cases: Value already set, does match or doesn't. */
18296 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
18297 return unify_success (explain_p
);
18299 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18303 /* If PARM is `const T' and ARG is only `int', we don't have
18304 a match unless we are allowing additional qualification.
18305 If ARG is `const int' and PARM is just `T' that's OK;
18306 that binds `const int' to `T'. */
18307 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
18309 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18311 /* Consider the case where ARG is `const volatile int' and
18312 PARM is `const T'. Then, T should be `volatile int'. */
18313 arg
= cp_build_qualified_type_real
18314 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
18315 if (arg
== error_mark_node
)
18316 return unify_invalid (explain_p
);
18318 /* Simple cases: Value already set, does match or doesn't. */
18319 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
18320 return unify_success (explain_p
);
18322 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18324 /* Make sure that ARG is not a variable-sized array. (Note
18325 that were talking about variable-sized arrays (like
18326 `int[n]'), rather than arrays of unknown size (like
18327 `int[]').) We'll get very confused by such a type since
18328 the bound of the array is not constant, and therefore
18329 not mangleable. Besides, such types are not allowed in
18330 ISO C++, so we can do as we please here. We do allow
18331 them for 'auto' deduction, since that isn't ABI-exposed. */
18332 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
18333 return unify_vla_arg (explain_p
, arg
);
18335 /* Strip typedefs as in convert_template_argument. */
18336 arg
= canonicalize_type_argument (arg
, tf_none
);
18339 /* If ARG is a parameter pack or an expansion, we cannot unify
18340 against it unless PARM is also a parameter pack. */
18341 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18342 && !template_parameter_pack_p (parm
))
18343 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18345 /* If the argument deduction results is a METHOD_TYPE,
18346 then there is a problem.
18347 METHOD_TYPE doesn't map to any real C++ type the result of
18348 the deduction can not be of that type. */
18349 if (TREE_CODE (arg
) == METHOD_TYPE
)
18350 return unify_method_type_error (explain_p
, arg
);
18352 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18353 return unify_success (explain_p
);
18355 case TEMPLATE_PARM_INDEX
:
18356 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18357 if (error_operand_p (tparm
))
18358 return unify_invalid (explain_p
);
18360 if (TEMPLATE_PARM_LEVEL (parm
)
18361 != template_decl_level (tparm
))
18363 /* The PARM is not one we're trying to unify. Just check
18364 to see if it matches ARG. */
18365 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
18366 && cp_tree_equal (parm
, arg
));
18368 unify_expression_unequal (explain_p
, parm
, arg
);
18372 idx
= TEMPLATE_PARM_IDX (parm
);
18373 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18377 int x
= !cp_tree_equal (targ
, arg
);
18379 unify_inconsistency (explain_p
, parm
, targ
, arg
);
18383 /* [temp.deduct.type] If, in the declaration of a function template
18384 with a non-type template-parameter, the non-type
18385 template-parameter is used in an expression in the function
18386 parameter-list and, if the corresponding template-argument is
18387 deduced, the template-argument type shall match the type of the
18388 template-parameter exactly, except that a template-argument
18389 deduced from an array bound may be of any integral type.
18390 The non-type parameter might use already deduced type parameters. */
18391 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
18392 if (!TREE_TYPE (arg
))
18393 /* Template-parameter dependent expression. Just accept it for now.
18394 It will later be processed in convert_template_argument. */
18396 else if (same_type_p (TREE_TYPE (arg
), tparm
))
18398 else if ((strict
& UNIFY_ALLOW_INTEGER
)
18399 && CP_INTEGRAL_TYPE_P (tparm
))
18400 /* Convert the ARG to the type of PARM; the deduced non-type
18401 template argument must exactly match the types of the
18402 corresponding parameter. */
18403 arg
= fold (build_nop (tparm
, arg
));
18404 else if (uses_template_parms (tparm
))
18405 /* We haven't deduced the type of this parameter yet. Try again
18407 return unify_success (explain_p
);
18409 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
18411 /* If ARG is a parameter pack or an expansion, we cannot unify
18412 against it unless PARM is also a parameter pack. */
18413 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18414 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
18415 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18418 bool removed_attr
= false;
18419 arg
= strip_typedefs_expr (arg
, &removed_attr
);
18421 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18422 return unify_success (explain_p
);
18426 /* A pointer-to-member constant can be unified only with
18427 another constant. */
18428 if (TREE_CODE (arg
) != PTRMEM_CST
)
18429 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
18431 /* Just unify the class member. It would be useless (and possibly
18432 wrong, depending on the strict flags) to unify also
18433 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18434 arg refer to the same variable, even if through different
18435 classes. For instance:
18437 struct A { int x; };
18440 Unification of &A::x and &B::x must succeed. */
18441 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
18442 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
18447 if (!TYPE_PTR_P (arg
))
18448 return unify_type_mismatch (explain_p
, parm
, arg
);
18450 /* [temp.deduct.call]
18452 A can be another pointer or pointer to member type that can
18453 be converted to the deduced A via a qualification
18454 conversion (_conv.qual_).
18456 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18457 This will allow for additional cv-qualification of the
18458 pointed-to types if appropriate. */
18460 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
18461 /* The derived-to-base conversion only persists through one
18462 level of pointers. */
18463 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
18465 return unify (tparms
, targs
, TREE_TYPE (parm
),
18466 TREE_TYPE (arg
), strict
, explain_p
);
18469 case REFERENCE_TYPE
:
18470 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
18471 return unify_type_mismatch (explain_p
, parm
, arg
);
18472 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18473 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18476 if (TREE_CODE (arg
) != ARRAY_TYPE
)
18477 return unify_type_mismatch (explain_p
, parm
, arg
);
18478 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
18479 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
18480 return unify_type_mismatch (explain_p
, parm
, arg
);
18481 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18482 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18483 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
18484 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18485 TYPE_DOMAIN (arg
), explain_p
);
18486 return unify_success (explain_p
);
18493 case ENUMERAL_TYPE
:
18496 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18497 return unify_type_mismatch (explain_p
, parm
, arg
);
18499 /* We have already checked cv-qualification at the top of the
18501 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
18502 return unify_type_mismatch (explain_p
, parm
, arg
);
18504 /* As far as unification is concerned, this wins. Later checks
18505 will invalidate it if necessary. */
18506 return unify_success (explain_p
);
18508 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18509 /* Type INTEGER_CST can come from ordinary constant template args. */
18511 while (TREE_CODE (arg
) == NOP_EXPR
)
18512 arg
= TREE_OPERAND (arg
, 0);
18514 if (TREE_CODE (arg
) != INTEGER_CST
)
18515 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18516 return (tree_int_cst_equal (parm
, arg
)
18517 ? unify_success (explain_p
)
18518 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18522 int i
, len
, argslen
;
18523 int parm_variadic_p
= 0;
18525 if (TREE_CODE (arg
) != TREE_VEC
)
18526 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18528 len
= TREE_VEC_LENGTH (parm
);
18529 argslen
= TREE_VEC_LENGTH (arg
);
18531 /* Check for pack expansions in the parameters. */
18532 for (i
= 0; i
< len
; ++i
)
18534 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18537 /* We can unify against something with a trailing
18539 parm_variadic_p
= 1;
18541 /* [temp.deduct.type]/9: If the template argument list of
18542 P contains a pack expansion that is not the last
18543 template argument, the entire template argument list
18544 is a non-deduced context. */
18545 return unify_success (explain_p
);
18549 /* If we don't have enough arguments to satisfy the parameters
18550 (not counting the pack expression at the end), or we have
18551 too many arguments for a parameter list that doesn't end in
18552 a pack expression, we can't unify. */
18553 if (parm_variadic_p
18554 ? argslen
< len
- parm_variadic_p
18556 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18558 /* Unify all of the parameters that precede the (optional)
18559 pack expression. */
18560 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18562 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18563 TREE_VEC_ELT (parm
, i
),
18564 TREE_VEC_ELT (arg
, i
),
18565 UNIFY_ALLOW_NONE
, explain_p
);
18567 if (parm_variadic_p
)
18568 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18570 /*subr=*/true, explain_p
);
18571 return unify_success (explain_p
);
18576 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18577 return unify_type_mismatch (explain_p
, parm
, arg
);
18579 if (TYPE_PTRMEMFUNC_P (parm
))
18581 if (!TYPE_PTRMEMFUNC_P (arg
))
18582 return unify_type_mismatch (explain_p
, parm
, arg
);
18584 return unify (tparms
, targs
,
18585 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18586 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18587 strict
, explain_p
);
18589 else if (TYPE_PTRMEMFUNC_P (arg
))
18590 return unify_type_mismatch (explain_p
, parm
, arg
);
18592 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18594 tree t
= NULL_TREE
;
18596 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18598 /* First, we try to unify the PARM and ARG directly. */
18599 t
= try_class_unification (tparms
, targs
,
18600 parm
, arg
, explain_p
);
18604 /* Fallback to the special case allowed in
18605 [temp.deduct.call]:
18607 If P is a class, and P has the form
18608 template-id, then A can be a derived class of
18609 the deduced A. Likewise, if P is a pointer to
18610 a class of the form template-id, A can be a
18611 pointer to a derived class pointed to by the
18613 enum template_base_result r
;
18614 r
= get_template_base (tparms
, targs
, parm
, arg
,
18618 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18621 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18622 && (CLASSTYPE_TI_TEMPLATE (parm
)
18623 == CLASSTYPE_TI_TEMPLATE (arg
)))
18624 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18625 Then, we should unify `int' and `U'. */
18628 /* There's no chance of unification succeeding. */
18629 return unify_type_mismatch (explain_p
, parm
, arg
);
18631 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18632 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18634 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18635 return unify_type_mismatch (explain_p
, parm
, arg
);
18636 return unify_success (explain_p
);
18639 case FUNCTION_TYPE
:
18641 unsigned int nargs
;
18646 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18647 return unify_type_mismatch (explain_p
, parm
, arg
);
18649 /* CV qualifications for methods can never be deduced, they must
18650 match exactly. We need to check them explicitly here,
18651 because type_unification_real treats them as any other
18652 cv-qualified parameter. */
18653 if (TREE_CODE (parm
) == METHOD_TYPE
18654 && (!check_cv_quals_for_unify
18656 class_of_this_parm (arg
),
18657 class_of_this_parm (parm
))))
18658 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18660 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18661 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18663 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18664 args
= XALLOCAVEC (tree
, nargs
);
18665 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18666 a
!= NULL_TREE
&& a
!= void_list_node
;
18667 a
= TREE_CHAIN (a
), ++i
)
18668 args
[i
] = TREE_VALUE (a
);
18671 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18672 args
, nargs
, 1, DEDUCE_EXACT
,
18673 LOOKUP_NORMAL
, NULL
, explain_p
);
18677 /* Unify a pointer to member with a pointer to member function, which
18678 deduces the type of the member as a function type. */
18679 if (TYPE_PTRMEMFUNC_P (arg
))
18681 /* Check top-level cv qualifiers */
18682 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18683 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18685 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18686 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18687 UNIFY_ALLOW_NONE
, explain_p
);
18689 /* Determine the type of the function we are unifying against. */
18690 tree fntype
= static_fn_type (arg
);
18692 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18695 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18696 return unify_type_mismatch (explain_p
, parm
, arg
);
18697 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18698 TYPE_OFFSET_BASETYPE (arg
),
18699 UNIFY_ALLOW_NONE
, explain_p
);
18700 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18701 strict
, explain_p
);
18704 if (DECL_TEMPLATE_PARM_P (parm
))
18705 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18706 if (arg
!= scalar_constant_value (parm
))
18707 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18708 return unify_success (explain_p
);
18711 case TEMPLATE_DECL
:
18712 /* Matched cases are handled by the ARG == PARM test above. */
18713 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18716 /* A non-type template parameter that is a variable should be a
18717 an integral constant, in which case, it whould have been
18718 folded into its (constant) value. So we should not be getting
18719 a variable here. */
18720 gcc_unreachable ();
18722 case TYPE_ARGUMENT_PACK
:
18723 case NONTYPE_ARGUMENT_PACK
:
18724 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18725 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18728 case DECLTYPE_TYPE
:
18729 case UNDERLYING_TYPE
:
18730 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18731 or UNDERLYING_TYPE nodes. */
18732 return unify_success (explain_p
);
18735 /* Unification fails if we hit an error node. */
18736 return unify_invalid (explain_p
);
18739 if (REFERENCE_REF_P (parm
))
18741 if (REFERENCE_REF_P (arg
))
18742 arg
= TREE_OPERAND (arg
, 0);
18743 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18744 strict
, explain_p
);
18749 /* An unresolved overload is a nondeduced context. */
18750 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18751 return unify_success (explain_p
);
18752 gcc_assert (EXPR_P (parm
));
18754 /* We must be looking at an expression. This can happen with
18758 void foo(S<I>, S<I + 2>);
18760 This is a "nondeduced context":
18764 The nondeduced contexts are:
18766 --A type that is a template-id in which one or more of
18767 the template-arguments is an expression that references
18768 a template-parameter.
18770 In these cases, we assume deduction succeeded, but don't
18771 actually infer any unifications. */
18773 if (!uses_template_parms (parm
)
18774 && !template_args_equal (parm
, arg
))
18775 return unify_expression_unequal (explain_p
, parm
, arg
);
18777 return unify_success (explain_p
);
18780 #undef RECUR_AND_CHECK_FAILURE
18782 /* Note that DECL can be defined in this translation unit, if
18786 mark_definable (tree decl
)
18789 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18790 FOR_EACH_CLONE (clone
, decl
)
18791 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18794 /* Called if RESULT is explicitly instantiated, or is a member of an
18795 explicitly instantiated class. */
18798 mark_decl_instantiated (tree result
, int extern_p
)
18800 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18802 /* If this entity has already been written out, it's too late to
18803 make any modifications. */
18804 if (TREE_ASM_WRITTEN (result
))
18807 /* For anonymous namespace we don't need to do anything. */
18808 if (decl_anon_ns_mem_p (result
))
18810 gcc_assert (!TREE_PUBLIC (result
));
18814 if (TREE_CODE (result
) != FUNCTION_DECL
)
18815 /* The TREE_PUBLIC flag for function declarations will have been
18816 set correctly by tsubst. */
18817 TREE_PUBLIC (result
) = 1;
18819 /* This might have been set by an earlier implicit instantiation. */
18820 DECL_COMDAT (result
) = 0;
18823 DECL_NOT_REALLY_EXTERN (result
) = 0;
18826 mark_definable (result
);
18827 mark_needed (result
);
18828 /* Always make artificials weak. */
18829 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18830 comdat_linkage (result
);
18831 /* For WIN32 we also want to put explicit instantiations in
18832 linkonce sections. */
18833 else if (TREE_PUBLIC (result
))
18834 maybe_make_one_only (result
);
18837 /* If EXTERN_P, then this function will not be emitted -- unless
18838 followed by an explicit instantiation, at which point its linkage
18839 will be adjusted. If !EXTERN_P, then this function will be
18840 emitted here. In neither circumstance do we want
18841 import_export_decl to adjust the linkage. */
18842 DECL_INTERFACE_KNOWN (result
) = 1;
18845 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18846 important template arguments. If any are missing, we check whether
18847 they're important by using error_mark_node for substituting into any
18848 args that were used for partial ordering (the ones between ARGS and END)
18849 and seeing if it bubbles up. */
18852 check_undeduced_parms (tree targs
, tree args
, tree end
)
18854 bool found
= false;
18856 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18857 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18860 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18864 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18865 if (substed
== error_mark_node
)
18871 /* Given two function templates PAT1 and PAT2, return:
18873 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18874 -1 if PAT2 is more specialized than PAT1.
18875 0 if neither is more specialized.
18877 LEN indicates the number of parameters we should consider
18878 (defaulted parameters should not be considered).
18880 The 1998 std underspecified function template partial ordering, and
18881 DR214 addresses the issue. We take pairs of arguments, one from
18882 each of the templates, and deduce them against each other. One of
18883 the templates will be more specialized if all the *other*
18884 template's arguments deduce against its arguments and at least one
18885 of its arguments *does* *not* deduce against the other template's
18886 corresponding argument. Deduction is done as for class templates.
18887 The arguments used in deduction have reference and top level cv
18888 qualifiers removed. Iff both arguments were originally reference
18889 types *and* deduction succeeds in both directions, an lvalue reference
18890 wins against an rvalue reference and otherwise the template
18891 with the more cv-qualified argument wins for that pairing (if
18892 neither is more cv-qualified, they both are equal). Unlike regular
18893 deduction, after all the arguments have been deduced in this way,
18894 we do *not* verify the deduced template argument values can be
18895 substituted into non-deduced contexts.
18897 The logic can be a bit confusing here, because we look at deduce1 and
18898 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18899 can find template arguments for pat1 to make arg1 look like arg2, that
18900 means that arg2 is at least as specialized as arg1. */
18903 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18905 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18906 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18907 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18908 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18909 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18910 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18911 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18912 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18913 tree origs1
, origs2
;
18914 bool lose1
= false;
18915 bool lose2
= false;
18917 /* Remove the this parameter from non-static member functions. If
18918 one is a non-static member function and the other is not a static
18919 member function, remove the first parameter from that function
18920 also. This situation occurs for operator functions where we
18921 locate both a member function (with this pointer) and non-member
18922 operator (with explicit first operand). */
18923 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18925 len
--; /* LEN is the number of significant arguments for DECL1 */
18926 args1
= TREE_CHAIN (args1
);
18927 if (!DECL_STATIC_FUNCTION_P (decl2
))
18928 args2
= TREE_CHAIN (args2
);
18930 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18932 args2
= TREE_CHAIN (args2
);
18933 if (!DECL_STATIC_FUNCTION_P (decl1
))
18936 args1
= TREE_CHAIN (args1
);
18940 /* If only one is a conversion operator, they are unordered. */
18941 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18944 /* Consider the return type for a conversion function */
18945 if (DECL_CONV_FN_P (decl1
))
18947 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18948 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18952 processing_template_decl
++;
18958 /* Stop when an ellipsis is seen. */
18959 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18961 tree arg1
= TREE_VALUE (args1
);
18962 tree arg2
= TREE_VALUE (args2
);
18963 int deduce1
, deduce2
;
18969 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18970 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18972 /* When both arguments are pack expansions, we need only
18973 unify the patterns themselves. */
18974 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18975 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18977 /* This is the last comparison we need to do. */
18981 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18983 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18984 arg1
= TREE_TYPE (arg1
);
18985 quals1
= cp_type_quals (arg1
);
18988 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18990 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18991 arg2
= TREE_TYPE (arg2
);
18992 quals2
= cp_type_quals (arg2
);
18995 arg1
= TYPE_MAIN_VARIANT (arg1
);
18996 arg2
= TYPE_MAIN_VARIANT (arg2
);
18998 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
19000 int i
, len2
= list_length (args2
);
19001 tree parmvec
= make_tree_vec (1);
19002 tree argvec
= make_tree_vec (len2
);
19005 /* Setup the parameter vector, which contains only ARG1. */
19006 TREE_VEC_ELT (parmvec
, 0) = arg1
;
19008 /* Setup the argument vector, which contains the remaining
19010 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
19011 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
19013 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
19014 argvec
, DEDUCE_EXACT
,
19015 /*subr=*/true, /*explain_p=*/false)
19018 /* We cannot deduce in the other direction, because ARG1 is
19019 a pack expansion but ARG2 is not. */
19022 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
19024 int i
, len1
= list_length (args1
);
19025 tree parmvec
= make_tree_vec (1);
19026 tree argvec
= make_tree_vec (len1
);
19029 /* Setup the parameter vector, which contains only ARG1. */
19030 TREE_VEC_ELT (parmvec
, 0) = arg2
;
19032 /* Setup the argument vector, which contains the remaining
19034 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
19035 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
19037 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
19038 argvec
, DEDUCE_EXACT
,
19039 /*subr=*/true, /*explain_p=*/false)
19042 /* We cannot deduce in the other direction, because ARG2 is
19043 a pack expansion but ARG1 is not.*/
19049 /* The normal case, where neither argument is a pack
19051 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
19052 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
19054 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
19055 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
19059 /* If we couldn't deduce arguments for tparms1 to make arg1 match
19060 arg2, then arg2 is not as specialized as arg1. */
19066 /* "If, for a given type, deduction succeeds in both directions
19067 (i.e., the types are identical after the transformations above)
19068 and both P and A were reference types (before being replaced with
19069 the type referred to above):
19070 - if the type from the argument template was an lvalue reference and
19071 the type from the parameter template was not, the argument type is
19072 considered to be more specialized than the other; otherwise,
19073 - if the type from the argument template is more cv-qualified
19074 than the type from the parameter template (as described above),
19075 the argument type is considered to be more specialized than the other;
19077 - neither type is more specialized than the other." */
19079 if (deduce1
&& deduce2
)
19081 if (ref1
&& ref2
&& ref1
!= ref2
)
19088 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
19090 if ((quals1
& quals2
) == quals2
)
19092 if ((quals1
& quals2
) == quals1
)
19097 if (lose1
&& lose2
)
19098 /* We've failed to deduce something in either direction.
19099 These must be unordered. */
19102 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
19103 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
19104 /* We have already processed all of the arguments in our
19105 handing of the pack expansion type. */
19108 args1
= TREE_CHAIN (args1
);
19109 args2
= TREE_CHAIN (args2
);
19112 /* "In most cases, all template parameters must have values in order for
19113 deduction to succeed, but for partial ordering purposes a template
19114 parameter may remain without a value provided it is not used in the
19115 types being used for partial ordering."
19117 Thus, if we are missing any of the targs1 we need to substitute into
19118 origs1, then pat2 is not as specialized as pat1. This can happen when
19119 there is a nondeduced context. */
19120 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
19122 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
19125 processing_template_decl
--;
19127 /* All things being equal, if the next argument is a pack expansion
19128 for one function but not for the other, prefer the
19129 non-variadic function. FIXME this is bogus; see c++/41958. */
19131 && args1
&& TREE_VALUE (args1
)
19132 && args2
&& TREE_VALUE (args2
))
19134 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
19135 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
19138 if (lose1
== lose2
)
19146 /* Determine which of two partial specializations of TMPL is more
19149 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
19150 to the first partial specialization. The TREE_PURPOSE is the
19151 innermost set of template parameters for the partial
19152 specialization. PAT2 is similar, but for the second template.
19154 Return 1 if the first partial specialization is more specialized;
19155 -1 if the second is more specialized; 0 if neither is more
19158 See [temp.class.order] for information about determining which of
19159 two templates is more specialized. */
19162 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
19166 bool any_deductions
= false;
19168 tree tmpl1
= TREE_VALUE (pat1
);
19169 tree tmpl2
= TREE_VALUE (pat2
);
19170 tree parms1
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl1
);
19171 tree parms2
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl2
);
19172 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
19173 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
19175 /* Just like what happens for functions, if we are ordering between
19176 different template specializations, we may encounter dependent
19177 types in the arguments, and we need our dependency check functions
19178 to behave correctly. */
19179 ++processing_template_decl
;
19180 targs
= get_partial_spec_bindings (tmpl
, parms1
, specargs1
, specargs2
);
19184 any_deductions
= true;
19187 targs
= get_partial_spec_bindings (tmpl
, parms2
, specargs2
, specargs1
);
19191 any_deductions
= true;
19193 --processing_template_decl
;
19195 /* In the case of a tie where at least one of the templates
19196 has a parameter pack at the end, the template with the most
19197 non-packed parameters wins. */
19200 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
19201 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
19203 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
19204 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
19205 int len1
= TREE_VEC_LENGTH (args1
);
19206 int len2
= TREE_VEC_LENGTH (args2
);
19208 /* We don't count the pack expansion at the end. */
19209 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
19211 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
19216 else if (len1
< len2
)
19223 /* Return the template arguments that will produce the function signature
19224 DECL from the function template FN, with the explicit template
19225 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
19226 also match. Return NULL_TREE if no satisfactory arguments could be
19230 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
19232 int ntparms
= DECL_NTPARMS (fn
);
19233 tree targs
= make_tree_vec (ntparms
);
19234 tree decl_type
= TREE_TYPE (decl
);
19235 tree decl_arg_types
;
19237 unsigned int nargs
, ix
;
19240 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
19242 /* Never do unification on the 'this' parameter. */
19243 decl_arg_types
= skip_artificial_parms_for (decl
,
19244 TYPE_ARG_TYPES (decl_type
));
19246 nargs
= list_length (decl_arg_types
);
19247 args
= XALLOCAVEC (tree
, nargs
);
19248 for (arg
= decl_arg_types
, ix
= 0;
19249 arg
!= NULL_TREE
&& arg
!= void_list_node
;
19250 arg
= TREE_CHAIN (arg
), ++ix
)
19251 args
[ix
] = TREE_VALUE (arg
);
19253 if (fn_type_unification (fn
, explicit_args
, targs
,
19255 (check_rettype
|| DECL_CONV_FN_P (fn
)
19256 ? TREE_TYPE (decl_type
) : NULL_TREE
),
19257 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
19259 == error_mark_node
)
19265 /* Return the innermost template arguments that, when applied to a partial
19266 specialization of TMPL whose innermost template parameters are
19267 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
19270 For example, suppose we have:
19272 template <class T, class U> struct S {};
19273 template <class T> struct S<T*, int> {};
19275 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
19276 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
19277 int}. The resulting vector will be {double}, indicating that `T'
19278 is bound to `double'. */
19281 get_partial_spec_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
19283 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
19285 tree innermost_deduced_args
;
19287 innermost_deduced_args
= make_tree_vec (ntparms
);
19288 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19290 deduced_args
= copy_node (args
);
19291 SET_TMPL_ARGS_LEVEL (deduced_args
,
19292 TMPL_ARGS_DEPTH (deduced_args
),
19293 innermost_deduced_args
);
19296 deduced_args
= innermost_deduced_args
;
19298 if (unify (tparms
, deduced_args
,
19299 INNERMOST_TEMPLATE_ARGS (spec_args
),
19300 INNERMOST_TEMPLATE_ARGS (args
),
19301 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
19304 for (i
= 0; i
< ntparms
; ++i
)
19305 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
19308 /* Verify that nondeduced template arguments agree with the type
19309 obtained from argument deduction.
19313 struct A { typedef int X; };
19314 template <class T, class U> struct C {};
19315 template <class T> struct C<T, typename T::X> {};
19317 Then with the instantiation `C<A, int>', we can deduce that
19318 `T' is `A' but unify () does not check whether `typename T::X'
19320 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
19321 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19323 tf_none
, false, false);
19324 if (spec_args
== error_mark_node
19325 /* We only need to check the innermost arguments; the other
19326 arguments will always agree. */
19327 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
19328 INNERMOST_TEMPLATE_ARGS (args
)))
19331 /* Now that we have bindings for all of the template arguments,
19332 ensure that the arguments deduced for the template template
19333 parameters have compatible template parameter lists. See the use
19334 of template_template_parm_bindings_ok_p in fn_type_unification
19335 for more information. */
19336 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
19339 return deduced_args
;
19342 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19343 Return the TREE_LIST node with the most specialized template, if
19344 any. If there is no most specialized template, the error_mark_node
19347 Note that this function does not look at, or modify, the
19348 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19349 returned is one of the elements of INSTANTIATIONS, callers may
19350 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19351 and retrieve it from the value returned. */
19354 most_specialized_instantiation (tree templates
)
19358 ++processing_template_decl
;
19361 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
19365 if (get_bindings (TREE_VALUE (champ
),
19366 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19367 NULL_TREE
, /*check_ret=*/true))
19370 if (get_bindings (TREE_VALUE (fn
),
19371 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19372 NULL_TREE
, /*check_ret=*/true))
19379 /* Equally specialized, move to next function. If there
19380 is no next function, nothing's most specialized. */
19381 fn
= TREE_CHAIN (fn
);
19389 /* Now verify that champ is better than everything earlier in the
19390 instantiation list. */
19391 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
19392 if (get_bindings (TREE_VALUE (champ
),
19393 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19394 NULL_TREE
, /*check_ret=*/true)
19395 || !get_bindings (TREE_VALUE (fn
),
19396 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19397 NULL_TREE
, /*check_ret=*/true))
19403 processing_template_decl
--;
19406 return error_mark_node
;
19411 /* If DECL is a specialization of some template, return the most
19412 general such template. Otherwise, returns NULL_TREE.
19414 For example, given:
19416 template <class T> struct S { template <class U> void f(U); };
19418 if TMPL is `template <class U> void S<int>::f(U)' this will return
19419 the full template. This function will not trace past partial
19420 specializations, however. For example, given in addition:
19422 template <class T> struct S<T*> { template <class U> void f(U); };
19424 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19425 `template <class T> template <class U> S<T*>::f(U)'. */
19428 most_general_template (tree decl
)
19430 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19432 if (tree tinfo
= get_template_info (decl
))
19433 decl
= TI_TEMPLATE (tinfo
);
19434 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19435 template friend, or a FIELD_DECL for a capture pack. */
19436 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19440 /* Look for more and more general templates. */
19441 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
19443 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19444 (See cp-tree.h for details.) */
19445 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
19448 if (CLASS_TYPE_P (TREE_TYPE (decl
))
19449 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
19450 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
19453 /* Stop if we run into an explicitly specialized class template. */
19454 if (!DECL_NAMESPACE_SCOPE_P (decl
)
19455 && DECL_CONTEXT (decl
)
19456 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
19459 decl
= DECL_TI_TEMPLATE (decl
);
19465 /* Return the most specialized of the template partial specializations
19466 which can produce TARGET, a specialization of some class or variable
19467 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
19468 a TEMPLATE_DECL node corresponding to the partial specialization, while
19469 the TREE_PURPOSE is the set of template arguments that must be
19470 substituted into the template pattern in order to generate TARGET.
19472 If the choice of partial specialization is ambiguous, a diagnostic
19473 is issued, and the error_mark_node is returned. If there are no
19474 partial specializations matching TARGET, then NULL_TREE is
19475 returned, indicating that the primary template should be used. */
19478 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
19480 tree list
= NULL_TREE
;
19485 tree outer_args
= NULL_TREE
;
19488 if (TYPE_P (target
))
19490 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
19491 tmpl
= TI_TEMPLATE (tinfo
);
19492 args
= TI_ARGS (tinfo
);
19494 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
19496 tmpl
= TREE_OPERAND (target
, 0);
19497 args
= TREE_OPERAND (target
, 1);
19499 else if (VAR_P (target
))
19501 tree tinfo
= DECL_TEMPLATE_INFO (target
);
19502 tmpl
= TI_TEMPLATE (tinfo
);
19503 args
= TI_ARGS (tinfo
);
19506 gcc_unreachable ();
19508 tree main_tmpl
= most_general_template (tmpl
);
19510 /* For determining which partial specialization to use, only the
19511 innermost args are interesting. */
19512 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19514 outer_args
= strip_innermost_template_args (args
, 1);
19515 args
= INNERMOST_TEMPLATE_ARGS (args
);
19518 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
19520 tree partial_spec_args
;
19522 tree spec_tmpl
= TREE_VALUE (t
);
19524 partial_spec_args
= TREE_PURPOSE (t
);
19526 ++processing_template_decl
;
19530 /* Discard the outer levels of args, and then substitute in the
19531 template args from the enclosing class. */
19532 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19533 partial_spec_args
= tsubst_template_args
19534 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19536 /* And the same for the partial specialization TEMPLATE_DECL. */
19537 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19540 partial_spec_args
=
19541 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19544 /*require_all_args=*/true,
19545 /*use_default_args=*/true);
19547 --processing_template_decl
;
19549 if (partial_spec_args
== error_mark_node
)
19550 return error_mark_node
;
19551 if (spec_tmpl
== error_mark_node
)
19552 return error_mark_node
;
19554 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19555 spec_args
= get_partial_spec_bindings (tmpl
, parms
,
19561 spec_args
= add_to_template_args (outer_args
, spec_args
);
19562 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
19563 TREE_TYPE (list
) = TREE_TYPE (t
);
19570 ambiguous_p
= false;
19573 t
= TREE_CHAIN (t
);
19574 for (; t
; t
= TREE_CHAIN (t
))
19576 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19583 t
= TREE_CHAIN (t
);
19586 ambiguous_p
= true;
19595 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19597 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
19600 ambiguous_p
= true;
19608 char *spaces
= NULL
;
19609 if (!(complain
& tf_error
))
19610 return error_mark_node
;
19611 if (TYPE_P (target
))
19612 error ("ambiguous template instantiation for %q#T", target
);
19614 error ("ambiguous template instantiation for %q#D", target
);
19615 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19616 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19618 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
19619 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
19620 "%s %#S", spaces
? spaces
: str
, subst
);
19621 spaces
= spaces
? spaces
: get_spaces (str
);
19624 return error_mark_node
;
19630 /* Explicitly instantiate DECL. */
19633 do_decl_instantiation (tree decl
, tree storage
)
19635 tree result
= NULL_TREE
;
19638 if (!decl
|| decl
== error_mark_node
)
19639 /* An error occurred, for which grokdeclarator has already issued
19640 an appropriate message. */
19642 else if (! DECL_LANG_SPECIFIC (decl
))
19644 error ("explicit instantiation of non-template %q#D", decl
);
19648 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
19649 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
19651 if (VAR_P (decl
) && !var_templ
)
19653 /* There is an asymmetry here in the way VAR_DECLs and
19654 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19655 the latter, the DECL we get back will be marked as a
19656 template instantiation, and the appropriate
19657 DECL_TEMPLATE_INFO will be set up. This does not happen for
19658 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19659 should handle VAR_DECLs as it currently handles
19661 if (!DECL_CLASS_SCOPE_P (decl
))
19663 error ("%qD is not a static data member of a class template", decl
);
19666 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19667 if (!result
|| !VAR_P (result
))
19669 error ("no matching template for %qD found", decl
);
19672 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19674 error ("type %qT for explicit instantiation %qD does not match "
19675 "declared type %qT", TREE_TYPE (result
), decl
,
19680 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
19682 error ("explicit instantiation of %q#D", decl
);
19688 /* Check for various error cases. Note that if the explicit
19689 instantiation is valid the RESULT will currently be marked as an
19690 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19691 until we get here. */
19693 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19695 /* DR 259 [temp.spec].
19697 Both an explicit instantiation and a declaration of an explicit
19698 specialization shall not appear in a program unless the explicit
19699 instantiation follows a declaration of the explicit specialization.
19701 For a given set of template parameters, if an explicit
19702 instantiation of a template appears after a declaration of an
19703 explicit specialization for that template, the explicit
19704 instantiation has no effect. */
19707 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19711 No program shall explicitly instantiate any template more
19714 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19715 the first instantiation was `extern' and the second is not,
19716 and EXTERN_P for the opposite case. */
19717 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19718 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19719 /* If an "extern" explicit instantiation follows an ordinary
19720 explicit instantiation, the template is instantiated. */
19724 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19726 error ("no matching template for %qD found", result
);
19729 else if (!DECL_TEMPLATE_INFO (result
))
19731 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19735 if (storage
== NULL_TREE
)
19737 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19739 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19740 pedwarn (input_location
, OPT_Wpedantic
,
19741 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19746 error ("storage class %qD applied to template instantiation", storage
);
19748 check_explicit_instantiation_namespace (result
);
19749 mark_decl_instantiated (result
, extern_p
);
19751 instantiate_decl (result
, /*defer_ok=*/1,
19752 /*expl_inst_class_mem_p=*/false);
19756 mark_class_instantiated (tree t
, int extern_p
)
19758 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19759 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19760 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19761 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19764 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19765 rest_of_type_compilation (t
, 1);
19769 /* Called from do_type_instantiation through binding_table_foreach to
19770 do recursive instantiation for the type bound in ENTRY. */
19772 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19774 tree storage
= *(tree
*) data
;
19776 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19777 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19778 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19781 /* Called from do_type_instantiation to instantiate a member
19782 (a member function or a static member variable) of an
19783 explicitly instantiated class template. */
19785 instantiate_class_member (tree decl
, int extern_p
)
19787 mark_decl_instantiated (decl
, extern_p
);
19789 instantiate_decl (decl
, /*defer_ok=*/1,
19790 /*expl_inst_class_mem_p=*/true);
19793 /* Perform an explicit instantiation of template class T. STORAGE, if
19794 non-null, is the RID for extern, inline or static. COMPLAIN is
19795 nonzero if this is called from the parser, zero if called recursively,
19796 since the standard is unclear (as detailed below). */
19799 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19804 int previous_instantiation_extern_p
= 0;
19806 if (TREE_CODE (t
) == TYPE_DECL
)
19809 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19812 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19814 error ("explicit instantiation of non-class template %qD", tmpl
);
19816 error ("explicit instantiation of non-template type %qT", t
);
19822 if (!COMPLETE_TYPE_P (t
))
19824 if (complain
& tf_error
)
19825 error ("explicit instantiation of %q#T before definition of template",
19830 if (storage
!= NULL_TREE
)
19832 if (!in_system_header_at (input_location
))
19834 if (storage
== ridpointers
[(int) RID_EXTERN
])
19836 if (cxx_dialect
== cxx98
)
19837 pedwarn (input_location
, OPT_Wpedantic
,
19838 "ISO C++ 1998 forbids the use of %<extern%> on "
19839 "explicit instantiations");
19842 pedwarn (input_location
, OPT_Wpedantic
,
19843 "ISO C++ forbids the use of %qE"
19844 " on explicit instantiations", storage
);
19847 if (storage
== ridpointers
[(int) RID_INLINE
])
19849 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19851 else if (storage
== ridpointers
[(int) RID_STATIC
])
19855 error ("storage class %qD applied to template instantiation",
19861 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19863 /* DR 259 [temp.spec].
19865 Both an explicit instantiation and a declaration of an explicit
19866 specialization shall not appear in a program unless the explicit
19867 instantiation follows a declaration of the explicit specialization.
19869 For a given set of template parameters, if an explicit
19870 instantiation of a template appears after a declaration of an
19871 explicit specialization for that template, the explicit
19872 instantiation has no effect. */
19875 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19879 No program shall explicitly instantiate any template more
19882 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19883 instantiation was `extern'. If EXTERN_P then the second is.
19884 These cases are OK. */
19885 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19887 if (!previous_instantiation_extern_p
&& !extern_p
19888 && (complain
& tf_error
))
19889 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19891 /* If we've already instantiated the template, just return now. */
19892 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19896 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19897 mark_class_instantiated (t
, extern_p
);
19905 /* In contrast to implicit instantiation, where only the
19906 declarations, and not the definitions, of members are
19907 instantiated, we have here:
19911 The explicit instantiation of a class template specialization
19912 implies the instantiation of all of its members not
19913 previously explicitly specialized in the translation unit
19914 containing the explicit instantiation.
19916 Of course, we can't instantiate member template classes, since
19917 we don't have any arguments for them. Note that the standard
19918 is unclear on whether the instantiation of the members are
19919 *explicit* instantiations or not. However, the most natural
19920 interpretation is that it should be an explicit instantiation. */
19923 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19924 if (TREE_CODE (tmp
) == FUNCTION_DECL
19925 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19926 instantiate_class_member (tmp
, extern_p
);
19928 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19929 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19930 instantiate_class_member (tmp
, extern_p
);
19932 if (CLASSTYPE_NESTED_UTDS (t
))
19933 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19934 bt_instantiate_type_proc
, &storage
);
19938 /* Given a function DECL, which is a specialization of TMPL, modify
19939 DECL to be a re-instantiation of TMPL with the same template
19940 arguments. TMPL should be the template into which tsubst'ing
19941 should occur for DECL, not the most general template.
19943 One reason for doing this is a scenario like this:
19946 void f(const T&, int i);
19948 void g() { f(3, 7); }
19951 void f(const T& t, const int i) { }
19953 Note that when the template is first instantiated, with
19954 instantiate_template, the resulting DECL will have no name for the
19955 first parameter, and the wrong type for the second. So, when we go
19956 to instantiate the DECL, we regenerate it. */
19959 regenerate_decl_from_template (tree decl
, tree tmpl
)
19961 /* The arguments used to instantiate DECL, from the most general
19966 args
= DECL_TI_ARGS (decl
);
19967 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19969 /* Make sure that we can see identifiers, and compute access
19971 push_access_scope (decl
);
19973 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19981 args_depth
= TMPL_ARGS_DEPTH (args
);
19982 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19983 if (args_depth
> parms_depth
)
19984 args
= get_innermost_template_args (args
, parms_depth
);
19986 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19987 args
, tf_error
, NULL_TREE
,
19988 /*defer_ok*/false);
19989 if (specs
&& specs
!= error_mark_node
)
19990 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19993 /* Merge parameter declarations. */
19994 decl_parm
= skip_artificial_parms_for (decl
,
19995 DECL_ARGUMENTS (decl
));
19997 = skip_artificial_parms_for (code_pattern
,
19998 DECL_ARGUMENTS (code_pattern
));
19999 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
20004 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
20005 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
20006 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
20008 parm_type
= type_decays_to (parm_type
);
20009 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
20010 TREE_TYPE (decl_parm
) = parm_type
;
20011 attributes
= DECL_ATTRIBUTES (pattern_parm
);
20012 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
20014 DECL_ATTRIBUTES (decl_parm
) = attributes
;
20015 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
20017 decl_parm
= DECL_CHAIN (decl_parm
);
20018 pattern_parm
= DECL_CHAIN (pattern_parm
);
20020 /* Merge any parameters that match with the function parameter
20022 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
20025 tree expanded_types
;
20026 /* Expand the TYPE_PACK_EXPANSION that provides the types for
20027 the parameters in this function parameter pack. */
20028 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
20029 args
, tf_error
, NULL_TREE
);
20030 len
= TREE_VEC_LENGTH (expanded_types
);
20031 for (i
= 0; i
< len
; i
++)
20036 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
20037 /* Rename the parameter to include the index. */
20038 DECL_NAME (decl_parm
) =
20039 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
20040 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
20041 parm_type
= type_decays_to (parm_type
);
20042 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
20043 TREE_TYPE (decl_parm
) = parm_type
;
20044 attributes
= DECL_ATTRIBUTES (pattern_parm
);
20045 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
20047 DECL_ATTRIBUTES (decl_parm
) = attributes
;
20048 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
20050 decl_parm
= DECL_CHAIN (decl_parm
);
20053 /* Merge additional specifiers from the CODE_PATTERN. */
20054 if (DECL_DECLARED_INLINE_P (code_pattern
)
20055 && !DECL_DECLARED_INLINE_P (decl
))
20056 DECL_DECLARED_INLINE_P (decl
) = 1;
20058 else if (VAR_P (decl
))
20060 DECL_INITIAL (decl
) =
20061 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
20062 tf_error
, DECL_TI_TEMPLATE (decl
),
20063 /*integral_constant_expression_p=*/false);
20064 if (VAR_HAD_UNKNOWN_BOUND (decl
))
20065 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
20066 tf_error
, DECL_TI_TEMPLATE (decl
));
20069 gcc_unreachable ();
20071 pop_access_scope (decl
);
20074 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
20075 substituted to get DECL. */
20078 template_for_substitution (tree decl
)
20080 tree tmpl
= DECL_TI_TEMPLATE (decl
);
20082 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
20083 for the instantiation. This is not always the most general
20084 template. Consider, for example:
20087 struct S { template <class U> void f();
20088 template <> void f<int>(); };
20090 and an instantiation of S<double>::f<int>. We want TD to be the
20091 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
20092 while (/* An instantiation cannot have a definition, so we need a
20093 more general template. */
20094 DECL_TEMPLATE_INSTANTIATION (tmpl
)
20095 /* We must also deal with friend templates. Given:
20097 template <class T> struct S {
20098 template <class U> friend void f() {};
20101 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
20102 so far as the language is concerned, but that's still
20103 where we get the pattern for the instantiation from. On
20104 other hand, if the definition comes outside the class, say:
20106 template <class T> struct S {
20107 template <class U> friend void f();
20109 template <class U> friend void f() {}
20111 we don't need to look any further. That's what the check for
20112 DECL_INITIAL is for. */
20113 || (TREE_CODE (decl
) == FUNCTION_DECL
20114 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
20115 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
20117 /* The present template, TD, should not be a definition. If it
20118 were a definition, we should be using it! Note that we
20119 cannot restructure the loop to just keep going until we find
20120 a template with a definition, since that might go too far if
20121 a specialization was declared, but not defined. */
20123 /* Fetch the more general template. */
20124 tmpl
= DECL_TI_TEMPLATE (tmpl
);
20130 /* Returns true if we need to instantiate this template instance even if we
20131 know we aren't going to emit it.. */
20134 always_instantiate_p (tree decl
)
20136 /* We always instantiate inline functions so that we can inline them. An
20137 explicit instantiation declaration prohibits implicit instantiation of
20138 non-inline functions. With high levels of optimization, we would
20139 normally inline non-inline functions -- but we're not allowed to do
20140 that for "extern template" functions. Therefore, we check
20141 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
20142 return ((TREE_CODE (decl
) == FUNCTION_DECL
20143 && (DECL_DECLARED_INLINE_P (decl
)
20144 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
20145 /* And we need to instantiate static data members so that
20146 their initializers are available in integral constant
20149 && decl_maybe_constant_var_p (decl
)));
20152 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
20153 instantiate it now, modifying TREE_TYPE (fn). */
20156 maybe_instantiate_noexcept (tree fn
)
20158 tree fntype
, spec
, noex
, clone
;
20160 /* Don't instantiate a noexcept-specification from template context. */
20161 if (processing_template_decl
)
20164 if (DECL_CLONED_FUNCTION_P (fn
))
20165 fn
= DECL_CLONED_FUNCTION (fn
);
20166 fntype
= TREE_TYPE (fn
);
20167 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
20169 if (!spec
|| !TREE_PURPOSE (spec
))
20172 noex
= TREE_PURPOSE (spec
);
20174 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
20176 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
20177 spec
= get_defaulted_eh_spec (fn
);
20178 else if (push_tinst_level (fn
))
20180 push_access_scope (fn
);
20181 push_deferring_access_checks (dk_no_deferred
);
20182 input_location
= DECL_SOURCE_LOCATION (fn
);
20183 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
20184 DEFERRED_NOEXCEPT_ARGS (noex
),
20185 tf_warning_or_error
, fn
,
20186 /*function_p=*/false,
20187 /*integral_constant_expression_p=*/true);
20188 pop_deferring_access_checks ();
20189 pop_access_scope (fn
);
20190 pop_tinst_level ();
20191 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
20192 if (spec
== error_mark_node
)
20193 spec
= noexcept_false_spec
;
20196 spec
= noexcept_false_spec
;
20198 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
20201 FOR_EACH_CLONE (clone
, fn
)
20203 if (TREE_TYPE (clone
) == fntype
)
20204 TREE_TYPE (clone
) = TREE_TYPE (fn
);
20206 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
20210 /* Produce the definition of D, a _DECL generated from a template. If
20211 DEFER_OK is nonzero, then we don't have to actually do the
20212 instantiation now; we just have to do it sometime. Normally it is
20213 an error if this is an explicit instantiation but D is undefined.
20214 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
20215 explicitly instantiated class template. */
20218 instantiate_decl (tree d
, int defer_ok
,
20219 bool expl_inst_class_mem_p
)
20221 tree tmpl
= DECL_TI_TEMPLATE (d
);
20228 bool pattern_defined
;
20229 location_t saved_loc
= input_location
;
20230 int saved_unevaluated_operand
= cp_unevaluated_operand
;
20231 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
20237 /* This function should only be used to instantiate templates for
20238 functions and static member variables. */
20239 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
20241 /* Variables are never deferred; if instantiation is required, they
20242 are instantiated right away. That allows for better code in the
20243 case that an expression refers to the value of the variable --
20244 if the variable has a constant value the referring expression can
20245 take advantage of that fact. */
20247 || DECL_DECLARED_CONSTEXPR_P (d
))
20250 /* Don't instantiate cloned functions. Instead, instantiate the
20251 functions they cloned. */
20252 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
20253 d
= DECL_CLONED_FUNCTION (d
);
20255 if (DECL_TEMPLATE_INSTANTIATED (d
)
20256 || (TREE_CODE (d
) == FUNCTION_DECL
20257 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
20258 || DECL_TEMPLATE_SPECIALIZATION (d
))
20259 /* D has already been instantiated or explicitly specialized, so
20260 there's nothing for us to do here.
20262 It might seem reasonable to check whether or not D is an explicit
20263 instantiation, and, if so, stop here. But when an explicit
20264 instantiation is deferred until the end of the compilation,
20265 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
20266 the instantiation. */
20269 /* Check to see whether we know that this template will be
20270 instantiated in some other file, as with "extern template"
20272 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
20274 /* In general, we do not instantiate such templates. */
20275 if (external_p
&& !always_instantiate_p (d
))
20278 gen_tmpl
= most_general_template (tmpl
);
20279 gen_args
= DECL_TI_ARGS (d
);
20281 if (tmpl
!= gen_tmpl
)
20282 /* We should already have the extra args. */
20283 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
20284 == TMPL_ARGS_DEPTH (gen_args
));
20285 /* And what's in the hash table should match D. */
20286 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
20287 || spec
== NULL_TREE
);
20289 /* This needs to happen before any tsubsting. */
20290 if (! push_tinst_level (d
))
20293 timevar_push (TV_TEMPLATE_INST
);
20295 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
20296 for the instantiation. */
20297 td
= template_for_substitution (d
);
20298 code_pattern
= DECL_TEMPLATE_RESULT (td
);
20300 /* We should never be trying to instantiate a member of a class
20301 template or partial specialization. */
20302 gcc_assert (d
!= code_pattern
);
20304 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
20305 || DECL_TEMPLATE_SPECIALIZATION (td
))
20306 /* In the case of a friend template whose definition is provided
20307 outside the class, we may have too many arguments. Drop the
20308 ones we don't need. The same is true for specializations. */
20309 args
= get_innermost_template_args
20310 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
20314 if (TREE_CODE (d
) == FUNCTION_DECL
)
20316 deleted_p
= DECL_DELETED_FN (code_pattern
);
20317 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
20318 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
20324 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
20327 /* We may be in the middle of deferred access check. Disable it now. */
20328 push_deferring_access_checks (dk_no_deferred
);
20330 /* Unless an explicit instantiation directive has already determined
20331 the linkage of D, remember that a definition is available for
20333 if (pattern_defined
20334 && !DECL_INTERFACE_KNOWN (d
)
20335 && !DECL_NOT_REALLY_EXTERN (d
))
20336 mark_definable (d
);
20338 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
20339 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
20340 input_location
= DECL_SOURCE_LOCATION (d
);
20342 /* If D is a member of an explicitly instantiated class template,
20343 and no definition is available, treat it like an implicit
20345 if (!pattern_defined
&& expl_inst_class_mem_p
20346 && DECL_EXPLICIT_INSTANTIATION (d
))
20348 /* Leave linkage flags alone on instantiations with anonymous
20350 if (TREE_PUBLIC (d
))
20352 DECL_NOT_REALLY_EXTERN (d
) = 0;
20353 DECL_INTERFACE_KNOWN (d
) = 0;
20355 SET_DECL_IMPLICIT_INSTANTIATION (d
);
20358 /* Defer all other templates, unless we have been explicitly
20359 forbidden from doing so. */
20360 if (/* If there is no definition, we cannot instantiate the
20363 /* If it's OK to postpone instantiation, do so. */
20365 /* If this is a static data member that will be defined
20366 elsewhere, we don't want to instantiate the entire data
20367 member, but we do want to instantiate the initializer so that
20368 we can substitute that elsewhere. */
20369 || (external_p
&& VAR_P (d
))
20370 /* Handle here a deleted function too, avoid generating
20371 its body (c++/61080). */
20374 /* The definition of the static data member is now required so
20375 we must substitute the initializer. */
20377 && !DECL_INITIAL (d
)
20378 && DECL_INITIAL (code_pattern
))
20382 bool const_init
= false;
20383 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20385 ns
= decl_namespace_context (d
);
20386 push_nested_namespace (ns
);
20388 push_nested_class (DECL_CONTEXT (d
));
20389 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
20391 tf_warning_or_error
, NULL_TREE
,
20392 /*integral_constant_expression_p=*/false);
20393 /* If instantiating the initializer involved instantiating this
20394 again, don't call cp_finish_decl twice. */
20395 if (!DECL_INITIAL (d
))
20397 /* Make sure the initializer is still constant, in case of
20398 circular dependency (template/instantiate6.C). */
20400 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20401 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
20402 /*asmspec_tree=*/NULL_TREE
,
20403 LOOKUP_ONLYCONVERTING
);
20406 pop_nested_class ();
20407 pop_nested_namespace (ns
);
20410 /* We restore the source position here because it's used by
20411 add_pending_template. */
20412 input_location
= saved_loc
;
20414 if (at_eof
&& !pattern_defined
20415 && DECL_EXPLICIT_INSTANTIATION (d
)
20416 && DECL_NOT_REALLY_EXTERN (d
))
20419 The definition of a non-exported function template, a
20420 non-exported member function template, or a non-exported
20421 member function or static data member of a class template
20422 shall be present in every translation unit in which it is
20423 explicitly instantiated. */
20424 permerror (input_location
, "explicit instantiation of %qD "
20425 "but no definition available", d
);
20427 /* If we're in unevaluated context, we just wanted to get the
20428 constant value; this isn't an odr use, so don't queue
20429 a full instantiation. */
20430 if (cp_unevaluated_operand
!= 0)
20432 /* ??? Historically, we have instantiated inline functions, even
20433 when marked as "extern template". */
20434 if (!(external_p
&& VAR_P (d
)))
20435 add_pending_template (d
);
20438 /* Tell the repository that D is available in this translation unit
20439 -- and see if it is supposed to be instantiated here. */
20440 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
20442 /* In a PCH file, despite the fact that the repository hasn't
20443 requested instantiation in the PCH it is still possible that
20444 an instantiation will be required in a file that includes the
20447 add_pending_template (d
);
20448 /* Instantiate inline functions so that the inliner can do its
20449 job, even though we'll not be emitting a copy of this
20451 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
20455 fn_context
= decl_function_context (d
);
20456 nested
= (current_function_decl
!= NULL_TREE
);
20458 push_to_top_level ();
20462 push_function_context ();
20463 cp_unevaluated_operand
= 0;
20464 c_inhibit_evaluation_warnings
= 0;
20467 /* Mark D as instantiated so that recursive calls to
20468 instantiate_decl do not try to instantiate it again. */
20469 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
20471 /* Regenerate the declaration in case the template has been modified
20472 by a subsequent redeclaration. */
20473 regenerate_decl_from_template (d
, td
);
20475 /* We already set the file and line above. Reset them now in case
20476 they changed as a result of calling regenerate_decl_from_template. */
20477 input_location
= DECL_SOURCE_LOCATION (d
);
20482 bool const_init
= false;
20484 /* Clear out DECL_RTL; whatever was there before may not be right
20485 since we've reset the type of the declaration. */
20486 SET_DECL_RTL (d
, NULL
);
20487 DECL_IN_AGGR_P (d
) = 0;
20489 /* The initializer is placed in DECL_INITIAL by
20490 regenerate_decl_from_template so we don't need to
20491 push/pop_access_scope again here. Pull it out so that
20492 cp_finish_decl can process it. */
20493 init
= DECL_INITIAL (d
);
20494 DECL_INITIAL (d
) = NULL_TREE
;
20495 DECL_INITIALIZED_P (d
) = 0;
20497 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20498 initializer. That function will defer actual emission until
20499 we have a chance to determine linkage. */
20500 DECL_EXTERNAL (d
) = 0;
20502 /* Enter the scope of D so that access-checking works correctly. */
20503 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20505 push_nested_class (DECL_CONTEXT (d
));
20507 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20508 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
20511 pop_nested_class ();
20513 if (variable_template_p (td
))
20514 note_variable_template_instantiation (d
);
20516 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
20517 synthesize_method (d
);
20518 else if (TREE_CODE (d
) == FUNCTION_DECL
)
20520 hash_map
<tree
, tree
> *saved_local_specializations
;
20524 tree block
= NULL_TREE
;
20526 /* Save away the current list, in case we are instantiating one
20527 template from within the body of another. */
20528 saved_local_specializations
= local_specializations
;
20530 /* Set up the list of local specializations. */
20531 local_specializations
= new hash_map
<tree
, tree
>;
20533 /* Set up context. */
20534 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20535 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20536 block
= push_stmt_list ();
20538 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
20540 /* Some typedefs referenced from within the template code need to be
20541 access checked at template instantiation time, i.e now. These
20542 types were added to the template at parsing time. Let's get those
20543 and perform the access checks then. */
20544 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20547 /* Create substitution entries for the parameters. */
20548 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20549 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20550 spec_parm
= DECL_ARGUMENTS (d
);
20551 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20553 register_local_specialization (spec_parm
, tmpl_parm
);
20554 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20555 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20557 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20559 if (!DECL_PACK_P (tmpl_parm
))
20561 register_local_specialization (spec_parm
, tmpl_parm
);
20562 spec_parm
= DECL_CHAIN (spec_parm
);
20566 /* Register the (value) argument pack as a specialization of
20567 TMPL_PARM, then move on. */
20568 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20569 register_local_specialization (argpack
, tmpl_parm
);
20572 gcc_assert (!spec_parm
);
20574 /* Substitute into the body of the function. */
20575 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20576 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20577 tf_warning_or_error
, tmpl
);
20580 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20581 tf_warning_or_error
, tmpl
,
20582 /*integral_constant_expression_p=*/false);
20584 /* Set the current input_location to the end of the function
20585 so that finish_function knows where we are. */
20587 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20589 /* Remember if we saw an infinite loop in the template. */
20590 current_function_infinite_loop
20591 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20594 /* We don't need the local specializations any more. */
20595 delete local_specializations
;
20596 local_specializations
= saved_local_specializations
;
20598 /* Finish the function. */
20599 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20600 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20601 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20604 d
= finish_function (0);
20605 expand_or_defer_fn (d
);
20608 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20609 cp_check_omp_declare_reduction (d
);
20612 /* We're not deferring instantiation any more. */
20613 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20616 pop_from_top_level ();
20618 pop_function_context ();
20621 input_location
= saved_loc
;
20622 cp_unevaluated_operand
= saved_unevaluated_operand
;
20623 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20624 pop_deferring_access_checks ();
20625 pop_tinst_level ();
20627 timevar_pop (TV_TEMPLATE_INST
);
20632 /* Run through the list of templates that we wish we could
20633 instantiate, and instantiate any we can. RETRIES is the
20634 number of times we retry pending template instantiation. */
20637 instantiate_pending_templates (int retries
)
20640 location_t saved_loc
= input_location
;
20642 /* Instantiating templates may trigger vtable generation. This in turn
20643 may require further template instantiations. We place a limit here
20644 to avoid infinite loop. */
20645 if (pending_templates
&& retries
>= max_tinst_depth
)
20647 tree decl
= pending_templates
->tinst
->decl
;
20649 fatal_error (input_location
,
20650 "template instantiation depth exceeds maximum of %d"
20651 " instantiating %q+D, possibly from virtual table generation"
20652 " (use -ftemplate-depth= to increase the maximum)",
20653 max_tinst_depth
, decl
);
20654 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20655 /* Pretend that we defined it. */
20656 DECL_INITIAL (decl
) = error_mark_node
;
20662 struct pending_template
**t
= &pending_templates
;
20663 struct pending_template
*last
= NULL
;
20667 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20668 bool complete
= false;
20670 if (TYPE_P (instantiation
))
20674 if (!COMPLETE_TYPE_P (instantiation
))
20676 instantiate_class_template (instantiation
);
20677 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20678 for (fn
= TYPE_METHODS (instantiation
);
20680 fn
= TREE_CHAIN (fn
))
20681 if (! DECL_ARTIFICIAL (fn
))
20682 instantiate_decl (fn
,
20684 /*expl_inst_class_mem_p=*/false);
20685 if (COMPLETE_TYPE_P (instantiation
))
20689 complete
= COMPLETE_TYPE_P (instantiation
);
20693 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20694 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20697 = instantiate_decl (instantiation
,
20699 /*expl_inst_class_mem_p=*/false);
20700 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20704 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20705 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20709 /* If INSTANTIATION has been instantiated, then we don't
20710 need to consider it again in the future. */
20718 current_tinst_level
= NULL
;
20720 last_pending_template
= last
;
20722 while (reconsider
);
20724 input_location
= saved_loc
;
20727 /* Substitute ARGVEC into T, which is a list of initializers for
20728 either base class or a non-static data member. The TREE_PURPOSEs
20729 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20730 instantiate_decl. */
20733 tsubst_initializer_list (tree t
, tree argvec
)
20735 tree inits
= NULL_TREE
;
20737 for (; t
; t
= TREE_CHAIN (t
))
20741 tree expanded_bases
= NULL_TREE
;
20742 tree expanded_arguments
= NULL_TREE
;
20745 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20750 /* Expand the base class expansion type into separate base
20752 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20753 tf_warning_or_error
,
20755 if (expanded_bases
== error_mark_node
)
20758 /* We'll be building separate TREE_LISTs of arguments for
20760 len
= TREE_VEC_LENGTH (expanded_bases
);
20761 expanded_arguments
= make_tree_vec (len
);
20762 for (i
= 0; i
< len
; i
++)
20763 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20765 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20766 expand each argument in the TREE_VALUE of t. */
20767 expr
= make_node (EXPR_PACK_EXPANSION
);
20768 PACK_EXPANSION_LOCAL_P (expr
) = true;
20769 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20770 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20772 if (TREE_VALUE (t
) == void_type_node
)
20773 /* VOID_TYPE_NODE is used to indicate
20774 value-initialization. */
20776 for (i
= 0; i
< len
; i
++)
20777 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20781 /* Substitute parameter packs into each argument in the
20783 in_base_initializer
= 1;
20784 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20786 tree expanded_exprs
;
20788 /* Expand the argument. */
20789 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20791 = tsubst_pack_expansion (expr
, argvec
,
20792 tf_warning_or_error
,
20794 if (expanded_exprs
== error_mark_node
)
20797 /* Prepend each of the expanded expressions to the
20798 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20799 for (i
= 0; i
< len
; i
++)
20801 TREE_VEC_ELT (expanded_arguments
, i
) =
20802 tree_cons (NULL_TREE
,
20803 TREE_VEC_ELT (expanded_exprs
, i
),
20804 TREE_VEC_ELT (expanded_arguments
, i
));
20807 in_base_initializer
= 0;
20809 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20810 since we built them backwards. */
20811 for (i
= 0; i
< len
; i
++)
20813 TREE_VEC_ELT (expanded_arguments
, i
) =
20814 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20819 for (i
= 0; i
< len
; ++i
)
20821 if (expanded_bases
)
20823 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20824 decl
= expand_member_init (decl
);
20825 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20830 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20831 tf_warning_or_error
, NULL_TREE
);
20833 decl
= expand_member_init (decl
);
20834 if (decl
&& !DECL_P (decl
))
20835 in_base_initializer
= 1;
20837 init
= TREE_VALUE (t
);
20839 if (init
!= void_type_node
)
20840 init
= tsubst_expr (init
, argvec
,
20841 tf_warning_or_error
, NULL_TREE
,
20842 /*integral_constant_expression_p=*/false);
20843 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20844 /* If we had an initializer but it instantiated to nothing,
20845 value-initialize the object. This will only occur when
20846 the initializer was a pack expansion where the parameter
20847 packs used in that expansion were of length zero. */
20848 init
= void_type_node
;
20849 in_base_initializer
= 0;
20854 init
= build_tree_list (decl
, init
);
20855 TREE_CHAIN (init
) = inits
;
20863 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20866 set_current_access_from_decl (tree decl
)
20868 if (TREE_PRIVATE (decl
))
20869 current_access_specifier
= access_private_node
;
20870 else if (TREE_PROTECTED (decl
))
20871 current_access_specifier
= access_protected_node
;
20873 current_access_specifier
= access_public_node
;
20876 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20877 is the instantiation (which should have been created with
20878 start_enum) and ARGS are the template arguments to use. */
20881 tsubst_enum (tree tag
, tree newtag
, tree args
)
20885 if (SCOPED_ENUM_P (newtag
))
20886 begin_scope (sk_scoped_enum
, newtag
);
20888 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20893 decl
= TREE_VALUE (e
);
20894 /* Note that in a template enum, the TREE_VALUE is the
20895 CONST_DECL, not the corresponding INTEGER_CST. */
20896 value
= tsubst_expr (DECL_INITIAL (decl
),
20897 args
, tf_warning_or_error
, NULL_TREE
,
20898 /*integral_constant_expression_p=*/true);
20900 /* Give this enumeration constant the correct access. */
20901 set_current_access_from_decl (decl
);
20903 /* Actually build the enumerator itself. Here we're assuming that
20904 enumerators can't have dependent attributes. */
20905 build_enumerator (DECL_NAME (decl
), value
, newtag
,
20906 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
20909 if (SCOPED_ENUM_P (newtag
))
20912 finish_enum_value_list (newtag
);
20913 finish_enum (newtag
);
20915 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20916 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20919 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20920 its type -- but without substituting the innermost set of template
20921 arguments. So, innermost set of template parameters will appear in
20925 get_mostly_instantiated_function_type (tree decl
)
20927 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
20928 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
20931 /* Return truthvalue if we're processing a template different from
20932 the last one involved in diagnostics. */
20934 problematic_instantiation_changed (void)
20936 return current_tinst_level
!= last_error_tinst_level
;
20939 /* Remember current template involved in diagnostics. */
20941 record_last_problematic_instantiation (void)
20943 last_error_tinst_level
= current_tinst_level
;
20946 struct tinst_level
*
20947 current_instantiation (void)
20949 return current_tinst_level
;
20952 /* Return TRUE if current_function_decl is being instantiated, false
20956 instantiating_current_function_p (void)
20958 return (current_instantiation ()
20959 && current_instantiation ()->decl
== current_function_decl
);
20962 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20963 type. Return zero for ok, nonzero for disallowed. Issue error and
20964 warning messages under control of COMPLAIN. */
20967 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20969 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20971 else if (POINTER_TYPE_P (type
))
20973 else if (TYPE_PTRMEM_P (type
))
20975 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20977 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20979 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20981 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20984 if (complain
& tf_error
)
20986 if (type
== error_mark_node
)
20987 inform (input_location
, "invalid template non-type parameter");
20989 error ("%q#T is not a valid type for a template non-type parameter",
20995 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20996 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20999 dependent_type_p_r (tree type
)
21005 A type is dependent if it is:
21007 -- a template parameter. Template template parameters are types
21008 for us (since TYPE_P holds true for them) so we handle
21010 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
21011 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
21013 /* -- a qualified-id with a nested-name-specifier which contains a
21014 class-name that names a dependent type or whose unqualified-id
21015 names a dependent type. */
21016 if (TREE_CODE (type
) == TYPENAME_TYPE
)
21019 /* An alias template specialization can be dependent even if the
21020 resulting type is not. */
21021 if (dependent_alias_template_spec_p (type
))
21024 /* -- a cv-qualified type where the cv-unqualified type is
21026 No code is necessary for this bullet; the code below handles
21027 cv-qualified types, and we don't want to strip aliases with
21028 TYPE_MAIN_VARIANT because of DR 1558. */
21029 /* -- a compound type constructed from any dependent type. */
21030 if (TYPE_PTRMEM_P (type
))
21031 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
21032 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
21034 else if (TYPE_PTR_P (type
)
21035 || TREE_CODE (type
) == REFERENCE_TYPE
)
21036 return dependent_type_p (TREE_TYPE (type
));
21037 else if (TREE_CODE (type
) == FUNCTION_TYPE
21038 || TREE_CODE (type
) == METHOD_TYPE
)
21042 if (dependent_type_p (TREE_TYPE (type
)))
21044 for (arg_type
= TYPE_ARG_TYPES (type
);
21046 arg_type
= TREE_CHAIN (arg_type
))
21047 if (dependent_type_p (TREE_VALUE (arg_type
)))
21051 /* -- an array type constructed from any dependent type or whose
21052 size is specified by a constant expression that is
21055 We checked for type- and value-dependence of the bounds in
21056 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
21057 if (TREE_CODE (type
) == ARRAY_TYPE
)
21059 if (TYPE_DOMAIN (type
)
21060 && dependent_type_p (TYPE_DOMAIN (type
)))
21062 return dependent_type_p (TREE_TYPE (type
));
21065 /* -- a template-id in which either the template name is a template
21067 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21069 /* ... or any of the template arguments is a dependent type or
21070 an expression that is type-dependent or value-dependent. */
21071 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
21072 && (any_dependent_template_arguments_p
21073 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
21076 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
21077 dependent; if the argument of the `typeof' expression is not
21078 type-dependent, then it should already been have resolved. */
21079 if (TREE_CODE (type
) == TYPEOF_TYPE
21080 || TREE_CODE (type
) == DECLTYPE_TYPE
21081 || TREE_CODE (type
) == UNDERLYING_TYPE
)
21084 /* A template argument pack is dependent if any of its packed
21086 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
21088 tree args
= ARGUMENT_PACK_ARGS (type
);
21089 int i
, len
= TREE_VEC_LENGTH (args
);
21090 for (i
= 0; i
< len
; ++i
)
21091 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21095 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
21096 be template parameters. */
21097 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
21100 /* The standard does not specifically mention types that are local
21101 to template functions or local classes, but they should be
21102 considered dependent too. For example:
21104 template <int I> void f() {
21109 The size of `E' cannot be known until the value of `I' has been
21110 determined. Therefore, `E' must be considered dependent. */
21111 scope
= TYPE_CONTEXT (type
);
21112 if (scope
&& TYPE_P (scope
))
21113 return dependent_type_p (scope
);
21114 /* Don't use type_dependent_expression_p here, as it can lead
21115 to infinite recursion trying to determine whether a lambda
21116 nested in a lambda is dependent (c++/47687). */
21117 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
21118 && DECL_LANG_SPECIFIC (scope
)
21119 && DECL_TEMPLATE_INFO (scope
)
21120 && (any_dependent_template_arguments_p
21121 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
21124 /* Other types are non-dependent. */
21128 /* Returns TRUE if TYPE is dependent, in the sense of
21129 [temp.dep.type]. Note that a NULL type is considered dependent. */
21132 dependent_type_p (tree type
)
21134 /* If there are no template parameters in scope, then there can't be
21135 any dependent types. */
21136 if (!processing_template_decl
)
21138 /* If we are not processing a template, then nobody should be
21139 providing us with a dependent type. */
21141 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
21145 /* If the type is NULL, we have not computed a type for the entity
21146 in question; in that case, the type is dependent. */
21150 /* Erroneous types can be considered non-dependent. */
21151 if (type
== error_mark_node
)
21154 /* If we have not already computed the appropriate value for TYPE,
21156 if (!TYPE_DEPENDENT_P_VALID (type
))
21158 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
21159 TYPE_DEPENDENT_P_VALID (type
) = 1;
21162 return TYPE_DEPENDENT_P (type
);
21165 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
21166 lookup. In other words, a dependent type that is not the current
21170 dependent_scope_p (tree scope
)
21172 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
21173 && !currently_open_class (scope
));
21176 /* T is a SCOPE_REF; return whether we need to consider it
21177 instantiation-dependent so that we can check access at instantiation
21178 time even though we know which member it resolves to. */
21181 instantiation_dependent_scope_ref_p (tree t
)
21183 if (DECL_P (TREE_OPERAND (t
, 1))
21184 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
21185 && accessible_in_template_p (TREE_OPERAND (t
, 0),
21186 TREE_OPERAND (t
, 1)))
21192 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
21193 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
21196 /* Note that this predicate is not appropriate for general expressions;
21197 only constant expressions (that satisfy potential_constant_expression)
21198 can be tested for value dependence. */
21201 value_dependent_expression_p (tree expression
)
21203 if (!processing_template_decl
)
21206 /* A name declared with a dependent type. */
21207 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
21210 switch (TREE_CODE (expression
))
21212 case IDENTIFIER_NODE
:
21213 /* A name that has not been looked up -- must be dependent. */
21216 case TEMPLATE_PARM_INDEX
:
21217 /* A non-type template parm. */
21221 /* A non-type template parm. */
21222 if (DECL_TEMPLATE_PARM_P (expression
))
21224 return value_dependent_expression_p (DECL_INITIAL (expression
));
21227 /* A constant with literal type and is initialized
21228 with an expression that is value-dependent.
21230 Note that a non-dependent parenthesized initializer will have
21231 already been replaced with its constant value, so if we see
21232 a TREE_LIST it must be dependent. */
21233 if (DECL_INITIAL (expression
)
21234 && decl_constant_var_p (expression
)
21235 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
21236 /* cp_finish_decl doesn't fold reference initializers. */
21237 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
21238 || value_dependent_expression_p (DECL_INITIAL (expression
))))
21242 case DYNAMIC_CAST_EXPR
:
21243 case STATIC_CAST_EXPR
:
21244 case CONST_CAST_EXPR
:
21245 case REINTERPRET_CAST_EXPR
:
21247 /* These expressions are value-dependent if the type to which
21248 the cast occurs is dependent or the expression being casted
21249 is value-dependent. */
21251 tree type
= TREE_TYPE (expression
);
21253 if (dependent_type_p (type
))
21256 /* A functional cast has a list of operands. */
21257 expression
= TREE_OPERAND (expression
, 0);
21260 /* If there are no operands, it must be an expression such
21261 as "int()". This should not happen for aggregate types
21262 because it would form non-constant expressions. */
21263 gcc_assert (cxx_dialect
>= cxx11
21264 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
21269 if (TREE_CODE (expression
) == TREE_LIST
)
21270 return any_value_dependent_elements_p (expression
);
21272 return value_dependent_expression_p (expression
);
21276 if (SIZEOF_EXPR_TYPE_P (expression
))
21277 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
21281 /* A `sizeof' expression is value-dependent if the operand is
21282 type-dependent or is a pack expansion. */
21283 expression
= TREE_OPERAND (expression
, 0);
21284 if (PACK_EXPANSION_P (expression
))
21286 else if (TYPE_P (expression
))
21287 return dependent_type_p (expression
);
21288 return instantiation_dependent_expression_p (expression
);
21290 case AT_ENCODE_EXPR
:
21291 /* An 'encode' expression is value-dependent if the operand is
21293 expression
= TREE_OPERAND (expression
, 0);
21294 return dependent_type_p (expression
);
21296 case NOEXCEPT_EXPR
:
21297 expression
= TREE_OPERAND (expression
, 0);
21298 return instantiation_dependent_expression_p (expression
);
21301 /* All instantiation-dependent expressions should also be considered
21302 value-dependent. */
21303 return instantiation_dependent_scope_ref_p (expression
);
21305 case COMPONENT_REF
:
21306 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
21307 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
21309 case NONTYPE_ARGUMENT_PACK
:
21310 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
21311 is value-dependent. */
21313 tree values
= ARGUMENT_PACK_ARGS (expression
);
21314 int i
, len
= TREE_VEC_LENGTH (values
);
21316 for (i
= 0; i
< len
; ++i
)
21317 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
21325 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
21326 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
21327 || (type2
? dependent_type_p (type2
) : false));
21331 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21332 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
21335 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21336 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
21340 tree op
= TREE_OPERAND (expression
, 0);
21341 return (value_dependent_expression_p (op
)
21342 || has_value_dependent_address (op
));
21347 tree fn
= get_callee_fndecl (expression
);
21349 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
21351 nargs
= call_expr_nargs (expression
);
21352 for (i
= 0; i
< nargs
; ++i
)
21354 tree op
= CALL_EXPR_ARG (expression
, i
);
21355 /* In a call to a constexpr member function, look through the
21356 implicit ADDR_EXPR on the object argument so that it doesn't
21357 cause the call to be considered value-dependent. We also
21358 look through it in potential_constant_expression. */
21359 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
21360 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
21361 && TREE_CODE (op
) == ADDR_EXPR
)
21362 op
= TREE_OPERAND (op
, 0);
21363 if (value_dependent_expression_p (op
))
21369 case TEMPLATE_ID_EXPR
:
21370 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21372 return type_dependent_expression_p (expression
);
21378 if (dependent_type_p (TREE_TYPE (expression
)))
21380 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
21381 if (value_dependent_expression_p (val
))
21387 /* Treat a GNU statement expression as dependent to avoid crashing
21388 under instantiate_non_dependent_expr; it can't be constant. */
21392 /* A constant expression is value-dependent if any subexpression is
21393 value-dependent. */
21394 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
21396 case tcc_reference
:
21398 case tcc_comparison
:
21400 case tcc_expression
:
21403 int i
, len
= cp_tree_operand_length (expression
);
21405 for (i
= 0; i
< len
; i
++)
21407 tree t
= TREE_OPERAND (expression
, i
);
21409 /* In some cases, some of the operands may be missing.l
21410 (For example, in the case of PREDECREMENT_EXPR, the
21411 amount to increment by may be missing.) That doesn't
21412 make the expression dependent. */
21413 if (t
&& value_dependent_expression_p (t
))
21424 /* The expression is not value-dependent. */
21428 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21429 [temp.dep.expr]. Note that an expression with no type is
21430 considered dependent. Other parts of the compiler arrange for an
21431 expression with type-dependent subexpressions to have no type, so
21432 this function doesn't have to be fully recursive. */
21435 type_dependent_expression_p (tree expression
)
21437 if (!processing_template_decl
)
21440 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
21443 /* An unresolved name is always dependent. */
21444 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
21447 /* Some expression forms are never type-dependent. */
21448 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
21449 || TREE_CODE (expression
) == SIZEOF_EXPR
21450 || TREE_CODE (expression
) == ALIGNOF_EXPR
21451 || TREE_CODE (expression
) == AT_ENCODE_EXPR
21452 || TREE_CODE (expression
) == NOEXCEPT_EXPR
21453 || TREE_CODE (expression
) == TRAIT_EXPR
21454 || TREE_CODE (expression
) == TYPEID_EXPR
21455 || TREE_CODE (expression
) == DELETE_EXPR
21456 || TREE_CODE (expression
) == VEC_DELETE_EXPR
21457 || TREE_CODE (expression
) == THROW_EXPR
)
21460 /* The types of these expressions depends only on the type to which
21461 the cast occurs. */
21462 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
21463 || TREE_CODE (expression
) == STATIC_CAST_EXPR
21464 || TREE_CODE (expression
) == CONST_CAST_EXPR
21465 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
21466 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
21467 || TREE_CODE (expression
) == CAST_EXPR
)
21468 return dependent_type_p (TREE_TYPE (expression
));
21470 /* The types of these expressions depends only on the type created
21471 by the expression. */
21472 if (TREE_CODE (expression
) == NEW_EXPR
21473 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
21475 /* For NEW_EXPR tree nodes created inside a template, either
21476 the object type itself or a TREE_LIST may appear as the
21478 tree type
= TREE_OPERAND (expression
, 1);
21479 if (TREE_CODE (type
) == TREE_LIST
)
21480 /* This is an array type. We need to check array dimensions
21482 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
21483 || value_dependent_expression_p
21484 (TREE_OPERAND (TREE_VALUE (type
), 1));
21486 return dependent_type_p (type
);
21489 if (TREE_CODE (expression
) == SCOPE_REF
)
21491 tree scope
= TREE_OPERAND (expression
, 0);
21492 tree name
= TREE_OPERAND (expression
, 1);
21494 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21495 contains an identifier associated by name lookup with one or more
21496 declarations declared with a dependent type, or...a
21497 nested-name-specifier or qualified-id that names a member of an
21498 unknown specialization. */
21499 return (type_dependent_expression_p (name
)
21500 || dependent_scope_p (scope
));
21503 if (TREE_CODE (expression
) == FUNCTION_DECL
21504 && DECL_LANG_SPECIFIC (expression
)
21505 && DECL_TEMPLATE_INFO (expression
)
21506 && (any_dependent_template_arguments_p
21507 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
21510 if (TREE_CODE (expression
) == TEMPLATE_DECL
21511 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
21514 if (TREE_CODE (expression
) == STMT_EXPR
)
21515 expression
= stmt_expr_value_expr (expression
);
21517 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21522 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21524 if (type_dependent_expression_p (elt
))
21530 /* A static data member of the current instantiation with incomplete
21531 array type is type-dependent, as the definition and specializations
21532 can have different bounds. */
21533 if (VAR_P (expression
)
21534 && DECL_CLASS_SCOPE_P (expression
)
21535 && dependent_type_p (DECL_CONTEXT (expression
))
21536 && VAR_HAD_UNKNOWN_BOUND (expression
))
21539 /* An array of unknown bound depending on a variadic parameter, eg:
21541 template<typename... Args>
21542 void foo (Args... args)
21544 int arr[] = { args... };
21547 template<int... vals>
21550 int arr[] = { vals... };
21553 If the array has no length and has an initializer, it must be that
21554 we couldn't determine its length in cp_complete_array_type because
21555 it is dependent. */
21556 if (VAR_P (expression
)
21557 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21558 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21559 && DECL_INITIAL (expression
))
21562 /* A variable template specialization is type-dependent if it has any
21563 dependent template arguments. */
21564 if (VAR_P (expression
)
21565 && DECL_LANG_SPECIFIC (expression
)
21566 && DECL_TEMPLATE_INFO (expression
)
21567 && variable_template_p (DECL_TI_TEMPLATE (expression
)))
21568 return any_dependent_template_arguments_p (DECL_TI_ARGS (expression
));
21570 /* Always dependent, on the number of arguments if nothing else. */
21571 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21574 if (TREE_TYPE (expression
) == unknown_type_node
)
21576 if (TREE_CODE (expression
) == ADDR_EXPR
)
21577 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21578 if (TREE_CODE (expression
) == COMPONENT_REF
21579 || TREE_CODE (expression
) == OFFSET_REF
)
21581 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21583 expression
= TREE_OPERAND (expression
, 1);
21584 if (identifier_p (expression
))
21587 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21588 if (TREE_CODE (expression
) == SCOPE_REF
)
21591 if (BASELINK_P (expression
))
21593 if (BASELINK_OPTYPE (expression
)
21594 && dependent_type_p (BASELINK_OPTYPE (expression
)))
21596 expression
= BASELINK_FUNCTIONS (expression
);
21599 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21601 if (any_dependent_template_arguments_p
21602 (TREE_OPERAND (expression
, 1)))
21604 expression
= TREE_OPERAND (expression
, 0);
21606 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21607 || TREE_CODE (expression
) == FUNCTION_DECL
);
21611 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21613 expression
= OVL_NEXT (expression
);
21618 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21620 return (dependent_type_p (TREE_TYPE (expression
)));
21623 /* walk_tree callback function for instantiation_dependent_expression_p,
21624 below. Returns non-zero if a dependent subexpression is found. */
21627 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21632 /* We don't have to worry about decltype currently because decltype
21633 of an instantiation-dependent expr is a dependent type. This
21634 might change depending on the resolution of DR 1172. */
21635 *walk_subtrees
= false;
21638 enum tree_code code
= TREE_CODE (*tp
);
21641 /* Don't treat an argument list as dependent just because it has no
21649 /* A constant with a dependent initializer is dependent. */
21650 if (value_dependent_expression_p (*tp
))
21654 case TEMPLATE_PARM_INDEX
:
21657 /* Handle expressions with type operands. */
21661 case AT_ENCODE_EXPR
:
21663 tree op
= TREE_OPERAND (*tp
, 0);
21664 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21665 op
= TREE_TYPE (op
);
21668 if (dependent_type_p (op
))
21672 *walk_subtrees
= false;
21680 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21681 || (TRAIT_EXPR_TYPE2 (*tp
)
21682 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21684 *walk_subtrees
= false;
21687 case COMPONENT_REF
:
21688 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21689 /* In a template, finish_class_member_access_expr creates a
21690 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21691 type-dependent, so that we can check access control at
21692 instantiation time (PR 42277). See also Core issue 1273. */
21697 if (instantiation_dependent_scope_ref_p (*tp
))
21702 /* Treat statement-expressions as dependent. */
21710 if (type_dependent_expression_p (*tp
))
21716 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21717 sense defined by the ABI:
21719 "An expression is instantiation-dependent if it is type-dependent
21720 or value-dependent, or it has a subexpression that is type-dependent
21721 or value-dependent." */
21724 instantiation_dependent_expression_p (tree expression
)
21728 if (!processing_template_decl
)
21731 if (expression
== error_mark_node
)
21734 result
= cp_walk_tree_without_duplicates (&expression
,
21735 instantiation_dependent_r
, NULL
);
21736 return result
!= NULL_TREE
;
21739 /* Like type_dependent_expression_p, but it also works while not processing
21740 a template definition, i.e. during substitution or mangling. */
21743 type_dependent_expression_p_push (tree expr
)
21746 ++processing_template_decl
;
21747 b
= type_dependent_expression_p (expr
);
21748 --processing_template_decl
;
21752 /* Returns TRUE if ARGS contains a type-dependent expression. */
21755 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21760 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21762 if (type_dependent_expression_p (arg
))
21768 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21769 expressions) contains any type-dependent expressions. */
21772 any_type_dependent_elements_p (const_tree list
)
21774 for (; list
; list
= TREE_CHAIN (list
))
21775 if (type_dependent_expression_p (TREE_VALUE (list
)))
21781 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21782 expressions) contains any value-dependent expressions. */
21785 any_value_dependent_elements_p (const_tree list
)
21787 for (; list
; list
= TREE_CHAIN (list
))
21788 if (value_dependent_expression_p (TREE_VALUE (list
)))
21794 /* Returns TRUE if the ARG (a template argument) is dependent. */
21797 dependent_template_arg_p (tree arg
)
21799 if (!processing_template_decl
)
21802 /* Assume a template argument that was wrongly written by the user
21803 is dependent. This is consistent with what
21804 any_dependent_template_arguments_p [that calls this function]
21806 if (!arg
|| arg
== error_mark_node
)
21809 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21810 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21812 if (TREE_CODE (arg
) == TEMPLATE_DECL
21813 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21814 return dependent_template_p (arg
);
21815 else if (ARGUMENT_PACK_P (arg
))
21817 tree args
= ARGUMENT_PACK_ARGS (arg
);
21818 int i
, len
= TREE_VEC_LENGTH (args
);
21819 for (i
= 0; i
< len
; ++i
)
21821 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21827 else if (TYPE_P (arg
))
21828 return dependent_type_p (arg
);
21830 return (type_dependent_expression_p (arg
)
21831 || value_dependent_expression_p (arg
));
21834 /* Returns true if ARGS (a collection of template arguments) contains
21835 any types that require structural equality testing. */
21838 any_template_arguments_need_structural_equality_p (tree args
)
21845 if (args
== error_mark_node
)
21848 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21850 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21851 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21853 tree arg
= TREE_VEC_ELT (level
, j
);
21854 tree packed_args
= NULL_TREE
;
21857 if (ARGUMENT_PACK_P (arg
))
21859 /* Look inside the argument pack. */
21860 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21861 len
= TREE_VEC_LENGTH (packed_args
);
21864 for (k
= 0; k
< len
; ++k
)
21867 arg
= TREE_VEC_ELT (packed_args
, k
);
21869 if (error_operand_p (arg
))
21871 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21873 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21875 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21876 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21885 /* Returns true if ARGS (a collection of template arguments) contains
21886 any dependent arguments. */
21889 any_dependent_template_arguments_p (const_tree args
)
21896 if (args
== error_mark_node
)
21899 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21901 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21902 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21903 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21910 /* Returns TRUE if the template TMPL is dependent. */
21913 dependent_template_p (tree tmpl
)
21915 if (TREE_CODE (tmpl
) == OVERLOAD
)
21919 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21921 tmpl
= OVL_NEXT (tmpl
);
21926 /* Template template parameters are dependent. */
21927 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21928 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21930 /* So are names that have not been looked up. */
21931 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21933 /* So are member templates of dependent classes. */
21934 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21935 return dependent_type_p (DECL_CONTEXT (tmpl
));
21939 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21942 dependent_template_id_p (tree tmpl
, tree args
)
21944 return (dependent_template_p (tmpl
)
21945 || any_dependent_template_arguments_p (args
));
21948 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21952 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21956 if (!processing_template_decl
)
21959 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21961 tree decl
= TREE_VEC_ELT (declv
, i
);
21962 tree init
= TREE_VEC_ELT (initv
, i
);
21963 tree cond
= TREE_VEC_ELT (condv
, i
);
21964 tree incr
= TREE_VEC_ELT (incrv
, i
);
21966 if (type_dependent_expression_p (decl
))
21969 if (init
&& type_dependent_expression_p (init
))
21972 if (type_dependent_expression_p (cond
))
21975 if (COMPARISON_CLASS_P (cond
)
21976 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21977 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21980 if (TREE_CODE (incr
) == MODOP_EXPR
)
21982 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21983 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21986 else if (type_dependent_expression_p (incr
))
21988 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21990 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21992 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21994 tree t
= TREE_OPERAND (incr
, 1);
21995 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21996 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
22005 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
22006 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
22007 no such TYPE can be found. Note that this function peers inside
22008 uninstantiated templates and therefore should be used only in
22009 extremely limited situations. ONLY_CURRENT_P restricts this
22010 peering to the currently open classes hierarchy (which is required
22011 when comparing types). */
22014 resolve_typename_type (tree type
, bool only_current_p
)
22023 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
22025 scope
= TYPE_CONTEXT (type
);
22026 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
22027 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
22028 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
22029 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
22030 identifier of the TYPENAME_TYPE anymore.
22031 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
22032 TYPENAME_TYPE instead, we avoid messing up with a possible
22033 typedef variant case. */
22034 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
22036 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
22037 it first before we can figure out what NAME refers to. */
22038 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
22040 if (TYPENAME_IS_RESOLVING_P (scope
))
22041 /* Given a class template A with a dependent base with nested type C,
22042 typedef typename A::C::C C will land us here, as trying to resolve
22043 the initial A::C leads to the local C typedef, which leads back to
22044 A::C::C. So we break the recursion now. */
22047 scope
= resolve_typename_type (scope
, only_current_p
);
22049 /* If we don't know what SCOPE refers to, then we cannot resolve the
22051 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
22053 /* If the SCOPE is a template type parameter, we have no way of
22054 resolving the name. */
22055 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
22057 /* If the SCOPE is not the current instantiation, there's no reason
22058 to look inside it. */
22059 if (only_current_p
&& !currently_open_class (scope
))
22061 /* If this is a typedef, we don't want to look inside (c++/11987). */
22062 if (typedef_variant_p (type
))
22064 /* If SCOPE isn't the template itself, it will not have a valid
22065 TYPE_FIELDS list. */
22066 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
22067 /* scope is either the template itself or a compatible instantiation
22068 like X<T>, so look up the name in the original template. */
22069 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
22071 /* scope is a partial instantiation, so we can't do the lookup or we
22072 will lose the template arguments. */
22074 /* Enter the SCOPE so that name lookup will be resolved as if we
22075 were in the class definition. In particular, SCOPE will no
22076 longer be considered a dependent type. */
22077 pushed_scope
= push_scope (scope
);
22078 /* Look up the declaration. */
22079 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
22080 tf_warning_or_error
);
22082 result
= NULL_TREE
;
22084 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
22085 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
22088 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
22089 && TREE_CODE (decl
) == TYPE_DECL
)
22091 result
= TREE_TYPE (decl
);
22092 if (result
== error_mark_node
)
22093 result
= NULL_TREE
;
22095 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
22096 && DECL_CLASS_TEMPLATE_P (decl
))
22100 /* Obtain the template and the arguments. */
22101 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
22102 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
22103 /* Instantiate the template. */
22104 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
22105 /*entering_scope=*/0,
22106 tf_error
| tf_user
);
22107 if (result
== error_mark_node
)
22108 result
= NULL_TREE
;
22111 /* Leave the SCOPE. */
22113 pop_scope (pushed_scope
);
22115 /* If we failed to resolve it, return the original typename. */
22119 /* If lookup found a typename type, resolve that too. */
22120 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
22122 /* Ill-formed programs can cause infinite recursion here, so we
22123 must catch that. */
22124 TYPENAME_IS_RESOLVING_P (type
) = 1;
22125 result
= resolve_typename_type (result
, only_current_p
);
22126 TYPENAME_IS_RESOLVING_P (type
) = 0;
22129 /* Qualify the resulting type. */
22130 quals
= cp_type_quals (type
);
22132 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
22137 /* EXPR is an expression which is not type-dependent. Return a proxy
22138 for EXPR that can be used to compute the types of larger
22139 expressions containing EXPR. */
22142 build_non_dependent_expr (tree expr
)
22146 #ifdef ENABLE_CHECKING
22147 /* Try to get a constant value for all non-dependent expressions in
22148 order to expose bugs in *_dependent_expression_p and constexpr. */
22149 if (cxx_dialect
>= cxx11
)
22150 fold_non_dependent_expr (expr
);
22153 /* Preserve OVERLOADs; the functions must be available to resolve
22156 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
22157 inner_expr
= stmt_expr_value_expr (inner_expr
);
22158 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
22159 inner_expr
= TREE_OPERAND (inner_expr
, 0);
22160 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
22161 inner_expr
= TREE_OPERAND (inner_expr
, 1);
22162 if (is_overloaded_fn (inner_expr
)
22163 || TREE_CODE (inner_expr
) == OFFSET_REF
)
22165 /* There is no need to return a proxy for a variable. */
22168 /* Preserve string constants; conversions from string constants to
22169 "char *" are allowed, even though normally a "const char *"
22170 cannot be used to initialize a "char *". */
22171 if (TREE_CODE (expr
) == STRING_CST
)
22173 /* Preserve void and arithmetic constants, as an optimization -- there is no
22174 reason to create a new node. */
22175 if (TREE_CODE (expr
) == VOID_CST
22176 || TREE_CODE (expr
) == INTEGER_CST
22177 || TREE_CODE (expr
) == REAL_CST
)
22179 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
22180 There is at least one place where we want to know that a
22181 particular expression is a throw-expression: when checking a ?:
22182 expression, there are special rules if the second or third
22183 argument is a throw-expression. */
22184 if (TREE_CODE (expr
) == THROW_EXPR
)
22187 /* Don't wrap an initializer list, we need to be able to look inside. */
22188 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
22191 /* Don't wrap a dummy object, we need to be able to test for it. */
22192 if (is_dummy_object (expr
))
22195 if (TREE_CODE (expr
) == COND_EXPR
)
22196 return build3 (COND_EXPR
,
22198 TREE_OPERAND (expr
, 0),
22199 (TREE_OPERAND (expr
, 1)
22200 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
22201 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
22202 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
22203 if (TREE_CODE (expr
) == COMPOUND_EXPR
22204 && !COMPOUND_EXPR_OVERLOADED (expr
))
22205 return build2 (COMPOUND_EXPR
,
22207 TREE_OPERAND (expr
, 0),
22208 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
22210 /* If the type is unknown, it can't really be non-dependent */
22211 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
22213 /* Otherwise, build a NON_DEPENDENT_EXPR. */
22214 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
22217 /* ARGS is a vector of expressions as arguments to a function call.
22218 Replace the arguments with equivalent non-dependent expressions.
22219 This modifies ARGS in place. */
22222 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
22227 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
22229 tree newarg
= build_non_dependent_expr (arg
);
22231 (*args
)[ix
] = newarg
;
22235 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
22236 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
22240 make_auto_1 (tree name
)
22242 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
22243 TYPE_NAME (au
) = build_decl (input_location
,
22244 TYPE_DECL
, name
, au
);
22245 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
22246 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
22247 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
22248 TYPE_NAME (au
), NULL_TREE
);
22249 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
22250 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
22251 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
22257 make_decltype_auto (void)
22259 return make_auto_1 (get_identifier ("decltype(auto)"));
22265 return make_auto_1 (get_identifier ("auto"));
22268 /* Given type ARG, return std::initializer_list<ARG>. */
22273 tree std_init_list
= namespace_binding
22274 (get_identifier ("initializer_list"), std_node
);
22276 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
22278 error ("deducing from brace-enclosed initializer list requires "
22279 "#include <initializer_list>");
22280 return error_mark_node
;
22282 argvec
= make_tree_vec (1);
22283 TREE_VEC_ELT (argvec
, 0) = arg
;
22284 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
22285 NULL_TREE
, 0, tf_warning_or_error
);
22288 /* Replace auto in TYPE with std::initializer_list<auto>. */
22291 listify_autos (tree type
, tree auto_node
)
22293 tree init_auto
= listify (auto_node
);
22294 tree argvec
= make_tree_vec (1);
22295 TREE_VEC_ELT (argvec
, 0) = init_auto
;
22296 if (processing_template_decl
)
22297 argvec
= add_to_template_args (current_template_args (), argvec
);
22298 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22301 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
22302 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
22305 do_auto_deduction (tree type
, tree init
, tree auto_node
)
22309 if (init
== error_mark_node
)
22310 return error_mark_node
;
22312 if (type_dependent_expression_p (init
))
22313 /* Defining a subset of type-dependent expressions that we can deduce
22314 from ahead of time isn't worth the trouble. */
22317 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
22318 with either a new invented type template parameter U or, if the
22319 initializer is a braced-init-list (8.5.4), with
22320 std::initializer_list<U>. */
22321 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
22323 if (!DIRECT_LIST_INIT_P (init
))
22324 type
= listify_autos (type
, auto_node
);
22325 else if (CONSTRUCTOR_NELTS (init
) == 1)
22326 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
22329 if (permerror (input_location
, "direct-list-initialization of "
22330 "%<auto%> requires exactly one element"))
22331 inform (input_location
,
22332 "for deduction to %<std::initializer_list%>, use copy-"
22333 "list-initialization (i.e. add %<=%> before the %<{%>)");
22334 type
= listify_autos (type
, auto_node
);
22338 init
= resolve_nondeduced_context (init
);
22340 targs
= make_tree_vec (1);
22341 if (AUTO_IS_DECLTYPE (auto_node
))
22343 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
22344 && !REF_PARENTHESIZED_P (init
)));
22345 TREE_VEC_ELT (targs
, 0)
22346 = finish_decltype_type (init
, id
, tf_warning_or_error
);
22347 if (type
!= auto_node
)
22349 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
22350 return error_mark_node
;
22355 tree parms
= build_tree_list (NULL_TREE
, type
);
22356 tree tparms
= make_tree_vec (1);
22359 TREE_VEC_ELT (tparms
, 0)
22360 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
22361 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
22362 DEDUCE_CALL
, LOOKUP_NORMAL
,
22363 NULL
, /*explain_p=*/false);
22366 if (processing_template_decl
)
22367 /* Try again at instantiation time. */
22369 if (type
&& type
!= error_mark_node
)
22370 /* If type is error_mark_node a diagnostic must have been
22371 emitted by now. Also, having a mention to '<type error>'
22372 in the diagnostic is not really useful to the user. */
22374 if (cfun
&& auto_node
== current_function_auto_return_pattern
22375 && LAMBDA_FUNCTION_P (current_function_decl
))
22376 error ("unable to deduce lambda return type from %qE", init
);
22378 error ("unable to deduce %qT from %qE", type
, init
);
22380 return error_mark_node
;
22384 /* If the list of declarators contains more than one declarator, the type
22385 of each declared variable is determined as described above. If the
22386 type deduced for the template parameter U is not the same in each
22387 deduction, the program is ill-formed. */
22388 if (TREE_TYPE (auto_node
)
22389 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
22391 if (cfun
&& auto_node
== current_function_auto_return_pattern
22392 && LAMBDA_FUNCTION_P (current_function_decl
))
22393 error ("inconsistent types %qT and %qT deduced for "
22394 "lambda return type", TREE_TYPE (auto_node
),
22395 TREE_VEC_ELT (targs
, 0));
22397 error ("inconsistent deduction for %qT: %qT and then %qT",
22398 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
22399 return error_mark_node
;
22401 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
22403 if (processing_template_decl
)
22404 targs
= add_to_template_args (current_template_args (), targs
);
22405 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
22408 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22412 splice_late_return_type (tree type
, tree late_return_type
)
22416 if (late_return_type
== NULL_TREE
)
22418 argvec
= make_tree_vec (1);
22419 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
22420 if (processing_template_parmlist
)
22421 /* For a late-specified return type in a template type-parameter, we
22422 need to add a dummy argument level for its parmlist. */
22423 argvec
= add_to_template_args
22424 (make_tree_vec (processing_template_parmlist
), argvec
);
22425 if (current_template_parms
)
22426 argvec
= add_to_template_args (current_template_args (), argvec
);
22427 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22430 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22431 'decltype(auto)'. */
22434 is_auto (const_tree type
)
22436 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
22437 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
22438 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
22444 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22445 a use of `auto'. Returns NULL_TREE otherwise. */
22448 type_uses_auto (tree type
)
22450 return find_type_usage (type
, is_auto
);
22453 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22454 'decltype(auto)' or a concept. */
22457 is_auto_or_concept (const_tree type
)
22459 return is_auto (type
); // or concept
22462 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22463 a concept identifier) iff TYPE contains a use of a generic type. Returns
22464 NULL_TREE otherwise. */
22467 type_uses_auto_or_concept (tree type
)
22469 return find_type_usage (type
, is_auto_or_concept
);
22473 /* For a given template T, return the vector of typedefs referenced
22474 in T for which access check is needed at T instantiation time.
22475 T is either a FUNCTION_DECL or a RECORD_TYPE.
22476 Those typedefs were added to T by the function
22477 append_type_to_template_for_access_check. */
22479 vec
<qualified_typedef_usage_t
, va_gc
> *
22480 get_types_needing_access_check (tree t
)
22483 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
22485 if (!t
|| t
== error_mark_node
)
22488 if (!(ti
= get_template_info (t
)))
22491 if (CLASS_TYPE_P (t
)
22492 || TREE_CODE (t
) == FUNCTION_DECL
)
22494 if (!TI_TEMPLATE (ti
))
22497 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
22503 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22504 tied to T. That list of typedefs will be access checked at
22505 T instantiation time.
22506 T is either a FUNCTION_DECL or a RECORD_TYPE.
22507 TYPE_DECL is a TYPE_DECL node representing a typedef.
22508 SCOPE is the scope through which TYPE_DECL is accessed.
22509 LOCATION is the location of the usage point of TYPE_DECL.
22511 This function is a subroutine of
22512 append_type_to_template_for_access_check. */
22515 append_type_to_template_for_access_check_1 (tree t
,
22518 location_t location
)
22520 qualified_typedef_usage_t typedef_usage
;
22523 if (!t
|| t
== error_mark_node
)
22526 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
22527 || CLASS_TYPE_P (t
))
22529 && TREE_CODE (type_decl
) == TYPE_DECL
22532 if (!(ti
= get_template_info (t
)))
22535 gcc_assert (TI_TEMPLATE (ti
));
22537 typedef_usage
.typedef_decl
= type_decl
;
22538 typedef_usage
.context
= scope
;
22539 typedef_usage
.locus
= location
;
22541 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22544 /* Append TYPE_DECL to the template TEMPL.
22545 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22546 At TEMPL instanciation time, TYPE_DECL will be checked to see
22547 if it can be accessed through SCOPE.
22548 LOCATION is the location of the usage point of TYPE_DECL.
22550 e.g. consider the following code snippet:
22557 template<class U> struct S
22559 C::myint mi; // <-- usage point of the typedef C::myint
22564 At S<char> instantiation time, we need to check the access of C::myint
22565 In other words, we need to check the access of the myint typedef through
22566 the C scope. For that purpose, this function will add the myint typedef
22567 and the scope C through which its being accessed to a list of typedefs
22568 tied to the template S. That list will be walked at template instantiation
22569 time and access check performed on each typedefs it contains.
22570 Note that this particular code snippet should yield an error because
22571 myint is private to C. */
22574 append_type_to_template_for_access_check (tree templ
,
22577 location_t location
)
22579 qualified_typedef_usage_t
*iter
;
22582 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22584 /* Make sure we don't append the type to the template twice. */
22585 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22586 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22589 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22593 /* Convert the generic type parameters in PARM that match the types given in the
22594 range [START_IDX, END_IDX) from the current_template_parms into generic type
22598 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22600 tree current
= current_template_parms
;
22601 int depth
= TMPL_PARMS_DEPTH (current
);
22602 current
= INNERMOST_TEMPLATE_PARMS (current
);
22603 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22605 for (int i
= 0; i
< start_idx
; ++i
)
22606 TREE_VEC_ELT (replacement
, i
)
22607 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22609 for (int i
= start_idx
; i
< end_idx
; ++i
)
22611 /* Create a distinct parameter pack type from the current parm and add it
22612 to the replacement args to tsubst below into the generic function
22615 tree o
= TREE_TYPE (TREE_VALUE
22616 (TREE_VEC_ELT (current
, i
)));
22617 tree t
= copy_type (o
);
22618 TEMPLATE_TYPE_PARM_INDEX (t
)
22619 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22621 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22622 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22623 TYPE_MAIN_VARIANT (t
) = t
;
22624 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22625 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22626 TREE_VEC_ELT (replacement
, i
) = t
;
22627 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22630 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22631 TREE_VEC_ELT (replacement
, i
)
22632 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22634 /* If there are more levels then build up the replacement with the outer
22637 replacement
= add_to_template_args (template_parms_to_args
22638 (TREE_CHAIN (current_template_parms
)),
22641 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22645 /* Set up the hash tables for template instantiations. */
22648 init_template_processing (void)
22650 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22651 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22654 /* Print stats about the template hash tables for -fstats. */
22657 print_template_statistics (void)
22659 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22660 "%f collisions\n", (long) decl_specializations
->size (),
22661 (long) decl_specializations
->elements (),
22662 decl_specializations
->collisions ());
22663 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22664 "%f collisions\n", (long) type_specializations
->size (),
22665 (long) type_specializations
->elements (),
22666 type_specializations
->collisions ());
22669 #include "gt-cp-pt.h"