1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2014 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"
32 #include "stringpool.h"
35 #include "stor-layout.h"
39 #include "c-family/c-common.h"
40 #include "c-family/c-objc.h"
41 #include "cp-objcp-common.h"
42 #include "tree-inline.h"
46 #include "tree-iterator.h"
47 #include "type-utils.h"
50 /* The type of functions taking a tree, and some additional data, and
52 typedef int (*tree_fn_t
) (tree
, void*);
54 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
55 instantiations have been deferred, either because their definitions
56 were not yet available, or because we were putting off doing the work. */
57 struct GTY ((chain_next ("%h.next"))) pending_template
{
58 struct pending_template
*next
;
59 struct tinst_level
*tinst
;
62 static GTY(()) struct pending_template
*pending_templates
;
63 static GTY(()) struct pending_template
*last_pending_template
;
65 int processing_template_parmlist
;
66 static int template_header_count
;
68 static GTY(()) tree saved_trees
;
69 static vec
<int> inline_parm_levels
;
71 static GTY(()) struct tinst_level
*current_tinst_level
;
73 static GTY(()) tree saved_access_scope
;
75 /* Live only within one (recursive) call to tsubst_expr. We use
76 this to pass the statement expression node from the STMT_EXPR
77 to the EXPR_STMT that is its result. */
78 static tree cur_stmt_expr
;
80 /* True if we've recursed into fn_type_unification too many times. */
81 static bool excessive_deduction_depth
;
83 struct GTY((for_user
)) spec_entry
90 struct spec_hasher
: ggc_hasher
<spec_entry
*>
92 static hashval_t
hash (spec_entry
*);
93 static bool equal (spec_entry
*, spec_entry
*);
96 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
98 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
100 /* Contains canonical template parameter types. The vector is indexed by
101 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
102 TREE_LIST, whose TREE_VALUEs contain the canonical template
103 parameters of various types and levels. */
104 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
106 #define UNIFY_ALLOW_NONE 0
107 #define UNIFY_ALLOW_MORE_CV_QUAL 1
108 #define UNIFY_ALLOW_LESS_CV_QUAL 2
109 #define UNIFY_ALLOW_DERIVED 4
110 #define UNIFY_ALLOW_INTEGER 8
111 #define UNIFY_ALLOW_OUTER_LEVEL 16
112 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
113 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
115 enum template_base_result
{
117 tbr_ambiguous_baseclass
,
121 static void push_access_scope (tree
);
122 static void pop_access_scope (tree
);
123 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
124 unification_kind_t
, int,
126 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
127 unification_kind_t
, int, bool, bool);
128 static int unify (tree
, tree
, tree
, tree
, int, bool);
129 static void add_pending_template (tree
);
130 static tree
reopen_tinst_level (struct tinst_level
*);
131 static tree
tsubst_initializer_list (tree
, tree
);
132 static tree
get_class_bindings (tree
, tree
, tree
, tree
);
133 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
135 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
137 static void tsubst_enum (tree
, tree
, tree
);
138 static tree
add_to_template_args (tree
, tree
);
139 static tree
add_outermost_template_args (tree
, tree
);
140 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
141 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
143 static int type_unification_real (tree
, tree
, tree
, const tree
*,
144 unsigned int, int, unification_kind_t
, int,
145 vec
<deferred_access_check
, va_gc
> **,
147 static void note_template_header (int);
148 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
149 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
150 static tree
convert_template_argument (tree
, tree
, tree
,
151 tsubst_flags_t
, int, tree
);
152 static int for_each_template_parm (tree
, tree_fn_t
, void*,
153 hash_set
<tree
> *, bool);
154 static tree
expand_template_argument_pack (tree
);
155 static tree
build_template_parm_index (int, int, int, tree
, tree
);
156 static bool inline_needs_template_parms (tree
, bool);
157 static void push_inline_template_parms_recursive (tree
, int);
158 static tree
retrieve_local_specialization (tree
);
159 static void register_local_specialization (tree
, tree
);
160 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
161 static int mark_template_parm (tree
, void *);
162 static int template_parm_this_level_p (tree
, void *);
163 static tree
tsubst_friend_function (tree
, tree
);
164 static tree
tsubst_friend_class (tree
, tree
);
165 static int can_complete_type_without_circularity (tree
);
166 static tree
get_bindings (tree
, tree
, tree
, bool);
167 static int template_decl_level (tree
);
168 static int check_cv_quals_for_unify (int, tree
, tree
);
169 static void template_parm_level_and_index (tree
, int*, int*);
170 static int unify_pack_expansion (tree
, tree
, tree
,
171 tree
, unification_kind_t
, bool, bool);
172 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
173 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
174 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
175 static void regenerate_decl_from_template (tree
, tree
);
176 static tree
most_specialized_class (tree
, tsubst_flags_t
);
177 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
178 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
179 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
180 static bool check_specialization_scope (void);
181 static tree
process_partial_specialization (tree
);
182 static void set_current_access_from_decl (tree
);
183 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
185 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
186 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
188 static bool template_template_parm_bindings_ok_p (tree
, tree
);
189 static int template_args_equal (tree
, tree
);
190 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
191 static tree
for_each_template_parm_r (tree
*, int *, void *);
192 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
193 static void copy_default_args_to_explicit_spec (tree
);
194 static int invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
195 static bool dependent_template_arg_p (tree
);
196 static bool any_template_arguments_need_structural_equality_p (tree
);
197 static bool dependent_type_p_r (tree
);
198 static tree
tsubst_expr (tree
, tree
, tsubst_flags_t
, tree
, bool);
199 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
200 static tree
tsubst_pack_expansion (tree
, tree
, tsubst_flags_t
, tree
);
201 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
202 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
203 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
205 static tree
listify (tree
);
206 static tree
listify_autos (tree
, tree
);
207 static tree
template_parm_to_arg (tree t
);
208 static tree
current_template_args (void);
209 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
210 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
212 /* Make the current scope suitable for access checking when we are
213 processing T. T can be FUNCTION_DECL for instantiated function
214 template, VAR_DECL for static member variable, or TYPE_DECL for
215 alias template (needed by instantiate_decl). */
218 push_access_scope (tree t
)
220 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
221 || TREE_CODE (t
) == TYPE_DECL
);
223 if (DECL_FRIEND_CONTEXT (t
))
224 push_nested_class (DECL_FRIEND_CONTEXT (t
));
225 else if (DECL_CLASS_SCOPE_P (t
))
226 push_nested_class (DECL_CONTEXT (t
));
228 push_to_top_level ();
230 if (TREE_CODE (t
) == FUNCTION_DECL
)
232 saved_access_scope
= tree_cons
233 (NULL_TREE
, current_function_decl
, saved_access_scope
);
234 current_function_decl
= t
;
238 /* Restore the scope set up by push_access_scope. T is the node we
242 pop_access_scope (tree t
)
244 if (TREE_CODE (t
) == FUNCTION_DECL
)
246 current_function_decl
= TREE_VALUE (saved_access_scope
);
247 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
250 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
253 pop_from_top_level ();
256 /* Do any processing required when DECL (a member template
257 declaration) is finished. Returns the TEMPLATE_DECL corresponding
258 to DECL, unless it is a specialization, in which case the DECL
259 itself is returned. */
262 finish_member_template_decl (tree decl
)
264 if (decl
== error_mark_node
)
265 return error_mark_node
;
267 gcc_assert (DECL_P (decl
));
269 if (TREE_CODE (decl
) == TYPE_DECL
)
273 type
= TREE_TYPE (decl
);
274 if (type
== error_mark_node
)
275 return error_mark_node
;
276 if (MAYBE_CLASS_TYPE_P (type
)
277 && CLASSTYPE_TEMPLATE_INFO (type
)
278 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
280 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
281 check_member_template (tmpl
);
286 else if (TREE_CODE (decl
) == FIELD_DECL
)
287 error ("data member %qD cannot be a member template", decl
);
288 else if (DECL_TEMPLATE_INFO (decl
))
290 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
292 check_member_template (DECL_TI_TEMPLATE (decl
));
293 return DECL_TI_TEMPLATE (decl
);
299 error ("invalid member template declaration %qD", decl
);
301 return error_mark_node
;
304 /* Create a template info node. */
307 build_template_info (tree template_decl
, tree template_args
)
309 tree result
= make_node (TEMPLATE_INFO
);
310 TI_TEMPLATE (result
) = template_decl
;
311 TI_ARGS (result
) = template_args
;
315 /* Return the template info node corresponding to T, whatever T is. */
318 get_template_info (const_tree t
)
320 tree tinfo
= NULL_TREE
;
322 if (!t
|| t
== error_mark_node
)
325 if (TREE_CODE (t
) == NAMESPACE_DECL
)
328 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
329 tinfo
= DECL_TEMPLATE_INFO (t
);
331 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
334 if (OVERLOAD_TYPE_P (t
))
335 tinfo
= TYPE_TEMPLATE_INFO (t
);
336 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
337 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
342 /* Returns the template nesting level of the indicated class TYPE.
352 A<T>::B<U> has depth two, while A<T> has depth one.
353 Both A<T>::B<int> and A<int>::B<U> have depth one, if
354 they are instantiations, not specializations.
356 This function is guaranteed to return 0 if passed NULL_TREE so
357 that, for example, `template_class_depth (current_class_type)' is
361 template_class_depth (tree type
)
366 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
367 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
368 ? CP_DECL_CONTEXT (type
) : CP_TYPE_CONTEXT (type
))
370 tree tinfo
= get_template_info (type
);
372 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
373 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
380 /* Subroutine of maybe_begin_member_template_processing.
381 Returns true if processing DECL needs us to push template parms. */
384 inline_needs_template_parms (tree decl
, bool nsdmi
)
386 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
389 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
390 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
393 /* Subroutine of maybe_begin_member_template_processing.
394 Push the template parms in PARMS, starting from LEVELS steps into the
395 chain, and ending at the beginning, since template parms are listed
399 push_inline_template_parms_recursive (tree parmlist
, int levels
)
401 tree parms
= TREE_VALUE (parmlist
);
405 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
407 ++processing_template_decl
;
408 current_template_parms
409 = tree_cons (size_int (processing_template_decl
),
410 parms
, current_template_parms
);
411 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
413 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
415 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
417 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
419 if (error_operand_p (parm
))
422 gcc_assert (DECL_P (parm
));
424 switch (TREE_CODE (parm
))
433 /* Make a CONST_DECL as is done in process_template_parm.
434 It is ugly that we recreate this here; the original
435 version built in process_template_parm is no longer
437 tree decl
= build_decl (DECL_SOURCE_LOCATION (parm
),
438 CONST_DECL
, DECL_NAME (parm
),
440 DECL_ARTIFICIAL (decl
) = 1;
441 TREE_CONSTANT (decl
) = 1;
442 TREE_READONLY (decl
) = 1;
443 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
444 SET_DECL_TEMPLATE_PARM_P (decl
);
455 /* Restore the template parameter context for a member template, a
456 friend template defined in a class definition, or a non-template
457 member of template class. */
460 maybe_begin_member_template_processing (tree decl
)
464 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
468 tree ctx
= DECL_CONTEXT (decl
);
469 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
470 /* Disregard full specializations (c++/60999). */
471 && uses_template_parms (ctx
)
472 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
475 if (inline_needs_template_parms (decl
, nsdmi
))
477 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
478 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
480 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
483 parms
= TREE_CHAIN (parms
);
486 push_inline_template_parms_recursive (parms
, levels
);
489 /* Remember how many levels of template parameters we pushed so that
490 we can pop them later. */
491 inline_parm_levels
.safe_push (levels
);
494 /* Undo the effects of maybe_begin_member_template_processing. */
497 maybe_end_member_template_processing (void)
502 if (inline_parm_levels
.length () == 0)
505 last
= inline_parm_levels
.pop ();
506 for (i
= 0; i
< last
; ++i
)
508 --processing_template_decl
;
509 current_template_parms
= TREE_CHAIN (current_template_parms
);
514 /* Return a new template argument vector which contains all of ARGS,
515 but has as its innermost set of arguments the EXTRA_ARGS. */
518 add_to_template_args (tree args
, tree extra_args
)
525 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
528 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
529 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
531 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
532 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
534 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
535 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
540 /* Like add_to_template_args, but only the outermost ARGS are added to
541 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
542 (EXTRA_ARGS) levels are added. This function is used to combine
543 the template arguments from a partial instantiation with the
544 template arguments used to attain the full instantiation from the
545 partial instantiation. */
548 add_outermost_template_args (tree args
, tree extra_args
)
552 /* If there are more levels of EXTRA_ARGS than there are ARGS,
553 something very fishy is going on. */
554 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
556 /* If *all* the new arguments will be the EXTRA_ARGS, just return
558 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
561 /* For the moment, we make ARGS look like it contains fewer levels. */
562 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
564 new_args
= add_to_template_args (args
, extra_args
);
566 /* Now, we restore ARGS to its full dimensions. */
567 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
572 /* Return the N levels of innermost template arguments from the ARGS. */
575 get_innermost_template_args (tree args
, int n
)
583 /* If N is 1, just return the innermost set of template arguments. */
585 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
587 /* If we're not removing anything, just return the arguments we were
589 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
590 gcc_assert (extra_levels
>= 0);
591 if (extra_levels
== 0)
594 /* Make a new set of arguments, not containing the outer arguments. */
595 new_args
= make_tree_vec (n
);
596 for (i
= 1; i
<= n
; ++i
)
597 SET_TMPL_ARGS_LEVEL (new_args
, i
,
598 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
603 /* The inverse of get_innermost_template_args: Return all but the innermost
604 EXTRA_LEVELS levels of template arguments from the ARGS. */
607 strip_innermost_template_args (tree args
, int extra_levels
)
610 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
615 /* If N is 1, just return the outermost set of template arguments. */
617 return TMPL_ARGS_LEVEL (args
, 1);
619 /* If we're not removing anything, just return the arguments we were
621 gcc_assert (extra_levels
>= 0);
622 if (extra_levels
== 0)
625 /* Make a new set of arguments, not containing the inner arguments. */
626 new_args
= make_tree_vec (n
);
627 for (i
= 1; i
<= n
; ++i
)
628 SET_TMPL_ARGS_LEVEL (new_args
, i
,
629 TMPL_ARGS_LEVEL (args
, i
));
634 /* We've got a template header coming up; push to a new level for storing
638 begin_template_parm_list (void)
640 /* We use a non-tag-transparent scope here, which causes pushtag to
641 put tags in this scope, rather than in the enclosing class or
642 namespace scope. This is the right thing, since we want
643 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
644 global template class, push_template_decl handles putting the
645 TEMPLATE_DECL into top-level scope. For a nested template class,
648 template <class T> struct S1 {
649 template <class T> struct S2 {};
652 pushtag contains special code to call pushdecl_with_scope on the
653 TEMPLATE_DECL for S2. */
654 begin_scope (sk_template_parms
, NULL
);
655 ++processing_template_decl
;
656 ++processing_template_parmlist
;
657 note_template_header (0);
660 /* This routine is called when a specialization is declared. If it is
661 invalid to declare a specialization here, an error is reported and
662 false is returned, otherwise this routine will return true. */
665 check_specialization_scope (void)
667 tree scope
= current_scope ();
671 An explicit specialization shall be declared in the namespace of
672 which the template is a member, or, for member templates, in the
673 namespace of which the enclosing class or enclosing class
674 template is a member. An explicit specialization of a member
675 function, member class or static data member of a class template
676 shall be declared in the namespace of which the class template
678 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
680 error ("explicit specialization in non-namespace scope %qD", scope
);
686 In an explicit specialization declaration for a member of a class
687 template or a member template that appears in namespace scope,
688 the member template and some of its enclosing class templates may
689 remain unspecialized, except that the declaration shall not
690 explicitly specialize a class member template if its enclosing
691 class templates are not explicitly specialized as well. */
692 if (current_template_parms
)
694 error ("enclosing class templates are not explicitly specialized");
701 /* We've just seen template <>. */
704 begin_specialization (void)
706 begin_scope (sk_template_spec
, NULL
);
707 note_template_header (1);
708 return check_specialization_scope ();
711 /* Called at then end of processing a declaration preceded by
715 end_specialization (void)
718 reset_specialization ();
721 /* Any template <>'s that we have seen thus far are not referring to a
722 function specialization. */
725 reset_specialization (void)
727 processing_specialization
= 0;
728 template_header_count
= 0;
731 /* We've just seen a template header. If SPECIALIZATION is nonzero,
732 it was of the form template <>. */
735 note_template_header (int specialization
)
737 processing_specialization
= specialization
;
738 template_header_count
++;
741 /* We're beginning an explicit instantiation. */
744 begin_explicit_instantiation (void)
746 gcc_assert (!processing_explicit_instantiation
);
747 processing_explicit_instantiation
= true;
752 end_explicit_instantiation (void)
754 gcc_assert (processing_explicit_instantiation
);
755 processing_explicit_instantiation
= false;
758 /* An explicit specialization or partial specialization of TMPL is being
759 declared. Check that the namespace in which the specialization is
760 occurring is permissible. Returns false iff it is invalid to
761 specialize TMPL in the current namespace. */
764 check_specialization_namespace (tree tmpl
)
766 tree tpl_ns
= decl_namespace_context (tmpl
);
770 An explicit specialization shall be declared in the namespace of
771 which the template is a member, or, for member templates, in the
772 namespace of which the enclosing class or enclosing class
773 template is a member. An explicit specialization of a member
774 function, member class or static data member of a class template
775 shall be declared in the namespace of which the class template is
777 if (current_scope() != DECL_CONTEXT (tmpl
)
778 && !at_namespace_scope_p ())
780 error ("specialization of %qD must appear at namespace scope", tmpl
);
783 if (is_associated_namespace (current_namespace
, tpl_ns
))
784 /* Same or super-using namespace. */
788 permerror (input_location
, "specialization of %qD in different namespace", tmpl
);
789 permerror (input_location
, " from definition of %q+#D", tmpl
);
794 /* SPEC is an explicit instantiation. Check that it is valid to
795 perform this explicit instantiation in the current namespace. */
798 check_explicit_instantiation_namespace (tree spec
)
802 /* DR 275: An explicit instantiation shall appear in an enclosing
803 namespace of its template. */
804 ns
= decl_namespace_context (spec
);
805 if (!is_ancestor (current_namespace
, ns
))
806 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
807 "(which does not enclose namespace %qD)",
808 spec
, current_namespace
, ns
);
811 /* The TYPE is being declared. If it is a template type, that means it
812 is a partial specialization. Do appropriate error-checking. */
815 maybe_process_partial_specialization (tree type
)
819 if (type
== error_mark_node
)
820 return error_mark_node
;
822 /* A lambda that appears in specialization context is not itself a
824 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
827 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
829 error ("name of class shadows template template parameter %qD",
831 return error_mark_node
;
834 context
= TYPE_CONTEXT (type
);
836 if (TYPE_ALIAS_P (type
))
838 if (TYPE_TEMPLATE_INFO (type
)
839 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type
)))
840 error ("specialization of alias template %qD",
841 TYPE_TI_TEMPLATE (type
));
843 error ("explicit specialization of non-template %qT", type
);
844 return error_mark_node
;
846 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
848 /* This is for ordinary explicit specialization and partial
849 specialization of a template class such as:
851 template <> class C<int>;
855 template <class T> class C<T*>;
857 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
859 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
860 && !COMPLETE_TYPE_P (type
))
862 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type
))
863 && !at_namespace_scope_p ())
864 return error_mark_node
;
865 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
866 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
867 if (processing_template_decl
)
869 if (push_template_decl (TYPE_MAIN_DECL (type
))
871 return error_mark_node
;
874 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
875 error ("specialization of %qT after instantiation", type
);
876 else if (errorcount
&& !processing_specialization
877 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
878 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
879 /* Trying to define a specialization either without a template<> header
880 or in an inappropriate place. We've already given an error, so just
881 bail now so we don't actually define the specialization. */
882 return error_mark_node
;
884 else if (CLASS_TYPE_P (type
)
885 && !CLASSTYPE_USE_TEMPLATE (type
)
886 && CLASSTYPE_TEMPLATE_INFO (type
)
887 && context
&& CLASS_TYPE_P (context
)
888 && CLASSTYPE_TEMPLATE_INFO (context
))
890 /* This is for an explicit specialization of member class
891 template according to [temp.expl.spec/18]:
893 template <> template <class U> class C<int>::D;
895 The context `C<int>' must be an implicit instantiation.
896 Otherwise this is just a member class template declared
899 template <> class C<int> { template <class U> class D; };
900 template <> template <class U> class C<int>::D;
902 In the first case, `C<int>::D' is a specialization of `C<T>::D'
903 while in the second case, `C<int>::D' is a primary template
904 and `C<T>::D' may not exist. */
906 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
907 && !COMPLETE_TYPE_P (type
))
910 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
912 if (current_namespace
913 != decl_namespace_context (tmpl
))
915 permerror (input_location
, "specializing %q#T in different namespace", type
);
916 permerror (input_location
, " from definition of %q+#D", tmpl
);
919 /* Check for invalid specialization after instantiation:
921 template <> template <> class C<int>::D<int>;
922 template <> template <class U> class C<int>::D; */
924 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
925 t
; t
= TREE_CHAIN (t
))
927 tree inst
= TREE_VALUE (t
);
928 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
929 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
931 /* We already have a full specialization of this partial
932 instantiation, or a full specialization has been
933 looked up but not instantiated. Reassign it to the
934 new member specialization template. */
938 elt
.tmpl
= most_general_template (tmpl
);
939 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
942 type_specializations
->remove_elt (&elt
);
945 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
948 = type_specializations
->find_slot (&elt
, INSERT
);
949 entry
= ggc_alloc
<spec_entry
> ();
954 /* But if we've had an implicit instantiation, that's a
955 problem ([temp.expl.spec]/6). */
956 error ("specialization %qT after instantiation %qT",
960 /* Mark TYPE as a specialization. And as a result, we only
961 have one level of template argument for the innermost
963 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
964 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
965 CLASSTYPE_TI_ARGS (type
)
966 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
969 else if (processing_specialization
)
971 /* Someday C++0x may allow for enum template specialization. */
972 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
973 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
974 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
975 "of %qD not allowed by ISO C++", type
);
978 error ("explicit specialization of non-template %qT", type
);
979 return error_mark_node
;
986 /* Returns nonzero if we can optimize the retrieval of specializations
987 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
988 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
991 optimize_specialization_lookup_p (tree tmpl
)
993 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
994 && DECL_CLASS_SCOPE_P (tmpl
)
995 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
997 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
998 /* The optimized lookup depends on the fact that the
999 template arguments for the member function template apply
1000 purely to the containing class, which is not true if the
1001 containing class is an explicit or partial
1003 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1004 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1005 && !DECL_CONV_FN_P (tmpl
)
1006 /* It is possible to have a template that is not a member
1007 template and is not a member of a template class:
1009 template <typename T>
1010 struct S { friend A::f(); };
1012 Here, the friend function is a template, but the context does
1013 not have template information. The optimized lookup relies
1014 on having ARGS be the template arguments for both the class
1015 and the function template. */
1016 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1019 /* Retrieve the specialization (in the sense of [temp.spec] - a
1020 specialization is either an instantiation or an explicit
1021 specialization) of TMPL for the given template ARGS. If there is
1022 no such specialization, return NULL_TREE. The ARGS are a vector of
1023 arguments, or a vector of vectors of arguments, in the case of
1024 templates with more than one level of parameters.
1026 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1027 then we search for a partial specialization matching ARGS. This
1028 parameter is ignored if TMPL is not a class template.
1030 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1031 result is a NONTYPE_ARGUMENT_PACK. */
1034 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1036 if (tmpl
== NULL_TREE
)
1039 if (args
== error_mark_node
)
1042 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1043 || TREE_CODE (tmpl
) == FIELD_DECL
);
1045 /* There should be as many levels of arguments as there are
1046 levels of parameters. */
1047 gcc_assert (TMPL_ARGS_DEPTH (args
)
1048 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1049 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1050 : template_class_depth (DECL_CONTEXT (tmpl
))));
1052 if (optimize_specialization_lookup_p (tmpl
))
1054 tree class_template
;
1055 tree class_specialization
;
1056 vec
<tree
, va_gc
> *methods
;
1060 /* The template arguments actually apply to the containing
1061 class. Find the class specialization with those
1063 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1064 class_specialization
1065 = retrieve_specialization (class_template
, args
, 0);
1066 if (!class_specialization
)
1068 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1069 for the specialization. */
1070 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
1073 /* Iterate through the methods with the indicated name, looking
1074 for the one that has an instance of TMPL. */
1075 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
1076 for (fns
= (*methods
)[idx
]; fns
; fns
= OVL_NEXT (fns
))
1078 tree fn
= OVL_CURRENT (fns
);
1079 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1080 /* using-declarations can add base methods to the method vec,
1081 and we don't want those here. */
1082 && DECL_CONTEXT (fn
) == class_specialization
)
1091 hash_table
<spec_hasher
> *specializations
;
1095 elt
.spec
= NULL_TREE
;
1097 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1098 specializations
= type_specializations
;
1100 specializations
= decl_specializations
;
1103 hash
= spec_hasher::hash (&elt
);
1104 found
= specializations
->find_with_hash (&elt
, hash
);
1112 /* Like retrieve_specialization, but for local declarations. */
1115 retrieve_local_specialization (tree tmpl
)
1117 if (local_specializations
== NULL
)
1120 tree
*slot
= local_specializations
->get (tmpl
);
1121 return slot
? *slot
: NULL_TREE
;
1124 /* Returns nonzero iff DECL is a specialization of TMPL. */
1127 is_specialization_of (tree decl
, tree tmpl
)
1131 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1135 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1141 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1143 for (t
= TREE_TYPE (decl
);
1145 t
= CLASSTYPE_USE_TEMPLATE (t
)
1146 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1147 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1154 /* Returns nonzero iff DECL is a specialization of friend declaration
1155 FRIEND_DECL according to [temp.friend]. */
1158 is_specialization_of_friend (tree decl
, tree friend_decl
)
1160 bool need_template
= true;
1163 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1164 || TREE_CODE (decl
) == TYPE_DECL
);
1166 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1167 of a template class, we want to check if DECL is a specialization
1169 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1170 && DECL_TEMPLATE_INFO (friend_decl
)
1171 && !DECL_USE_TEMPLATE (friend_decl
))
1173 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1174 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1175 need_template
= false;
1177 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1178 && !PRIMARY_TEMPLATE_P (friend_decl
))
1179 need_template
= false;
1181 /* There is nothing to do if this is not a template friend. */
1182 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1185 if (is_specialization_of (decl
, friend_decl
))
1189 A member of a class template may be declared to be a friend of a
1190 non-template class. In this case, the corresponding member of
1191 every specialization of the class template is a friend of the
1192 class granting friendship.
1194 For example, given a template friend declaration
1196 template <class T> friend void A<T>::f();
1198 the member function below is considered a friend
1200 template <> struct A<int> {
1204 For this type of template friend, TEMPLATE_DEPTH below will be
1205 nonzero. To determine if DECL is a friend of FRIEND, we first
1206 check if the enclosing class is a specialization of another. */
1208 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1210 && DECL_CLASS_SCOPE_P (decl
)
1211 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1212 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1214 /* Next, we check the members themselves. In order to handle
1215 a few tricky cases, such as when FRIEND_DECL's are
1217 template <class T> friend void A<T>::g(T t);
1218 template <class T> template <T t> friend void A<T>::h();
1222 void A<int>::g(int);
1223 template <int> void A<int>::h();
1225 we need to figure out ARGS, the template arguments from
1226 the context of DECL. This is required for template substitution
1227 of `T' in the function parameter of `g' and template parameter
1228 of `h' in the above examples. Here ARGS corresponds to `int'. */
1230 tree context
= DECL_CONTEXT (decl
);
1231 tree args
= NULL_TREE
;
1232 int current_depth
= 0;
1234 while (current_depth
< template_depth
)
1236 if (CLASSTYPE_TEMPLATE_INFO (context
))
1238 if (current_depth
== 0)
1239 args
= TYPE_TI_ARGS (context
);
1241 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1244 context
= TYPE_CONTEXT (context
);
1247 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1252 tree friend_args_type
;
1253 tree decl_args_type
;
1255 /* Make sure that both DECL and FRIEND_DECL are templates or
1257 is_template
= DECL_TEMPLATE_INFO (decl
)
1258 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1259 if (need_template
^ is_template
)
1261 else if (is_template
)
1263 /* If both are templates, check template parameter list. */
1265 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1267 if (!comp_template_parms
1268 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1272 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1275 decl_type
= TREE_TYPE (decl
);
1277 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1278 tf_none
, NULL_TREE
);
1279 if (friend_type
== error_mark_node
)
1282 /* Check if return types match. */
1283 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1286 /* Check if function parameter types match, ignoring the
1287 `this' parameter. */
1288 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1289 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1290 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1291 friend_args_type
= TREE_CHAIN (friend_args_type
);
1292 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1293 decl_args_type
= TREE_CHAIN (decl_args_type
);
1295 return compparms (decl_args_type
, friend_args_type
);
1299 /* DECL is a TYPE_DECL */
1301 tree decl_type
= TREE_TYPE (decl
);
1303 /* Make sure that both DECL and FRIEND_DECL are templates or
1306 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1307 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1309 if (need_template
^ is_template
)
1311 else if (is_template
)
1314 /* If both are templates, check the name of the two
1315 TEMPLATE_DECL's first because is_friend didn't. */
1316 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1317 != DECL_NAME (friend_decl
))
1320 /* Now check template parameter list. */
1322 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1324 return comp_template_parms
1325 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1329 return (DECL_NAME (decl
)
1330 == DECL_NAME (friend_decl
));
1336 /* Register the specialization SPEC as a specialization of TMPL with
1337 the indicated ARGS. IS_FRIEND indicates whether the specialization
1338 is actually just a friend declaration. Returns SPEC, or an
1339 equivalent prior declaration, if available.
1341 We also store instantiations of field packs in the hash table, even
1342 though they are not themselves templates, to make lookup easier. */
1345 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1349 spec_entry
**slot
= NULL
;
1352 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1353 || (TREE_CODE (tmpl
) == FIELD_DECL
1354 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1356 if (TREE_CODE (spec
) == FUNCTION_DECL
1357 && uses_template_parms (DECL_TI_ARGS (spec
)))
1358 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1359 register it; we want the corresponding TEMPLATE_DECL instead.
1360 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1361 the more obvious `uses_template_parms (spec)' to avoid problems
1362 with default function arguments. In particular, given
1363 something like this:
1365 template <class T> void f(T t1, T t = T())
1367 the default argument expression is not substituted for in an
1368 instantiation unless and until it is actually needed. */
1371 if (optimize_specialization_lookup_p (tmpl
))
1372 /* We don't put these specializations in the hash table, but we might
1373 want to give an error about a mismatch. */
1374 fn
= retrieve_specialization (tmpl
, args
, 0);
1382 hash
= spec_hasher::hash (&elt
);
1385 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1387 fn
= ((spec_entry
*) *slot
)->spec
;
1392 /* We can sometimes try to re-register a specialization that we've
1393 already got. In particular, regenerate_decl_from_template calls
1394 duplicate_decls which will update the specialization list. But,
1395 we'll still get called again here anyhow. It's more convenient
1396 to simply allow this than to try to prevent it. */
1399 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1401 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1403 if (DECL_ODR_USED (fn
)
1404 || DECL_EXPLICIT_INSTANTIATION (fn
))
1406 error ("specialization of %qD after instantiation",
1408 return error_mark_node
;
1413 /* This situation should occur only if the first
1414 specialization is an implicit instantiation, the
1415 second is an explicit specialization, and the
1416 implicit instantiation has not yet been used. That
1417 situation can occur if we have implicitly
1418 instantiated a member function and then specialized
1421 We can also wind up here if a friend declaration that
1422 looked like an instantiation turns out to be a
1425 template <class T> void foo(T);
1426 class S { friend void foo<>(int) };
1427 template <> void foo(int);
1429 We transform the existing DECL in place so that any
1430 pointers to it become pointers to the updated
1433 If there was a definition for the template, but not
1434 for the specialization, we want this to look as if
1435 there were no definition, and vice versa. */
1436 DECL_INITIAL (fn
) = NULL_TREE
;
1437 duplicate_decls (spec
, fn
, is_friend
);
1438 /* The call to duplicate_decls will have applied
1441 An explicit specialization of a function template
1442 is inline only if it is explicitly declared to be,
1443 and independently of whether its function template
1446 to the primary function; now copy the inline bits to
1447 the various clones. */
1448 FOR_EACH_CLONE (clone
, fn
)
1450 DECL_DECLARED_INLINE_P (clone
)
1451 = DECL_DECLARED_INLINE_P (fn
);
1452 DECL_SOURCE_LOCATION (clone
)
1453 = DECL_SOURCE_LOCATION (fn
);
1454 DECL_DELETED_FN (clone
)
1455 = DECL_DELETED_FN (fn
);
1457 check_specialization_namespace (tmpl
);
1462 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1464 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1465 /* Dup decl failed, but this is a new definition. Set the
1466 line number so any errors match this new
1468 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1474 return duplicate_decls (spec
, fn
, is_friend
);
1476 /* A specialization must be declared in the same namespace as the
1477 template it is specializing. */
1478 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1479 && !check_specialization_namespace (tmpl
))
1480 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1482 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1484 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1485 gcc_assert (tmpl
&& args
&& spec
);
1488 if (TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1489 && PRIMARY_TEMPLATE_P (tmpl
)
1490 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1491 /* TMPL is a forward declaration of a template function; keep a list
1492 of all specializations in case we need to reassign them to a friend
1493 template later in tsubst_friend_function. */
1494 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1495 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1501 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1502 TMPL and ARGS members, ignores SPEC. */
1504 int comparing_specializations
;
1507 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1511 ++comparing_specializations
;
1512 equal
= (e1
->tmpl
== e2
->tmpl
1513 && comp_template_args (e1
->args
, e2
->args
));
1514 --comparing_specializations
;
1519 /* Returns a hash for a template TMPL and template arguments ARGS. */
1522 hash_tmpl_and_args (tree tmpl
, tree args
)
1524 hashval_t val
= DECL_UID (tmpl
);
1525 return iterative_hash_template_arg (args
, val
);
1528 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1532 spec_hasher::hash (spec_entry
*e
)
1534 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1537 /* Recursively calculate a hash value for a template argument ARG, for use
1538 in the hash tables of template specializations. */
1541 iterative_hash_template_arg (tree arg
, hashval_t val
)
1543 unsigned HOST_WIDE_INT i
;
1544 enum tree_code code
;
1547 if (arg
== NULL_TREE
)
1548 return iterative_hash_object (arg
, val
);
1553 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1554 /* We can get one of these when re-hashing a previous entry in the middle
1555 of substituting into a pack expansion. Just look through it. */
1556 arg
= ARGUMENT_PACK_SELECT_FROM_PACK (arg
);
1558 code
= TREE_CODE (arg
);
1559 tclass
= TREE_CODE_CLASS (code
);
1561 val
= iterative_hash_object (code
, val
);
1568 case IDENTIFIER_NODE
:
1569 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1573 int i
, len
= TREE_VEC_LENGTH (arg
);
1574 for (i
= 0; i
< len
; ++i
)
1575 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1579 case TYPE_PACK_EXPANSION
:
1580 case EXPR_PACK_EXPANSION
:
1581 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1582 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1584 case TYPE_ARGUMENT_PACK
:
1585 case NONTYPE_ARGUMENT_PACK
:
1586 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1589 for (; arg
; arg
= TREE_CHAIN (arg
))
1590 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1594 for (; arg
; arg
= OVL_NEXT (arg
))
1595 val
= iterative_hash_template_arg (OVL_CURRENT (arg
), val
);
1601 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1602 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1604 val
= iterative_hash_template_arg (field
, val
);
1605 val
= iterative_hash_template_arg (value
, val
);
1611 if (!DECL_ARTIFICIAL (arg
))
1613 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1614 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1616 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1619 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1622 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1623 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1625 case TEMPLATE_PARM_INDEX
:
1626 val
= iterative_hash_template_arg
1627 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1628 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1629 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1632 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1633 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1634 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1637 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1639 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1643 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1644 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1645 val
= iterative_hash_object (code
, val
);
1646 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1649 /* A lambda can't appear in a template arg, but don't crash on
1651 gcc_assert (seen_error ());
1655 case IMPLICIT_CONV_EXPR
:
1656 case STATIC_CAST_EXPR
:
1657 case REINTERPRET_CAST_EXPR
:
1658 case CONST_CAST_EXPR
:
1659 case DYNAMIC_CAST_EXPR
:
1661 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1662 /* Now hash operands as usual. */
1672 if (TYPE_CANONICAL (arg
))
1673 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1675 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1676 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1677 /* Otherwise just compare the types during lookup. */
1680 case tcc_declaration
:
1682 return iterative_hash_expr (arg
, val
);
1685 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1687 unsigned n
= cp_tree_operand_length (arg
);
1688 for (i
= 0; i
< n
; ++i
)
1689 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1697 /* Unregister the specialization SPEC as a specialization of TMPL.
1698 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1699 if the SPEC was listed as a specialization of TMPL.
1701 Note that SPEC has been ggc_freed, so we can't look inside it. */
1704 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1709 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1710 elt
.args
= TI_ARGS (tinfo
);
1711 elt
.spec
= NULL_TREE
;
1713 entry
= decl_specializations
->find (&elt
);
1716 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1717 gcc_assert (new_spec
!= NULL_TREE
);
1718 entry
->spec
= new_spec
;
1725 /* Like register_specialization, but for local declarations. We are
1726 registering SPEC, an instantiation of TMPL. */
1729 register_local_specialization (tree spec
, tree tmpl
)
1731 local_specializations
->put (tmpl
, spec
);
1734 /* TYPE is a class type. Returns true if TYPE is an explicitly
1735 specialized class. */
1738 explicit_class_specialization_p (tree type
)
1740 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1742 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1745 /* Print the list of functions at FNS, going through all the overloads
1746 for each element of the list. Alternatively, FNS can not be a
1747 TREE_LIST, in which case it will be printed together with all the
1750 MORE and *STR should respectively be FALSE and NULL when the function
1751 is called from the outside. They are used internally on recursive
1752 calls. print_candidates manages the two parameters and leaves NULL
1753 in *STR when it ends. */
1756 print_candidates_1 (tree fns
, bool more
, const char **str
)
1759 char *spaces
= NULL
;
1761 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
1762 if (TREE_CODE (fn
) == TREE_LIST
)
1764 for (fn2
= fn
; fn2
!= NULL_TREE
; fn2
= TREE_CHAIN (fn2
))
1765 print_candidates_1 (TREE_VALUE (fn2
),
1766 TREE_CHAIN (fn2
) || more
, str
);
1770 tree cand
= OVL_CURRENT (fn
);
1773 /* Pick the prefix string. */
1774 if (!more
&& !OVL_NEXT (fns
))
1776 inform (DECL_SOURCE_LOCATION (cand
),
1777 "candidate is: %#D", cand
);
1781 *str
= _("candidates are:");
1782 spaces
= get_spaces (*str
);
1784 inform (DECL_SOURCE_LOCATION (cand
), "%s %#D", *str
, cand
);
1785 *str
= spaces
? spaces
: *str
;
1795 /* Print the list of candidate FNS in an error message. FNS can also
1796 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1799 print_candidates (tree fns
)
1801 const char *str
= NULL
;
1802 print_candidates_1 (fns
, false, &str
);
1803 gcc_assert (str
== NULL
);
1806 /* Returns the template (one of the functions given by TEMPLATE_ID)
1807 which can be specialized to match the indicated DECL with the
1808 explicit template args given in TEMPLATE_ID. The DECL may be
1809 NULL_TREE if none is available. In that case, the functions in
1810 TEMPLATE_ID are non-members.
1812 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1813 specialization of a member template.
1815 The TEMPLATE_COUNT is the number of references to qualifying
1816 template classes that appeared in the name of the function. See
1817 check_explicit_specialization for a more accurate description.
1819 TSK indicates what kind of template declaration (if any) is being
1820 declared. TSK_TEMPLATE indicates that the declaration given by
1821 DECL, though a FUNCTION_DECL, has template parameters, and is
1822 therefore a template function.
1824 The template args (those explicitly specified and those deduced)
1825 are output in a newly created vector *TARGS_OUT.
1827 If it is impossible to determine the result, an error message is
1828 issued. The error_mark_node is returned to indicate failure. */
1831 determine_specialization (tree template_id
,
1834 int need_member_template
,
1840 tree explicit_targs
;
1841 tree candidates
= NULL_TREE
;
1842 /* A TREE_LIST of templates of which DECL may be a specialization.
1843 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1844 corresponding TREE_PURPOSE is the set of template arguments that,
1845 when used to instantiate the template, would produce a function
1846 with the signature of DECL. */
1847 tree templates
= NULL_TREE
;
1849 cp_binding_level
*b
;
1851 *targs_out
= NULL_TREE
;
1853 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
1854 return error_mark_node
;
1856 /* We shouldn't be specializing a member template of an
1857 unspecialized class template; we already gave an error in
1858 check_specialization_scope, now avoid crashing. */
1859 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
1860 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
1862 gcc_assert (errorcount
);
1863 return error_mark_node
;
1866 fns
= TREE_OPERAND (template_id
, 0);
1867 explicit_targs
= TREE_OPERAND (template_id
, 1);
1869 if (fns
== error_mark_node
)
1870 return error_mark_node
;
1872 /* Check for baselinks. */
1873 if (BASELINK_P (fns
))
1874 fns
= BASELINK_FUNCTIONS (fns
);
1876 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
1878 error ("%qD is not a function template", fns
);
1879 return error_mark_node
;
1881 else if (VAR_P (decl
) && !variable_template_p (fns
))
1883 error ("%qD is not a variable template", fns
);
1884 return error_mark_node
;
1887 /* Count the number of template headers specified for this
1890 for (b
= current_binding_level
;
1891 b
->kind
== sk_template_parms
;
1895 if (variable_template_p (fns
))
1896 templates
= tree_cons (explicit_targs
, fns
, templates
);
1897 else for (; fns
; fns
= OVL_NEXT (fns
))
1899 tree fn
= OVL_CURRENT (fns
);
1901 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1903 tree decl_arg_types
;
1907 /* In case of explicit specialization, we need to check if
1908 the number of template headers appearing in the specialization
1909 is correct. This is usually done in check_explicit_specialization,
1910 but the check done there cannot be exhaustive when specializing
1911 member functions. Consider the following code:
1913 template <> void A<int>::f(int);
1914 template <> template <> void A<int>::f(int);
1916 Assuming that A<int> is not itself an explicit specialization
1917 already, the first line specializes "f" which is a non-template
1918 member function, whilst the second line specializes "f" which
1919 is a template member function. So both lines are syntactically
1920 correct, and check_explicit_specialization does not reject
1923 Here, we can do better, as we are matching the specialization
1924 against the declarations. We count the number of template
1925 headers, and we check if they match TEMPLATE_COUNT + 1
1926 (TEMPLATE_COUNT is the number of qualifying template classes,
1927 plus there must be another header for the member template
1930 Notice that if header_count is zero, this is not a
1931 specialization but rather a template instantiation, so there
1932 is no check we can perform here. */
1933 if (header_count
&& header_count
!= template_count
+ 1)
1936 /* Check that the number of template arguments at the
1937 innermost level for DECL is the same as for FN. */
1938 if (current_binding_level
->kind
== sk_template_parms
1939 && !current_binding_level
->explicit_spec_p
1940 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
1941 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1942 (current_template_parms
))))
1945 /* DECL might be a specialization of FN. */
1946 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1947 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1949 /* For a non-static member function, we need to make sure
1950 that the const qualification is the same. Since
1951 get_bindings does not try to merge the "this" parameter,
1952 we must do the comparison explicitly. */
1953 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1954 && !same_type_p (TREE_VALUE (fn_arg_types
),
1955 TREE_VALUE (decl_arg_types
)))
1958 /* Skip the "this" parameter and, for constructors of
1959 classes with virtual bases, the VTT parameter. A
1960 full specialization of a constructor will have a VTT
1961 parameter, but a template never will. */
1963 = skip_artificial_parms_for (decl
, decl_arg_types
);
1965 = skip_artificial_parms_for (fn
, fn_arg_types
);
1967 /* Function templates cannot be specializations; there are
1968 no partial specializations of functions. Therefore, if
1969 the type of DECL does not match FN, there is no
1971 if (tsk
== tsk_template
)
1973 if (compparms (fn_arg_types
, decl_arg_types
))
1974 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1978 /* See whether this function might be a specialization of this
1979 template. Suppress access control because we might be trying
1980 to make this specialization a friend, and we have already done
1981 access control for the declaration of the specialization. */
1982 push_deferring_access_checks (dk_no_check
);
1983 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
1984 pop_deferring_access_checks ();
1987 /* We cannot deduce template arguments that when used to
1988 specialize TMPL will produce DECL. */
1991 /* Make sure that the deduced arguments actually work. */
1992 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
);
1993 if (insttype
== error_mark_node
)
1996 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
1997 if (!compparms (fn_arg_types
, decl_arg_types
))
2000 /* Save this template, and the arguments deduced. */
2001 templates
= tree_cons (targs
, fn
, templates
);
2003 else if (need_member_template
)
2004 /* FN is an ordinary member function, and we need a
2005 specialization of a member template. */
2007 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2008 /* We can get IDENTIFIER_NODEs here in certain erroneous
2011 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2012 /* This is just an ordinary non-member function. Nothing can
2013 be a specialization of that. */
2015 else if (DECL_ARTIFICIAL (fn
))
2016 /* Cannot specialize functions that are created implicitly. */
2020 tree decl_arg_types
;
2022 /* This is an ordinary member function. However, since
2023 we're here, we can assume its enclosing class is a
2024 template class. For example,
2026 template <typename T> struct S { void f(); };
2027 template <> void S<int>::f() {}
2029 Here, S<int>::f is a non-template, but S<int> is a
2030 template class. If FN has the same type as DECL, we
2031 might be in business. */
2033 if (!DECL_TEMPLATE_INFO (fn
))
2034 /* Its enclosing class is an explicit specialization
2035 of a template class. This is not a candidate. */
2038 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2039 TREE_TYPE (TREE_TYPE (fn
))))
2040 /* The return types differ. */
2043 /* Adjust the type of DECL in case FN is a static member. */
2044 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2045 if (DECL_STATIC_FUNCTION_P (fn
)
2046 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2047 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2049 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2052 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2056 if (templates
&& TREE_CHAIN (templates
))
2062 It is possible for a specialization with a given function
2063 signature to be instantiated from more than one function
2064 template. In such cases, explicit specification of the
2065 template arguments must be used to uniquely identify the
2066 function template specialization being specialized.
2068 Note that here, there's no suggestion that we're supposed to
2069 determine which of the candidate templates is most
2070 specialized. However, we, also have:
2074 Partial ordering of overloaded function template
2075 declarations is used in the following contexts to select
2076 the function template to which a function template
2077 specialization refers:
2079 -- when an explicit specialization refers to a function
2082 So, we do use the partial ordering rules, at least for now.
2083 This extension can only serve to make invalid programs valid,
2084 so it's safe. And, there is strong anecdotal evidence that
2085 the committee intended the partial ordering rules to apply;
2086 the EDG front end has that behavior, and John Spicer claims
2087 that the committee simply forgot to delete the wording in
2088 [temp.expl.spec]. */
2089 tree tmpl
= most_specialized_instantiation (templates
);
2090 if (tmpl
!= error_mark_node
)
2093 TREE_CHAIN (templates
) = NULL_TREE
;
2097 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2099 error ("template-id %qD for %q+D does not match any template "
2100 "declaration", template_id
, decl
);
2101 if (header_count
&& header_count
!= template_count
+ 1)
2102 inform (input_location
, "saw %d %<template<>%>, need %d for "
2103 "specializing a member function template",
2104 header_count
, template_count
+ 1);
2105 return error_mark_node
;
2107 else if ((templates
&& TREE_CHAIN (templates
))
2108 || (candidates
&& TREE_CHAIN (candidates
))
2109 || (templates
&& candidates
))
2111 error ("ambiguous template specialization %qD for %q+D",
2113 candidates
= chainon (candidates
, templates
);
2114 print_candidates (candidates
);
2115 return error_mark_node
;
2118 /* We have one, and exactly one, match. */
2121 tree fn
= TREE_VALUE (candidates
);
2122 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2123 /* DECL is a re-declaration or partial instantiation of a template
2125 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2127 /* It was a specialization of an ordinary member function in a
2129 return DECL_TI_TEMPLATE (fn
);
2132 /* It was a specialization of a template. */
2133 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2134 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2136 *targs_out
= copy_node (targs
);
2137 SET_TMPL_ARGS_LEVEL (*targs_out
,
2138 TMPL_ARGS_DEPTH (*targs_out
),
2139 TREE_PURPOSE (templates
));
2142 *targs_out
= TREE_PURPOSE (templates
);
2143 return TREE_VALUE (templates
);
2146 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2147 but with the default argument values filled in from those in the
2151 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2154 tree new_spec_types
;
2159 if (spec_types
== void_list_node
)
2160 return void_list_node
;
2162 /* Substitute into the rest of the list. */
2164 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2165 TREE_CHAIN (tmpl_types
));
2167 /* Add the default argument for this parameter. */
2168 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2169 TREE_VALUE (spec_types
),
2173 /* DECL is an explicit specialization. Replicate default arguments
2174 from the template it specializes. (That way, code like:
2176 template <class T> void f(T = 3);
2177 template <> void f(double);
2180 works, as required.) An alternative approach would be to look up
2181 the correct default arguments at the call-site, but this approach
2182 is consistent with how implicit instantiations are handled. */
2185 copy_default_args_to_explicit_spec (tree decl
)
2190 tree new_spec_types
;
2194 tree object_type
= NULL_TREE
;
2195 tree in_charge
= NULL_TREE
;
2196 tree vtt
= NULL_TREE
;
2198 /* See if there's anything we need to do. */
2199 tmpl
= DECL_TI_TEMPLATE (decl
);
2200 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2201 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2202 if (TREE_PURPOSE (t
))
2207 old_type
= TREE_TYPE (decl
);
2208 spec_types
= TYPE_ARG_TYPES (old_type
);
2210 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2212 /* Remove the this pointer, but remember the object's type for
2214 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2215 spec_types
= TREE_CHAIN (spec_types
);
2216 tmpl_types
= TREE_CHAIN (tmpl_types
);
2218 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2220 /* DECL may contain more parameters than TMPL due to the extra
2221 in-charge parameter in constructors and destructors. */
2222 in_charge
= spec_types
;
2223 spec_types
= TREE_CHAIN (spec_types
);
2225 if (DECL_HAS_VTT_PARM_P (decl
))
2228 spec_types
= TREE_CHAIN (spec_types
);
2232 /* Compute the merged default arguments. */
2234 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2236 /* Compute the new FUNCTION_TYPE. */
2240 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2245 /* Put the in-charge parameter back. */
2246 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2247 TREE_VALUE (in_charge
),
2250 new_type
= build_method_type_directly (object_type
,
2251 TREE_TYPE (old_type
),
2255 new_type
= build_function_type (TREE_TYPE (old_type
),
2257 new_type
= cp_build_type_attribute_variant (new_type
,
2258 TYPE_ATTRIBUTES (old_type
));
2259 new_type
= build_exception_variant (new_type
,
2260 TYPE_RAISES_EXCEPTIONS (old_type
));
2262 if (TYPE_HAS_LATE_RETURN_TYPE (old_type
))
2263 TYPE_HAS_LATE_RETURN_TYPE (new_type
) = 1;
2265 TREE_TYPE (decl
) = new_type
;
2268 /* Return the number of template headers we expect to see for a definition
2269 or specialization of CTYPE or one of its non-template members. */
2272 num_template_headers_for_class (tree ctype
)
2274 int num_templates
= 0;
2276 while (ctype
&& CLASS_TYPE_P (ctype
))
2278 /* You're supposed to have one `template <...>' for every
2279 template class, but you don't need one for a full
2280 specialization. For example:
2282 template <class T> struct S{};
2283 template <> struct S<int> { void f(); };
2284 void S<int>::f () {}
2286 is correct; there shouldn't be a `template <>' for the
2287 definition of `S<int>::f'. */
2288 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2289 /* If CTYPE does not have template information of any
2290 kind, then it is not a template, nor is it nested
2291 within a template. */
2293 if (explicit_class_specialization_p (ctype
))
2295 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2298 ctype
= TYPE_CONTEXT (ctype
);
2301 return num_templates
;
2304 /* Do a simple sanity check on the template headers that precede the
2305 variable declaration DECL. */
2308 check_template_variable (tree decl
)
2310 tree ctx
= CP_DECL_CONTEXT (decl
);
2311 int wanted
= num_template_headers_for_class (ctx
);
2312 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2313 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2315 if (cxx_dialect
< cxx14
)
2316 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2317 "variable templates only available with "
2318 "-std=c++14 or -std=gnu++14");
2320 // Namespace-scope variable templates should have a template header.
2323 if (template_header_count
> wanted
)
2325 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2326 "too many template headers for %D (should be %d)",
2328 if (warned
&& CLASS_TYPE_P (ctx
)
2329 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2330 inform (DECL_SOURCE_LOCATION (decl
),
2331 "members of an explicitly specialized class are defined "
2332 "without a template header");
2336 /* Check to see if the function just declared, as indicated in
2337 DECLARATOR, and in DECL, is a specialization of a function
2338 template. We may also discover that the declaration is an explicit
2339 instantiation at this point.
2341 Returns DECL, or an equivalent declaration that should be used
2342 instead if all goes well. Issues an error message if something is
2343 amiss. Returns error_mark_node if the error is not easily
2346 FLAGS is a bitmask consisting of the following flags:
2348 2: The function has a definition.
2349 4: The function is a friend.
2351 The TEMPLATE_COUNT is the number of references to qualifying
2352 template classes that appeared in the name of the function. For
2355 template <class T> struct S { void f(); };
2358 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2359 classes are not counted in the TEMPLATE_COUNT, so that in
2361 template <class T> struct S {};
2362 template <> struct S<int> { void f(); }
2363 template <> void S<int>::f();
2365 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2366 invalid; there should be no template <>.)
2368 If the function is a specialization, it is marked as such via
2369 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2370 is set up correctly, and it is added to the list of specializations
2371 for that template. */
2374 check_explicit_specialization (tree declarator
,
2379 int have_def
= flags
& 2;
2380 int is_friend
= flags
& 4;
2381 int specialization
= 0;
2382 int explicit_instantiation
= 0;
2383 int member_specialization
= 0;
2384 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2385 tree dname
= DECL_NAME (decl
);
2390 if (!processing_specialization
)
2393 tsk
= tsk_excessive_parms
;
2396 tsk
= current_tmpl_spec_kind (template_count
);
2401 if (processing_specialization
)
2404 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2406 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2409 /* This could be something like:
2411 template <class T> void f(T);
2412 class S { friend void f<>(int); } */
2416 /* This case handles bogus declarations like template <>
2417 template <class T> void f<int>(); */
2419 error ("template-id %qD in declaration of primary template",
2426 case tsk_invalid_member_spec
:
2427 /* The error has already been reported in
2428 check_specialization_scope. */
2429 return error_mark_node
;
2431 case tsk_invalid_expl_inst
:
2432 error ("template parameter list used in explicit instantiation");
2438 error ("definition provided for explicit instantiation");
2440 explicit_instantiation
= 1;
2443 case tsk_excessive_parms
:
2444 case tsk_insufficient_parms
:
2445 if (tsk
== tsk_excessive_parms
)
2446 error ("too many template parameter lists in declaration of %qD",
2448 else if (template_header_count
)
2449 error("too few template parameter lists in declaration of %qD", decl
);
2451 error("explicit specialization of %qD must be introduced by "
2452 "%<template <>%>", decl
);
2456 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2457 /* In cases like template<> constexpr bool v = true;
2458 We'll give an error in check_template_variable. */
2461 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2463 member_specialization
= 1;
2469 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2471 /* This case handles bogus declarations like template <>
2472 template <class T> void f<int>(); */
2474 if (uses_template_parms (declarator
))
2475 error ("non-type partial specialization %qD "
2476 "is not allowed", declarator
);
2478 error ("template-id %qD in declaration of primary template",
2483 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2484 /* This is a specialization of a member template, without
2485 specialization the containing class. Something like:
2487 template <class T> struct S {
2488 template <class U> void f (U);
2490 template <> template <class U> void S<int>::f(U) {}
2492 That's a specialization -- but of the entire template. */
2500 if ((specialization
|| member_specialization
)
2501 /* This doesn't apply to variable templates. */
2502 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2503 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
2505 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2506 for (; t
; t
= TREE_CHAIN (t
))
2507 if (TREE_PURPOSE (t
))
2509 permerror (input_location
,
2510 "default argument specified in explicit specialization");
2515 if (specialization
|| member_specialization
|| explicit_instantiation
)
2517 tree tmpl
= NULL_TREE
;
2518 tree targs
= NULL_TREE
;
2520 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2521 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2525 gcc_assert (identifier_p (declarator
));
2530 /* If there is no class context, the explicit instantiation
2531 must be at namespace scope. */
2532 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2534 /* Find the namespace binding, using the declaration
2536 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2538 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2540 error ("%qD is not a template function", dname
);
2541 fns
= error_mark_node
;
2545 tree fn
= OVL_CURRENT (fns
);
2546 if (!is_associated_namespace (CP_DECL_CONTEXT (decl
),
2547 CP_DECL_CONTEXT (fn
)))
2548 error ("%qD is not declared in %qD",
2549 decl
, current_namespace
);
2553 declarator
= lookup_template_function (fns
, NULL_TREE
);
2556 if (declarator
== error_mark_node
)
2557 return error_mark_node
;
2559 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2561 if (!explicit_instantiation
)
2562 /* A specialization in class scope. This is invalid,
2563 but the error will already have been flagged by
2564 check_specialization_scope. */
2565 return error_mark_node
;
2568 /* It's not valid to write an explicit instantiation in
2571 class C { template void f(); }
2573 This case is caught by the parser. However, on
2576 template class C { void f(); };
2578 (which is invalid) we can get here. The error will be
2585 else if (ctype
!= NULL_TREE
2586 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2588 // Ignore variable templates.
2592 /* Find the list of functions in ctype that have the same
2593 name as the declared function. */
2594 tree name
= TREE_OPERAND (declarator
, 0);
2595 tree fns
= NULL_TREE
;
2598 if (constructor_name_p (name
, ctype
))
2600 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2602 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2603 : !CLASSTYPE_DESTRUCTORS (ctype
))
2605 /* From [temp.expl.spec]:
2607 If such an explicit specialization for the member
2608 of a class template names an implicitly-declared
2609 special member function (clause _special_), the
2610 program is ill-formed.
2612 Similar language is found in [temp.explicit]. */
2613 error ("specialization of implicitly-declared special member function");
2614 return error_mark_node
;
2617 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2620 if (!DECL_CONV_FN_P (decl
))
2622 idx
= lookup_fnfields_1 (ctype
, name
);
2624 fns
= (*CLASSTYPE_METHOD_VEC (ctype
))[idx
];
2628 vec
<tree
, va_gc
> *methods
;
2631 /* For a type-conversion operator, we cannot do a
2632 name-based lookup. We might be looking for `operator
2633 int' which will be a specialization of `operator T'.
2634 So, we find *all* the conversion operators, and then
2635 select from them. */
2638 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2640 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2641 methods
->iterate (idx
, &ovl
);
2644 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2645 /* There are no more conversion functions. */
2648 /* Glue all these conversion functions together
2649 with those we already have. */
2650 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2651 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2655 if (fns
== NULL_TREE
)
2657 error ("no member function %qD declared in %qT", name
, ctype
);
2658 return error_mark_node
;
2661 TREE_OPERAND (declarator
, 0) = fns
;
2664 /* Figure out what exactly is being specialized at this point.
2665 Note that for an explicit instantiation, even one for a
2666 member function, we cannot tell apriori whether the
2667 instantiation is for a member template, or just a member
2668 function of a template class. Even if a member template is
2669 being instantiated, the member template arguments may be
2670 elided if they can be deduced from the rest of the
2672 tmpl
= determine_specialization (declarator
, decl
,
2674 member_specialization
,
2678 if (!tmpl
|| tmpl
== error_mark_node
)
2679 /* We couldn't figure out what this declaration was
2681 return error_mark_node
;
2684 tree gen_tmpl
= most_general_template (tmpl
);
2686 if (explicit_instantiation
)
2688 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2689 is done by do_decl_instantiation later. */
2691 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2692 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2694 if (arg_depth
> parm_depth
)
2696 /* If TMPL is not the most general template (for
2697 example, if TMPL is a friend template that is
2698 injected into namespace scope), then there will
2699 be too many levels of TARGS. Remove some of them
2704 new_targs
= make_tree_vec (parm_depth
);
2705 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2706 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2707 = TREE_VEC_ELT (targs
, i
);
2711 return instantiate_template (tmpl
, targs
, tf_error
);
2714 /* If we thought that the DECL was a member function, but it
2715 turns out to be specializing a static member function,
2716 make DECL a static member function as well. */
2717 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
2718 && DECL_STATIC_FUNCTION_P (tmpl
)
2719 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2720 revert_static_member_fn (decl
);
2722 /* If this is a specialization of a member template of a
2723 template class, we want to return the TEMPLATE_DECL, not
2724 the specialization of it. */
2725 if (tsk
== tsk_template
)
2727 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
2728 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2729 DECL_INITIAL (result
) = NULL_TREE
;
2733 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2734 DECL_SOURCE_LOCATION (result
)
2735 = DECL_SOURCE_LOCATION (decl
);
2736 /* We want to use the argument list specified in the
2737 definition, not in the original declaration. */
2738 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
2739 for (parm
= DECL_ARGUMENTS (result
); parm
;
2740 parm
= DECL_CHAIN (parm
))
2741 DECL_CONTEXT (parm
) = result
;
2743 return register_specialization (tmpl
, gen_tmpl
, targs
,
2747 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2748 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
2750 /* Inherit default function arguments from the template
2751 DECL is specializing. */
2752 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
2753 copy_default_args_to_explicit_spec (decl
);
2755 /* This specialization has the same protection as the
2756 template it specializes. */
2757 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
2758 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
2760 /* 7.1.1-1 [dcl.stc]
2762 A storage-class-specifier shall not be specified in an
2763 explicit specialization...
2765 The parser rejects these, so unless action is taken here,
2766 explicit function specializations will always appear with
2769 The action recommended by the C++ CWG in response to C++
2770 defect report 605 is to make the storage class and linkage
2771 of the explicit specialization match the templated function:
2773 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2775 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
2777 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
2778 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
2780 /* This specialization has the same linkage and visibility as
2781 the function template it specializes. */
2782 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
2783 if (! TREE_PUBLIC (decl
))
2785 DECL_INTERFACE_KNOWN (decl
) = 1;
2786 DECL_NOT_REALLY_EXTERN (decl
) = 1;
2788 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
2789 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
2791 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
2792 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
2796 /* If DECL is a friend declaration, declared using an
2797 unqualified name, the namespace associated with DECL may
2798 have been set incorrectly. For example, in:
2800 template <typename T> void f(T);
2802 struct S { friend void f<int>(int); }
2805 we will have set the DECL_CONTEXT for the friend
2806 declaration to N, rather than to the global namespace. */
2807 if (DECL_NAMESPACE_SCOPE_P (decl
))
2808 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
2810 if (is_friend
&& !have_def
)
2811 /* This is not really a declaration of a specialization.
2812 It's just the name of an instantiation. But, it's not
2813 a request for an instantiation, either. */
2814 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
2815 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2816 /* A specialization is not necessarily COMDAT. */
2817 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
2818 && DECL_DECLARED_INLINE_P (decl
));
2819 else if (TREE_CODE (decl
) == VAR_DECL
)
2820 DECL_COMDAT (decl
) = false;
2822 /* Register this specialization so that we can find it
2824 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
, 0);
2826 /* A 'structor should already have clones. */
2827 gcc_assert (decl
== error_mark_node
2828 || variable_template_p (tmpl
)
2829 || !(DECL_CONSTRUCTOR_P (decl
)
2830 || DECL_DESTRUCTOR_P (decl
))
2831 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
2838 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2839 parameters. These are represented in the same format used for
2840 DECL_TEMPLATE_PARMS. */
2843 comp_template_parms (const_tree parms1
, const_tree parms2
)
2848 if (parms1
== parms2
)
2851 for (p1
= parms1
, p2
= parms2
;
2852 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2853 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2855 tree t1
= TREE_VALUE (p1
);
2856 tree t2
= TREE_VALUE (p2
);
2859 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2860 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2862 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2865 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2867 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2868 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2870 /* If either of the template parameters are invalid, assume
2871 they match for the sake of error recovery. */
2872 if (error_operand_p (parm1
) || error_operand_p (parm2
))
2875 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2878 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2879 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2880 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2882 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2887 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2888 /* One set of parameters has more parameters lists than the
2895 /* Determine whether PARM is a parameter pack. */
2898 template_parameter_pack_p (const_tree parm
)
2900 /* Determine if we have a non-type template parameter pack. */
2901 if (TREE_CODE (parm
) == PARM_DECL
)
2902 return (DECL_TEMPLATE_PARM_P (parm
)
2903 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2904 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
2905 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
2907 /* If this is a list of template parameters, we could get a
2908 TYPE_DECL or a TEMPLATE_DECL. */
2909 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2910 parm
= TREE_TYPE (parm
);
2912 /* Otherwise it must be a type template parameter. */
2913 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2914 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2915 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2918 /* Determine if T is a function parameter pack. */
2921 function_parameter_pack_p (const_tree t
)
2923 if (t
&& TREE_CODE (t
) == PARM_DECL
)
2924 return DECL_PACK_P (t
);
2928 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2929 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2932 get_function_template_decl (const_tree primary_func_tmpl_inst
)
2934 if (! primary_func_tmpl_inst
2935 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
2936 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
2939 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
2942 /* Return true iff the function parameter PARAM_DECL was expanded
2943 from the function parameter pack PACK. */
2946 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
2948 if (DECL_ARTIFICIAL (param_decl
)
2949 || !function_parameter_pack_p (pack
))
2952 /* The parameter pack and its pack arguments have the same
2954 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
2957 /* Determine whether ARGS describes a variadic template args list,
2958 i.e., one that is terminated by a template argument pack. */
2961 template_args_variadic_p (tree args
)
2966 if (args
== NULL_TREE
)
2969 args
= INNERMOST_TEMPLATE_ARGS (args
);
2970 nargs
= TREE_VEC_LENGTH (args
);
2975 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
2977 return ARGUMENT_PACK_P (last_parm
);
2980 /* Generate a new name for the parameter pack name NAME (an
2981 IDENTIFIER_NODE) that incorporates its */
2984 make_ith_pack_parameter_name (tree name
, int i
)
2986 /* Munge the name to include the parameter index. */
2987 #define NUMBUF_LEN 128
2988 char numbuf
[NUMBUF_LEN
];
2992 if (name
== NULL_TREE
)
2994 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
2995 newname_len
= IDENTIFIER_LENGTH (name
)
2996 + strlen (numbuf
) + 2;
2997 newname
= (char*)alloca (newname_len
);
2998 snprintf (newname
, newname_len
,
2999 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3000 return get_identifier (newname
);
3003 /* Return true if T is a primary function, class or alias template
3007 primary_template_instantiation_p (const_tree t
)
3012 if (TREE_CODE (t
) == FUNCTION_DECL
)
3013 return DECL_LANG_SPECIFIC (t
)
3014 && DECL_TEMPLATE_INSTANTIATION (t
)
3015 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
3016 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3017 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
3018 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
3019 else if (alias_template_specialization_p (t
))
3024 /* Return true if PARM is a template template parameter. */
3027 template_template_parameter_p (const_tree parm
)
3029 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3032 /* Return true iff PARM is a DECL representing a type template
3036 template_type_parameter_p (const_tree parm
)
3039 && (TREE_CODE (parm
) == TYPE_DECL
3040 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3041 && DECL_TEMPLATE_PARM_P (parm
));
3044 /* Return the template parameters of T if T is a
3045 primary template instantiation, NULL otherwise. */
3048 get_primary_template_innermost_parameters (const_tree t
)
3050 tree parms
= NULL
, template_info
= NULL
;
3052 if ((template_info
= get_template_info (t
))
3053 && primary_template_instantiation_p (t
))
3054 parms
= INNERMOST_TEMPLATE_PARMS
3055 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3060 /* Return the template parameters of the LEVELth level from the full list
3061 of template parameters PARMS. */
3064 get_template_parms_at_level (tree parms
, int level
)
3068 || TREE_CODE (parms
) != TREE_LIST
3069 || level
> TMPL_PARMS_DEPTH (parms
))
3072 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3073 if (TMPL_PARMS_DEPTH (p
) == level
)
3079 /* Returns the template arguments of T if T is a template instantiation,
3083 get_template_innermost_arguments (const_tree t
)
3085 tree args
= NULL
, template_info
= NULL
;
3087 if ((template_info
= get_template_info (t
))
3088 && TI_ARGS (template_info
))
3089 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3094 /* Return the argument pack elements of T if T is a template argument pack,
3098 get_template_argument_pack_elems (const_tree t
)
3100 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3101 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3104 return ARGUMENT_PACK_ARGS (t
);
3107 /* Structure used to track the progress of find_parameter_packs_r. */
3108 struct find_parameter_pack_data
3110 /* TREE_LIST that will contain all of the parameter packs found by
3112 tree
* parameter_packs
;
3114 /* Set of AST nodes that have been visited by the traversal. */
3115 hash_set
<tree
> *visited
;
3118 /* Identifies all of the argument packs that occur in a template
3119 argument and appends them to the TREE_LIST inside DATA, which is a
3120 find_parameter_pack_data structure. This is a subroutine of
3121 make_pack_expansion and uses_parameter_packs. */
3123 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3126 struct find_parameter_pack_data
* ppd
=
3127 (struct find_parameter_pack_data
*)data
;
3128 bool parameter_pack_p
= false;
3130 /* Handle type aliases/typedefs. */
3131 if (TYPE_ALIAS_P (t
))
3133 if (TYPE_TEMPLATE_INFO (t
))
3134 cp_walk_tree (&TYPE_TI_ARGS (t
),
3135 &find_parameter_packs_r
,
3141 /* Identify whether this is a parameter pack or not. */
3142 switch (TREE_CODE (t
))
3144 case TEMPLATE_PARM_INDEX
:
3145 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3146 parameter_pack_p
= true;
3149 case TEMPLATE_TYPE_PARM
:
3150 t
= TYPE_MAIN_VARIANT (t
);
3151 case TEMPLATE_TEMPLATE_PARM
:
3152 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3153 parameter_pack_p
= true;
3158 if (DECL_PACK_P (t
))
3160 /* We don't want to walk into the type of a PARM_DECL,
3161 because we don't want to see the type parameter pack. */
3163 parameter_pack_p
= true;
3167 /* Look through a lambda capture proxy to the field pack. */
3169 if (DECL_HAS_VALUE_EXPR_P (t
))
3171 tree v
= DECL_VALUE_EXPR (t
);
3173 &find_parameter_packs_r
,
3180 parameter_pack_p
= true;
3183 /* Not a parameter pack. */
3187 if (parameter_pack_p
)
3189 /* Add this parameter pack to the list. */
3190 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3194 cp_walk_tree (&TYPE_CONTEXT (t
),
3195 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3197 /* This switch statement will return immediately if we don't find a
3199 switch (TREE_CODE (t
))
3201 case TEMPLATE_PARM_INDEX
:
3204 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3205 /* Check the template itself. */
3206 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3207 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3208 /* Check the template arguments. */
3209 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3214 case TEMPLATE_TYPE_PARM
:
3215 case TEMPLATE_TEMPLATE_PARM
:
3222 if (TYPE_PTRMEMFUNC_P (t
))
3228 if (TYPE_TEMPLATE_INFO (t
))
3229 cp_walk_tree (&TYPE_TI_ARGS (t
),
3230 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3237 cp_walk_tree (&TREE_TYPE (t
),
3238 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3242 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3247 case TYPE_PACK_EXPANSION
:
3248 case EXPR_PACK_EXPANSION
:
3253 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3258 case IDENTIFIER_NODE
:
3259 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3271 /* Determines if the expression or type T uses any parameter packs. */
3273 uses_parameter_packs (tree t
)
3275 tree parameter_packs
= NULL_TREE
;
3276 struct find_parameter_pack_data ppd
;
3277 ppd
.parameter_packs
= ¶meter_packs
;
3278 ppd
.visited
= new hash_set
<tree
>;
3279 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3281 return parameter_packs
!= NULL_TREE
;
3284 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3285 representation a base-class initializer into a parameter pack
3286 expansion. If all goes well, the resulting node will be an
3287 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3290 make_pack_expansion (tree arg
)
3293 tree parameter_packs
= NULL_TREE
;
3294 bool for_types
= false;
3295 struct find_parameter_pack_data ppd
;
3297 if (!arg
|| arg
== error_mark_node
)
3300 if (TREE_CODE (arg
) == TREE_LIST
)
3302 /* The only time we will see a TREE_LIST here is for a base
3303 class initializer. In this case, the TREE_PURPOSE will be a
3304 _TYPE node (representing the base class expansion we're
3305 initializing) and the TREE_VALUE will be a TREE_LIST
3306 containing the initialization arguments.
3308 The resulting expansion looks somewhat different from most
3309 expansions. Rather than returning just one _EXPANSION, we
3310 return a TREE_LIST whose TREE_PURPOSE is a
3311 TYPE_PACK_EXPANSION containing the bases that will be
3312 initialized. The TREE_VALUE will be identical to the
3313 original TREE_VALUE, which is a list of arguments that will
3314 be passed to each base. We do not introduce any new pack
3315 expansion nodes into the TREE_VALUE (although it is possible
3316 that some already exist), because the TREE_PURPOSE and
3317 TREE_VALUE all need to be expanded together with the same
3318 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3319 resulting TREE_PURPOSE will mention the parameter packs in
3320 both the bases and the arguments to the bases. */
3323 tree parameter_packs
= NULL_TREE
;
3325 /* Determine which parameter packs will be used by the base
3327 ppd
.visited
= new hash_set
<tree
>;
3328 ppd
.parameter_packs
= ¶meter_packs
;
3329 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3332 if (parameter_packs
== NULL_TREE
)
3334 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3336 return error_mark_node
;
3339 if (TREE_VALUE (arg
) != void_type_node
)
3341 /* Collect the sets of parameter packs used in each of the
3342 initialization arguments. */
3343 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3345 /* Determine which parameter packs will be expanded in this
3347 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3354 /* Create the pack expansion type for the base type. */
3355 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3356 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3357 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3359 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3360 they will rarely be compared to anything. */
3361 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3363 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3366 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3369 /* Build the PACK_EXPANSION_* node. */
3371 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3372 : make_node (EXPR_PACK_EXPANSION
);
3373 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3374 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3376 /* Propagate type and const-expression information. */
3377 TREE_TYPE (result
) = TREE_TYPE (arg
);
3378 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3381 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3382 they will rarely be compared to anything. */
3383 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3385 /* Determine which parameter packs will be expanded. */
3386 ppd
.parameter_packs
= ¶meter_packs
;
3387 ppd
.visited
= new hash_set
<tree
>;
3388 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3391 /* Make sure we found some parameter packs. */
3392 if (parameter_packs
== NULL_TREE
)
3395 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3397 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3398 return error_mark_node
;
3400 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3402 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3407 /* Checks T for any "bare" parameter packs, which have not yet been
3408 expanded, and issues an error if any are found. This operation can
3409 only be done on full expressions or types (e.g., an expression
3410 statement, "if" condition, etc.), because we could have expressions like:
3412 foo(f(g(h(args)))...)
3414 where "args" is a parameter pack. check_for_bare_parameter_packs
3415 should not be called for the subexpressions args, h(args),
3416 g(h(args)), or f(g(h(args))), because we would produce erroneous
3419 Returns TRUE and emits an error if there were bare parameter packs,
3420 returns FALSE otherwise. */
3422 check_for_bare_parameter_packs (tree t
)
3424 tree parameter_packs
= NULL_TREE
;
3425 struct find_parameter_pack_data ppd
;
3427 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3430 if (TREE_CODE (t
) == TYPE_DECL
)
3433 ppd
.parameter_packs
= ¶meter_packs
;
3434 ppd
.visited
= new hash_set
<tree
>;
3435 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3438 if (parameter_packs
)
3440 error ("parameter packs not expanded with %<...%>:");
3441 while (parameter_packs
)
3443 tree pack
= TREE_VALUE (parameter_packs
);
3444 tree name
= NULL_TREE
;
3446 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3447 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3448 name
= TYPE_NAME (pack
);
3449 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3450 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3452 name
= DECL_NAME (pack
);
3455 inform (input_location
, " %qD", name
);
3457 inform (input_location
, " <anonymous>");
3459 parameter_packs
= TREE_CHAIN (parameter_packs
);
3468 /* Expand any parameter packs that occur in the template arguments in
3471 expand_template_argument_pack (tree args
)
3473 tree result_args
= NULL_TREE
;
3474 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3475 int num_result_args
= -1;
3476 int non_default_args_count
= -1;
3478 /* First, determine if we need to expand anything, and the number of
3479 slots we'll need. */
3480 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3482 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3483 if (arg
== NULL_TREE
)
3485 if (ARGUMENT_PACK_P (arg
))
3487 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3488 if (num_result_args
< 0)
3489 num_result_args
= in_arg
+ num_packed
;
3491 num_result_args
+= num_packed
;
3495 if (num_result_args
>= 0)
3500 /* If no expansion is necessary, we're done. */
3501 if (num_result_args
< 0)
3504 /* Expand arguments. */
3505 result_args
= make_tree_vec (num_result_args
);
3506 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3507 non_default_args_count
=
3508 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3509 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3511 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3512 if (ARGUMENT_PACK_P (arg
))
3514 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3515 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3516 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3517 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3518 if (non_default_args_count
> 0)
3519 non_default_args_count
+= num_packed
- 1;
3523 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3527 if (non_default_args_count
>= 0)
3528 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3532 /* Checks if DECL shadows a template parameter.
3534 [temp.local]: A template-parameter shall not be redeclared within its
3535 scope (including nested scopes).
3537 Emits an error and returns TRUE if the DECL shadows a parameter,
3538 returns FALSE otherwise. */
3541 check_template_shadow (tree decl
)
3545 /* If we're not in a template, we can't possibly shadow a template
3547 if (!current_template_parms
)
3550 /* Figure out what we're shadowing. */
3551 if (TREE_CODE (decl
) == OVERLOAD
)
3552 decl
= OVL_CURRENT (decl
);
3553 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3555 /* If there's no previous binding for this name, we're not shadowing
3556 anything, let alone a template parameter. */
3560 /* If we're not shadowing a template parameter, we're done. Note
3561 that OLDDECL might be an OVERLOAD (or perhaps even an
3562 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3564 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3567 /* We check for decl != olddecl to avoid bogus errors for using a
3568 name inside a class. We check TPFI to avoid duplicate errors for
3569 inline member templates. */
3571 || (DECL_TEMPLATE_PARM_P (decl
)
3572 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
3575 /* Don't complain about the injected class name, as we've already
3576 complained about the class itself. */
3577 if (DECL_SELF_REFERENCE_P (decl
))
3580 error ("declaration of %q+#D", decl
);
3581 error (" shadows template parm %q+#D", olddecl
);
3585 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3586 ORIG_LEVEL, DECL, and TYPE. */
3589 build_template_parm_index (int index
,
3595 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3596 TEMPLATE_PARM_IDX (t
) = index
;
3597 TEMPLATE_PARM_LEVEL (t
) = level
;
3598 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3599 TEMPLATE_PARM_DECL (t
) = decl
;
3600 TREE_TYPE (t
) = type
;
3601 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3602 TREE_READONLY (t
) = TREE_READONLY (decl
);
3607 /* Find the canonical type parameter for the given template type
3608 parameter. Returns the canonical type parameter, which may be TYPE
3609 if no such parameter existed. */
3612 canonical_type_parameter (tree type
)
3615 int idx
= TEMPLATE_TYPE_IDX (type
);
3616 if (!canonical_template_parms
)
3617 vec_alloc (canonical_template_parms
, idx
+1);
3619 while (canonical_template_parms
->length () <= (unsigned)idx
)
3620 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3622 list
= (*canonical_template_parms
)[idx
];
3623 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3624 list
= TREE_CHAIN (list
);
3627 return TREE_VALUE (list
);
3630 (*canonical_template_parms
)[idx
]
3631 = tree_cons (NULL_TREE
, type
,
3632 (*canonical_template_parms
)[idx
]);
3637 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3638 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3639 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3640 new one is created. */
3643 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3644 tsubst_flags_t complain
)
3646 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3647 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3648 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3649 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3651 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3654 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3655 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3656 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3657 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3658 DECL_ARTIFICIAL (decl
) = 1;
3659 SET_DECL_TEMPLATE_PARM_P (decl
);
3661 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3662 TEMPLATE_PARM_LEVEL (index
) - levels
,
3663 TEMPLATE_PARM_ORIG_LEVEL (index
),
3665 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3666 TEMPLATE_PARM_PARAMETER_PACK (t
)
3667 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3669 /* Template template parameters need this. */
3670 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3671 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3672 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
)),
3676 return TEMPLATE_PARM_DESCENDANTS (index
);
3679 /* Process information from new template parameter PARM and append it
3680 to the LIST being built. This new parameter is a non-type
3681 parameter iff IS_NON_TYPE is true. This new parameter is a
3682 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3686 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
3687 bool is_non_type
, bool is_parameter_pack
)
3693 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
3694 defval
= TREE_PURPOSE (parm
);
3698 tree p
= tree_last (list
);
3700 if (p
&& TREE_VALUE (p
) != error_mark_node
)
3703 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
3704 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
3706 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
3714 parm
= TREE_VALUE (parm
);
3716 SET_DECL_TEMPLATE_PARM_P (parm
);
3718 if (TREE_TYPE (parm
) != error_mark_node
)
3722 The top-level cv-qualifiers on the template-parameter are
3723 ignored when determining its type. */
3724 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
3725 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
3726 TREE_TYPE (parm
) = error_mark_node
;
3727 else if (uses_parameter_packs (TREE_TYPE (parm
))
3728 && !is_parameter_pack
3729 /* If we're in a nested template parameter list, the template
3730 template parameter could be a parameter pack. */
3731 && processing_template_parmlist
== 1)
3733 /* This template parameter is not a parameter pack, but it
3734 should be. Complain about "bare" parameter packs. */
3735 check_for_bare_parameter_packs (TREE_TYPE (parm
));
3737 /* Recover by calling this a parameter pack. */
3738 is_parameter_pack
= true;
3742 /* A template parameter is not modifiable. */
3743 TREE_CONSTANT (parm
) = 1;
3744 TREE_READONLY (parm
) = 1;
3745 decl
= build_decl (parm_loc
,
3746 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
3747 TREE_CONSTANT (decl
) = 1;
3748 TREE_READONLY (decl
) = 1;
3749 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
3750 = build_template_parm_index (idx
, processing_template_decl
,
3751 processing_template_decl
,
3752 decl
, TREE_TYPE (parm
));
3754 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
3755 = is_parameter_pack
;
3760 parm
= TREE_VALUE (TREE_VALUE (parm
));
3762 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
3764 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
3765 /* This is for distinguishing between real templates and template
3766 template parameters */
3767 TREE_TYPE (parm
) = t
;
3768 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
3773 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
3774 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3775 decl
= build_decl (parm_loc
,
3776 TYPE_DECL
, parm
, t
);
3779 TYPE_NAME (t
) = decl
;
3780 TYPE_STUB_DECL (t
) = decl
;
3782 TEMPLATE_TYPE_PARM_INDEX (t
)
3783 = build_template_parm_index (idx
, processing_template_decl
,
3784 processing_template_decl
,
3785 decl
, TREE_TYPE (parm
));
3786 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
3787 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
3789 DECL_ARTIFICIAL (decl
) = 1;
3790 SET_DECL_TEMPLATE_PARM_P (decl
);
3792 parm
= build_tree_list (defval
, parm
);
3793 return chainon (list
, parm
);
3796 /* The end of a template parameter list has been reached. Process the
3797 tree list into a parameter vector, converting each parameter into a more
3798 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3802 end_template_parm_list (tree parms
)
3806 tree saved_parmlist
= make_tree_vec (list_length (parms
));
3808 current_template_parms
3809 = tree_cons (size_int (processing_template_decl
),
3810 saved_parmlist
, current_template_parms
);
3812 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3814 next
= TREE_CHAIN (parm
);
3815 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3816 TREE_CHAIN (parm
) = NULL_TREE
;
3819 --processing_template_parmlist
;
3821 return saved_parmlist
;
3824 /* end_template_decl is called after a template declaration is seen. */
3827 end_template_decl (void)
3829 reset_specialization ();
3831 if (! processing_template_decl
)
3834 /* This matches the pushlevel in begin_template_parm_list. */
3837 --processing_template_decl
;
3838 current_template_parms
= TREE_CHAIN (current_template_parms
);
3841 /* Takes a TREE_LIST representing a template parameter and convert it
3842 into an argument suitable to be passed to the type substitution
3843 functions. Note that If the TREE_LIST contains an error_mark
3844 node, the returned argument is error_mark_node. */
3847 template_parm_to_arg (tree t
)
3851 || TREE_CODE (t
) != TREE_LIST
)
3854 if (error_operand_p (TREE_VALUE (t
)))
3855 return error_mark_node
;
3859 if (TREE_CODE (t
) == TYPE_DECL
3860 || TREE_CODE (t
) == TEMPLATE_DECL
)
3864 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3866 /* Turn this argument into a TYPE_ARGUMENT_PACK
3867 with a single element, which expands T. */
3868 tree vec
= make_tree_vec (1);
3869 #ifdef ENABLE_CHECKING
3870 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3871 (vec
, TREE_VEC_LENGTH (vec
));
3873 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3875 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
3876 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3881 t
= DECL_INITIAL (t
);
3883 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3885 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3886 with a single element, which expands T. */
3887 tree vec
= make_tree_vec (1);
3888 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3889 #ifdef ENABLE_CHECKING
3890 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3891 (vec
, TREE_VEC_LENGTH (vec
));
3893 t
= convert_from_reference (t
);
3894 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3896 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3897 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3898 TREE_TYPE (t
) = type
;
3901 t
= convert_from_reference (t
);
3906 /* Given a set of template parameters, return them as a set of template
3907 arguments. The template parameters are represented as a TREE_VEC, in
3908 the form documented in cp-tree.h for template arguments. */
3911 template_parms_to_args (tree parms
)
3914 tree args
= NULL_TREE
;
3915 int length
= TMPL_PARMS_DEPTH (parms
);
3918 /* If there is only one level of template parameters, we do not
3919 create a TREE_VEC of TREE_VECs. Instead, we return a single
3920 TREE_VEC containing the arguments. */
3922 args
= make_tree_vec (length
);
3924 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
3926 tree a
= copy_node (TREE_VALUE (header
));
3929 TREE_TYPE (a
) = NULL_TREE
;
3930 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
3931 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
3933 #ifdef ENABLE_CHECKING
3934 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
3938 TREE_VEC_ELT (args
, --l
) = a
;
3943 if (length
> 1 && TREE_VEC_ELT (args
, 0) == NULL_TREE
)
3944 /* This can happen for template parms of a template template
3947 template<template<class T, class U> class TT> struct S;
3949 Consider the level of the parms of TT; T and U both have
3950 level 2; TT has no template parm of level 1. So in this case
3951 the first element of full_template_args is NULL_TREE. If we
3952 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
3953 of 2. This will make tsubst wrongly consider that T and U
3954 have level 1. Instead, let's create a dummy vector as the
3955 first element of full_template_args so that TMPL_ARGS_DEPTH
3956 returns the correct depth for args. */
3957 TREE_VEC_ELT (args
, 0) = make_tree_vec (1);
3961 /* Within the declaration of a template, return the currently active
3962 template parameters as an argument TREE_VEC. */
3965 current_template_args (void)
3967 return template_parms_to_args (current_template_parms
);
3970 /* Update the declared TYPE by doing any lookups which were thought to be
3971 dependent, but are not now that we know the SCOPE of the declarator. */
3974 maybe_update_decl_type (tree orig_type
, tree scope
)
3976 tree type
= orig_type
;
3978 if (type
== NULL_TREE
)
3981 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3982 type
= TREE_TYPE (type
);
3984 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
3985 && dependent_type_p (type
)
3986 /* Don't bother building up the args in this case. */
3987 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
3989 /* tsubst in the args corresponding to the template parameters,
3990 including auto if present. Most things will be unchanged, but
3991 make_typename_type and tsubst_qualified_id will resolve
3992 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3993 tree args
= current_template_args ();
3994 tree auto_node
= type_uses_auto (type
);
3998 tree auto_vec
= make_tree_vec (1);
3999 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4000 args
= add_to_template_args (args
, auto_vec
);
4002 pushed
= push_scope (scope
);
4003 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4008 if (type
== error_mark_node
)
4011 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4013 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4016 type
= TYPE_NAME (type
);
4021 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4022 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
4023 a member template. Used by push_template_decl below. */
4026 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4028 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4029 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4030 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4031 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4032 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4037 struct template_parm_data
4039 /* The level of the template parameters we are currently
4043 /* The index of the specialization argument we are currently
4047 /* An array whose size is the number of template parameters. The
4048 elements are nonzero if the parameter has been used in any one
4049 of the arguments processed so far. */
4052 /* An array whose size is the number of template arguments. The
4053 elements are nonzero if the argument makes use of template
4054 parameters of this level. */
4055 int* arg_uses_template_parms
;
4058 /* Subroutine of push_template_decl used to see if each template
4059 parameter in a partial specialization is used in the explicit
4060 argument list. If T is of the LEVEL given in DATA (which is
4061 treated as a template_parm_data*), then DATA->PARMS is marked
4065 mark_template_parm (tree t
, void* data
)
4069 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4071 template_parm_level_and_index (t
, &level
, &idx
);
4073 if (level
== tpd
->level
)
4075 tpd
->parms
[idx
] = 1;
4076 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4079 /* Return zero so that for_each_template_parm will continue the
4080 traversal of the tree; we want to mark *every* template parm. */
4084 /* Process the partial specialization DECL. */
4087 process_partial_specialization (tree decl
)
4089 tree type
= TREE_TYPE (decl
);
4090 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
4091 tree specargs
= CLASSTYPE_TI_ARGS (type
);
4092 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4093 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4096 int nargs
= TREE_VEC_LENGTH (inner_args
);
4099 bool did_error_intro
= false;
4100 struct template_parm_data tpd
;
4101 struct template_parm_data tpd2
;
4103 gcc_assert (current_template_parms
);
4105 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4106 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4108 /* We check that each of the template parameters given in the
4109 partial specialization is used in the argument list to the
4110 specialization. For example:
4112 template <class T> struct S;
4113 template <class T> struct S<T*>;
4115 The second declaration is OK because `T*' uses the template
4116 parameter T, whereas
4118 template <class T> struct S<int>;
4120 is no good. Even trickier is:
4131 The S2<T> declaration is actually invalid; it is a
4132 full-specialization. Of course,
4135 struct S2<T (*)(U)>;
4137 or some such would have been OK. */
4138 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4139 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4140 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4142 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4143 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4144 for (i
= 0; i
< nargs
; ++i
)
4146 tpd
.current_arg
= i
;
4147 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4148 &mark_template_parm
,
4151 /*include_nondeduced_p=*/false);
4153 for (i
= 0; i
< ntparms
; ++i
)
4154 if (tpd
.parms
[i
] == 0)
4156 /* One of the template parms was not used in a deduced context in the
4158 if (!did_error_intro
)
4160 error ("template parameters not deducible in "
4161 "partial specialization:");
4162 did_error_intro
= true;
4165 inform (input_location
, " %qD",
4166 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4169 if (did_error_intro
)
4170 return error_mark_node
;
4172 /* [temp.class.spec]
4174 The argument list of the specialization shall not be identical to
4175 the implicit argument list of the primary template. */
4176 if (comp_template_args
4178 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
4180 error ("partial specialization %qT does not specialize any template arguments", type
);
4182 /* A partial specialization that replaces multiple parameters of the
4183 primary template with a pack expansion is less specialized for those
4185 if (nargs
< DECL_NTPARMS (maintmpl
))
4187 error ("partial specialization is not more specialized than the "
4188 "primary template because it replaces multiple parameters "
4189 "with a pack expansion");
4190 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4194 /* [temp.class.spec]
4196 A partially specialized non-type argument expression shall not
4197 involve template parameters of the partial specialization except
4198 when the argument expression is a simple identifier.
4200 The type of a template parameter corresponding to a specialized
4201 non-type argument shall not be dependent on a parameter of the
4204 Also, we verify that pack expansions only occur at the
4205 end of the argument list. */
4206 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4208 for (i
= 0; i
< nargs
; ++i
)
4210 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4211 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4212 tree packed_args
= NULL_TREE
;
4215 if (ARGUMENT_PACK_P (arg
))
4217 /* Extract the arguments from the argument pack. We'll be
4218 iterating over these in the following loop. */
4219 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4220 len
= TREE_VEC_LENGTH (packed_args
);
4223 for (j
= 0; j
< len
; j
++)
4226 /* Get the Jth argument in the parameter pack. */
4227 arg
= TREE_VEC_ELT (packed_args
, j
);
4229 if (PACK_EXPANSION_P (arg
))
4231 /* Pack expansions must come at the end of the
4233 if ((packed_args
&& j
< len
- 1)
4234 || (!packed_args
&& i
< nargs
- 1))
4236 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4237 error ("parameter pack argument %qE must be at the "
4238 "end of the template argument list", arg
);
4240 error ("parameter pack argument %qT must be at the "
4241 "end of the template argument list", arg
);
4245 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4246 /* We only care about the pattern. */
4247 arg
= PACK_EXPANSION_PATTERN (arg
);
4249 if (/* These first two lines are the `non-type' bit. */
4251 && TREE_CODE (arg
) != TEMPLATE_DECL
4252 /* This next two lines are the `argument expression is not just a
4253 simple identifier' condition and also the `specialized
4254 non-type argument' bit. */
4255 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4256 && !(REFERENCE_REF_P (arg
)
4257 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4259 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4260 || (packed_args
&& uses_template_parms (arg
)))
4261 error ("template argument %qE involves template parameter(s)",
4265 /* Look at the corresponding template parameter,
4266 marking which template parameters its type depends
4268 tree type
= TREE_TYPE (parm
);
4272 /* We haven't yet initialized TPD2. Do so now. */
4273 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4274 /* The number of parameters here is the number in the
4275 main template, which, as checked in the assertion
4277 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4279 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4282 /* Mark the template parameters. But this time, we're
4283 looking for the template parameters of the main
4284 template, not in the specialization. */
4285 tpd2
.current_arg
= i
;
4286 tpd2
.arg_uses_template_parms
[i
] = 0;
4287 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4288 for_each_template_parm (type
,
4289 &mark_template_parm
,
4292 /*include_nondeduced_p=*/false);
4294 if (tpd2
.arg_uses_template_parms
[i
])
4296 /* The type depended on some template parameters.
4297 If they are fully specialized in the
4298 specialization, that's OK. */
4301 for (j
= 0; j
< nargs
; ++j
)
4302 if (tpd2
.parms
[j
] != 0
4303 && tpd
.arg_uses_template_parms
[j
])
4306 error_n (input_location
, count
,
4307 "type %qT of template argument %qE depends "
4308 "on a template parameter",
4309 "type %qT of template argument %qE depends "
4310 "on template parameters",
4319 /* We should only get here once. */
4320 gcc_assert (!COMPLETE_TYPE_P (type
));
4322 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4323 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4324 TREE_TYPE (tmpl
) = type
;
4325 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4326 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4327 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4328 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4330 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4331 = tree_cons (specargs
, tmpl
,
4332 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4333 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4335 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4336 inst
= TREE_CHAIN (inst
))
4338 tree inst_type
= TREE_VALUE (inst
);
4339 if (COMPLETE_TYPE_P (inst_type
)
4340 && CLASSTYPE_IMPLICIT_INSTANTIATION (inst_type
))
4342 tree spec
= most_specialized_class (inst_type
, tf_none
);
4343 if (spec
&& TREE_TYPE (spec
) == type
)
4344 permerror (input_location
,
4345 "partial specialization of %qT after instantiation "
4346 "of %qT", type
, inst_type
);
4353 /* PARM is a template parameter of some form; return the corresponding
4354 TEMPLATE_PARM_INDEX. */
4357 get_template_parm_index (tree parm
)
4359 if (TREE_CODE (parm
) == PARM_DECL
4360 || TREE_CODE (parm
) == CONST_DECL
)
4361 parm
= DECL_INITIAL (parm
);
4362 else if (TREE_CODE (parm
) == TYPE_DECL
4363 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4364 parm
= TREE_TYPE (parm
);
4365 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4366 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4367 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4368 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4372 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4373 parameter packs used by the template parameter PARM. */
4376 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4378 /* A type parm can't refer to another parm. */
4379 if (TREE_CODE (parm
) == TYPE_DECL
)
4381 else if (TREE_CODE (parm
) == PARM_DECL
)
4383 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4388 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4390 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4391 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4392 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4395 /* PARM is a template parameter pack. Return any parameter packs used in
4396 its type or the type of any of its template parameters. If there are
4397 any such packs, it will be instantiated into a fixed template parameter
4398 list by partial instantiation rather than be fully deduced. */
4401 fixed_parameter_pack_p (tree parm
)
4403 /* This can only be true in a member template. */
4404 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4406 /* This can only be true for a parameter pack. */
4407 if (!template_parameter_pack_p (parm
))
4409 /* A type parm can't refer to another parm. */
4410 if (TREE_CODE (parm
) == TYPE_DECL
)
4413 tree parameter_packs
= NULL_TREE
;
4414 struct find_parameter_pack_data ppd
;
4415 ppd
.parameter_packs
= ¶meter_packs
;
4416 ppd
.visited
= new hash_set
<tree
>;
4418 fixed_parameter_pack_p_1 (parm
, &ppd
);
4421 return parameter_packs
;
4424 /* Check that a template declaration's use of default arguments and
4425 parameter packs is not invalid. Here, PARMS are the template
4426 parameters. IS_PRIMARY is true if DECL is the thing declared by
4427 a primary template. IS_PARTIAL is true if DECL is a partial
4430 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4431 declaration (but not a definition); 1 indicates a declaration, 2
4432 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4433 emitted for extraneous default arguments.
4435 Returns TRUE if there were no errors found, FALSE otherwise. */
4438 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4439 bool is_partial
, int is_friend_decl
)
4442 int last_level_to_check
;
4444 bool no_errors
= true;
4448 A default template-argument shall not be specified in a
4449 function template declaration or a function template definition, nor
4450 in the template-parameter-list of the definition of a member of a
4453 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
4454 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
4455 /* You can't have a function template declaration in a local
4456 scope, nor you can you define a member of a class template in a
4460 if ((TREE_CODE (decl
) == TYPE_DECL
4462 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4463 || (TREE_CODE (decl
) == FUNCTION_DECL
4464 && LAMBDA_FUNCTION_P (decl
)))
4465 /* A lambda doesn't have an explicit declaration; don't complain
4466 about the parms of the enclosing class. */
4469 if (current_class_type
4470 && !TYPE_BEING_DEFINED (current_class_type
)
4471 && DECL_LANG_SPECIFIC (decl
)
4472 && DECL_DECLARES_FUNCTION_P (decl
)
4473 /* If this is either a friend defined in the scope of the class
4474 or a member function. */
4475 && (DECL_FUNCTION_MEMBER_P (decl
)
4476 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4477 : DECL_FRIEND_CONTEXT (decl
)
4478 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4480 /* And, if it was a member function, it really was defined in
4481 the scope of the class. */
4482 && (!DECL_FUNCTION_MEMBER_P (decl
)
4483 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4484 /* We already checked these parameters when the template was
4485 declared, so there's no need to do it again now. This function
4486 was defined in class scope, but we're processing its body now
4487 that the class is complete. */
4490 /* Core issue 226 (C++0x only): the following only applies to class
4493 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4497 If a template-parameter has a default template-argument, all
4498 subsequent template-parameters shall have a default
4499 template-argument supplied. */
4500 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4502 tree inner_parms
= TREE_VALUE (parm_level
);
4503 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4504 int seen_def_arg_p
= 0;
4507 for (i
= 0; i
< ntparms
; ++i
)
4509 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4511 if (parm
== error_mark_node
)
4514 if (TREE_PURPOSE (parm
))
4516 else if (seen_def_arg_p
4517 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4519 error ("no default argument for %qD", TREE_VALUE (parm
));
4520 /* For better subsequent error-recovery, we indicate that
4521 there should have been a default argument. */
4522 TREE_PURPOSE (parm
) = error_mark_node
;
4525 else if (!is_partial
4527 /* Don't complain about an enclosing partial
4529 && parm_level
== parms
4530 && TREE_CODE (decl
) == TYPE_DECL
4532 && template_parameter_pack_p (TREE_VALUE (parm
))
4533 /* A fixed parameter pack will be partially
4534 instantiated into a fixed length list. */
4535 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4537 /* A primary class template can only have one
4538 parameter pack, at the end of the template
4541 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
4542 error ("parameter pack %qE must be at the end of the"
4543 " template parameter list", TREE_VALUE (parm
));
4545 error ("parameter pack %qT must be at the end of the"
4546 " template parameter list",
4547 TREE_TYPE (TREE_VALUE (parm
)));
4549 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4557 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4561 /* For an ordinary class template, default template arguments are
4562 allowed at the innermost level, e.g.:
4563 template <class T = int>
4565 but, in a partial specialization, they're not allowed even
4566 there, as we have in [temp.class.spec]:
4568 The template parameter list of a specialization shall not
4569 contain default template argument values.
4571 So, for a partial specialization, or for a function template
4572 (in C++98/C++03), we look at all of them. */
4575 /* But, for a primary class template that is not a partial
4576 specialization we look at all template parameters except the
4578 parms
= TREE_CHAIN (parms
);
4580 /* Figure out what error message to issue. */
4581 if (is_friend_decl
== 2)
4582 msg
= G_("default template arguments may not be used in function template "
4583 "friend re-declaration");
4584 else if (is_friend_decl
)
4585 msg
= G_("default template arguments may not be used in function template "
4586 "friend declarations");
4587 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4588 msg
= G_("default template arguments may not be used in function templates "
4589 "without -std=c++11 or -std=gnu++11");
4590 else if (is_partial
)
4591 msg
= G_("default template arguments may not be used in "
4592 "partial specializations");
4594 msg
= G_("default argument for template parameter for class enclosing %qD");
4596 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4597 /* If we're inside a class definition, there's no need to
4598 examine the parameters to the class itself. On the one
4599 hand, they will be checked when the class is defined, and,
4600 on the other, default arguments are valid in things like:
4601 template <class T = double>
4602 struct S { template <class U> void f(U); };
4603 Here the default argument for `S' has no bearing on the
4604 declaration of `f'. */
4605 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4607 /* Check everything. */
4608 last_level_to_check
= 0;
4610 for (parm_level
= parms
;
4611 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4612 parm_level
= TREE_CHAIN (parm_level
))
4614 tree inner_parms
= TREE_VALUE (parm_level
);
4618 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4619 for (i
= 0; i
< ntparms
; ++i
)
4621 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4624 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4629 if (is_friend_decl
== 2)
4636 /* Clear out the default argument so that we are not
4638 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
4642 /* At this point, if we're still interested in issuing messages,
4643 they must apply to classes surrounding the object declared. */
4645 msg
= G_("default argument for template parameter for class "
4652 /* Worker for push_template_decl_real, called via
4653 for_each_template_parm. DATA is really an int, indicating the
4654 level of the parameters we are interested in. If T is a template
4655 parameter of that level, return nonzero. */
4658 template_parm_this_level_p (tree t
, void* data
)
4660 int this_level
= *(int *)data
;
4663 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4664 level
= TEMPLATE_PARM_LEVEL (t
);
4666 level
= TEMPLATE_TYPE_LEVEL (t
);
4667 return level
== this_level
;
4670 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4671 parameters given by current_template_args, or reuses a
4672 previously existing one, if appropriate. Returns the DECL, or an
4673 equivalent one, if it is replaced via a call to duplicate_decls.
4675 If IS_FRIEND is true, DECL is a friend declaration. */
4678 push_template_decl_real (tree decl
, bool is_friend
)
4686 int new_template_p
= 0;
4687 /* True if the template is a member template, in the sense of
4689 bool member_template_p
= false;
4691 if (decl
== error_mark_node
|| !current_template_parms
)
4692 return error_mark_node
;
4694 /* See if this is a partial specialization. */
4695 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
4696 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
4697 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
4699 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
4703 /* For a friend, we want the context of the friend function, not
4704 the type of which it is a friend. */
4705 ctx
= CP_DECL_CONTEXT (decl
);
4706 else if (CP_DECL_CONTEXT (decl
)
4707 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4708 /* In the case of a virtual function, we want the class in which
4710 ctx
= CP_DECL_CONTEXT (decl
);
4712 /* Otherwise, if we're currently defining some class, the DECL
4713 is assumed to be a member of the class. */
4714 ctx
= current_scope ();
4716 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
4719 if (!DECL_CONTEXT (decl
))
4720 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
4722 /* See if this is a primary template. */
4723 if (is_friend
&& ctx
4724 && uses_template_parms_level (ctx
, processing_template_decl
))
4725 /* A friend template that specifies a class context, i.e.
4726 template <typename T> friend void A<T>::f();
4729 else if (TREE_CODE (decl
) == TYPE_DECL
4730 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4733 is_primary
= template_parm_scope_p ();
4737 if (DECL_CLASS_SCOPE_P (decl
))
4738 member_template_p
= true;
4739 if (TREE_CODE (decl
) == TYPE_DECL
4740 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
4742 error ("template class without a name");
4743 return error_mark_node
;
4745 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
4747 if (member_template_p
)
4749 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
4750 error ("member template %qD may not have virt-specifiers", decl
);
4752 if (DECL_DESTRUCTOR_P (decl
))
4756 A destructor shall not be a member template. */
4757 error ("destructor %qD declared as member template", decl
);
4758 return error_mark_node
;
4760 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
4761 && (!prototype_p (TREE_TYPE (decl
))
4762 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
4763 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
4764 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
4765 == void_list_node
)))
4767 /* [basic.stc.dynamic.allocation]
4769 An allocation function can be a function
4770 template. ... Template allocation functions shall
4771 have two or more parameters. */
4772 error ("invalid template declaration of %qD", decl
);
4773 return error_mark_node
;
4776 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4777 && CLASS_TYPE_P (TREE_TYPE (decl
)))
4779 else if (TREE_CODE (decl
) == TYPE_DECL
4780 && TYPE_DECL_ALIAS_P (decl
))
4781 /* alias-declaration */
4782 gcc_assert (!DECL_ARTIFICIAL (decl
));
4783 else if (VAR_P (decl
))
4784 /* C++14 variable template. */;
4787 error ("template declaration of %q#D", decl
);
4788 return error_mark_node
;
4792 /* Check to see that the rules regarding the use of default
4793 arguments are not being violated. */
4794 check_default_tmpl_args (decl
, current_template_parms
,
4795 is_primary
, is_partial
, /*is_friend_decl=*/0);
4797 /* Ensure that there are no parameter packs in the type of this
4798 declaration that have not been expanded. */
4799 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4801 /* Check each of the arguments individually to see if there are
4802 any bare parameter packs. */
4803 tree type
= TREE_TYPE (decl
);
4804 tree arg
= DECL_ARGUMENTS (decl
);
4805 tree argtype
= TYPE_ARG_TYPES (type
);
4807 while (arg
&& argtype
)
4809 if (!DECL_PACK_P (arg
)
4810 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
4812 /* This is a PARM_DECL that contains unexpanded parameter
4813 packs. We have already complained about this in the
4814 check_for_bare_parameter_packs call, so just replace
4815 these types with ERROR_MARK_NODE. */
4816 TREE_TYPE (arg
) = error_mark_node
;
4817 TREE_VALUE (argtype
) = error_mark_node
;
4820 arg
= DECL_CHAIN (arg
);
4821 argtype
= TREE_CHAIN (argtype
);
4824 /* Check for bare parameter packs in the return type and the
4825 exception specifiers. */
4826 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
4827 /* Errors were already issued, set return type to int
4828 as the frontend doesn't expect error_mark_node as
4830 TREE_TYPE (type
) = integer_type_node
;
4831 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
4832 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
4834 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
4835 && TYPE_DECL_ALIAS_P (decl
))
4836 ? DECL_ORIGINAL_TYPE (decl
)
4837 : TREE_TYPE (decl
)))
4839 TREE_TYPE (decl
) = error_mark_node
;
4840 return error_mark_node
;
4844 return process_partial_specialization (decl
);
4846 args
= current_template_args ();
4849 || TREE_CODE (ctx
) == FUNCTION_DECL
4850 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
4851 || (TREE_CODE (decl
) == TYPE_DECL
4852 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4853 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
4855 if (DECL_LANG_SPECIFIC (decl
)
4856 && DECL_TEMPLATE_INFO (decl
)
4857 && DECL_TI_TEMPLATE (decl
))
4858 tmpl
= DECL_TI_TEMPLATE (decl
);
4859 /* If DECL is a TYPE_DECL for a class-template, then there won't
4860 be DECL_LANG_SPECIFIC. The information equivalent to
4861 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4862 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4863 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
4864 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
4866 /* Since a template declaration already existed for this
4867 class-type, we must be redeclaring it here. Make sure
4868 that the redeclaration is valid. */
4869 redeclare_class_template (TREE_TYPE (decl
),
4870 current_template_parms
);
4871 /* We don't need to create a new TEMPLATE_DECL; just use the
4872 one we already had. */
4873 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
4877 tmpl
= build_template_decl (decl
, current_template_parms
,
4881 if (DECL_LANG_SPECIFIC (decl
)
4882 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4884 /* A specialization of a member template of a template
4886 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4887 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
4888 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
4894 tree a
, t
, current
, parms
;
4896 tree tinfo
= get_template_info (decl
);
4900 error ("template definition of non-template %q#D", decl
);
4901 return error_mark_node
;
4904 tmpl
= TI_TEMPLATE (tinfo
);
4906 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
4907 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
4908 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4909 && DECL_MEMBER_TEMPLATE_P (tmpl
))
4913 /* The declaration is a specialization of a member
4914 template, declared outside the class. Therefore, the
4915 innermost template arguments will be NULL, so we
4916 replace them with the arguments determined by the
4917 earlier call to check_explicit_specialization. */
4918 args
= DECL_TI_ARGS (decl
);
4921 = build_template_decl (decl
, current_template_parms
,
4923 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
4924 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
4925 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
4926 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
4927 DECL_TEMPLATE_INFO (new_tmpl
)
4928 = build_template_info (tmpl
, args
);
4930 register_specialization (new_tmpl
,
4931 most_general_template (tmpl
),
4937 /* Make sure the template headers we got make sense. */
4939 parms
= DECL_TEMPLATE_PARMS (tmpl
);
4940 i
= TMPL_PARMS_DEPTH (parms
);
4941 if (TMPL_ARGS_DEPTH (args
) != i
)
4943 error ("expected %d levels of template parms for %q#D, got %d",
4944 i
, decl
, TMPL_ARGS_DEPTH (args
));
4945 DECL_INTERFACE_KNOWN (decl
) = 1;
4946 return error_mark_node
;
4949 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
4951 a
= TMPL_ARGS_LEVEL (args
, i
);
4952 t
= INNERMOST_TEMPLATE_PARMS (parms
);
4954 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
4956 if (current
== decl
)
4957 error ("got %d template parameters for %q#D",
4958 TREE_VEC_LENGTH (a
), decl
);
4960 error ("got %d template parameters for %q#T",
4961 TREE_VEC_LENGTH (a
), current
);
4962 error (" but %d required", TREE_VEC_LENGTH (t
));
4963 /* Avoid crash in import_export_decl. */
4964 DECL_INTERFACE_KNOWN (decl
) = 1;
4965 return error_mark_node
;
4968 if (current
== decl
)
4970 else if (current
== NULL_TREE
)
4971 /* Can happen in erroneous input. */
4974 current
= get_containing_scope (current
);
4977 /* Check that the parms are used in the appropriate qualifying scopes
4978 in the declarator. */
4979 if (!comp_template_args
4981 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
4984 template arguments to %qD do not match original template %qD",
4985 decl
, DECL_TEMPLATE_RESULT (tmpl
));
4986 if (!uses_template_parms (TI_ARGS (tinfo
)))
4987 inform (input_location
, "use template<> for an explicit specialization");
4988 /* Avoid crash in import_export_decl. */
4989 DECL_INTERFACE_KNOWN (decl
) = 1;
4990 return error_mark_node
;
4994 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4995 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
4997 /* Push template declarations for global functions and types. Note
4998 that we do not try to push a global template friend declared in a
4999 template class; such a thing may well depend on the template
5000 parameters of the class. */
5001 if (new_template_p
&& !ctx
5002 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5004 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5005 if (tmpl
== error_mark_node
)
5006 return error_mark_node
;
5008 /* Hide template friend classes that haven't been declared yet. */
5009 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5011 DECL_ANTICIPATED (tmpl
) = 1;
5012 DECL_FRIEND_P (tmpl
) = 1;
5018 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5021 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5022 if (DECL_CONV_FN_P (tmpl
))
5024 int depth
= TMPL_PARMS_DEPTH (parms
);
5026 /* It is a conversion operator. See if the type converted to
5027 depends on innermost template operands. */
5029 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
5031 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
5034 /* Give template template parms a DECL_CONTEXT of the template
5035 for which they are a parameter. */
5036 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5037 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5039 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5040 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5041 DECL_CONTEXT (parm
) = tmpl
;
5045 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5046 back to its most general template. If TMPL is a specialization,
5047 ARGS may only have the innermost set of arguments. Add the missing
5048 argument levels if necessary. */
5049 if (DECL_TEMPLATE_INFO (tmpl
))
5050 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5052 info
= build_template_info (tmpl
, args
);
5054 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5055 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5058 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5059 retrofit_lang_decl (decl
);
5060 if (DECL_LANG_SPECIFIC (decl
))
5061 DECL_TEMPLATE_INFO (decl
) = info
;
5064 if (flag_implicit_templates
5066 && TREE_PUBLIC (decl
)
5067 && VAR_OR_FUNCTION_DECL_P (decl
))
5068 /* Set DECL_COMDAT on template instantiations; if we force
5069 them to be emitted by explicit instantiation or -frepo,
5070 mark_needed will tell cgraph to do the right thing. */
5071 DECL_COMDAT (decl
) = true;
5073 return DECL_TEMPLATE_RESULT (tmpl
);
5077 push_template_decl (tree decl
)
5079 return push_template_decl_real (decl
, false);
5082 /* FN is an inheriting constructor that inherits from the constructor
5083 template INHERITED; turn FN into a constructor template with a matching
5087 add_inherited_template_parms (tree fn
, tree inherited
)
5090 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5091 inner_parms
= copy_node (inner_parms
);
5093 = tree_cons (size_int (processing_template_decl
+ 1),
5094 inner_parms
, current_template_parms
);
5095 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5096 tree args
= template_parms_to_args (parms
);
5097 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5098 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5099 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5100 DECL_ARTIFICIAL (tmpl
) = true;
5101 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5105 /* Called when a class template TYPE is redeclared with the indicated
5106 template PARMS, e.g.:
5108 template <class T> struct S;
5109 template <class T> struct S {}; */
5112 redeclare_class_template (tree type
, tree parms
)
5118 if (!TYPE_TEMPLATE_INFO (type
))
5120 error ("%qT is not a template type", type
);
5124 tmpl
= TYPE_TI_TEMPLATE (type
);
5125 if (!PRIMARY_TEMPLATE_P (tmpl
))
5126 /* The type is nested in some template class. Nothing to worry
5127 about here; there are no new template parameters for the nested
5133 error ("template specifiers not specified in declaration of %qD",
5138 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5139 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5141 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5143 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5144 "redeclared with %d template parameter",
5145 "redeclared with %d template parameters",
5146 TREE_VEC_LENGTH (parms
));
5147 inform_n (input_location
, TREE_VEC_LENGTH (tmpl_parms
),
5148 "previous declaration %q+D used %d template parameter",
5149 "previous declaration %q+D used %d template parameters",
5150 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5154 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5161 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5162 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5165 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5166 if (error_operand_p (tmpl_parm
))
5169 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5170 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5171 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5173 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5175 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5176 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5177 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5178 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5179 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5180 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5181 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5182 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5183 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5185 error ("template parameter %q+#D", tmpl_parm
);
5186 error ("redeclared here as %q#D", parm
);
5190 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5192 /* We have in [temp.param]:
5194 A template-parameter may not be given default arguments
5195 by two different declarations in the same scope. */
5196 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5197 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5198 "original definition appeared here");
5202 if (parm_default
!= NULL_TREE
)
5203 /* Update the previous template parameters (which are the ones
5204 that will really count) with the new default value. */
5205 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5206 else if (tmpl_default
!= NULL_TREE
)
5207 /* Update the new parameters, too; they'll be used as the
5208 parameters for any members. */
5209 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5215 /* Simplify EXPR if it is a non-dependent expression. Returns the
5216 (possibly simplified) expression. */
5219 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5221 if (expr
== NULL_TREE
)
5224 /* If we're in a template, but EXPR isn't value dependent, simplify
5225 it. We're supposed to treat:
5227 template <typename T> void f(T[1 + 1]);
5228 template <typename T> void f(T[2]);
5230 as two declarations of the same function, for example. */
5231 if (processing_template_decl
5232 && !instantiation_dependent_expression_p (expr
)
5233 && potential_constant_expression (expr
))
5235 HOST_WIDE_INT saved_processing_template_decl
;
5237 saved_processing_template_decl
= processing_template_decl
;
5238 processing_template_decl
= 0;
5239 expr
= tsubst_copy_and_build (expr
,
5242 /*in_decl=*/NULL_TREE
,
5243 /*function_p=*/false,
5244 /*integral_constant_expression_p=*/true);
5245 processing_template_decl
= saved_processing_template_decl
;
5251 instantiate_non_dependent_expr (tree expr
)
5253 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
5256 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5257 template declaration, or a TYPE_DECL for an alias declaration. */
5260 alias_type_or_template_p (tree t
)
5264 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5267 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5268 || DECL_ALIAS_TEMPLATE_P (t
));
5271 /* Return TRUE iff T is a specialization of an alias template. */
5274 alias_template_specialization_p (const_tree t
)
5280 && TYPE_TEMPLATE_INFO (t
)
5281 && PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (t
))
5282 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (t
)));
5285 /* Return TRUE iff T is a specialization of an alias template with
5286 dependent template-arguments. */
5289 dependent_alias_template_spec_p (const_tree t
)
5291 return (alias_template_specialization_p (t
)
5292 && any_dependent_template_arguments_p (TYPE_TI_ARGS (t
)));
5295 /* Return the number of innermost template parameters in TMPL. */
5298 num_innermost_template_parms (tree tmpl
)
5300 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5301 return TREE_VEC_LENGTH (parms
);
5304 /* Return either TMPL or another template that it is equivalent to under DR
5305 1286: An alias that just changes the name of a template is equivalent to
5306 the other template. */
5309 get_underlying_template (tree tmpl
)
5311 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5312 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5314 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5315 if (TYPE_TEMPLATE_INFO (result
))
5317 tree sub
= TYPE_TI_TEMPLATE (result
);
5318 if (PRIMARY_TEMPLATE_P (sub
)
5319 && (num_innermost_template_parms (tmpl
)
5320 == num_innermost_template_parms (sub
)))
5322 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5323 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5324 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5326 /* The alias type is equivalent to the pattern of the
5327 underlying template, so strip the alias. */
5337 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5338 must be a function or a pointer-to-function type, as specified
5339 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5340 and check that the resulting function has external linkage. */
5343 convert_nontype_argument_function (tree type
, tree expr
,
5344 tsubst_flags_t complain
)
5348 linkage_kind linkage
;
5350 fn
= instantiate_type (type
, fns
, tf_none
);
5351 if (fn
== error_mark_node
)
5352 return error_mark_node
;
5355 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5356 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5357 if (BASELINK_P (fn_no_ptr
))
5358 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5360 /* [temp.arg.nontype]/1
5362 A template-argument for a non-type, non-template template-parameter
5365 -- the address of an object or function with external [C++11: or
5366 internal] linkage. */
5368 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5370 if (complain
& tf_error
)
5372 error ("%qE is not a valid template argument for type %qT",
5374 if (TYPE_PTR_P (type
))
5375 error ("it must be the address of a function with "
5376 "external linkage");
5378 error ("it must be the name of a function with "
5379 "external linkage");
5384 linkage
= decl_linkage (fn_no_ptr
);
5385 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5387 if (complain
& tf_error
)
5389 if (cxx_dialect
>= cxx11
)
5390 error ("%qE is not a valid template argument for type %qT "
5391 "because %qD has no linkage",
5392 expr
, type
, fn_no_ptr
);
5394 error ("%qE is not a valid template argument for type %qT "
5395 "because %qD does not have external linkage",
5396 expr
, type
, fn_no_ptr
);
5404 /* Subroutine of convert_nontype_argument.
5405 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5406 Emit an error otherwise. */
5409 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5410 tsubst_flags_t complain
)
5413 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5415 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5417 if (processing_template_decl
5418 && TREE_CODE (expr
) == ADDR_EXPR
5419 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
5421 if (complain
& tf_error
)
5423 error ("%qE is not a valid template argument for type %qT",
5425 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5430 /* Returns TRUE iff the address of OP is value-dependent.
5432 14.6.2.4 [temp.dep.temp]:
5433 A non-integral non-type template-argument is dependent if its type is
5434 dependent or it has either of the following forms
5437 and contains a nested-name-specifier which specifies a class-name that
5438 names a dependent type.
5440 We generalize this to just say that the address of a member of a
5441 dependent class is value-dependent; the above doesn't cover the
5442 address of a static data member named with an unqualified-id. */
5445 has_value_dependent_address (tree op
)
5447 /* We could use get_inner_reference here, but there's no need;
5448 this is only relevant for template non-type arguments, which
5449 can only be expressed as &id-expression. */
5452 tree ctx
= CP_DECL_CONTEXT (op
);
5453 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5460 /* The next set of functions are used for providing helpful explanatory
5461 diagnostics for failed overload resolution. Their messages should be
5462 indented by two spaces for consistency with the messages in
5466 unify_success (bool /*explain_p*/)
5472 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5475 inform (input_location
,
5476 " couldn't deduce template parameter %qD", parm
);
5481 unify_invalid (bool /*explain_p*/)
5487 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5490 inform (input_location
,
5491 " types %qT and %qT have incompatible cv-qualifiers",
5497 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5500 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5505 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5508 inform (input_location
,
5509 " template parameter %qD is not a parameter pack, but "
5516 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5519 inform (input_location
,
5520 " template argument %qE does not match "
5521 "pointer-to-member constant %qE",
5527 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5530 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5535 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5538 inform (input_location
,
5539 " inconsistent parameter pack deduction with %qT and %qT",
5545 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5550 inform (input_location
,
5551 " deduced conflicting types for parameter %qT (%qT and %qT)",
5552 parm
, first
, second
);
5554 inform (input_location
,
5555 " deduced conflicting values for non-type parameter "
5556 "%qE (%qE and %qE)", parm
, first
, second
);
5562 unify_vla_arg (bool explain_p
, tree arg
)
5565 inform (input_location
,
5566 " variable-sized array type %qT is not "
5567 "a valid template argument",
5573 unify_method_type_error (bool explain_p
, tree arg
)
5576 inform (input_location
,
5577 " member function type %qT is not a valid template argument",
5583 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
5588 inform_n (input_location
, wanted
,
5589 " candidate expects at least %d argument, %d provided",
5590 " candidate expects at least %d arguments, %d provided",
5593 inform_n (input_location
, wanted
,
5594 " candidate expects %d argument, %d provided",
5595 " candidate expects %d arguments, %d provided",
5602 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5604 return unify_arity (explain_p
, have
, wanted
);
5608 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
5609 bool least_p
= false)
5611 return unify_arity (explain_p
, have
, wanted
, least_p
);
5615 unify_arg_conversion (bool explain_p
, tree to_type
,
5616 tree from_type
, tree arg
)
5619 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5620 " cannot convert %qE (type %qT) to type %qT",
5621 arg
, from_type
, to_type
);
5626 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5627 tree parm
, tree arg
)
5632 case tbr_ambiguous_baseclass
:
5633 inform (input_location
, " %qT is an ambiguous base class of %qT",
5637 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5644 unify_inconsistent_template_template_parameters (bool explain_p
)
5647 inform (input_location
,
5648 " template parameters of a template template argument are "
5649 "inconsistent with other deduced template arguments");
5654 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5657 inform (input_location
,
5658 " can't deduce a template for %qT from non-template type %qT",
5664 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5667 inform (input_location
,
5668 " template argument %qE does not match %qD", arg
, parm
);
5673 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5676 inform (input_location
,
5677 " could not resolve address from overloaded function %qE",
5682 /* Attempt to convert the non-type template parameter EXPR to the
5683 indicated TYPE. If the conversion is successful, return the
5684 converted value. If the conversion is unsuccessful, return
5685 NULL_TREE if we issued an error message, or error_mark_node if we
5686 did not. We issue error messages for out-and-out bad template
5687 parameters, but not simply because the conversion failed, since we
5688 might be just trying to do argument deduction. Both TYPE and EXPR
5689 must be non-dependent.
5691 The conversion follows the special rules described in
5692 [temp.arg.nontype], and it is much more strict than an implicit
5695 This function is called twice for each template argument (see
5696 lookup_template_class for a more accurate description of this
5697 problem). This means that we need to handle expressions which
5698 are not valid in a C++ source, but can be created from the
5699 first call (for instance, casts to perform conversions). These
5700 hacks can go away after we fix the double coercion problem. */
5703 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5707 /* Detect immediately string literals as invalid non-type argument.
5708 This special-case is not needed for correctness (we would easily
5709 catch this later), but only to provide better diagnostic for this
5710 common user mistake. As suggested by DR 100, we do not mention
5711 linkage issues in the diagnostic as this is not the point. */
5712 /* FIXME we're making this OK. */
5713 if (TREE_CODE (expr
) == STRING_CST
)
5715 if (complain
& tf_error
)
5716 error ("%qE is not a valid template argument for type %qT "
5717 "because string literals can never be used in this context",
5722 /* Add the ADDR_EXPR now for the benefit of
5723 value_dependent_expression_p. */
5724 if (TYPE_PTROBV_P (type
)
5725 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5727 expr
= decay_conversion (expr
, complain
);
5728 if (expr
== error_mark_node
)
5729 return error_mark_node
;
5732 /* If we are in a template, EXPR may be non-dependent, but still
5733 have a syntactic, rather than semantic, form. For example, EXPR
5734 might be a SCOPE_REF, rather than the VAR_DECL to which the
5735 SCOPE_REF refers. Preserving the qualifying scope is necessary
5736 so that access checking can be performed when the template is
5737 instantiated -- but here we need the resolved form so that we can
5738 convert the argument. */
5739 if (TYPE_REF_OBJ_P (type
)
5740 && has_value_dependent_address (expr
))
5741 /* If we want the address and it's value-dependent, don't fold. */;
5742 else if (!type_unknown_p (expr
))
5743 expr
= instantiate_non_dependent_expr_sfinae (expr
, complain
);
5744 if (error_operand_p (expr
))
5745 return error_mark_node
;
5746 expr_type
= TREE_TYPE (expr
);
5747 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5748 expr
= mark_lvalue_use (expr
);
5750 expr
= mark_rvalue_use (expr
);
5752 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5753 to a non-type argument of "nullptr". */
5754 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5755 expr
= convert (type
, expr
);
5757 /* In C++11, integral or enumeration non-type template arguments can be
5758 arbitrary constant expressions. Pointer and pointer to
5759 member arguments can be general constant expressions that evaluate
5760 to a null value, but otherwise still need to be of a specific form. */
5761 if (cxx_dialect
>= cxx11
)
5763 if (TREE_CODE (expr
) == PTRMEM_CST
)
5764 /* A PTRMEM_CST is already constant, and a valid template
5765 argument for a parameter of pointer to member type, we just want
5766 to leave it in that form rather than lower it to a
5768 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5769 expr
= maybe_constant_value (expr
);
5770 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5772 tree folded
= maybe_constant_value (expr
);
5773 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5774 : null_member_pointer_value_p (folded
))
5779 /* HACK: Due to double coercion, we can get a
5780 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5781 which is the tree that we built on the first call (see
5782 below when coercing to reference to object or to reference to
5783 function). We just strip everything and get to the arg.
5784 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5786 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5788 tree probe_type
, probe
= expr
;
5789 if (REFERENCE_REF_P (probe
))
5790 probe
= TREE_OPERAND (probe
, 0);
5791 probe_type
= TREE_TYPE (probe
);
5792 if (TREE_CODE (probe
) == NOP_EXPR
)
5794 /* ??? Maybe we could use convert_from_reference here, but we
5795 would need to relax its constraints because the NOP_EXPR
5796 could actually change the type to something more cv-qualified,
5797 and this is not folded by convert_from_reference. */
5798 tree addr
= TREE_OPERAND (probe
, 0);
5799 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5800 && TREE_CODE (addr
) == ADDR_EXPR
5801 && TYPE_PTR_P (TREE_TYPE (addr
))
5802 && (same_type_ignoring_top_level_qualifiers_p
5803 (TREE_TYPE (probe_type
),
5804 TREE_TYPE (TREE_TYPE (addr
)))))
5806 expr
= TREE_OPERAND (addr
, 0);
5807 expr_type
= TREE_TYPE (probe_type
);
5812 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5813 parameter is a pointer to object, through decay and
5814 qualification conversion. Let's strip everything. */
5815 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5819 if (TREE_CODE (probe
) == ADDR_EXPR
5820 && TYPE_PTR_P (TREE_TYPE (probe
)))
5822 /* Skip the ADDR_EXPR only if it is part of the decay for
5823 an array. Otherwise, it is part of the original argument
5824 in the source code. */
5825 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5826 probe
= TREE_OPERAND (probe
, 0);
5828 expr_type
= TREE_TYPE (expr
);
5832 /* [temp.arg.nontype]/5, bullet 1
5834 For a non-type template-parameter of integral or enumeration type,
5835 integral promotions (_conv.prom_) and integral conversions
5836 (_conv.integral_) are applied. */
5837 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5839 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5840 t
= maybe_constant_value (t
);
5841 if (t
!= error_mark_node
)
5844 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5845 return error_mark_node
;
5847 /* Notice that there are constant expressions like '4 % 0' which
5848 do not fold into integer constants. */
5849 if (TREE_CODE (expr
) != INTEGER_CST
)
5851 if (complain
& tf_error
)
5853 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
5854 if (processing_template_decl
5855 && !require_potential_constant_expression (expr
))
5857 expr
= cxx_constant_value (expr
);
5858 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
5859 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
5860 "in template argument for type %qT ", type
);
5861 if (expr
== error_mark_node
)
5863 /* else cxx_constant_value complained but gave us
5864 a real constant, so go ahead. */
5865 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
5871 /* Avoid typedef problems. */
5872 if (TREE_TYPE (expr
) != type
)
5873 expr
= fold_convert (type
, expr
);
5875 /* [temp.arg.nontype]/5, bullet 2
5877 For a non-type template-parameter of type pointer to object,
5878 qualification conversions (_conv.qual_) and the array-to-pointer
5879 conversion (_conv.array_) are applied. */
5880 else if (TYPE_PTROBV_P (type
))
5882 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5884 A template-argument for a non-type, non-template template-parameter
5885 shall be one of: [...]
5887 -- the name of a non-type template-parameter;
5888 -- the address of an object or function with external linkage, [...]
5889 expressed as "& id-expression" where the & is optional if the name
5890 refers to a function or array, or if the corresponding
5891 template-parameter is a reference.
5893 Here, we do not care about functions, as they are invalid anyway
5894 for a parameter of type pointer-to-object. */
5896 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
5897 /* Non-type template parameters are OK. */
5899 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5900 /* Null pointer values are OK in C++11. */;
5901 else if (TREE_CODE (expr
) != ADDR_EXPR
5902 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
5906 if (complain
& tf_error
)
5907 error ("%qD is not a valid template argument "
5908 "because %qD is a variable, not the address of "
5909 "a variable", expr
, expr
);
5912 if (POINTER_TYPE_P (expr_type
))
5914 if (complain
& tf_error
)
5915 error ("%qE is not a valid template argument for %qT "
5916 "because it is not the address of a variable",
5920 /* Other values, like integer constants, might be valid
5921 non-type arguments of some other type. */
5922 return error_mark_node
;
5928 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
5929 ? TREE_OPERAND (expr
, 0) : expr
);
5932 if (complain
& tf_error
)
5933 error ("%qE is not a valid template argument of type %qT "
5934 "because %qE is not a variable", expr
, type
, decl
);
5937 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
5939 if (complain
& tf_error
)
5940 error ("%qE is not a valid template argument of type %qT "
5941 "because %qD does not have external linkage",
5945 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
5947 if (complain
& tf_error
)
5948 error ("%qE is not a valid template argument of type %qT "
5949 "because %qD has no linkage", expr
, type
, decl
);
5954 expr
= decay_conversion (expr
, complain
);
5955 if (expr
== error_mark_node
)
5956 return error_mark_node
;
5958 expr
= perform_qualification_conversions (type
, expr
);
5959 if (expr
== error_mark_node
)
5960 return error_mark_node
;
5962 /* [temp.arg.nontype]/5, bullet 3
5964 For a non-type template-parameter of type reference to object, no
5965 conversions apply. The type referred to by the reference may be more
5966 cv-qualified than the (otherwise identical) type of the
5967 template-argument. The template-parameter is bound directly to the
5968 template-argument, which must be an lvalue. */
5969 else if (TYPE_REF_OBJ_P (type
))
5971 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
5973 return error_mark_node
;
5975 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
5977 if (complain
& tf_error
)
5978 error ("%qE is not a valid template argument for type %qT "
5979 "because of conflicts in cv-qualification", expr
, type
);
5983 if (!real_lvalue_p (expr
))
5985 if (complain
& tf_error
)
5986 error ("%qE is not a valid template argument for type %qT "
5987 "because it is not an lvalue", expr
, type
);
5991 /* [temp.arg.nontype]/1
5993 A template-argument for a non-type, non-template template-parameter
5994 shall be one of: [...]
5996 -- the address of an object or function with external linkage. */
5997 if (INDIRECT_REF_P (expr
)
5998 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
6000 expr
= TREE_OPERAND (expr
, 0);
6003 if (complain
& tf_error
)
6004 error ("%q#D is not a valid template argument for type %qT "
6005 "because a reference variable does not have a constant "
6006 "address", expr
, type
);
6013 if (complain
& tf_error
)
6014 error ("%qE is not a valid template argument for type %qT "
6015 "because it is not an object with external linkage",
6020 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
6022 if (complain
& tf_error
)
6023 error ("%qE is not a valid template argument for type %qT "
6024 "because object %qD has not external linkage",
6029 expr
= build_nop (type
, build_address (expr
));
6031 /* [temp.arg.nontype]/5, bullet 4
6033 For a non-type template-parameter of type pointer to function, only
6034 the function-to-pointer conversion (_conv.func_) is applied. If the
6035 template-argument represents a set of overloaded functions (or a
6036 pointer to such), the matching function is selected from the set
6038 else if (TYPE_PTRFN_P (type
))
6040 /* If the argument is a template-id, we might not have enough
6041 context information to decay the pointer. */
6042 if (!type_unknown_p (expr_type
))
6044 expr
= decay_conversion (expr
, complain
);
6045 if (expr
== error_mark_node
)
6046 return error_mark_node
;
6049 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6050 /* Null pointer values are OK in C++11. */
6051 return perform_qualification_conversions (type
, expr
);
6053 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6054 if (!expr
|| expr
== error_mark_node
)
6057 /* [temp.arg.nontype]/5, bullet 5
6059 For a non-type template-parameter of type reference to function, no
6060 conversions apply. If the template-argument represents a set of
6061 overloaded functions, the matching function is selected from the set
6063 else if (TYPE_REFFN_P (type
))
6065 if (TREE_CODE (expr
) == ADDR_EXPR
)
6067 if (complain
& tf_error
)
6069 error ("%qE is not a valid template argument for type %qT "
6070 "because it is a pointer", expr
, type
);
6071 inform (input_location
, "try using %qE instead",
6072 TREE_OPERAND (expr
, 0));
6077 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6078 if (!expr
|| expr
== error_mark_node
)
6081 expr
= build_nop (type
, build_address (expr
));
6083 /* [temp.arg.nontype]/5, bullet 6
6085 For a non-type template-parameter of type pointer to member function,
6086 no conversions apply. If the template-argument represents a set of
6087 overloaded member functions, the matching member function is selected
6088 from the set (_over.over_). */
6089 else if (TYPE_PTRMEMFUNC_P (type
))
6091 expr
= instantiate_type (type
, expr
, tf_none
);
6092 if (expr
== error_mark_node
)
6093 return error_mark_node
;
6095 /* [temp.arg.nontype] bullet 1 says the pointer to member
6096 expression must be a pointer-to-member constant. */
6097 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6098 return error_mark_node
;
6100 /* There is no way to disable standard conversions in
6101 resolve_address_of_overloaded_function (called by
6102 instantiate_type). It is possible that the call succeeded by
6103 converting &B::I to &D::I (where B is a base of D), so we need
6104 to reject this conversion here.
6106 Actually, even if there was a way to disable standard conversions,
6107 it would still be better to reject them here so that we can
6108 provide a superior diagnostic. */
6109 if (!same_type_p (TREE_TYPE (expr
), type
))
6111 if (complain
& tf_error
)
6113 error ("%qE is not a valid template argument for type %qT "
6114 "because it is of type %qT", expr
, type
,
6116 /* If we are just one standard conversion off, explain. */
6117 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6118 inform (input_location
,
6119 "standard conversions are not allowed in this context");
6124 /* [temp.arg.nontype]/5, bullet 7
6126 For a non-type template-parameter of type pointer to data member,
6127 qualification conversions (_conv.qual_) are applied. */
6128 else if (TYPE_PTRDATAMEM_P (type
))
6130 /* [temp.arg.nontype] bullet 1 says the pointer to member
6131 expression must be a pointer-to-member constant. */
6132 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6133 return error_mark_node
;
6135 expr
= perform_qualification_conversions (type
, expr
);
6136 if (expr
== error_mark_node
)
6139 else if (NULLPTR_TYPE_P (type
))
6141 if (expr
!= nullptr_node
)
6143 if (complain
& tf_error
)
6144 error ("%qE is not a valid template argument for type %qT "
6145 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6150 /* A template non-type parameter must be one of the above. */
6154 /* Sanity check: did we actually convert the argument to the
6156 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6157 (type
, TREE_TYPE (expr
)));
6161 /* Subroutine of coerce_template_template_parms, which returns 1 if
6162 PARM_PARM and ARG_PARM match using the rule for the template
6163 parameters of template template parameters. Both PARM and ARG are
6164 template parameters; the rest of the arguments are the same as for
6165 coerce_template_template_parms.
6168 coerce_template_template_parm (tree parm
,
6170 tsubst_flags_t complain
,
6174 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6175 || parm
== NULL_TREE
|| error_operand_p (parm
))
6178 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6181 switch (TREE_CODE (parm
))
6184 /* We encounter instantiations of templates like
6185 template <template <template <class> class> class TT>
6188 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6189 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6191 if (!coerce_template_template_parms
6192 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6198 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6199 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6200 /* Argument is a parameter pack but parameter is not. */
6205 /* The tsubst call is used to handle cases such as
6207 template <int> class C {};
6208 template <class T, template <T> class TT> class D {};
6211 i.e. the parameter list of TT depends on earlier parameters. */
6212 if (!uses_template_parms (TREE_TYPE (arg
))
6214 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6218 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6219 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6220 /* Argument is a parameter pack but parameter is not. */
6233 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6234 template template parameters. Both PARM_PARMS and ARG_PARMS are
6235 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6238 Consider the example:
6239 template <class T> class A;
6240 template<template <class U> class TT> class B;
6242 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6243 the parameters to A, and OUTER_ARGS contains A. */
6246 coerce_template_template_parms (tree parm_parms
,
6248 tsubst_flags_t complain
,
6252 int nparms
, nargs
, i
;
6256 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6257 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6259 nparms
= TREE_VEC_LENGTH (parm_parms
);
6260 nargs
= TREE_VEC_LENGTH (arg_parms
);
6262 /* Determine whether we have a parameter pack at the end of the
6263 template template parameter's template parameter list. */
6264 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6266 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6268 if (error_operand_p (parm
))
6271 switch (TREE_CODE (parm
))
6275 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6280 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6290 && !(variadic_p
&& nargs
>= nparms
- 1))
6293 /* Check all of the template parameters except the parameter pack at
6294 the end (if any). */
6295 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6297 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6298 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6301 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6302 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6304 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6312 /* Check each of the template parameters in the template
6313 argument against the template parameter pack at the end of
6314 the template template parameter. */
6315 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6318 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6320 for (; i
< nargs
; ++i
)
6322 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6325 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6327 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6336 /* Verifies that the deduced template arguments (in TARGS) for the
6337 template template parameters (in TPARMS) represent valid bindings,
6338 by comparing the template parameter list of each template argument
6339 to the template parameter list of its corresponding template
6340 template parameter, in accordance with DR150. This
6341 routine can only be called after all template arguments have been
6342 deduced. It will return TRUE if all of the template template
6343 parameter bindings are okay, FALSE otherwise. */
6345 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6347 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6350 /* We're dealing with template parms in this process. */
6351 ++processing_template_decl
;
6353 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6355 for (i
= 0; i
< ntparms
; ++i
)
6357 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6358 tree targ
= TREE_VEC_ELT (targs
, i
);
6360 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6362 tree packed_args
= NULL_TREE
;
6365 if (ARGUMENT_PACK_P (targ
))
6367 /* Look inside the argument pack. */
6368 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6369 len
= TREE_VEC_LENGTH (packed_args
);
6372 for (idx
= 0; idx
< len
; ++idx
)
6374 tree targ_parms
= NULL_TREE
;
6377 /* Extract the next argument from the argument
6379 targ
= TREE_VEC_ELT (packed_args
, idx
);
6381 if (PACK_EXPANSION_P (targ
))
6382 /* Look at the pattern of the pack expansion. */
6383 targ
= PACK_EXPANSION_PATTERN (targ
);
6385 /* Extract the template parameters from the template
6387 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6388 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6389 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6390 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6392 /* Verify that we can coerce the template template
6393 parameters from the template argument to the template
6394 parameter. This requires an exact match. */
6396 && !coerce_template_template_parms
6397 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6412 --processing_template_decl
;
6416 /* Since type attributes aren't mangled, we need to strip them from
6417 template type arguments. */
6420 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6423 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6425 mv
= TYPE_MAIN_VARIANT (arg
);
6426 arg
= strip_typedefs (arg
);
6427 if (TYPE_ALIGN (arg
) != TYPE_ALIGN (mv
)
6428 || TYPE_ATTRIBUTES (arg
) != TYPE_ATTRIBUTES (mv
))
6430 if (complain
& tf_warning
)
6431 warning (0, "ignoring attributes on template argument %qT", arg
);
6432 arg
= build_aligned_type (arg
, TYPE_ALIGN (mv
));
6433 arg
= cp_build_type_attribute_variant (arg
, TYPE_ATTRIBUTES (mv
));
6438 /* Convert the indicated template ARG as necessary to match the
6439 indicated template PARM. Returns the converted ARG, or
6440 error_mark_node if the conversion was unsuccessful. Error and
6441 warning messages are issued under control of COMPLAIN. This
6442 conversion is for the Ith parameter in the parameter list. ARGS is
6443 the full set of template arguments deduced so far. */
6446 convert_template_argument (tree parm
,
6449 tsubst_flags_t complain
,
6455 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6457 if (TREE_CODE (arg
) == TREE_LIST
6458 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6460 /* The template argument was the name of some
6461 member function. That's usually
6462 invalid, but static members are OK. In any
6463 case, grab the underlying fields/functions
6464 and issue an error later if required. */
6465 orig_arg
= TREE_VALUE (arg
);
6466 TREE_TYPE (arg
) = unknown_type_node
;
6471 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6472 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6473 || requires_tmpl_type
);
6475 /* When determining whether an argument pack expansion is a template,
6476 look at the pattern. */
6477 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6478 arg
= PACK_EXPANSION_PATTERN (arg
);
6480 /* Deal with an injected-class-name used as a template template arg. */
6481 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6483 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6484 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6486 if (cxx_dialect
>= cxx11
)
6487 /* OK under DR 1004. */;
6488 else if (complain
& tf_warning_or_error
)
6489 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6490 " used as template template argument", TYPE_NAME (arg
));
6491 else if (flag_pedantic_errors
)
6499 ((TREE_CODE (arg
) == TEMPLATE_DECL
6500 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6501 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6502 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6503 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6506 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6507 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6508 arg
= TYPE_STUB_DECL (arg
);
6510 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6512 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6513 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6515 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6517 if (complain
& tf_error
)
6518 error ("invalid use of destructor %qE as a type", orig_arg
);
6519 return error_mark_node
;
6522 permerror (input_location
,
6523 "to refer to a type member of a template parameter, "
6524 "use %<typename %E%>", orig_arg
);
6526 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6527 TREE_OPERAND (arg
, 1),
6533 if (is_type
!= requires_type
)
6537 if (complain
& tf_error
)
6539 error ("type/value mismatch at argument %d in template "
6540 "parameter list for %qD",
6543 inform (input_location
,
6544 " expected a constant of type %qT, got %qT",
6546 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6547 else if (requires_tmpl_type
)
6548 inform (input_location
,
6549 " expected a class template, got %qE", orig_arg
);
6551 inform (input_location
,
6552 " expected a type, got %qE", orig_arg
);
6555 return error_mark_node
;
6557 if (is_tmpl_type
^ requires_tmpl_type
)
6559 if (in_decl
&& (complain
& tf_error
))
6561 error ("type/value mismatch at argument %d in template "
6562 "parameter list for %qD",
6565 inform (input_location
,
6566 " expected a type, got %qT", DECL_NAME (arg
));
6568 inform (input_location
,
6569 " expected a class template, got %qT", orig_arg
);
6571 return error_mark_node
;
6576 if (requires_tmpl_type
)
6578 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6580 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6581 /* The number of argument required is not known yet.
6582 Just accept it for now. */
6583 val
= TREE_TYPE (arg
);
6586 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6589 /* Strip alias templates that are equivalent to another
6591 arg
= get_underlying_template (arg
);
6592 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6594 if (coerce_template_template_parms (parmparm
, argparm
,
6600 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6602 if (val
!= error_mark_node
)
6604 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6605 val
= TREE_TYPE (val
);
6606 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6607 val
= make_pack_expansion (val
);
6612 if (in_decl
&& (complain
& tf_error
))
6614 error ("type/value mismatch at argument %d in "
6615 "template parameter list for %qD",
6617 inform (input_location
,
6618 " expected a template of type %qD, got %qT",
6622 val
= error_mark_node
;
6628 /* We only form one instance of each template specialization.
6629 Therefore, if we use a non-canonical variant (i.e., a
6630 typedef), any future messages referring to the type will use
6631 the typedef, which is confusing if those future uses do not
6632 themselves also use the typedef. */
6634 val
= canonicalize_type_argument (val
, complain
);
6638 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6640 if (invalid_nontype_parm_type_p (t
, complain
))
6641 return error_mark_node
;
6643 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6645 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6649 /* Not sure if this is reachable, but it doesn't hurt
6651 error ("type mismatch in nontype parameter pack");
6652 val
= error_mark_node
;
6655 else if (!dependent_template_arg_p (orig_arg
)
6656 && !uses_template_parms (t
))
6657 /* We used to call digest_init here. However, digest_init
6658 will report errors, which we don't want when complain
6659 is zero. More importantly, digest_init will try too
6660 hard to convert things: for example, `0' should not be
6661 converted to pointer type at this point according to
6662 the standard. Accepting this is not merely an
6663 extension, since deciding whether or not these
6664 conversions can occur is part of determining which
6665 function template to call, or whether a given explicit
6666 argument specification is valid. */
6667 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6669 val
= strip_typedefs_expr (orig_arg
);
6671 if (val
== NULL_TREE
)
6672 val
= error_mark_node
;
6673 else if (val
== error_mark_node
&& (complain
& tf_error
))
6674 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6676 if (TREE_CODE (val
) == SCOPE_REF
)
6678 /* Strip typedefs from the SCOPE_REF. */
6679 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6680 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6682 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6683 QUALIFIED_NAME_IS_TEMPLATE (val
));
6690 /* Coerces the remaining template arguments in INNER_ARGS (from
6691 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6692 Returns the coerced argument pack. PARM_IDX is the position of this
6693 parameter in the template parameter list. ARGS is the original
6694 template argument list. */
6696 coerce_template_parameter_pack (tree parms
,
6704 tsubst_flags_t complain
)
6706 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6707 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6710 tree packed_parms
= NULL_TREE
;
6712 if (arg_idx
> nargs
)
6715 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6717 /* When the template parameter is a non-type template parameter pack
6718 or template template parameter pack whose type or template
6719 parameters use parameter packs, we know exactly how many arguments
6720 we are looking for. Build a vector of the instantiated decls for
6721 these template parameters in PACKED_PARMS. */
6722 /* We can't use make_pack_expansion here because it would interpret a
6723 _DECL as a use rather than a declaration. */
6724 tree decl
= TREE_VALUE (parm
);
6725 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6726 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6727 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6728 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6730 TREE_VEC_LENGTH (args
)--;
6731 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6732 TREE_VEC_LENGTH (args
)++;
6734 if (packed_parms
== error_mark_node
)
6735 return error_mark_node
;
6737 /* If we're doing a partial instantiation of a member template,
6738 verify that all of the types used for the non-type
6739 template parameter pack are, in fact, valid for non-type
6740 template parameters. */
6742 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6744 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6745 for (j
= 0; j
< len
; ++j
)
6747 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6748 if (invalid_nontype_parm_type_p (t
, complain
))
6749 return error_mark_node
;
6753 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6756 packed_args
= make_tree_vec (nargs
- arg_idx
);
6758 /* Convert the remaining arguments, which will be a part of the
6759 parameter pack "parm". */
6760 for (; arg_idx
< nargs
; ++arg_idx
)
6762 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6763 tree actual_parm
= TREE_VALUE (parm
);
6764 int pack_idx
= arg_idx
- parm_idx
;
6768 /* Once we've packed as many args as we have types, stop. */
6769 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6771 else if (PACK_EXPANSION_P (arg
))
6772 /* We don't know how many args we have yet, just
6773 use the unconverted ones for now. */
6776 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6779 if (arg
== error_mark_node
)
6781 if (complain
& tf_error
)
6782 error ("template argument %d is invalid", arg_idx
+ 1);
6785 arg
= convert_template_argument (actual_parm
,
6786 arg
, new_args
, complain
, parm_idx
,
6788 if (arg
== error_mark_node
)
6790 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6793 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6794 && TREE_VEC_LENGTH (packed_args
) > 0)
6796 if (complain
& tf_error
)
6797 error ("wrong number of template arguments (%d, should be %d)",
6798 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6799 return error_mark_node
;
6802 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6803 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6804 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6807 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6808 TREE_TYPE (argument_pack
)
6809 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6810 TREE_CONSTANT (argument_pack
) = 1;
6813 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6814 #ifdef ENABLE_CHECKING
6815 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6816 TREE_VEC_LENGTH (packed_args
));
6818 return argument_pack
;
6821 /* Returns the number of pack expansions in the template argument vector
6825 pack_expansion_args_count (tree args
)
6830 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6832 tree elt
= TREE_VEC_ELT (args
, i
);
6833 if (elt
&& PACK_EXPANSION_P (elt
))
6839 /* Convert all template arguments to their appropriate types, and
6840 return a vector containing the innermost resulting template
6841 arguments. If any error occurs, return error_mark_node. Error and
6842 warning messages are issued under control of COMPLAIN.
6844 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6845 for arguments not specified in ARGS. Otherwise, if
6846 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6847 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6848 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6852 coerce_template_parms (tree parms
,
6855 tsubst_flags_t complain
,
6856 bool require_all_args
,
6857 bool use_default_args
)
6859 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6860 tree orig_inner_args
;
6863 tree new_inner_args
;
6864 int saved_unevaluated_operand
;
6865 int saved_inhibit_evaluation_warnings
;
6867 /* When used as a boolean value, indicates whether this is a
6868 variadic template parameter list. Since it's an int, we can also
6869 subtract it from nparms to get the number of non-variadic
6872 int variadic_args_p
= 0;
6873 int post_variadic_parms
= 0;
6875 /* Likewise for parameters with default arguments. */
6878 if (args
== error_mark_node
)
6879 return error_mark_node
;
6881 nparms
= TREE_VEC_LENGTH (parms
);
6883 /* Determine if there are any parameter packs or default arguments. */
6884 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
6886 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6888 ++post_variadic_parms
;
6889 if (template_parameter_pack_p (TREE_VALUE (parm
)))
6891 if (TREE_PURPOSE (parm
))
6895 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
6896 /* If there are no parameters that follow a parameter pack, we need to
6897 expand any argument packs so that we can deduce a parameter pack from
6898 some non-packed args followed by an argument pack, as in variadic85.C.
6899 If there are such parameters, we need to leave argument packs intact
6900 so the arguments are assigned properly. This can happen when dealing
6901 with a nested class inside a partial specialization of a class
6902 template, as in variadic92.C, or when deducing a template parameter pack
6903 from a sub-declarator, as in variadic114.C. */
6904 if (!post_variadic_parms
)
6905 inner_args
= expand_template_argument_pack (inner_args
);
6907 /* Count any pack expansion args. */
6908 variadic_args_p
= pack_expansion_args_count (inner_args
);
6910 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6911 if ((nargs
> nparms
&& !variadic_p
)
6912 || (nargs
< nparms
- variadic_p
6915 && (!use_default_args
6916 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
6917 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
6919 if (complain
& tf_error
)
6921 if (variadic_p
|| default_p
)
6923 nparms
-= variadic_p
+ default_p
;
6924 error ("wrong number of template arguments "
6925 "(%d, should be at least %d)", nargs
, nparms
);
6928 error ("wrong number of template arguments "
6929 "(%d, should be %d)", nargs
, nparms
);
6932 inform (input_location
, "provided for %q+D", in_decl
);
6935 return error_mark_node
;
6937 /* We can't pass a pack expansion to a non-pack parameter of an alias
6938 template (DR 1430). */
6939 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
6941 && nargs
- variadic_args_p
< nparms
- variadic_p
)
6943 if (complain
& tf_error
)
6945 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
6947 tree arg
= TREE_VEC_ELT (inner_args
, i
);
6948 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
6950 if (PACK_EXPANSION_P (arg
)
6951 && !template_parameter_pack_p (parm
))
6953 error ("pack expansion argument for non-pack parameter "
6954 "%qD of alias template %qD", parm
, in_decl
);
6955 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
6962 return error_mark_node
;
6965 /* We need to evaluate the template arguments, even though this
6966 template-id may be nested within a "sizeof". */
6967 saved_unevaluated_operand
= cp_unevaluated_operand
;
6968 cp_unevaluated_operand
= 0;
6969 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6970 c_inhibit_evaluation_warnings
= 0;
6971 new_inner_args
= make_tree_vec (nparms
);
6972 new_args
= add_outermost_template_args (args
, new_inner_args
);
6973 int pack_adjust
= 0;
6974 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
6979 /* Get the Ith template parameter. */
6980 parm
= TREE_VEC_ELT (parms
, parm_idx
);
6982 if (parm
== error_mark_node
)
6984 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
6988 /* Calculate the next argument. */
6989 if (arg_idx
< nargs
)
6990 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6994 if (template_parameter_pack_p (TREE_VALUE (parm
))
6995 && !(arg
&& ARGUMENT_PACK_P (arg
)))
6997 /* Some arguments will be placed in the
6998 template parameter pack PARM. */
6999 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
7000 inner_args
, arg_idx
,
7004 if (arg
== NULL_TREE
)
7006 /* We don't know how many args we have yet, just use the
7007 unconverted (and still packed) ones for now. */
7008 new_inner_args
= orig_inner_args
;
7013 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
7015 /* Store this argument. */
7016 if (arg
== error_mark_node
)
7019 /* We are done with all of the arguments. */
7024 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
7025 arg_idx
+= pack_adjust
;
7032 if (PACK_EXPANSION_P (arg
))
7034 /* "If every valid specialization of a variadic template
7035 requires an empty template parameter pack, the template is
7036 ill-formed, no diagnostic required." So check that the
7037 pattern works with this parameter. */
7038 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
7039 tree conv
= convert_template_argument (TREE_VALUE (parm
),
7043 if (conv
== error_mark_node
)
7045 inform (input_location
, "so any instantiation with a "
7046 "non-empty parameter pack would be ill-formed");
7049 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
7050 /* Recover from missing typename. */
7051 TREE_VEC_ELT (inner_args
, arg_idx
)
7052 = make_pack_expansion (conv
);
7054 /* We don't know how many args we have yet, just
7055 use the unconverted ones for now. */
7056 new_inner_args
= inner_args
;
7061 else if (require_all_args
)
7063 /* There must be a default arg in this case. */
7064 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
7066 /* The position of the first default template argument,
7067 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7069 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7070 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7071 arg_idx
- pack_adjust
);
7076 if (arg
== error_mark_node
)
7078 if (complain
& tf_error
)
7079 error ("template argument %d is invalid", arg_idx
+ 1);
7082 /* This only occurs if there was an error in the template
7083 parameter list itself (which we would already have
7084 reported) that we are trying to recover from, e.g., a class
7085 template with a parameter list such as
7086 template<typename..., typename>. */
7089 arg
= convert_template_argument (TREE_VALUE (parm
),
7090 arg
, new_args
, complain
,
7093 if (arg
== error_mark_node
)
7095 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7097 cp_unevaluated_operand
= saved_unevaluated_operand
;
7098 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7100 if (variadic_p
&& arg_idx
< nargs
)
7102 if (complain
& tf_error
)
7104 error ("wrong number of template arguments "
7105 "(%d, should be %d)", nargs
, arg_idx
);
7107 error ("provided for %q+D", in_decl
);
7109 return error_mark_node
;
7113 return error_mark_node
;
7115 #ifdef ENABLE_CHECKING
7116 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7117 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7118 TREE_VEC_LENGTH (new_inner_args
));
7121 return new_inner_args
;
7124 /* Like coerce_template_parms. If PARMS represents all template
7125 parameters levels, this function returns a vector of vectors
7126 representing all the resulting argument levels. Note that in this
7127 case, only the innermost arguments are coerced because the
7128 outermost ones are supposed to have been coerced already.
7130 Otherwise, if PARMS represents only (the innermost) vector of
7131 parameters, this function returns a vector containing just the
7132 innermost resulting arguments. */
7135 coerce_innermost_template_parms (tree parms
,
7138 tsubst_flags_t complain
,
7139 bool require_all_args
,
7140 bool use_default_args
)
7142 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7143 int args_depth
= TMPL_ARGS_DEPTH (args
);
7146 if (parms_depth
> 1)
7148 coerced_args
= make_tree_vec (parms_depth
);
7152 for (level
= parms
, cur_depth
= parms_depth
;
7153 parms_depth
> 0 && level
!= NULL_TREE
;
7154 level
= TREE_CHAIN (level
), --cur_depth
)
7157 if (cur_depth
== args_depth
)
7158 l
= coerce_template_parms (TREE_VALUE (level
),
7159 args
, in_decl
, complain
,
7163 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7165 if (l
== error_mark_node
)
7166 return error_mark_node
;
7168 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7172 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7173 args
, in_decl
, complain
,
7176 return coerced_args
;
7179 /* Returns 1 if template args OT and NT are equivalent. */
7182 template_args_equal (tree ot
, tree nt
)
7186 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7189 if (TREE_CODE (nt
) == TREE_VEC
)
7190 /* For member templates */
7191 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7192 else if (PACK_EXPANSION_P (ot
))
7193 return (PACK_EXPANSION_P (nt
)
7194 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7195 PACK_EXPANSION_PATTERN (nt
))
7196 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7197 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7198 else if (ARGUMENT_PACK_P (ot
))
7203 if (!ARGUMENT_PACK_P (nt
))
7206 opack
= ARGUMENT_PACK_ARGS (ot
);
7207 npack
= ARGUMENT_PACK_ARGS (nt
);
7208 len
= TREE_VEC_LENGTH (opack
);
7209 if (TREE_VEC_LENGTH (npack
) != len
)
7211 for (i
= 0; i
< len
; ++i
)
7212 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7213 TREE_VEC_ELT (npack
, i
)))
7217 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7219 /* We get here probably because we are in the middle of substituting
7220 into the pattern of a pack expansion. In that case the
7221 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7222 interested in. So we want to use the initial pack argument for
7224 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7225 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7226 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7227 return template_args_equal (ot
, nt
);
7229 else if (TYPE_P (nt
))
7233 /* Don't treat an alias template specialization with dependent
7234 arguments as equivalent to its underlying type when used as a
7235 template argument; we need them to hash differently. */
7236 bool ndep
= dependent_alias_template_spec_p (nt
);
7237 ++processing_template_decl
;
7238 bool odep
= dependent_alias_template_spec_p (ot
);
7239 --processing_template_decl
;
7243 return (TYPE_TI_TEMPLATE (nt
) == TYPE_TI_TEMPLATE (ot
)
7244 && template_args_equal (TYPE_TI_ARGS (nt
), TYPE_TI_ARGS (ot
)));
7246 return same_type_p (ot
, nt
);
7248 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7251 return cp_tree_equal (ot
, nt
);
7254 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7255 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7256 NEWARG_PTR with the offending arguments if they are non-NULL. */
7259 comp_template_args_with_info (tree oldargs
, tree newargs
,
7260 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7264 if (oldargs
== newargs
)
7267 if (!oldargs
|| !newargs
)
7270 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7273 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7275 tree nt
= TREE_VEC_ELT (newargs
, i
);
7276 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7278 if (! template_args_equal (ot
, nt
))
7280 if (oldarg_ptr
!= NULL
)
7282 if (newarg_ptr
!= NULL
)
7290 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7291 of template arguments. Returns 0 otherwise. */
7294 comp_template_args (tree oldargs
, tree newargs
)
7296 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7300 add_pending_template (tree d
)
7302 tree ti
= (TYPE_P (d
)
7303 ? CLASSTYPE_TEMPLATE_INFO (d
)
7304 : DECL_TEMPLATE_INFO (d
));
7305 struct pending_template
*pt
;
7308 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7311 /* We are called both from instantiate_decl, where we've already had a
7312 tinst_level pushed, and instantiate_template, where we haven't.
7314 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7317 push_tinst_level (d
);
7319 pt
= ggc_alloc
<pending_template
> ();
7321 pt
->tinst
= current_tinst_level
;
7322 if (last_pending_template
)
7323 last_pending_template
->next
= pt
;
7325 pending_templates
= pt
;
7327 last_pending_template
= pt
;
7329 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7336 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7337 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7338 documentation for TEMPLATE_ID_EXPR. */
7341 lookup_template_function (tree fns
, tree arglist
)
7345 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7346 return error_mark_node
;
7348 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7350 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7352 error ("%q#D is not a function template", fns
);
7353 return error_mark_node
;
7356 if (BASELINK_P (fns
))
7358 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7360 BASELINK_FUNCTIONS (fns
),
7365 type
= TREE_TYPE (fns
);
7366 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7367 type
= unknown_type_node
;
7369 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7372 /* Within the scope of a template class S<T>, the name S gets bound
7373 (in build_self_reference) to a TYPE_DECL for the class, not a
7374 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7375 or one of its enclosing classes, and that type is a template,
7376 return the associated TEMPLATE_DECL. Otherwise, the original
7379 Also handle the case when DECL is a TREE_LIST of ambiguous
7380 injected-class-names from different bases. */
7383 maybe_get_template_decl_from_type_decl (tree decl
)
7385 if (decl
== NULL_TREE
)
7388 /* DR 176: A lookup that finds an injected-class-name (10.2
7389 [class.member.lookup]) can result in an ambiguity in certain cases
7390 (for example, if it is found in more than one base class). If all of
7391 the injected-class-names that are found refer to specializations of
7392 the same class template, and if the name is followed by a
7393 template-argument-list, the reference refers to the class template
7394 itself and not a specialization thereof, and is not ambiguous. */
7395 if (TREE_CODE (decl
) == TREE_LIST
)
7397 tree t
, tmpl
= NULL_TREE
;
7398 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7400 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7403 else if (tmpl
!= elt
)
7406 if (tmpl
&& t
== NULL_TREE
)
7412 return (decl
!= NULL_TREE
7413 && DECL_SELF_REFERENCE_P (decl
)
7414 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7415 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7418 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7419 parameters, find the desired type.
7421 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7423 IN_DECL, if non-NULL, is the template declaration we are trying to
7426 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7427 the class we are looking up.
7429 Issue error and warning messages under control of COMPLAIN.
7431 If the template class is really a local class in a template
7432 function, then the FUNCTION_CONTEXT is the function in which it is
7435 ??? Note that this function is currently called *twice* for each
7436 template-id: the first time from the parser, while creating the
7437 incomplete type (finish_template_type), and the second type during the
7438 real instantiation (instantiate_template_class). This is surely something
7439 that we want to avoid. It also causes some problems with argument
7440 coercion (see convert_nontype_argument for more information on this). */
7443 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7444 int entering_scope
, tsubst_flags_t complain
)
7446 tree templ
= NULL_TREE
, parmlist
;
7453 if (identifier_p (d1
))
7455 tree value
= innermost_non_namespace_value (d1
);
7456 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7461 push_decl_namespace (context
);
7462 templ
= lookup_name (d1
);
7463 templ
= maybe_get_template_decl_from_type_decl (templ
);
7465 pop_decl_namespace ();
7468 context
= DECL_CONTEXT (templ
);
7470 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7472 tree type
= TREE_TYPE (d1
);
7474 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7475 an implicit typename for the second A. Deal with it. */
7476 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7477 type
= TREE_TYPE (type
);
7479 if (CLASSTYPE_TEMPLATE_INFO (type
))
7481 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7482 d1
= DECL_NAME (templ
);
7485 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7486 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7488 templ
= TYPE_TI_TEMPLATE (d1
);
7489 d1
= DECL_NAME (templ
);
7491 else if (DECL_TYPE_TEMPLATE_P (d1
))
7494 d1
= DECL_NAME (templ
);
7495 context
= DECL_CONTEXT (templ
);
7497 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7500 d1
= DECL_NAME (templ
);
7503 /* Issue an error message if we didn't find a template. */
7506 if (complain
& tf_error
)
7507 error ("%qT is not a template", d1
);
7508 return error_mark_node
;
7511 if (TREE_CODE (templ
) != TEMPLATE_DECL
7512 /* Make sure it's a user visible template, if it was named by
7514 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7515 && !PRIMARY_TEMPLATE_P (templ
)))
7517 if (complain
& tf_error
)
7519 error ("non-template type %qT used as a template", d1
);
7521 error ("for template declaration %q+D", in_decl
);
7523 return error_mark_node
;
7526 complain
&= ~tf_user
;
7528 /* An alias that just changes the name of a template is equivalent to the
7529 other template, so if any of the arguments are pack expansions, strip
7530 the alias to avoid problems with a pack expansion passed to a non-pack
7531 alias template parameter (DR 1430). */
7532 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7533 templ
= get_underlying_template (templ
);
7535 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7537 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7538 template arguments */
7544 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7546 /* Consider an example where a template template parameter declared as
7548 template <class T, class U = std::allocator<T> > class TT
7550 The template parameter level of T and U are one level larger than
7551 of TT. To proper process the default argument of U, say when an
7552 instantiation `TT<int>' is seen, we need to build the full
7553 arguments containing {int} as the innermost level. Outer levels,
7554 available when not appearing as default template argument, can be
7555 obtained from the arguments of the enclosing template.
7557 Suppose that TT is later substituted with std::vector. The above
7558 instantiation is `TT<int, std::allocator<T> >' with TT at
7559 level 1, and T at level 2, while the template arguments at level 1
7560 becomes {std::vector} and the inner level 2 is {int}. */
7562 outer
= DECL_CONTEXT (templ
);
7564 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7565 else if (current_template_parms
)
7566 /* This is an argument of the current template, so we haven't set
7567 DECL_CONTEXT yet. */
7568 outer
= current_template_args ();
7571 arglist
= add_to_template_args (outer
, arglist
);
7573 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7575 /*require_all_args=*/true,
7576 /*use_default_args=*/true);
7577 if (arglist2
== error_mark_node
7578 || (!uses_template_parms (arglist2
)
7579 && check_instantiated_args (templ
, arglist2
, complain
)))
7580 return error_mark_node
;
7582 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7587 tree template_type
= TREE_TYPE (templ
);
7590 tree found
= NULL_TREE
;
7593 int is_dependent_type
;
7594 int use_partial_inst_tmpl
= false;
7596 if (template_type
== error_mark_node
)
7597 /* An error occurred while building the template TEMPL, and a
7598 diagnostic has most certainly been emitted for that
7599 already. Let's propagate that error. */
7600 return error_mark_node
;
7602 gen_tmpl
= most_general_template (templ
);
7603 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7604 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7605 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7607 if (arg_depth
== 1 && parm_depth
> 1)
7609 /* We've been given an incomplete set of template arguments.
7612 template <class T> struct S1 {
7613 template <class U> struct S2 {};
7614 template <class U> struct S2<U*> {};
7617 we will be called with an ARGLIST of `U*', but the
7618 TEMPLATE will be `template <class T> template
7619 <class U> struct S1<T>::S2'. We must fill in the missing
7622 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7624 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7627 /* Now we should have enough arguments. */
7628 gcc_assert (parm_depth
== arg_depth
);
7630 /* From here on, we're only interested in the most general
7633 /* Calculate the BOUND_ARGS. These will be the args that are
7634 actually tsubst'd into the definition to create the
7638 /* We have multiple levels of arguments to coerce, at once. */
7640 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
7642 tree bound_args
= make_tree_vec (parm_depth
);
7644 for (i
= saved_depth
,
7645 t
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7646 i
> 0 && t
!= NULL_TREE
;
7647 --i
, t
= TREE_CHAIN (t
))
7650 if (i
== saved_depth
)
7651 a
= coerce_template_parms (TREE_VALUE (t
),
7654 /*require_all_args=*/true,
7655 /*use_default_args=*/true);
7657 /* Outer levels should have already been coerced. */
7658 a
= TMPL_ARGS_LEVEL (arglist
, i
);
7660 /* Don't process further if one of the levels fails. */
7661 if (a
== error_mark_node
)
7663 /* Restore the ARGLIST to its full size. */
7664 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7665 return error_mark_node
;
7668 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
7670 /* We temporarily reduce the length of the ARGLIST so
7671 that coerce_template_parms will see only the arguments
7672 corresponding to the template parameters it is
7674 TREE_VEC_LENGTH (arglist
)--;
7677 /* Restore the ARGLIST to its full size. */
7678 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7680 arglist
= bound_args
;
7684 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
7685 INNERMOST_TEMPLATE_ARGS (arglist
),
7688 /*require_all_args=*/true,
7689 /*use_default_args=*/true);
7691 if (arglist
== error_mark_node
)
7692 /* We were unable to bind the arguments. */
7693 return error_mark_node
;
7695 /* In the scope of a template class, explicit references to the
7696 template class refer to the type of the template, not any
7697 instantiation of it. For example, in:
7699 template <class T> class C { void f(C<T>); }
7701 the `C<T>' is just the same as `C'. Outside of the
7702 class, however, such a reference is an instantiation. */
7704 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7705 || currently_open_class (template_type
))
7706 /* comp_template_args is expensive, check it last. */
7707 && comp_template_args (TYPE_TI_ARGS (template_type
),
7709 return template_type
;
7711 /* If we already have this specialization, return it. */
7712 elt
.tmpl
= gen_tmpl
;
7714 hash
= spec_hasher::hash (&elt
);
7715 entry
= type_specializations
->find_with_hash (&elt
, hash
);
7720 is_dependent_type
= uses_template_parms (arglist
);
7722 /* If the deduced arguments are invalid, then the binding
7724 if (!is_dependent_type
7725 && check_instantiated_args (gen_tmpl
,
7726 INNERMOST_TEMPLATE_ARGS (arglist
),
7728 return error_mark_node
;
7730 if (!is_dependent_type
7731 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7732 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7733 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7735 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7736 DECL_NAME (gen_tmpl
),
7737 /*tag_scope=*/ts_global
);
7741 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7743 if (context
== error_mark_node
)
7744 return error_mark_node
;
7747 context
= global_namespace
;
7749 /* Create the type. */
7750 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7752 /* The user referred to a specialization of an alias
7753 template represented by GEN_TMPL.
7755 [temp.alias]/2 says:
7757 When a template-id refers to the specialization of an
7758 alias template, it is equivalent to the associated
7759 type obtained by substitution of its
7760 template-arguments for the template-parameters in the
7761 type-id of the alias template. */
7763 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7764 /* Note that the call above (by indirectly calling
7765 register_specialization in tsubst_decl) registers the
7766 TYPE_DECL representing the specialization of the alias
7767 template. So next time someone substitutes ARGLIST for
7768 the template parms into the alias template (GEN_TMPL),
7769 she'll get that TYPE_DECL back. */
7771 if (t
== error_mark_node
)
7774 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7776 if (!is_dependent_type
)
7778 set_current_access_from_decl (TYPE_NAME (template_type
));
7779 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7780 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7781 arglist
, complain
, in_decl
),
7782 SCOPED_ENUM_P (template_type
), NULL
);
7784 if (t
== error_mark_node
)
7789 /* We don't want to call start_enum for this type, since
7790 the values for the enumeration constants may involve
7791 template parameters. And, no one should be interested
7792 in the enumeration constants for such a type. */
7793 t
= cxx_make_type (ENUMERAL_TYPE
);
7794 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7796 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7797 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7798 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7800 else if (CLASS_TYPE_P (template_type
))
7802 t
= make_class_type (TREE_CODE (template_type
));
7803 CLASSTYPE_DECLARED_CLASS (t
)
7804 = CLASSTYPE_DECLARED_CLASS (template_type
);
7805 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7806 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7808 /* A local class. Make sure the decl gets registered properly. */
7809 if (context
== current_function_decl
)
7810 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7812 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7813 /* This instantiation is another name for the primary
7814 template type. Set the TYPE_CANONICAL field
7816 TYPE_CANONICAL (t
) = template_type
;
7817 else if (any_template_arguments_need_structural_equality_p (arglist
))
7818 /* Some of the template arguments require structural
7819 equality testing, so this template class requires
7820 structural equality testing. */
7821 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7826 /* If we called start_enum or pushtag above, this information
7827 will already be set up. */
7830 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7832 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7833 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7834 DECL_SOURCE_LOCATION (type_decl
)
7835 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7838 type_decl
= TYPE_NAME (t
);
7840 if (CLASS_TYPE_P (template_type
))
7842 TREE_PRIVATE (type_decl
)
7843 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7844 TREE_PROTECTED (type_decl
)
7845 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7846 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7848 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7849 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7853 if (OVERLOAD_TYPE_P (t
)
7854 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7857 = lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (template_type
)))
7859 if (!TREE_CHAIN (attributes
))
7860 TYPE_ATTRIBUTES (t
) = attributes
;
7863 = build_tree_list (TREE_PURPOSE (attributes
),
7864 TREE_VALUE (attributes
));
7868 /* Let's consider the explicit specialization of a member
7869 of a class template specialization that is implicitly instantiated,
7874 template<class U> struct M {}; //#0
7879 struct S<int>::M<char> //#1
7883 [temp.expl.spec]/4 says this is valid.
7885 In this case, when we write:
7888 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7891 When we encounter #1, we want to store the partial instantiation
7892 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7894 For all cases other than this "explicit specialization of member of a
7895 class template", we just want to store the most general template into
7896 the CLASSTYPE_TI_TEMPLATE of M.
7898 This case of "explicit specialization of member of a class template"
7900 1/ the enclosing class is an instantiation of, and therefore not
7901 the same as, the context of the most general template, and
7902 2/ we aren't looking at the partial instantiation itself, i.e.
7903 the innermost arguments are not the same as the innermost parms of
7904 the most general template.
7906 So it's only when 1/ and 2/ happens that we want to use the partial
7907 instantiation of the member template in lieu of its most general
7910 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
7911 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
7912 /* the enclosing class must be an instantiation... */
7913 && CLASS_TYPE_P (context
)
7914 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
7916 tree partial_inst_args
;
7917 TREE_VEC_LENGTH (arglist
)--;
7918 ++processing_template_decl
;
7920 tsubst (INNERMOST_TEMPLATE_ARGS
7921 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
7922 arglist
, complain
, NULL_TREE
);
7923 --processing_template_decl
;
7924 TREE_VEC_LENGTH (arglist
)++;
7925 use_partial_inst_tmpl
=
7926 /*...and we must not be looking at the partial instantiation
7928 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
7932 if (!use_partial_inst_tmpl
)
7933 /* This case is easy; there are no member templates involved. */
7937 /* This is a full instantiation of a member template. Find
7938 the partial instantiation of which this is an instance. */
7940 /* Temporarily reduce by one the number of levels in the ARGLIST
7941 so as to avoid comparing the last set of arguments. */
7942 TREE_VEC_LENGTH (arglist
)--;
7943 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
7944 TREE_VEC_LENGTH (arglist
)++;
7945 /* FOUND is either a proper class type, or an alias
7946 template specialization. In the later case, it's a
7947 TYPE_DECL, resulting from the substituting of arguments
7948 for parameters in the TYPE_DECL of the alias template
7949 done earlier. So be careful while getting the template
7951 found
= TREE_CODE (found
) == TYPE_DECL
7952 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
7953 : CLASSTYPE_TI_TEMPLATE (found
);
7956 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
7959 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
7960 entry
= ggc_alloc
<spec_entry
> ();
7964 /* Note this use of the partial instantiation so we can check it
7965 later in maybe_process_partial_specialization. */
7966 DECL_TEMPLATE_INSTANTIATIONS (found
)
7967 = tree_cons (arglist
, t
,
7968 DECL_TEMPLATE_INSTANTIATIONS (found
));
7970 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
7971 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7972 /* Now that the type has been registered on the instantiations
7973 list, we set up the enumerators. Because the enumeration
7974 constants may involve the enumeration type itself, we make
7975 sure to register the type first, and then create the
7976 constants. That way, doing tsubst_expr for the enumeration
7977 constants won't result in recursive calls here; we'll find
7978 the instantiation and exit above. */
7979 tsubst_enum (template_type
, t
, arglist
);
7981 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
7982 /* If the type makes use of template parameters, the
7983 code that generates debugging information will crash. */
7984 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
7986 /* Possibly limit visibility based on template args. */
7987 TREE_PUBLIC (type_decl
) = 1;
7988 determine_visibility (type_decl
);
7990 inherit_targ_abi_tags (t
);
7996 /* Wrapper for lookup_template_class_1. */
7999 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
8000 int entering_scope
, tsubst_flags_t complain
)
8003 timevar_push (TV_TEMPLATE_INST
);
8004 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
8005 entering_scope
, complain
);
8006 timevar_pop (TV_TEMPLATE_INST
);
8010 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST.
8011 If the ARGLIST refers to any template parameters, the type of the
8012 expression is the unknown_type_node since the template-id could
8013 refer to an explicit or partial specialization. */
8016 lookup_template_variable (tree templ
, tree arglist
)
8019 if (uses_template_parms (arglist
))
8020 type
= unknown_type_node
;
8022 type
= TREE_TYPE (templ
);
8023 tsubst_flags_t complain
= tf_warning_or_error
;
8024 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (templ
));
8025 arglist
= coerce_template_parms (parms
, arglist
, templ
, complain
,
8026 /*req_all*/true, /*use_default*/true);
8027 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
8035 /* True when we should also visit template parameters that occur in
8036 non-deduced contexts. */
8037 bool include_nondeduced_p
;
8038 hash_set
<tree
> *visited
;
8041 /* Called from for_each_template_parm via walk_tree. */
8044 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
8047 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
8048 tree_fn_t fn
= pfd
->fn
;
8049 void *data
= pfd
->data
;
8052 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
8053 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
8054 pfd
->include_nondeduced_p
))
8055 return error_mark_node
;
8057 switch (TREE_CODE (t
))
8060 if (TYPE_PTRMEMFUNC_P (t
))
8066 if (!TYPE_TEMPLATE_INFO (t
))
8068 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
8069 fn
, data
, pfd
->visited
,
8070 pfd
->include_nondeduced_p
))
8071 return error_mark_node
;
8075 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
8076 fn
, data
, pfd
->visited
,
8077 pfd
->include_nondeduced_p
)
8078 || for_each_template_parm (TYPE_MAX_VALUE (t
),
8079 fn
, data
, pfd
->visited
,
8080 pfd
->include_nondeduced_p
))
8081 return error_mark_node
;
8085 /* Since we're not going to walk subtrees, we have to do this
8087 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
8088 pfd
->visited
, pfd
->include_nondeduced_p
))
8089 return error_mark_node
;
8093 /* Check the return type. */
8094 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8095 pfd
->include_nondeduced_p
))
8096 return error_mark_node
;
8098 /* Check the parameter types. Since default arguments are not
8099 instantiated until they are needed, the TYPE_ARG_TYPES may
8100 contain expressions that involve template parameters. But,
8101 no-one should be looking at them yet. And, once they're
8102 instantiated, they don't contain template parameters, so
8103 there's no point in looking at them then, either. */
8107 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
8108 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
8109 pfd
->visited
, pfd
->include_nondeduced_p
))
8110 return error_mark_node
;
8112 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8113 want walk_tree walking into them itself. */
8119 case UNDERLYING_TYPE
:
8120 if (pfd
->include_nondeduced_p
8121 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
8123 pfd
->include_nondeduced_p
))
8124 return error_mark_node
;
8129 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
8130 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
8131 pfd
->visited
, pfd
->include_nondeduced_p
))
8132 return error_mark_node
;
8137 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
8138 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
8139 pfd
->visited
, pfd
->include_nondeduced_p
))
8140 return error_mark_node
;
8141 if (DECL_CONTEXT (t
)
8142 && pfd
->include_nondeduced_p
8143 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
8144 pfd
->visited
, pfd
->include_nondeduced_p
))
8145 return error_mark_node
;
8148 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8149 /* Record template parameters such as `T' inside `TT<T>'. */
8150 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
8151 pfd
->include_nondeduced_p
))
8152 return error_mark_node
;
8155 case TEMPLATE_TEMPLATE_PARM
:
8156 case TEMPLATE_TYPE_PARM
:
8157 case TEMPLATE_PARM_INDEX
:
8158 if (fn
&& (*fn
)(t
, data
))
8159 return error_mark_node
;
8161 return error_mark_node
;
8165 /* A template template parameter is encountered. */
8166 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
8167 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8168 pfd
->include_nondeduced_p
))
8169 return error_mark_node
;
8171 /* Already substituted template template parameter */
8177 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8179 pfd
->include_nondeduced_p
))
8180 return error_mark_node
;
8184 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8185 && pfd
->include_nondeduced_p
8186 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8187 (TREE_TYPE (t
)), fn
, data
,
8188 pfd
->visited
, pfd
->include_nondeduced_p
))
8189 return error_mark_node
;
8194 /* If there's no type, then this thing must be some expression
8195 involving template parameters. */
8196 if (!fn
&& !TREE_TYPE (t
))
8197 return error_mark_node
;
8202 case IMPLICIT_CONV_EXPR
:
8203 case REINTERPRET_CAST_EXPR
:
8204 case CONST_CAST_EXPR
:
8205 case STATIC_CAST_EXPR
:
8206 case DYNAMIC_CAST_EXPR
:
8210 case PSEUDO_DTOR_EXPR
:
8212 return error_mark_node
;
8219 /* We didn't find any template parameters we liked. */
8223 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8224 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8225 call FN with the parameter and the DATA.
8226 If FN returns nonzero, the iteration is terminated, and
8227 for_each_template_parm returns 1. Otherwise, the iteration
8228 continues. If FN never returns a nonzero value, the value
8229 returned by for_each_template_parm is 0. If FN is NULL, it is
8230 considered to be the function which always returns 1.
8232 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8233 parameters that occur in non-deduced contexts. When false, only
8234 visits those template parameters that can be deduced. */
8237 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8238 hash_set
<tree
> *visited
,
8239 bool include_nondeduced_p
)
8241 struct pair_fn_data pfd
;
8247 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8249 /* Walk the tree. (Conceptually, we would like to walk without
8250 duplicates, but for_each_template_parm_r recursively calls
8251 for_each_template_parm, so we would need to reorganize a fair
8252 bit to use walk_tree_without_duplicates, so we keep our own
8255 pfd
.visited
= visited
;
8257 pfd
.visited
= new hash_set
<tree
>;
8258 result
= cp_walk_tree (&t
,
8259 for_each_template_parm_r
,
8261 pfd
.visited
) != NULL_TREE
;
8273 /* Returns true if T depends on any template parameter. */
8276 uses_template_parms (tree t
)
8279 int saved_processing_template_decl
;
8281 saved_processing_template_decl
= processing_template_decl
;
8282 if (!saved_processing_template_decl
)
8283 processing_template_decl
= 1;
8285 dependent_p
= dependent_type_p (t
);
8286 else if (TREE_CODE (t
) == TREE_VEC
)
8287 dependent_p
= any_dependent_template_arguments_p (t
);
8288 else if (TREE_CODE (t
) == TREE_LIST
)
8289 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8290 || uses_template_parms (TREE_CHAIN (t
)));
8291 else if (TREE_CODE (t
) == TYPE_DECL
)
8292 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8295 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8296 || TREE_CODE (t
) == OVERLOAD
8299 || TREE_CODE (t
) == TRAIT_EXPR
8300 || TREE_CODE (t
) == CONSTRUCTOR
8301 || CONSTANT_CLASS_P (t
))
8302 dependent_p
= (type_dependent_expression_p (t
)
8303 || value_dependent_expression_p (t
));
8306 gcc_assert (t
== error_mark_node
);
8307 dependent_p
= false;
8310 processing_template_decl
= saved_processing_template_decl
;
8315 /* Returns true iff current_function_decl is an incompletely instantiated
8316 template. Useful instead of processing_template_decl because the latter
8317 is set to 0 during instantiate_non_dependent_expr. */
8320 in_template_function (void)
8322 tree fn
= current_function_decl
;
8324 ++processing_template_decl
;
8325 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8326 && DECL_TEMPLATE_INFO (fn
)
8327 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8328 --processing_template_decl
;
8332 /* Returns true if T depends on any template parameter with level LEVEL. */
8335 uses_template_parms_level (tree t
, int level
)
8337 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8338 /*include_nondeduced_p=*/true);
8341 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8342 ill-formed translation unit, i.e. a variable or function that isn't
8343 usable in a constant expression. */
8346 neglectable_inst_p (tree d
)
8349 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8350 : decl_maybe_constant_var_p (d
)));
8353 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8354 neglectable and instantiated from within an erroneous instantiation. */
8357 limit_bad_template_recursion (tree decl
)
8359 struct tinst_level
*lev
= current_tinst_level
;
8360 int errs
= errorcount
+ sorrycount
;
8361 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8364 for (; lev
; lev
= lev
->next
)
8365 if (neglectable_inst_p (lev
->decl
))
8368 return (lev
&& errs
> lev
->errors
);
8371 static int tinst_depth
;
8372 extern int max_tinst_depth
;
8375 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8377 /* We're starting to instantiate D; record the template instantiation context
8378 for diagnostics and to restore it later. */
8381 push_tinst_level (tree d
)
8383 return push_tinst_level_loc (d
, input_location
);
8386 /* We're starting to instantiate D; record the template instantiation context
8387 at LOC for diagnostics and to restore it later. */
8390 push_tinst_level_loc (tree d
, location_t loc
)
8392 struct tinst_level
*new_level
;
8394 if (tinst_depth
>= max_tinst_depth
)
8396 fatal_error ("template instantiation depth exceeds maximum of %d"
8397 " (use -ftemplate-depth= to increase the maximum)",
8402 /* If the current instantiation caused problems, don't let it instantiate
8403 anything else. Do allow deduction substitution and decls usable in
8404 constant expressions. */
8405 if (limit_bad_template_recursion (d
))
8408 new_level
= ggc_alloc
<tinst_level
> ();
8409 new_level
->decl
= d
;
8410 new_level
->locus
= loc
;
8411 new_level
->errors
= errorcount
+sorrycount
;
8412 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8413 new_level
->next
= current_tinst_level
;
8414 current_tinst_level
= new_level
;
8417 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8418 depth_reached
= tinst_depth
;
8423 /* We're done instantiating this template; return to the instantiation
8427 pop_tinst_level (void)
8429 /* Restore the filename and line number stashed away when we started
8430 this instantiation. */
8431 input_location
= current_tinst_level
->locus
;
8432 current_tinst_level
= current_tinst_level
->next
;
8436 /* We're instantiating a deferred template; restore the template
8437 instantiation context in which the instantiation was requested, which
8438 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8441 reopen_tinst_level (struct tinst_level
*level
)
8443 struct tinst_level
*t
;
8446 for (t
= level
; t
; t
= t
->next
)
8449 current_tinst_level
= level
;
8451 if (current_tinst_level
)
8452 current_tinst_level
->errors
= errorcount
+sorrycount
;
8456 /* Returns the TINST_LEVEL which gives the original instantiation
8459 struct tinst_level
*
8460 outermost_tinst_level (void)
8462 struct tinst_level
*level
= current_tinst_level
;
8465 level
= level
->next
;
8469 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8470 vector of template arguments, as for tsubst.
8472 Returns an appropriate tsubst'd friend declaration. */
8475 tsubst_friend_function (tree decl
, tree args
)
8479 if (TREE_CODE (decl
) == FUNCTION_DECL
8480 && DECL_TEMPLATE_INSTANTIATION (decl
)
8481 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8482 /* This was a friend declared with an explicit template
8483 argument list, e.g.:
8487 to indicate that f was a template instantiation, not a new
8488 function declaration. Now, we have to figure out what
8489 instantiation of what template. */
8491 tree template_id
, arglist
, fns
;
8494 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8496 /* Friend functions are looked up in the containing namespace scope.
8497 We must enter that scope, to avoid finding member functions of the
8498 current class with same name. */
8499 push_nested_namespace (ns
);
8500 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8501 tf_warning_or_error
, NULL_TREE
,
8502 /*integral_constant_expression_p=*/false);
8503 pop_nested_namespace (ns
);
8504 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8505 tf_warning_or_error
, NULL_TREE
);
8506 template_id
= lookup_template_function (fns
, arglist
);
8508 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8509 tmpl
= determine_specialization (template_id
, new_friend
,
8511 /*need_member_template=*/0,
8512 TREE_VEC_LENGTH (args
),
8514 return instantiate_template (tmpl
, new_args
, tf_error
);
8517 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8519 /* The NEW_FRIEND will look like an instantiation, to the
8520 compiler, but is not an instantiation from the point of view of
8521 the language. For example, we might have had:
8523 template <class T> struct S {
8524 template <class U> friend void f(T, U);
8527 Then, in S<int>, template <class U> void f(int, U) is not an
8528 instantiation of anything. */
8529 if (new_friend
== error_mark_node
)
8530 return error_mark_node
;
8532 DECL_USE_TEMPLATE (new_friend
) = 0;
8533 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8535 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8536 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8537 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8540 /* The mangled name for the NEW_FRIEND is incorrect. The function
8541 is not a template instantiation and should not be mangled like
8542 one. Therefore, we forget the mangling here; we'll recompute it
8543 later if we need it. */
8544 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8546 SET_DECL_RTL (new_friend
, NULL
);
8547 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8550 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8553 tree new_friend_template_info
;
8554 tree new_friend_result_template_info
;
8556 int new_friend_is_defn
;
8558 /* We must save some information from NEW_FRIEND before calling
8559 duplicate decls since that function will free NEW_FRIEND if
8561 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8562 new_friend_is_defn
=
8563 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8564 (template_for_substitution (new_friend
)))
8566 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8568 /* This declaration is a `primary' template. */
8569 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8571 new_friend_result_template_info
8572 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8575 new_friend_result_template_info
= NULL_TREE
;
8577 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8578 if (new_friend_is_defn
)
8579 DECL_INITIAL (new_friend
) = error_mark_node
;
8581 /* Inside pushdecl_namespace_level, we will push into the
8582 current namespace. However, the friend function should go
8583 into the namespace of the template. */
8584 ns
= decl_namespace_context (new_friend
);
8585 push_nested_namespace (ns
);
8586 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8587 pop_nested_namespace (ns
);
8589 if (old_decl
== error_mark_node
)
8590 return error_mark_node
;
8592 if (old_decl
!= new_friend
)
8594 /* This new friend declaration matched an existing
8595 declaration. For example, given:
8597 template <class T> void f(T);
8598 template <class U> class C {
8599 template <class T> friend void f(T) {}
8602 the friend declaration actually provides the definition
8603 of `f', once C has been instantiated for some type. So,
8604 old_decl will be the out-of-class template declaration,
8605 while new_friend is the in-class definition.
8607 But, if `f' was called before this point, the
8608 instantiation of `f' will have DECL_TI_ARGS corresponding
8609 to `T' but not to `U', references to which might appear
8610 in the definition of `f'. Previously, the most general
8611 template for an instantiation of `f' was the out-of-class
8612 version; now it is the in-class version. Therefore, we
8613 run through all specialization of `f', adding to their
8614 DECL_TI_ARGS appropriately. In particular, they need a
8615 new set of outer arguments, corresponding to the
8616 arguments for this class instantiation.
8618 The same situation can arise with something like this:
8621 template <class T> class C {
8625 when `C<int>' is instantiated. Now, `f(int)' is defined
8628 if (!new_friend_is_defn
)
8629 /* On the other hand, if the in-class declaration does
8630 *not* provide a definition, then we don't want to alter
8631 existing definitions. We can just leave everything
8636 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8637 tree new_args
= TI_ARGS (new_friend_template_info
);
8639 /* Overwrite whatever template info was there before, if
8640 any, with the new template information pertaining to
8642 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8644 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8646 /* We should have called reregister_specialization in
8648 gcc_assert (retrieve_specialization (new_template
,
8652 /* Instantiate it if the global has already been used. */
8653 if (DECL_ODR_USED (old_decl
))
8654 instantiate_decl (old_decl
, /*defer_ok=*/true,
8655 /*expl_inst_class_mem_p=*/false);
8661 /* Indicate that the old function template is a partial
8663 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8664 = new_friend_result_template_info
;
8666 gcc_assert (new_template
8667 == most_general_template (new_template
));
8668 gcc_assert (new_template
!= old_decl
);
8670 /* Reassign any specializations already in the hash table
8671 to the new more general template, and add the
8672 additional template args. */
8673 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8677 tree spec
= TREE_VALUE (t
);
8680 elt
.tmpl
= old_decl
;
8681 elt
.args
= DECL_TI_ARGS (spec
);
8682 elt
.spec
= NULL_TREE
;
8684 decl_specializations
->remove_elt (&elt
);
8687 = add_outermost_template_args (new_args
,
8688 DECL_TI_ARGS (spec
));
8690 register_specialization
8691 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8694 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8698 /* The information from NEW_FRIEND has been merged into OLD_DECL
8699 by duplicate_decls. */
8700 new_friend
= old_decl
;
8705 tree context
= DECL_CONTEXT (new_friend
);
8709 template <class T> class C {
8710 template <class U> friend void C1<U>::f (); // case 1
8711 friend void C2<T>::f (); // case 2
8713 we only need to make sure CONTEXT is a complete type for
8714 case 2. To distinguish between the two cases, we note that
8715 CONTEXT of case 1 remains dependent type after tsubst while
8716 this isn't true for case 2. */
8717 ++processing_template_decl
;
8718 dependent_p
= dependent_type_p (context
);
8719 --processing_template_decl
;
8722 && !complete_type_or_else (context
, NULL_TREE
))
8723 return error_mark_node
;
8725 if (COMPLETE_TYPE_P (context
))
8727 tree fn
= new_friend
;
8728 /* do_friend adds the TEMPLATE_DECL for any member friend
8729 template even if it isn't a member template, i.e.
8730 template <class T> friend A<T>::f();
8731 Look through it in that case. */
8732 if (TREE_CODE (fn
) == TEMPLATE_DECL
8733 && !PRIMARY_TEMPLATE_P (fn
))
8734 fn
= DECL_TEMPLATE_RESULT (fn
);
8735 /* Check to see that the declaration is really present, and,
8736 possibly obtain an improved declaration. */
8737 fn
= check_classfn (context
, fn
, NULL_TREE
);
8747 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8748 template arguments, as for tsubst.
8750 Returns an appropriate tsubst'd friend type or error_mark_node on
8754 tsubst_friend_class (tree friend_tmpl
, tree args
)
8760 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8762 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8763 return TREE_TYPE (t
);
8766 context
= CP_DECL_CONTEXT (friend_tmpl
);
8768 if (context
!= global_namespace
)
8770 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8771 push_nested_namespace (context
);
8773 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8776 /* Look for a class template declaration. We look for hidden names
8777 because two friend declarations of the same template are the
8778 same. For example, in:
8781 template <typename> friend class F;
8783 template <typename> struct B {
8784 template <typename> friend class F;
8787 both F templates are the same. */
8788 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8789 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8791 /* But, if we don't find one, it might be because we're in a
8792 situation like this:
8800 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8801 for `S<int>', not the TEMPLATE_DECL. */
8802 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8804 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8805 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8808 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8810 /* The friend template has already been declared. Just
8811 check to see that the declarations match, and install any new
8812 default parameters. We must tsubst the default parameters,
8813 of course. We only need the innermost template parameters
8814 because that is all that redeclare_class_template will look
8816 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8817 > TMPL_ARGS_DEPTH (args
))
8820 location_t saved_input_location
;
8821 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8822 args
, tf_warning_or_error
);
8824 saved_input_location
= input_location
;
8825 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8826 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8827 input_location
= saved_input_location
;
8831 friend_type
= TREE_TYPE (tmpl
);
8835 /* The friend template has not already been declared. In this
8836 case, the instantiation of the template class will cause the
8837 injection of this template into the global scope. */
8838 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8839 if (tmpl
== error_mark_node
)
8840 return error_mark_node
;
8842 /* The new TMPL is not an instantiation of anything, so we
8843 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8844 the new type because that is supposed to be the corresponding
8845 template decl, i.e., TMPL. */
8846 DECL_USE_TEMPLATE (tmpl
) = 0;
8847 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8848 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8849 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8850 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8852 /* Inject this template into the global scope. */
8853 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8856 if (context
!= global_namespace
)
8858 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8859 pop_nested_namespace (context
);
8861 pop_nested_class ();
8867 /* Returns zero if TYPE cannot be completed later due to circularity.
8868 Otherwise returns one. */
8871 can_complete_type_without_circularity (tree type
)
8873 if (type
== NULL_TREE
|| type
== error_mark_node
)
8875 else if (COMPLETE_TYPE_P (type
))
8877 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8878 return can_complete_type_without_circularity (TREE_TYPE (type
));
8879 else if (CLASS_TYPE_P (type
)
8880 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
8886 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
8888 /* Apply any attributes which had to be deferred until instantiation
8889 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8890 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8893 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
8894 tree args
, tsubst_flags_t complain
, tree in_decl
)
8896 tree last_dep
= NULL_TREE
;
8900 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
8901 if (ATTR_IS_DEPENDENT (t
))
8904 attributes
= copy_list (attributes
);
8908 if (DECL_P (*decl_p
))
8910 if (TREE_TYPE (*decl_p
) == error_mark_node
)
8912 p
= &DECL_ATTRIBUTES (*decl_p
);
8915 p
= &TYPE_ATTRIBUTES (*decl_p
);
8919 tree late_attrs
= NULL_TREE
;
8920 tree
*q
= &late_attrs
;
8922 for (*p
= attributes
; *p
; )
8925 if (ATTR_IS_DEPENDENT (t
))
8927 *p
= TREE_CHAIN (t
);
8928 TREE_CHAIN (t
) = NULL_TREE
;
8929 if ((flag_openmp
|| flag_cilkplus
)
8930 && is_attribute_p ("omp declare simd",
8931 get_attribute_name (t
))
8934 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
8935 clauses
= tsubst_omp_clauses (clauses
, true, args
,
8937 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
8938 clauses
= finish_omp_clauses (clauses
);
8939 tree parms
= DECL_ARGUMENTS (*decl_p
);
8941 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
8943 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
8945 TREE_VALUE (t
) = NULL_TREE
;
8947 /* If the first attribute argument is an identifier, don't
8948 pass it through tsubst. Attributes like mode, format,
8949 cleanup and several target specific attributes expect it
8951 else if (attribute_takes_identifier_p (get_attribute_name (t
))
8955 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
8957 /*integral_constant_expression_p=*/false);
8958 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
8960 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
8965 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
8966 /*integral_constant_expression_p=*/false);
8968 q
= &TREE_CHAIN (t
);
8971 p
= &TREE_CHAIN (t
);
8974 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
8978 /* Perform (or defer) access check for typedefs that were referenced
8979 from within the template TMPL code.
8980 This is a subroutine of instantiate_decl and instantiate_class_template.
8981 TMPL is the template to consider and TARGS is the list of arguments of
8985 perform_typedefs_access_check (tree tmpl
, tree targs
)
8987 location_t saved_location
;
8989 qualified_typedef_usage_t
*iter
;
8992 || (!CLASS_TYPE_P (tmpl
)
8993 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
8996 saved_location
= input_location
;
8997 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
8999 tree type_decl
= iter
->typedef_decl
;
9000 tree type_scope
= iter
->context
;
9002 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
9005 if (uses_template_parms (type_decl
))
9006 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
9007 if (uses_template_parms (type_scope
))
9008 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
9010 /* Make access check error messages point to the location
9011 of the use of the typedef. */
9012 input_location
= iter
->locus
;
9013 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
9014 type_decl
, type_decl
,
9015 tf_warning_or_error
);
9017 input_location
= saved_location
;
9021 instantiate_class_template_1 (tree type
)
9023 tree templ
, args
, pattern
, t
, member
;
9027 unsigned int saved_maximum_field_alignment
;
9030 if (type
== error_mark_node
)
9031 return error_mark_node
;
9033 if (COMPLETE_OR_OPEN_TYPE_P (type
)
9034 || uses_template_parms (type
))
9037 /* Figure out which template is being instantiated. */
9038 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
9039 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
9041 /* Determine what specialization of the original template to
9043 t
= most_specialized_class (type
, tf_warning_or_error
);
9044 if (t
== error_mark_node
)
9046 TYPE_BEING_DEFINED (type
) = 1;
9047 return error_mark_node
;
9051 /* This TYPE is actually an instantiation of a partial
9052 specialization. We replace the innermost set of ARGS with
9053 the arguments appropriate for substitution. For example,
9056 template <class T> struct S {};
9057 template <class T> struct S<T*> {};
9059 and supposing that we are instantiating S<int*>, ARGS will
9060 presently be {int*} -- but we need {int}. */
9061 pattern
= TREE_TYPE (t
);
9062 args
= TREE_PURPOSE (t
);
9066 pattern
= TREE_TYPE (templ
);
9067 args
= CLASSTYPE_TI_ARGS (type
);
9070 /* If the template we're instantiating is incomplete, then clearly
9071 there's nothing we can do. */
9072 if (!COMPLETE_TYPE_P (pattern
))
9075 /* If we've recursively instantiated too many templates, stop. */
9076 if (! push_tinst_level (type
))
9079 /* Now we're really doing the instantiation. Mark the type as in
9080 the process of being defined. */
9081 TYPE_BEING_DEFINED (type
) = 1;
9083 /* We may be in the middle of deferred access check. Disable
9085 push_deferring_access_checks (dk_no_deferred
);
9087 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
9088 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9089 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
9090 fn_context
= error_mark_node
;
9092 push_to_top_level ();
9093 /* Use #pragma pack from the template context. */
9094 saved_maximum_field_alignment
= maximum_field_alignment
;
9095 maximum_field_alignment
= TYPE_PRECISION (pattern
);
9097 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
9099 /* Set the input location to the most specialized template definition.
9100 This is needed if tsubsting causes an error. */
9101 typedecl
= TYPE_MAIN_DECL (pattern
);
9102 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
9103 DECL_SOURCE_LOCATION (typedecl
);
9105 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
9106 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
9107 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
9108 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
9109 if (ANON_AGGR_TYPE_P (pattern
))
9110 SET_ANON_AGGR_TYPE_P (type
);
9111 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
9113 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
9114 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
9115 /* Adjust visibility for template arguments. */
9116 determine_visibility (TYPE_MAIN_DECL (type
));
9118 if (CLASS_TYPE_P (type
))
9119 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
9121 pbinfo
= TYPE_BINFO (pattern
);
9123 /* We should never instantiate a nested class before its enclosing
9124 class; we need to look up the nested class by name before we can
9125 instantiate it, and that lookup should instantiate the enclosing
9127 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
9128 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
9130 base_list
= NULL_TREE
;
9131 if (BINFO_N_BASE_BINFOS (pbinfo
))
9137 /* We must enter the scope containing the type, as that is where
9138 the accessibility of types named in dependent bases are
9140 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9142 /* Substitute into each of the bases to determine the actual
9144 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9147 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9148 tree expanded_bases
= NULL_TREE
;
9151 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9154 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9155 args
, tf_error
, NULL_TREE
);
9156 if (expanded_bases
== error_mark_node
)
9159 len
= TREE_VEC_LENGTH (expanded_bases
);
9162 for (idx
= 0; idx
< len
; idx
++)
9165 /* Extract the already-expanded base class. */
9166 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9168 /* Substitute to figure out the base class. */
9169 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9172 if (base
== error_mark_node
)
9175 base_list
= tree_cons (access
, base
, base_list
);
9176 if (BINFO_VIRTUAL_P (pbase_binfo
))
9177 TREE_TYPE (base_list
) = integer_type_node
;
9181 /* The list is now in reverse order; correct that. */
9182 base_list
= nreverse (base_list
);
9185 pop_scope (pushed_scope
);
9187 /* Now call xref_basetypes to set up all the base-class
9189 xref_basetypes (type
, base_list
);
9191 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9192 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9193 args
, tf_error
, NULL_TREE
);
9194 fixup_attribute_variants (type
);
9196 /* Now that our base classes are set up, enter the scope of the
9197 class, so that name lookups into base classes, etc. will work
9198 correctly. This is precisely analogous to what we do in
9199 begin_class_definition when defining an ordinary non-template
9200 class, except we also need to push the enclosing classes. */
9201 push_nested_class (type
);
9203 /* Now members are processed in the order of declaration. */
9204 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9205 member
; member
= TREE_CHAIN (member
))
9207 tree t
= TREE_VALUE (member
);
9209 if (TREE_PURPOSE (member
))
9213 /* Build new CLASSTYPE_NESTED_UTDS. */
9216 bool class_template_p
;
9218 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9219 && TYPE_LANG_SPECIFIC (t
)
9220 && CLASSTYPE_IS_TEMPLATE (t
));
9221 /* If the member is a class template, then -- even after
9222 substitution -- there may be dependent types in the
9223 template argument list for the class. We increment
9224 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9225 that function will assume that no types are dependent
9226 when outside of a template. */
9227 if (class_template_p
)
9228 ++processing_template_decl
;
9229 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9230 if (class_template_p
)
9231 --processing_template_decl
;
9232 if (newtag
== error_mark_node
)
9235 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9237 tree name
= TYPE_IDENTIFIER (t
);
9239 if (class_template_p
)
9240 /* Unfortunately, lookup_template_class sets
9241 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9242 instantiation (i.e., for the type of a member
9243 template class nested within a template class.)
9244 This behavior is required for
9245 maybe_process_partial_specialization to work
9246 correctly, but is not accurate in this case;
9247 the TAG is not an instantiation of anything.
9248 (The corresponding TEMPLATE_DECL is an
9249 instantiation, but the TYPE is not.) */
9250 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9252 /* Now, we call pushtag to put this NEWTAG into the scope of
9253 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9254 pushtag calling push_template_decl. We don't have to do
9255 this for enums because it will already have been done in
9258 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9259 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9262 else if (DECL_DECLARES_FUNCTION_P (t
))
9264 /* Build new TYPE_METHODS. */
9267 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9268 ++processing_template_decl
;
9269 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9270 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9271 --processing_template_decl
;
9272 set_current_access_from_decl (r
);
9273 finish_member_declaration (r
);
9274 /* Instantiate members marked with attribute used. */
9275 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9277 if (TREE_CODE (r
) == FUNCTION_DECL
9278 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9279 cp_check_omp_declare_reduction (r
);
9281 else if (DECL_CLASS_TEMPLATE_P (t
)
9282 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
9283 /* A closure type for a lambda in a default argument for a
9284 member template. Ignore it; it will be instantiated with
9285 the default argument. */;
9288 /* Build new TYPE_FIELDS. */
9289 if (TREE_CODE (t
) == STATIC_ASSERT
)
9293 ++c_inhibit_evaluation_warnings
;
9295 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9296 tf_warning_or_error
, NULL_TREE
,
9297 /*integral_constant_expression_p=*/true);
9298 --c_inhibit_evaluation_warnings
;
9300 finish_static_assert (condition
,
9301 STATIC_ASSERT_MESSAGE (t
),
9302 STATIC_ASSERT_SOURCE_LOCATION (t
),
9305 else if (TREE_CODE (t
) != CONST_DECL
)
9308 tree vec
= NULL_TREE
;
9311 /* The file and line for this declaration, to
9312 assist in error message reporting. Since we
9313 called push_tinst_level above, we don't need to
9315 input_location
= DECL_SOURCE_LOCATION (t
);
9317 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9318 ++processing_template_decl
;
9319 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9320 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9321 --processing_template_decl
;
9323 if (TREE_CODE (r
) == TREE_VEC
)
9325 /* A capture pack became multiple fields. */
9327 len
= TREE_VEC_LENGTH (vec
);
9330 for (int i
= 0; i
< len
; ++i
)
9333 r
= TREE_VEC_ELT (vec
, i
);
9338 [t]he initialization (and any associated
9339 side-effects) of a static data member does
9340 not occur unless the static data member is
9341 itself used in a way that requires the
9342 definition of the static data member to
9345 Therefore, we do not substitute into the
9346 initialized for the static data member here. */
9347 finish_static_data_member_decl
9350 /*init_const_expr_p=*/false,
9351 /*asmspec_tree=*/NULL_TREE
,
9353 /* Instantiate members marked with attribute used. */
9354 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9357 else if (TREE_CODE (r
) == FIELD_DECL
)
9359 /* Determine whether R has a valid type and can be
9360 completed later. If R is invalid, then its type
9361 is replaced by error_mark_node. */
9362 tree rtype
= TREE_TYPE (r
);
9363 if (can_complete_type_without_circularity (rtype
))
9364 complete_type (rtype
);
9366 if (!COMPLETE_TYPE_P (rtype
))
9368 cxx_incomplete_type_error (r
, rtype
);
9369 TREE_TYPE (r
) = error_mark_node
;
9373 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9374 such a thing will already have been added to the field
9375 list by tsubst_enum in finish_member_declaration in the
9376 CLASSTYPE_NESTED_UTDS case above. */
9377 if (!(TREE_CODE (r
) == TYPE_DECL
9378 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9379 && DECL_ARTIFICIAL (r
)))
9381 set_current_access_from_decl (r
);
9382 finish_member_declaration (r
);
9390 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9391 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9393 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9395 tree friend_type
= t
;
9396 bool adjust_processing_template_decl
= false;
9398 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9400 /* template <class T> friend class C; */
9401 friend_type
= tsubst_friend_class (friend_type
, args
);
9402 adjust_processing_template_decl
= true;
9404 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9406 /* template <class T> friend class C::D; */
9407 friend_type
= tsubst (friend_type
, args
,
9408 tf_warning_or_error
, NULL_TREE
);
9409 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9410 friend_type
= TREE_TYPE (friend_type
);
9411 adjust_processing_template_decl
= true;
9413 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9414 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9416 /* This could be either
9420 when dependent_type_p is false or
9422 template <class U> friend class T::C;
9425 friend_type
= tsubst (friend_type
, args
,
9426 tf_warning_or_error
, NULL_TREE
);
9427 /* Bump processing_template_decl for correct
9428 dependent_type_p calculation. */
9429 ++processing_template_decl
;
9430 if (dependent_type_p (friend_type
))
9431 adjust_processing_template_decl
= true;
9432 --processing_template_decl
;
9434 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9435 && hidden_name_p (TYPE_NAME (friend_type
)))
9439 where C hasn't been declared yet. Let's lookup name
9440 from namespace scope directly, bypassing any name that
9441 come from dependent base class. */
9442 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9444 /* The call to xref_tag_from_type does injection for friend
9446 push_nested_namespace (ns
);
9448 xref_tag_from_type (friend_type
, NULL_TREE
,
9449 /*tag_scope=*/ts_current
);
9450 pop_nested_namespace (ns
);
9452 else if (uses_template_parms (friend_type
))
9453 /* friend class C<T>; */
9454 friend_type
= tsubst (friend_type
, args
,
9455 tf_warning_or_error
, NULL_TREE
);
9460 where C is already declared or
9462 friend class C<int>;
9464 We don't have to do anything in these cases. */
9466 if (adjust_processing_template_decl
)
9467 /* Trick make_friend_class into realizing that the friend
9468 we're adding is a template, not an ordinary class. It's
9469 important that we use make_friend_class since it will
9470 perform some error-checking and output cross-reference
9472 ++processing_template_decl
;
9474 if (friend_type
!= error_mark_node
)
9475 make_friend_class (type
, friend_type
, /*complain=*/false);
9477 if (adjust_processing_template_decl
)
9478 --processing_template_decl
;
9482 /* Build new DECL_FRIENDLIST. */
9485 /* The file and line for this declaration, to
9486 assist in error message reporting. Since we
9487 called push_tinst_level above, we don't need to
9489 input_location
= DECL_SOURCE_LOCATION (t
);
9491 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9493 ++processing_template_decl
;
9494 push_deferring_access_checks (dk_no_check
);
9497 r
= tsubst_friend_function (t
, args
);
9498 add_friend (type
, r
, /*complain=*/false);
9499 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9501 pop_deferring_access_checks ();
9502 --processing_template_decl
;
9508 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9510 tree decl
= lambda_function (type
);
9513 if (!DECL_TEMPLATE_INFO (decl
)
9514 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9515 instantiate_decl (decl
, false, false);
9517 /* We need to instantiate the capture list from the template
9518 after we've instantiated the closure members, but before we
9519 consider adding the conversion op. Also keep any captures
9520 that may have been added during instantiation of the op(). */
9521 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9523 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9524 args
, tf_warning_or_error
, NULL_TREE
,
9527 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9528 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9530 maybe_add_lambda_conv_op (type
);
9533 gcc_assert (errorcount
);
9536 /* Set the file and line number information to whatever is given for
9537 the class itself. This puts error messages involving generated
9538 implicit functions at a predictable point, and the same point
9539 that would be used for non-template classes. */
9540 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9542 unreverse_member_declarations (type
);
9543 finish_struct_1 (type
);
9544 TYPE_BEING_DEFINED (type
) = 0;
9546 /* We don't instantiate default arguments for member functions. 14.7.1:
9548 The implicit instantiation of a class template specialization causes
9549 the implicit instantiation of the declarations, but not of the
9550 definitions or default arguments, of the class member functions,
9551 member classes, static data members and member templates.... */
9553 /* Some typedefs referenced from within the template code need to be access
9554 checked at template instantiation time, i.e now. These types were
9555 added to the template at parsing time. Let's get those and perform
9556 the access checks then. */
9557 perform_typedefs_access_check (pattern
, args
);
9558 perform_deferred_access_checks (tf_warning_or_error
);
9559 pop_nested_class ();
9560 maximum_field_alignment
= saved_maximum_field_alignment
;
9562 pop_from_top_level ();
9563 pop_deferring_access_checks ();
9566 /* The vtable for a template class can be emitted in any translation
9567 unit in which the class is instantiated. When there is no key
9568 method, however, finish_struct_1 will already have added TYPE to
9569 the keyed_classes list. */
9570 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9571 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9576 /* Wrapper for instantiate_class_template_1. */
9579 instantiate_class_template (tree type
)
9582 timevar_push (TV_TEMPLATE_INST
);
9583 ret
= instantiate_class_template_1 (type
);
9584 timevar_pop (TV_TEMPLATE_INST
);
9589 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9595 else if (TYPE_P (t
))
9596 r
= tsubst (t
, args
, complain
, in_decl
);
9599 if (!(complain
& tf_warning
))
9600 ++c_inhibit_evaluation_warnings
;
9601 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9602 /*integral_constant_expression_p=*/true);
9603 if (!(complain
& tf_warning
))
9604 --c_inhibit_evaluation_warnings
;
9609 /* Given a function parameter pack TMPL_PARM and some function parameters
9610 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9611 and set *SPEC_P to point at the next point in the list. */
9614 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9616 /* Collect all of the extra "packed" parameters into an
9620 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9621 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9622 tree spec_parm
= *spec_p
;
9625 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9627 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9630 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9631 parmvec
= make_tree_vec (len
);
9632 parmtypevec
= make_tree_vec (len
);
9633 spec_parm
= *spec_p
;
9634 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9636 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9637 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9640 /* Build the argument packs. */
9641 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9642 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9643 TREE_TYPE (argpack
) = argtypepack
;
9644 *spec_p
= spec_parm
;
9649 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9650 NONTYPE_ARGUMENT_PACK. */
9653 make_fnparm_pack (tree spec_parm
)
9655 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9658 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9662 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9664 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9665 if (i
>= TREE_VEC_LENGTH (vec
))
9667 return PACK_EXPANSION_P (TREE_VEC_ELT (vec
, i
));
9671 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9674 make_argument_pack_select (tree arg_pack
, unsigned index
)
9676 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9678 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9679 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9684 /* This is a subroutine of tsubst_pack_expansion.
9686 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9687 mechanism to store the (non complete list of) arguments of the
9688 substitution and return a non substituted pack expansion, in order
9689 to wait for when we have enough arguments to really perform the
9693 use_pack_expansion_extra_args_p (tree parm_packs
,
9697 /* If one pack has an expansion and another pack has a normal
9698 argument or if one pack has an empty argument and an another
9699 one hasn't then tsubst_pack_expansion cannot perform the
9700 substitution and need to fall back on the
9701 PACK_EXPANSION_EXTRA mechanism. */
9702 if (parm_packs
== NULL_TREE
)
9704 else if (has_empty_arg
)
9707 bool has_expansion_arg
= false;
9708 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9710 bool has_non_expansion_arg
= false;
9711 for (tree parm_pack
= parm_packs
;
9713 parm_pack
= TREE_CHAIN (parm_pack
))
9715 tree arg
= TREE_VALUE (parm_pack
);
9717 if (argument_pack_element_is_expansion_p (arg
, i
))
9718 has_expansion_arg
= true;
9720 has_non_expansion_arg
= true;
9723 if (has_expansion_arg
&& has_non_expansion_arg
)
9729 /* [temp.variadic]/6 says that:
9731 The instantiation of a pack expansion [...]
9732 produces a list E1,E2, ..., En, where N is the number of elements
9733 in the pack expansion parameters.
9735 This subroutine of tsubst_pack_expansion produces one of these Ei.
9737 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9738 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9739 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9740 INDEX is the index 'i' of the element Ei to produce. ARGS,
9741 COMPLAIN, and IN_DECL are the same parameters as for the
9742 tsubst_pack_expansion function.
9744 The function returns the resulting Ei upon successful completion,
9747 Note that this function possibly modifies the ARGS parameter, so
9748 it's the responsibility of the caller to restore it. */
9751 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9754 tree args
/* This parm gets
9756 tsubst_flags_t complain
,
9760 bool ith_elem_is_expansion
= false;
9762 /* For each parameter pack, change the substitution of the parameter
9763 pack to the ith argument in its argument pack, then expand the
9765 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9767 tree parm
= TREE_PURPOSE (pack
);
9768 tree arg_pack
= TREE_VALUE (pack
);
9769 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9771 ith_elem_is_expansion
|=
9772 argument_pack_element_is_expansion_p (arg_pack
, index
);
9774 /* Select the Ith argument from the pack. */
9775 if (TREE_CODE (parm
) == PARM_DECL
9776 || TREE_CODE (parm
) == FIELD_DECL
)
9780 aps
= make_argument_pack_select (arg_pack
, index
);
9782 register_local_specialization (aps
, parm
);
9785 aps
= retrieve_local_specialization (parm
);
9790 template_parm_level_and_index (parm
, &level
, &idx
);
9794 aps
= make_argument_pack_select (arg_pack
, index
);
9795 /* Update the corresponding argument. */
9796 TMPL_ARG (args
, level
, idx
) = aps
;
9799 /* Re-use the ARGUMENT_PACK_SELECT. */
9800 aps
= TMPL_ARG (args
, level
, idx
);
9802 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9805 /* Substitute into the PATTERN with the (possibly altered)
9807 if (pattern
== in_decl
)
9808 /* Expanding a fixed parameter pack from
9809 coerce_template_parameter_pack. */
9810 t
= tsubst_decl (pattern
, args
, complain
);
9811 else if (!TYPE_P (pattern
))
9812 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9813 /*integral_constant_expression_p=*/false);
9815 t
= tsubst (pattern
, args
, complain
, in_decl
);
9817 /* If the Ith argument pack element is a pack expansion, then
9818 the Ith element resulting from the substituting is going to
9819 be a pack expansion as well. */
9820 if (ith_elem_is_expansion
)
9821 t
= make_pack_expansion (t
);
9826 /* Substitute ARGS into T, which is an pack expansion
9827 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9828 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9829 (if only a partial substitution could be performed) or
9830 ERROR_MARK_NODE if there was an error. */
9832 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9836 tree pack
, packs
= NULL_TREE
;
9837 bool unsubstituted_packs
= false;
9840 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
9841 bool need_local_specializations
= false;
9844 gcc_assert (PACK_EXPANSION_P (t
));
9845 pattern
= PACK_EXPANSION_PATTERN (t
);
9847 /* Add in any args remembered from an earlier partial instantiation. */
9848 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9850 levels
= TMPL_ARGS_DEPTH (args
);
9852 /* Determine the argument packs that will instantiate the parameter
9853 packs used in the expansion expression. While we're at it,
9854 compute the number of arguments to be expanded and make sure it
9856 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
9857 pack
= TREE_CHAIN (pack
))
9859 tree parm_pack
= TREE_VALUE (pack
);
9860 tree arg_pack
= NULL_TREE
;
9861 tree orig_arg
= NULL_TREE
;
9864 if (TREE_CODE (parm_pack
) == BASES
)
9866 if (BASES_DIRECT (parm_pack
))
9867 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9868 args
, complain
, in_decl
, false));
9870 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9871 args
, complain
, in_decl
, false));
9873 if (TREE_CODE (parm_pack
) == PARM_DECL
)
9875 if (PACK_EXPANSION_LOCAL_P (t
))
9876 arg_pack
= retrieve_local_specialization (parm_pack
);
9879 /* We can't rely on local_specializations for a parameter
9880 name used later in a function declaration (such as in a
9881 late-specified return type). Even if it exists, it might
9882 have the wrong value for a recursive call. Just make a
9883 dummy decl, since it's only used for its type. */
9884 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
9885 if (arg_pack
&& DECL_PACK_P (arg_pack
))
9886 /* Partial instantiation of the parm_pack, we can't build
9887 up an argument pack yet. */
9888 arg_pack
= NULL_TREE
;
9890 arg_pack
= make_fnparm_pack (arg_pack
);
9891 need_local_specializations
= true;
9894 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
9895 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
9899 template_parm_level_and_index (parm_pack
, &level
, &idx
);
9901 if (level
<= levels
)
9902 arg_pack
= TMPL_ARG (args
, level
, idx
);
9905 orig_arg
= arg_pack
;
9906 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
9907 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
9909 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
9910 /* This can only happen if we forget to expand an argument
9911 pack somewhere else. Just return an error, silently. */
9913 result
= make_tree_vec (1);
9914 TREE_VEC_ELT (result
, 0) = error_mark_node
;
9921 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
9923 /* Don't bother trying to do a partial substitution with
9924 incomplete packs; we'll try again after deduction. */
9925 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
9930 else if (len
!= my_len
)
9932 if (!(complain
& tf_error
))
9933 /* Fail quietly. */;
9934 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
9935 error ("mismatched argument pack lengths while expanding "
9939 error ("mismatched argument pack lengths while expanding "
9942 return error_mark_node
;
9945 /* Keep track of the parameter packs and their corresponding
9947 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
9948 TREE_TYPE (packs
) = orig_arg
;
9952 /* We can't substitute for this parameter pack. We use a flag as
9953 well as the missing_level counter because function parameter
9954 packs don't have a level. */
9955 unsubstituted_packs
= true;
9959 /* If the expansion is just T..., return the matching argument pack. */
9960 if (!unsubstituted_packs
9961 && TREE_PURPOSE (packs
) == pattern
)
9963 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
9964 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
9965 || pack_expansion_args_count (args
))
9967 /* Otherwise use the normal path so we get convert_from_reference. */
9970 /* We cannot expand this expansion expression, because we don't have
9971 all of the argument packs we need. */
9972 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
9974 /* We got some full packs, but we can't substitute them in until we
9975 have values for all the packs. So remember these until then. */
9977 t
= make_pack_expansion (pattern
);
9978 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
9981 else if (unsubstituted_packs
)
9983 /* There were no real arguments, we're just replacing a parameter
9984 pack with another version of itself. Substitute into the
9985 pattern and return a PACK_EXPANSION_*. The caller will need to
9987 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
9988 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9989 /*integral_constant_expression_p=*/false);
9991 t
= tsubst (pattern
, args
, complain
, in_decl
);
9992 t
= make_pack_expansion (t
);
9996 gcc_assert (len
>= 0);
9998 if (need_local_specializations
)
10000 /* We're in a late-specified return type, so create our own local
10001 specializations map; the current map is either NULL or (in the
10002 case of recursive unification) might have bindings that we don't
10003 want to use or alter. */
10004 saved_local_specializations
= local_specializations
;
10005 local_specializations
= new hash_map
<tree
, tree
>;
10008 /* For each argument in each argument pack, substitute into the
10010 result
= make_tree_vec (len
);
10011 for (i
= 0; i
< len
; ++i
)
10013 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
10017 TREE_VEC_ELT (result
, i
) = t
;
10018 if (t
== error_mark_node
)
10020 result
= error_mark_node
;
10025 /* Update ARGS to restore the substitution from parameter packs to
10026 their argument packs. */
10027 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
10029 tree parm
= TREE_PURPOSE (pack
);
10031 if (TREE_CODE (parm
) == PARM_DECL
10032 || TREE_CODE (parm
) == FIELD_DECL
)
10033 register_local_specialization (TREE_TYPE (pack
), parm
);
10038 if (TREE_VALUE (pack
) == NULL_TREE
)
10041 template_parm_level_and_index (parm
, &level
, &idx
);
10043 /* Update the corresponding argument. */
10044 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
10045 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
10048 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
10052 if (need_local_specializations
)
10054 delete local_specializations
;
10055 local_specializations
= saved_local_specializations
;
10061 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10062 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10063 parameter packs; all parms generated from a function parameter pack will
10064 have the same DECL_PARM_INDEX. */
10067 get_pattern_parm (tree parm
, tree tmpl
)
10069 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
10072 if (DECL_ARTIFICIAL (parm
))
10074 for (patparm
= DECL_ARGUMENTS (pattern
);
10075 patparm
; patparm
= DECL_CHAIN (patparm
))
10076 if (DECL_ARTIFICIAL (patparm
)
10077 && DECL_NAME (parm
) == DECL_NAME (patparm
))
10082 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
10083 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
10084 gcc_assert (DECL_PARM_INDEX (patparm
)
10085 == DECL_PARM_INDEX (parm
));
10091 /* Substitute ARGS into the vector or list of template arguments T. */
10094 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10097 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
10100 if (t
== error_mark_node
)
10101 return error_mark_node
;
10103 len
= TREE_VEC_LENGTH (t
);
10104 elts
= XALLOCAVEC (tree
, len
);
10106 for (i
= 0; i
< len
; i
++)
10108 tree orig_arg
= TREE_VEC_ELT (t
, i
);
10111 if (TREE_CODE (orig_arg
) == TREE_VEC
)
10112 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
10113 else if (PACK_EXPANSION_P (orig_arg
))
10115 /* Substitute into an expansion expression. */
10116 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
10118 if (TREE_CODE (new_arg
) == TREE_VEC
)
10119 /* Add to the expanded length adjustment the number of
10120 expanded arguments. We subtract one from this
10121 measurement, because the argument pack expression
10122 itself is already counted as 1 in
10123 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10124 the argument pack is empty. */
10125 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
10127 else if (ARGUMENT_PACK_P (orig_arg
))
10129 /* Substitute into each of the arguments. */
10130 new_arg
= TYPE_P (orig_arg
)
10131 ? cxx_make_type (TREE_CODE (orig_arg
))
10132 : make_node (TREE_CODE (orig_arg
));
10134 SET_ARGUMENT_PACK_ARGS (
10136 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
10137 args
, complain
, in_decl
));
10139 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
10140 new_arg
= error_mark_node
;
10142 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
10143 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
10144 complain
, in_decl
);
10145 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
10147 if (TREE_TYPE (new_arg
) == error_mark_node
)
10148 new_arg
= error_mark_node
;
10152 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
10154 if (new_arg
== error_mark_node
)
10155 return error_mark_node
;
10158 if (new_arg
!= orig_arg
)
10165 /* Make space for the expanded arguments coming from template
10167 t
= make_tree_vec (len
+ expanded_len_adjust
);
10168 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10169 arguments for a member template.
10170 In that case each TREE_VEC in ORIG_T represents a level of template
10171 arguments, and ORIG_T won't carry any non defaulted argument count.
10172 It will rather be the nested TREE_VECs that will carry one.
10173 In other words, ORIG_T carries a non defaulted argument count only
10174 if it doesn't contain any nested TREE_VEC. */
10175 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
10177 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
10178 count
+= expanded_len_adjust
;
10179 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
10181 for (i
= 0, out
= 0; i
< len
; i
++)
10183 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
10184 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
10185 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10189 /* Now expand the template argument pack "in place". */
10190 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10191 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10195 TREE_VEC_ELT (t
, out
) = elts
[i
];
10203 /* Return the result of substituting ARGS into the template parameters
10204 given by PARMS. If there are m levels of ARGS and m + n levels of
10205 PARMS, then the result will contain n levels of PARMS. For
10206 example, if PARMS is `template <class T> template <class U>
10207 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10208 result will be `template <int*, double, class V>'. */
10211 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10213 tree r
= NULL_TREE
;
10216 /* When substituting into a template, we must set
10217 PROCESSING_TEMPLATE_DECL as the template parameters may be
10218 dependent if they are based on one-another, and the dependency
10219 predicates are short-circuit outside of templates. */
10220 ++processing_template_decl
;
10222 for (new_parms
= &r
;
10223 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10224 new_parms
= &(TREE_CHAIN (*new_parms
)),
10225 parms
= TREE_CHAIN (parms
))
10228 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10231 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10235 if (parms
== error_mark_node
)
10238 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10240 if (tuple
== error_mark_node
)
10243 TREE_VEC_ELT (new_vec
, i
) =
10244 tsubst_template_parm (tuple
, args
, complain
);
10248 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10249 - TMPL_ARGS_DEPTH (args
)),
10250 new_vec
, NULL_TREE
);
10253 --processing_template_decl
;
10258 /* Return the result of substituting ARGS into one template parameter
10259 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10260 parameter and which TREE_PURPOSE is the default argument of the
10261 template parameter. */
10264 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10266 tree default_value
, parm_decl
;
10268 if (args
== NULL_TREE
10270 || t
== error_mark_node
)
10273 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10275 default_value
= TREE_PURPOSE (t
);
10276 parm_decl
= TREE_VALUE (t
);
10278 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10279 if (TREE_CODE (parm_decl
) == PARM_DECL
10280 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10281 parm_decl
= error_mark_node
;
10282 default_value
= tsubst_template_arg (default_value
, args
,
10283 complain
, NULL_TREE
);
10285 return build_tree_list (default_value
, parm_decl
);
10288 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10289 type T. If T is not an aggregate or enumeration type, it is
10290 handled as if by tsubst. IN_DECL is as for tsubst. If
10291 ENTERING_SCOPE is nonzero, T is the context for a template which
10292 we are presently tsubst'ing. Return the substituted value. */
10295 tsubst_aggr_type (tree t
,
10297 tsubst_flags_t complain
,
10299 int entering_scope
)
10301 if (t
== NULL_TREE
)
10304 switch (TREE_CODE (t
))
10307 if (TYPE_PTRMEMFUNC_P (t
))
10308 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10310 /* Else fall through. */
10311 case ENUMERAL_TYPE
:
10313 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10318 int saved_unevaluated_operand
;
10319 int saved_inhibit_evaluation_warnings
;
10321 /* In "sizeof(X<I>)" we need to evaluate "I". */
10322 saved_unevaluated_operand
= cp_unevaluated_operand
;
10323 cp_unevaluated_operand
= 0;
10324 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10325 c_inhibit_evaluation_warnings
= 0;
10327 /* First, determine the context for the type we are looking
10329 context
= TYPE_CONTEXT (t
);
10330 if (context
&& TYPE_P (context
))
10332 context
= tsubst_aggr_type (context
, args
, complain
,
10333 in_decl
, /*entering_scope=*/1);
10334 /* If context is a nested class inside a class template,
10335 it may still need to be instantiated (c++/33959). */
10336 context
= complete_type (context
);
10339 /* Then, figure out what arguments are appropriate for the
10340 type we are trying to find. For example, given:
10342 template <class T> struct S;
10343 template <class T, class U> void f(T, U) { S<U> su; }
10345 and supposing that we are instantiating f<int, double>,
10346 then our ARGS will be {int, double}, but, when looking up
10347 S we only want {double}. */
10348 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10349 complain
, in_decl
);
10350 if (argvec
== error_mark_node
)
10351 r
= error_mark_node
;
10354 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10355 entering_scope
, complain
);
10356 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10359 cp_unevaluated_operand
= saved_unevaluated_operand
;
10360 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10365 /* This is not a template type, so there's nothing to do. */
10369 return tsubst (t
, args
, complain
, in_decl
);
10373 /* Substitute into the default argument ARG (a default argument for
10374 FN), which has the indicated TYPE. */
10377 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10379 tree saved_class_ptr
= NULL_TREE
;
10380 tree saved_class_ref
= NULL_TREE
;
10381 int errs
= errorcount
+ sorrycount
;
10383 /* This can happen in invalid code. */
10384 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10387 /* This default argument came from a template. Instantiate the
10388 default argument here, not in tsubst. In the case of
10397 we must be careful to do name lookup in the scope of S<T>,
10398 rather than in the current class. */
10399 push_access_scope (fn
);
10400 /* The "this" pointer is not valid in a default argument. */
10403 saved_class_ptr
= current_class_ptr
;
10404 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10405 saved_class_ref
= current_class_ref
;
10406 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10409 push_deferring_access_checks(dk_no_deferred
);
10410 /* The default argument expression may cause implicitly defined
10411 member functions to be synthesized, which will result in garbage
10412 collection. We must treat this situation as if we were within
10413 the body of function so as to avoid collecting live data on the
10416 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10417 complain
, NULL_TREE
,
10418 /*integral_constant_expression_p=*/false);
10420 pop_deferring_access_checks();
10422 /* Restore the "this" pointer. */
10425 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10426 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10429 if (errorcount
+sorrycount
> errs
10430 && (complain
& tf_warning_or_error
))
10431 inform (input_location
,
10432 " when instantiating default argument for call to %D", fn
);
10434 /* Make sure the default argument is reasonable. */
10435 arg
= check_default_argument (type
, arg
, complain
);
10437 pop_access_scope (fn
);
10442 /* Substitute into all the default arguments for FN. */
10445 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10450 tmpl_args
= DECL_TI_ARGS (fn
);
10452 /* If this function is not yet instantiated, we certainly don't need
10453 its default arguments. */
10454 if (uses_template_parms (tmpl_args
))
10456 /* Don't do this again for clones. */
10457 if (DECL_CLONED_FUNCTION_P (fn
))
10460 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10462 arg
= TREE_CHAIN (arg
))
10463 if (TREE_PURPOSE (arg
))
10464 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10466 TREE_PURPOSE (arg
),
10470 /* Substitute the ARGS into the T, which is a _DECL. Return the
10471 result of the substitution. Issue error and warning messages under
10472 control of COMPLAIN. */
10475 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10477 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10478 location_t saved_loc
;
10479 tree r
= NULL_TREE
;
10481 hashval_t hash
= 0;
10483 /* Set the filename and linenumber to improve error-reporting. */
10484 saved_loc
= input_location
;
10485 input_location
= DECL_SOURCE_LOCATION (t
);
10487 switch (TREE_CODE (t
))
10489 case TEMPLATE_DECL
:
10491 /* We can get here when processing a member function template,
10492 member class template, or template template parameter. */
10493 tree decl
= DECL_TEMPLATE_RESULT (t
);
10498 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10500 /* Template template parameter is treated here. */
10501 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10502 if (new_type
== error_mark_node
)
10503 RETURN (error_mark_node
);
10504 /* If we get a real template back, return it. This can happen in
10505 the context of most_specialized_class. */
10506 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10510 DECL_CHAIN (r
) = NULL_TREE
;
10511 TREE_TYPE (r
) = new_type
;
10512 DECL_TEMPLATE_RESULT (r
)
10513 = build_decl (DECL_SOURCE_LOCATION (decl
),
10514 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10515 DECL_TEMPLATE_PARMS (r
)
10516 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10518 TYPE_NAME (new_type
) = r
;
10522 /* We might already have an instance of this template.
10523 The ARGS are for the surrounding class type, so the
10524 full args contain the tsubst'd args for the context,
10525 plus the innermost args from the template decl. */
10526 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10527 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10528 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10529 /* Because this is a template, the arguments will still be
10530 dependent, even after substitution. If
10531 PROCESSING_TEMPLATE_DECL is not set, the dependency
10532 predicates will short-circuit. */
10533 ++processing_template_decl
;
10534 full_args
= tsubst_template_args (tmpl_args
, args
,
10535 complain
, in_decl
);
10536 --processing_template_decl
;
10537 if (full_args
== error_mark_node
)
10538 RETURN (error_mark_node
);
10540 /* If this is a default template template argument,
10541 tsubst might not have changed anything. */
10542 if (full_args
== tmpl_args
)
10545 hash
= hash_tmpl_and_args (t
, full_args
);
10546 spec
= retrieve_specialization (t
, full_args
, hash
);
10547 if (spec
!= NULL_TREE
)
10553 /* Make a new template decl. It will be similar to the
10554 original, but will record the current template arguments.
10555 We also create a new function declaration, which is just
10556 like the old one, but points to this new template, rather
10557 than the old one. */
10559 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10560 DECL_CHAIN (r
) = NULL_TREE
;
10562 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10564 if (TREE_CODE (decl
) == TYPE_DECL
10565 && !TYPE_DECL_ALIAS_P (decl
))
10568 ++processing_template_decl
;
10569 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10570 --processing_template_decl
;
10571 if (new_type
== error_mark_node
)
10572 RETURN (error_mark_node
);
10574 TREE_TYPE (r
) = new_type
;
10575 /* For a partial specialization, we need to keep pointing to
10576 the primary template. */
10577 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10578 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10579 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10580 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10581 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10586 ++processing_template_decl
;
10587 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10588 --processing_template_decl
;
10589 if (new_decl
== error_mark_node
)
10590 RETURN (error_mark_node
);
10592 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10593 DECL_TI_TEMPLATE (new_decl
) = r
;
10594 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10595 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10596 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10599 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10600 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10601 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10603 /* The template parameters for this new template are all the
10604 template parameters for the old template, except the
10605 outermost level of parameters. */
10606 DECL_TEMPLATE_PARMS (r
)
10607 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10610 if (PRIMARY_TEMPLATE_P (t
))
10611 DECL_PRIMARY_TEMPLATE (r
) = r
;
10613 if (TREE_CODE (decl
) != TYPE_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
10614 /* Record this non-type partial instantiation. */
10615 register_specialization (r
, t
,
10616 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10621 case FUNCTION_DECL
:
10624 tree argvec
= NULL_TREE
;
10632 /* Nobody should be tsubst'ing into non-template functions. */
10633 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10635 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10640 /* If T is not dependent, just return it. We have to
10641 increment PROCESSING_TEMPLATE_DECL because
10642 value_dependent_expression_p assumes that nothing is
10643 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10644 ++processing_template_decl
;
10645 dependent_p
= value_dependent_expression_p (t
);
10646 --processing_template_decl
;
10650 /* Calculate the most general template of which R is a
10651 specialization, and the complete set of arguments used to
10653 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10654 argvec
= tsubst_template_args (DECL_TI_ARGS
10655 (DECL_TEMPLATE_RESULT
10656 (DECL_TI_TEMPLATE (t
))),
10657 args
, complain
, in_decl
);
10658 if (argvec
== error_mark_node
)
10659 RETURN (error_mark_node
);
10661 /* Check to see if we already have this specialization. */
10662 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10663 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10671 /* We can see more levels of arguments than parameters if
10672 there was a specialization of a member template, like
10675 template <class T> struct S { template <class U> void f(); }
10676 template <> template <class U> void S<int>::f(U);
10678 Here, we'll be substituting into the specialization,
10679 because that's where we can find the code we actually
10680 want to generate, but we'll have enough arguments for
10681 the most general template.
10683 We also deal with the peculiar case:
10685 template <class T> struct S {
10686 template <class U> friend void f();
10688 template <class U> void f() {}
10690 template void f<double>();
10692 Here, the ARGS for the instantiation of will be {int,
10693 double}. But, we only need as many ARGS as there are
10694 levels of template parameters in CODE_PATTERN. We are
10695 careful not to get fooled into reducing the ARGS in
10698 template <class T> struct S { template <class U> void f(U); }
10699 template <class T> template <> void S<T>::f(int) {}
10701 which we can spot because the pattern will be a
10702 specialization in this case. */
10703 args_depth
= TMPL_ARGS_DEPTH (args
);
10705 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10706 if (args_depth
> parms_depth
10707 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10708 args
= get_innermost_template_args (args
, parms_depth
);
10712 /* This special case arises when we have something like this:
10714 template <class T> struct S {
10715 friend void f<int>(int, double);
10718 Here, the DECL_TI_TEMPLATE for the friend declaration
10719 will be an IDENTIFIER_NODE. We are being called from
10720 tsubst_friend_function, and we want only to create a
10721 new decl (R) with appropriate types so that we can call
10722 determine_specialization. */
10723 gen_tmpl
= NULL_TREE
;
10726 if (DECL_CLASS_SCOPE_P (t
))
10728 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10732 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10733 complain
, t
, /*entering_scope=*/1);
10738 ctx
= DECL_CONTEXT (t
);
10740 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10741 if (type
== error_mark_node
)
10742 RETURN (error_mark_node
);
10744 /* If we hit excessive deduction depth, the type is bogus even if
10745 it isn't error_mark_node, so don't build a decl. */
10746 if (excessive_deduction_depth
)
10747 RETURN (error_mark_node
);
10749 /* We do NOT check for matching decls pushed separately at this
10750 point, as they may not represent instantiations of this
10751 template, and in any case are considered separate under the
10754 DECL_USE_TEMPLATE (r
) = 0;
10755 TREE_TYPE (r
) = type
;
10756 /* Clear out the mangled name and RTL for the instantiation. */
10757 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10758 SET_DECL_RTL (r
, NULL
);
10759 /* Leave DECL_INITIAL set on deleted instantiations. */
10760 if (!DECL_DELETED_FN (r
))
10761 DECL_INITIAL (r
) = NULL_TREE
;
10762 DECL_CONTEXT (r
) = ctx
;
10764 /* OpenMP UDRs have the only argument a reference to the declared
10765 type. We want to diagnose if the declared type is a reference,
10766 which is invalid, but as references to references are usually
10767 quietly merged, diagnose it here. */
10768 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10771 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10772 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10773 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10774 error_at (DECL_SOURCE_LOCATION (t
),
10775 "reference type %qT in "
10776 "%<#pragma omp declare reduction%>", argtype
);
10777 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10778 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10782 if (member
&& DECL_CONV_FN_P (r
))
10783 /* Type-conversion operator. Reconstruct the name, in
10784 case it's the name of one of the template's parameters. */
10785 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10787 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10789 DECL_RESULT (r
) = NULL_TREE
;
10791 TREE_STATIC (r
) = 0;
10792 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10793 DECL_EXTERNAL (r
) = 1;
10794 /* If this is an instantiation of a function with internal
10795 linkage, we already know what object file linkage will be
10796 assigned to the instantiation. */
10797 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10798 DECL_DEFER_OUTPUT (r
) = 0;
10799 DECL_CHAIN (r
) = NULL_TREE
;
10800 DECL_PENDING_INLINE_INFO (r
) = 0;
10801 DECL_PENDING_INLINE_P (r
) = 0;
10802 DECL_SAVED_TREE (r
) = NULL_TREE
;
10803 DECL_STRUCT_FUNCTION (r
) = NULL
;
10805 /* We'll re-clone as appropriate in instantiate_template. */
10806 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10808 /* If we aren't complaining now, return on error before we register
10809 the specialization so that we'll complain eventually. */
10810 if ((complain
& tf_error
) == 0
10811 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10812 && !grok_op_properties (r
, /*complain=*/false))
10813 RETURN (error_mark_node
);
10815 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10816 this in the special friend case mentioned above where
10817 GEN_TMPL is NULL. */
10820 DECL_TEMPLATE_INFO (r
)
10821 = build_template_info (gen_tmpl
, argvec
);
10822 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10825 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10827 /* We instantiated this while substituting into
10828 the type earlier (template/friend54.C). */
10831 /* We're not supposed to instantiate default arguments
10832 until they are called, for a template. But, for a
10835 template <class T> void f ()
10836 { extern void g(int i = T()); }
10838 we should do the substitution when the template is
10839 instantiated. We handle the member function case in
10840 instantiate_class_template since the default arguments
10841 might refer to other members of the class. */
10843 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10844 && !uses_template_parms (argvec
))
10845 tsubst_default_arguments (r
, complain
);
10848 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10850 /* Copy the list of befriending classes. */
10851 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10853 friends
= &TREE_CHAIN (*friends
))
10855 *friends
= copy_node (*friends
);
10856 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
10861 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
10863 maybe_retrofit_in_chrg (r
);
10864 if (DECL_CONSTRUCTOR_P (r
))
10865 grok_ctor_properties (ctx
, r
);
10866 if (DECL_INHERITED_CTOR_BASE (r
))
10867 deduce_inheriting_ctor (r
);
10868 /* If this is an instantiation of a member template, clone it.
10869 If it isn't, that'll be handled by
10870 clone_constructors_and_destructors. */
10871 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
10872 clone_function_decl (r
, /*update_method_vec_p=*/0);
10874 else if ((complain
& tf_error
) != 0
10875 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10876 && !grok_op_properties (r
, /*complain=*/true))
10877 RETURN (error_mark_node
);
10879 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
10880 SET_DECL_FRIEND_CONTEXT (r
,
10881 tsubst (DECL_FRIEND_CONTEXT (t
),
10882 args
, complain
, in_decl
));
10884 /* Possibly limit visibility based on template args. */
10885 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10886 if (DECL_VISIBILITY_SPECIFIED (t
))
10888 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10889 DECL_ATTRIBUTES (r
)
10890 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10892 determine_visibility (r
);
10893 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
10894 && !processing_template_decl
)
10895 defaulted_late_check (r
);
10897 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10898 args
, complain
, in_decl
);
10904 tree type
= NULL_TREE
;
10906 tree expanded_types
= NULL_TREE
;
10907 tree prev_r
= NULL_TREE
;
10908 tree first_r
= NULL_TREE
;
10910 if (DECL_PACK_P (t
))
10912 /* If there is a local specialization that isn't a
10913 parameter pack, it means that we're doing a "simple"
10914 substitution from inside tsubst_pack_expansion. Just
10915 return the local specialization (which will be a single
10917 tree spec
= retrieve_local_specialization (t
);
10919 && TREE_CODE (spec
) == PARM_DECL
10920 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
10923 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10924 the parameters in this function parameter pack. */
10925 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10926 complain
, in_decl
);
10927 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10929 len
= TREE_VEC_LENGTH (expanded_types
);
10931 /* Zero-length parameter packs are boring. Just substitute
10934 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
10939 /* All we did was update the type. Make a note of that. */
10940 type
= expanded_types
;
10941 expanded_types
= NULL_TREE
;
10945 /* Loop through all of the parameters we'll build. When T is
10946 a function parameter pack, LEN is the number of expanded
10947 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10949 for (i
= 0; i
< len
; ++i
)
10953 if (DECL_TEMPLATE_PARM_P (t
))
10954 SET_DECL_TEMPLATE_PARM_P (r
);
10956 if (expanded_types
)
10957 /* We're on the Ith parameter of the function parameter
10960 /* Get the Ith type. */
10961 type
= TREE_VEC_ELT (expanded_types
, i
);
10963 /* Rename the parameter to include the index. */
10965 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10968 /* We're dealing with a normal parameter. */
10969 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10971 type
= type_decays_to (type
);
10972 TREE_TYPE (r
) = type
;
10973 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10975 if (DECL_INITIAL (r
))
10977 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
10978 DECL_INITIAL (r
) = TREE_TYPE (r
);
10980 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
10981 complain
, in_decl
);
10984 DECL_CONTEXT (r
) = NULL_TREE
;
10986 if (!DECL_TEMPLATE_PARM_P (r
))
10987 DECL_ARG_TYPE (r
) = type_passed_as (type
);
10989 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10990 args
, complain
, in_decl
);
10992 /* Keep track of the first new parameter we
10993 generate. That's what will be returned to the
10998 /* Build a proper chain of parameters when substituting
10999 into a function parameter pack. */
11001 DECL_CHAIN (prev_r
) = r
;
11004 /* If cp_unevaluated_operand is set, we're just looking for a
11005 single dummy parameter, so don't keep going. */
11006 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
11007 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
11008 complain
, DECL_CHAIN (t
));
11010 /* FIRST_R contains the start of the chain we've built. */
11017 tree type
= NULL_TREE
;
11018 tree vec
= NULL_TREE
;
11019 tree expanded_types
= NULL_TREE
;
11022 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
11024 /* This field is a lambda capture pack. Return a TREE_VEC of
11025 the expanded fields to instantiate_class_template_1 and
11026 store them in the specializations hash table as a
11027 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11028 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11029 complain
, in_decl
);
11030 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11032 len
= TREE_VEC_LENGTH (expanded_types
);
11033 vec
= make_tree_vec (len
);
11037 /* All we did was update the type. Make a note of that. */
11038 type
= expanded_types
;
11039 expanded_types
= NULL_TREE
;
11043 for (int i
= 0; i
< len
; ++i
)
11046 if (expanded_types
)
11048 type
= TREE_VEC_ELT (expanded_types
, i
);
11050 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11053 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11055 if (type
== error_mark_node
)
11056 RETURN (error_mark_node
);
11057 TREE_TYPE (r
) = type
;
11058 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11060 if (DECL_C_BIT_FIELD (r
))
11061 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11062 non-bit-fields DECL_INITIAL is a non-static data member
11063 initializer, which gets deferred instantiation. */
11065 = tsubst_expr (DECL_INITIAL (t
), args
,
11067 /*integral_constant_expression_p=*/true);
11068 else if (DECL_INITIAL (t
))
11070 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11071 NSDMI in perform_member_init. Still set DECL_INITIAL
11072 so that we know there is one. */
11073 DECL_INITIAL (r
) = void_node
;
11074 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
11075 retrofit_lang_decl (r
);
11076 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
11078 /* We don't have to set DECL_CONTEXT here; it is set by
11079 finish_member_declaration. */
11080 DECL_CHAIN (r
) = NULL_TREE
;
11082 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11083 args
, complain
, in_decl
);
11086 TREE_VEC_ELT (vec
, i
) = r
;
11092 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
11093 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
11094 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
11095 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
11096 TREE_TYPE (pack
) = tpack
;
11097 register_specialization (pack
, t
, args
, false, 0);
11103 /* We reach here only for member using decls. We also need to check
11104 uses_template_parms because DECL_DEPENDENT_P is not set for a
11105 using-declaration that designates a member of the current
11106 instantiation (c++/53549). */
11107 if (DECL_DEPENDENT_P (t
)
11108 || uses_template_parms (USING_DECL_SCOPE (t
)))
11110 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
11111 complain
, in_decl
);
11112 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
11113 r
= do_class_using_decl (inst_scope
, name
);
11115 r
= error_mark_node
;
11118 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
11119 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
11125 DECL_CHAIN (r
) = NULL_TREE
;
11132 tree argvec
= NULL_TREE
;
11133 tree gen_tmpl
= NULL_TREE
;
11135 tree tmpl
= NULL_TREE
;
11137 tree type
= NULL_TREE
;
11140 if (TREE_TYPE (t
) == error_mark_node
)
11141 RETURN (error_mark_node
);
11143 if (TREE_CODE (t
) == TYPE_DECL
11144 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
11146 /* If this is the canonical decl, we don't have to
11147 mess with instantiations, and often we can't (for
11148 typename, template type parms and such). Note that
11149 TYPE_NAME is not correct for the above test if
11150 we've copied the type for a typedef. */
11151 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11152 if (type
== error_mark_node
)
11153 RETURN (error_mark_node
);
11154 r
= TYPE_NAME (type
);
11158 /* Check to see if we already have the specialization we
11161 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
11163 /* T is a static data member or namespace-scope entity.
11164 We have to substitute into namespace-scope variables
11165 (even though such entities are never templates) because
11168 template <class T> void f() { extern T t; }
11170 where the entity referenced is not known until
11171 instantiation time. */
11173 ctx
= DECL_CONTEXT (t
);
11174 if (DECL_CLASS_SCOPE_P (t
))
11176 ctx
= tsubst_aggr_type (ctx
, args
,
11178 in_decl
, /*entering_scope=*/1);
11179 /* If CTX is unchanged, then T is in fact the
11180 specialization we want. That situation occurs when
11181 referencing a static data member within in its own
11182 class. We can use pointer equality, rather than
11183 same_type_p, because DECL_CONTEXT is always
11185 if (ctx
== DECL_CONTEXT (t
)
11186 /* ... unless T is a member template; in which
11187 case our caller can be willing to create a
11188 specialization of that template represented
11190 && !(DECL_TI_TEMPLATE (t
)
11191 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
11197 tmpl
= DECL_TI_TEMPLATE (t
);
11198 gen_tmpl
= most_general_template (tmpl
);
11199 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11200 if (argvec
== error_mark_node
)
11201 RETURN (error_mark_node
);
11202 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11203 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11208 /* A local variable. */
11210 /* Subsequent calls to pushdecl will fill this in. */
11212 spec
= retrieve_local_specialization (t
);
11214 /* If we already have the specialization we need, there is
11215 nothing more to do. */
11222 /* Create a new node for the specialization we need. */
11224 if (type
== NULL_TREE
)
11226 if (is_typedef_decl (t
))
11227 type
= DECL_ORIGINAL_TYPE (t
);
11229 type
= TREE_TYPE (t
);
11231 && VAR_HAD_UNKNOWN_BOUND (t
)
11232 && type
!= error_mark_node
)
11233 type
= strip_array_domain (type
);
11234 type
= tsubst (type
, args
, complain
, in_decl
);
11238 /* Even if the original location is out of scope, the
11239 newly substituted one is not. */
11240 DECL_DEAD_FOR_LOCAL (r
) = 0;
11241 DECL_INITIALIZED_P (r
) = 0;
11242 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11243 if (type
== error_mark_node
)
11244 RETURN (error_mark_node
);
11245 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11247 /* It may seem that this case cannot occur, since:
11252 declares a function, not a variable. However:
11255 template <typename T> void g() { T t; }
11256 template void g<f>();
11258 is an attempt to declare a variable with function
11260 error ("variable %qD has function type",
11261 /* R is not yet sufficiently initialized, so we
11262 just use its name. */
11264 RETURN (error_mark_node
);
11266 type
= complete_type (type
);
11267 /* Wait until cp_finish_decl to set this again, to handle
11268 circular dependency (template/instantiate6.C). */
11269 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11270 type
= check_var_type (DECL_NAME (r
), type
);
11272 if (DECL_HAS_VALUE_EXPR_P (t
))
11274 tree ve
= DECL_VALUE_EXPR (t
);
11275 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11276 /*constant_expression_p=*/false);
11277 if (REFERENCE_REF_P (ve
))
11279 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11280 ve
= TREE_OPERAND (ve
, 0);
11282 SET_DECL_VALUE_EXPR (r
, ve
);
11284 if (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
11285 set_decl_tls_model (r
, decl_tls_model (t
));
11287 else if (DECL_SELF_REFERENCE_P (t
))
11288 SET_DECL_SELF_REFERENCE_P (r
);
11289 TREE_TYPE (r
) = type
;
11290 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11291 DECL_CONTEXT (r
) = ctx
;
11292 /* Clear out the mangled name and RTL for the instantiation. */
11293 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11294 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11295 SET_DECL_RTL (r
, NULL
);
11296 /* The initializer must not be expanded until it is required;
11297 see [temp.inst]. */
11298 DECL_INITIAL (r
) = NULL_TREE
;
11299 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11300 SET_DECL_RTL (r
, NULL
);
11301 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11304 /* Possibly limit visibility based on template args. */
11305 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11306 if (DECL_VISIBILITY_SPECIFIED (t
))
11308 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11309 DECL_ATTRIBUTES (r
)
11310 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11312 determine_visibility (r
);
11317 /* A static data member declaration is always marked
11318 external when it is declared in-class, even if an
11319 initializer is present. We mimic the non-template
11320 processing here. */
11321 DECL_EXTERNAL (r
) = 1;
11323 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11324 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11325 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11327 else if (!cp_unevaluated_operand
)
11328 register_local_specialization (r
, t
);
11330 DECL_CHAIN (r
) = NULL_TREE
;
11332 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11334 args
, complain
, in_decl
);
11336 /* Preserve a typedef that names a type. */
11337 if (is_typedef_decl (r
))
11339 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11340 set_underlying_type (r
);
11343 layout_decl (r
, 0);
11348 gcc_unreachable ();
11353 /* Restore the file and line information. */
11354 input_location
= saved_loc
;
11359 /* Substitute into the ARG_TYPES of a function type.
11360 If END is a TREE_CHAIN, leave it and any following types
11364 tsubst_arg_types (tree arg_types
,
11367 tsubst_flags_t complain
,
11370 tree remaining_arg_types
;
11371 tree type
= NULL_TREE
;
11373 tree expanded_args
= NULL_TREE
;
11376 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11379 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11380 args
, end
, complain
, in_decl
);
11381 if (remaining_arg_types
== error_mark_node
)
11382 return error_mark_node
;
11384 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11386 /* For a pack expansion, perform substitution on the
11387 entire expression. Later on, we'll handle the arguments
11389 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11390 args
, complain
, in_decl
);
11392 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11393 /* So that we'll spin through the parameters, one by one. */
11394 i
= TREE_VEC_LENGTH (expanded_args
);
11397 /* We only partially substituted into the parameter
11398 pack. Our type is TYPE_PACK_EXPANSION. */
11399 type
= expanded_args
;
11400 expanded_args
= NULL_TREE
;
11408 type
= TREE_VEC_ELT (expanded_args
, i
);
11410 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11412 if (type
== error_mark_node
)
11413 return error_mark_node
;
11414 if (VOID_TYPE_P (type
))
11416 if (complain
& tf_error
)
11418 error ("invalid parameter type %qT", type
);
11420 error ("in declaration %q+D", in_decl
);
11422 return error_mark_node
;
11425 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11426 return error_mark_node
;
11428 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11429 top-level qualifiers as required. */
11430 type
= cv_unqualified (type_decays_to (type
));
11432 /* We do not substitute into default arguments here. The standard
11433 mandates that they be instantiated only when needed, which is
11434 done in build_over_call. */
11435 default_arg
= TREE_PURPOSE (arg_types
);
11437 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11439 /* We've instantiated a template before its default arguments
11440 have been parsed. This can happen for a nested template
11441 class, and is not an error unless we require the default
11442 argument in a call of this function. */
11443 remaining_arg_types
=
11444 tree_cons (default_arg
, type
, remaining_arg_types
);
11445 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11448 remaining_arg_types
=
11449 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11452 return remaining_arg_types
;
11455 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11456 *not* handle the exception-specification for FNTYPE, because the
11457 initial substitution of explicitly provided template parameters
11458 during argument deduction forbids substitution into the
11459 exception-specification:
11463 All references in the function type of the function template to the
11464 corresponding template parameters are replaced by the specified tem-
11465 plate argument values. If a substitution in a template parameter or
11466 in the function type of the function template results in an invalid
11467 type, type deduction fails. [Note: The equivalent substitution in
11468 exception specifications is done only when the function is instanti-
11469 ated, at which point a program is ill-formed if the substitution
11470 results in an invalid type.] */
11473 tsubst_function_type (tree t
,
11475 tsubst_flags_t complain
,
11479 tree arg_types
= NULL_TREE
;
11482 /* The TYPE_CONTEXT is not used for function/method types. */
11483 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11485 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11487 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11489 if (late_return_type_p
)
11491 /* Substitute the argument types. */
11492 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11493 complain
, in_decl
);
11494 if (arg_types
== error_mark_node
)
11495 return error_mark_node
;
11497 tree save_ccp
= current_class_ptr
;
11498 tree save_ccr
= current_class_ref
;
11499 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11500 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11501 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11504 /* DR 1207: 'this' is in scope in the trailing return type. */
11505 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11508 /* Substitute the return type. */
11509 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11513 current_class_ptr
= save_ccp
;
11514 current_class_ref
= save_ccr
;
11518 /* Substitute the return type. */
11519 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11521 if (return_type
== error_mark_node
)
11522 return error_mark_node
;
11523 /* DR 486 clarifies that creation of a function type with an
11524 invalid return type is a deduction failure. */
11525 if (TREE_CODE (return_type
) == ARRAY_TYPE
11526 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11528 if (complain
& tf_error
)
11530 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11531 error ("function returning an array");
11533 error ("function returning a function");
11535 return error_mark_node
;
11538 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11539 return error_mark_node
;
11541 if (!late_return_type_p
)
11543 /* Substitute the argument types. */
11544 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11545 complain
, in_decl
);
11546 if (arg_types
== error_mark_node
)
11547 return error_mark_node
;
11550 /* Construct a new type node and return it. */
11551 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11553 fntype
= build_function_type (return_type
, arg_types
);
11554 fntype
= apply_memfn_quals (fntype
,
11555 type_memfn_quals (t
),
11556 type_memfn_rqual (t
));
11560 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11561 /* Don't pick up extra function qualifiers from the basetype. */
11562 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11563 if (! MAYBE_CLASS_TYPE_P (r
))
11567 Type deduction may fail for any of the following
11570 -- Attempting to create "pointer to member of T" when T
11571 is not a class type. */
11572 if (complain
& tf_error
)
11573 error ("creating pointer to member function of non-class type %qT",
11575 return error_mark_node
;
11578 fntype
= build_method_type_directly (r
, return_type
,
11579 TREE_CHAIN (arg_types
));
11580 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11582 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11584 if (late_return_type_p
)
11585 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11590 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11591 ARGS into that specification, and return the substituted
11592 specification. If there is no specification, return NULL_TREE. */
11595 tsubst_exception_specification (tree fntype
,
11597 tsubst_flags_t complain
,
11604 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11605 new_specs
= NULL_TREE
;
11606 if (specs
&& TREE_PURPOSE (specs
))
11608 /* A noexcept-specifier. */
11609 tree expr
= TREE_PURPOSE (specs
);
11610 if (TREE_CODE (expr
) == INTEGER_CST
)
11614 /* Defer instantiation of noexcept-specifiers to avoid
11615 excessive instantiations (c++/49107). */
11616 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11617 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11619 /* We already partially instantiated this member template,
11620 so combine the new args with the old. */
11621 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11622 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11623 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11624 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11628 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11629 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11633 new_specs
= tsubst_copy_and_build
11634 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11635 /*integral_constant_expression_p=*/true);
11636 new_specs
= build_noexcept_spec (new_specs
, complain
);
11640 if (! TREE_VALUE (specs
))
11647 tree expanded_specs
= NULL_TREE
;
11649 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11651 /* Expand the pack expansion type. */
11652 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11656 if (expanded_specs
== error_mark_node
)
11657 return error_mark_node
;
11658 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11659 len
= TREE_VEC_LENGTH (expanded_specs
);
11662 /* We're substituting into a member template, so
11663 we got a TYPE_PACK_EXPANSION back. Add that
11664 expansion and move on. */
11665 gcc_assert (TREE_CODE (expanded_specs
)
11666 == TYPE_PACK_EXPANSION
);
11667 new_specs
= add_exception_specifier (new_specs
,
11670 specs
= TREE_CHAIN (specs
);
11675 for (i
= 0; i
< len
; ++i
)
11677 if (expanded_specs
)
11678 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11680 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11681 if (spec
== error_mark_node
)
11683 new_specs
= add_exception_specifier (new_specs
, spec
,
11687 specs
= TREE_CHAIN (specs
);
11693 /* Take the tree structure T and replace template parameters used
11694 therein with the argument vector ARGS. IN_DECL is an associated
11695 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11696 Issue error and warning messages under control of COMPLAIN. Note
11697 that we must be relatively non-tolerant of extensions here, in
11698 order to preserve conformance; if we allow substitutions that
11699 should not be allowed, we may allow argument deductions that should
11700 not succeed, and therefore report ambiguous overload situations
11701 where there are none. In theory, we could allow the substitution,
11702 but indicate that it should have failed, and allow our caller to
11703 make sure that the right thing happens, but we don't try to do this
11706 This function is used for dealing with types, decls and the like;
11707 for expressions, use tsubst_expr or tsubst_copy. */
11710 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11712 enum tree_code code
;
11713 tree type
, r
= NULL_TREE
;
11715 if (t
== NULL_TREE
|| t
== error_mark_node
11716 || t
== integer_type_node
11717 || t
== void_type_node
11718 || t
== char_type_node
11719 || t
== unknown_type_node
11720 || TREE_CODE (t
) == NAMESPACE_DECL
11721 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11725 return tsubst_decl (t
, args
, complain
);
11727 if (args
== NULL_TREE
)
11730 code
= TREE_CODE (t
);
11732 if (code
== IDENTIFIER_NODE
)
11733 type
= IDENTIFIER_TYPE_VALUE (t
);
11735 type
= TREE_TYPE (t
);
11737 gcc_assert (type
!= unknown_type_node
);
11739 /* Reuse typedefs. We need to do this to handle dependent attributes,
11740 such as attribute aligned. */
11742 && typedef_variant_p (t
))
11744 tree decl
= TYPE_NAME (t
);
11746 if (alias_template_specialization_p (t
))
11748 /* DECL represents an alias template and we want to
11750 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11751 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11752 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11754 else if (DECL_CLASS_SCOPE_P (decl
)
11755 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11756 && uses_template_parms (DECL_CONTEXT (decl
)))
11758 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11759 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11760 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11762 else if (DECL_FUNCTION_SCOPE_P (decl
)
11763 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11764 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11765 r
= retrieve_local_specialization (decl
);
11767 /* The typedef is from a non-template context. */
11773 r
= cp_build_qualified_type_real
11774 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11775 complain
| tf_ignore_bad_quals
);
11780 /* We don't have an instantiation yet, so drop the typedef. */
11781 int quals
= cp_type_quals (t
);
11782 t
= DECL_ORIGINAL_TYPE (decl
);
11783 t
= cp_build_qualified_type_real (t
, quals
,
11784 complain
| tf_ignore_bad_quals
);
11789 && code
!= TYPENAME_TYPE
11790 && code
!= TEMPLATE_TYPE_PARM
11791 && code
!= IDENTIFIER_NODE
11792 && code
!= FUNCTION_TYPE
11793 && code
!= METHOD_TYPE
)
11794 type
= tsubst (type
, args
, complain
, in_decl
);
11795 if (type
== error_mark_node
)
11796 return error_mark_node
;
11802 case ENUMERAL_TYPE
:
11803 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11804 /*entering_scope=*/0);
11807 case IDENTIFIER_NODE
:
11818 if (t
== integer_type_node
)
11821 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11822 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11826 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11828 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11829 /*integral_constant_expression_p=*/false);
11831 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11833 if (TREE_CODE (max
) == NOP_EXPR
11834 && TREE_SIDE_EFFECTS (omax
)
11835 && !TREE_TYPE (max
))
11836 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11838 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11839 with TREE_SIDE_EFFECTS that indicates this is not an integral
11840 constant expression. */
11841 if (processing_template_decl
11842 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11844 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11845 TREE_SIDE_EFFECTS (max
) = 1;
11848 return compute_array_index_type (NULL_TREE
, max
, complain
);
11851 case TEMPLATE_TYPE_PARM
:
11852 case TEMPLATE_TEMPLATE_PARM
:
11853 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11854 case TEMPLATE_PARM_INDEX
:
11859 tree arg
= NULL_TREE
;
11863 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
11864 template_parm_level_and_index (t
, &level
, &idx
);
11866 levels
= TMPL_ARGS_DEPTH (args
);
11867 if (level
<= levels
)
11869 arg
= TMPL_ARG (args
, level
, idx
);
11871 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
11873 /* See through ARGUMENT_PACK_SELECT arguments. */
11874 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
11875 /* If the selected argument is an expansion E, that most
11876 likely means we were called from
11877 gen_elem_of_pack_expansion_instantiation during the
11878 substituting of pack an argument pack (which Ith
11879 element is a pack expansion, where I is
11880 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11881 In this case, the Ith element resulting from this
11882 substituting is going to be a pack expansion, which
11883 pattern is the pattern of E. Let's return the
11885 gen_elem_of_pack_expansion_instantiation will
11886 build the resulting pack expansion from it. */
11887 if (PACK_EXPANSION_P (arg
))
11889 /* Make sure we aren't throwing away arg info. */
11890 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
11891 arg
= PACK_EXPANSION_PATTERN (arg
);
11896 if (arg
== error_mark_node
)
11897 return error_mark_node
;
11898 else if (arg
!= NULL_TREE
)
11900 if (ARGUMENT_PACK_P (arg
))
11901 /* If ARG is an argument pack, we don't actually want to
11902 perform a substitution here, because substitutions
11903 for argument packs are only done
11904 element-by-element. We can get to this point when
11905 substituting the type of a non-type template
11906 parameter pack, when that type actually contains
11907 template parameter packs from an outer template, e.g.,
11909 template<typename... Types> struct A {
11910 template<Types... Values> struct B { };
11914 if (code
== TEMPLATE_TYPE_PARM
)
11917 gcc_assert (TYPE_P (arg
));
11919 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
11921 return cp_build_qualified_type_real
11922 (arg
, quals
, complain
| tf_ignore_bad_quals
);
11924 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11926 /* We are processing a type constructed from a
11927 template template parameter. */
11928 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
11929 args
, complain
, in_decl
);
11930 if (argvec
== error_mark_node
)
11931 return error_mark_node
;
11933 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
11934 || TREE_CODE (arg
) == TEMPLATE_DECL
11935 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
11937 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
11938 /* Consider this code:
11940 template <template <class> class Template>
11942 template <class Arg> using Bind = Template<Arg>;
11945 template <template <class> class Template, class Arg>
11946 using Instantiate = Template<Arg>; //#0
11948 template <template <class> class Template,
11951 Instantiate<Internal<Template>::template Bind,
11954 When #1 is parsed, the
11955 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11956 parameter `Template' in #0 matches the
11957 UNBOUND_CLASS_TEMPLATE representing the argument
11958 `Internal<Template>::template Bind'; We then want
11959 to assemble the type `Bind<Argument>' that can't
11960 be fully created right now, because
11961 `Internal<Template>' not being complete, the Bind
11962 template cannot be looked up in that context. So
11963 we need to "store" `Bind<Argument>' for later
11964 when the context of Bind becomes complete. Let's
11965 store that in a TYPENAME_TYPE. */
11966 return make_typename_type (TYPE_CONTEXT (arg
),
11967 build_nt (TEMPLATE_ID_EXPR
,
11968 TYPE_IDENTIFIER (arg
),
11973 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11974 are resolving nested-types in the signature of a
11975 member function templates. Otherwise ARG is a
11976 TEMPLATE_DECL and is the real template to be
11978 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11979 arg
= TYPE_NAME (arg
);
11981 r
= lookup_template_class (arg
,
11983 DECL_CONTEXT (arg
),
11984 /*entering_scope=*/0,
11986 return cp_build_qualified_type_real
11987 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
11990 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11991 return convert_from_reference (unshare_expr (arg
));
11995 /* This can happen during the attempted tsubst'ing in
11996 unify. This means that we don't yet have any information
11997 about the template parameter in question. */
12000 /* Early in template argument deduction substitution, we don't
12001 want to reduce the level of 'auto', or it will be confused
12002 with a normal template parm in subsequent deduction. */
12003 if (is_auto (t
) && (complain
& tf_partial
))
12006 /* If we get here, we must have been looking at a parm for a
12007 more deeply nested template. Make a new version of this
12008 template parameter, but with a lower level. */
12011 case TEMPLATE_TYPE_PARM
:
12012 case TEMPLATE_TEMPLATE_PARM
:
12013 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12014 if (cp_type_quals (t
))
12016 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
12017 r
= cp_build_qualified_type_real
12018 (r
, cp_type_quals (t
),
12019 complain
| (code
== TEMPLATE_TYPE_PARM
12020 ? tf_ignore_bad_quals
: 0));
12025 TEMPLATE_TYPE_PARM_INDEX (r
)
12026 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
12027 r
, levels
, args
, complain
);
12028 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
12029 TYPE_MAIN_VARIANT (r
) = r
;
12030 TYPE_POINTER_TO (r
) = NULL_TREE
;
12031 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
12033 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
12034 /* We have reduced the level of the template
12035 template parameter, but not the levels of its
12036 template parameters, so canonical_type_parameter
12037 will not be able to find the canonical template
12038 template parameter for this level. Thus, we
12039 require structural equality checking to compare
12040 TEMPLATE_TEMPLATE_PARMs. */
12041 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12042 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
12043 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12045 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
12047 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12049 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
12050 complain
, in_decl
);
12051 if (argvec
== error_mark_node
)
12052 return error_mark_node
;
12054 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
12055 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
12060 case TEMPLATE_PARM_INDEX
:
12061 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
12065 gcc_unreachable ();
12073 tree purpose
, value
, chain
;
12075 if (t
== void_list_node
)
12078 purpose
= TREE_PURPOSE (t
);
12081 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
12082 if (purpose
== error_mark_node
)
12083 return error_mark_node
;
12085 value
= TREE_VALUE (t
);
12088 value
= tsubst (value
, args
, complain
, in_decl
);
12089 if (value
== error_mark_node
)
12090 return error_mark_node
;
12092 chain
= TREE_CHAIN (t
);
12093 if (chain
&& chain
!= void_type_node
)
12095 chain
= tsubst (chain
, args
, complain
, in_decl
);
12096 if (chain
== error_mark_node
)
12097 return error_mark_node
;
12099 if (purpose
== TREE_PURPOSE (t
)
12100 && value
== TREE_VALUE (t
)
12101 && chain
== TREE_CHAIN (t
))
12103 return hash_tree_cons (purpose
, value
, chain
);
12107 /* We should never be tsubsting a binfo. */
12108 gcc_unreachable ();
12111 /* A vector of template arguments. */
12112 gcc_assert (!type
);
12113 return tsubst_template_args (t
, args
, complain
, in_decl
);
12116 case REFERENCE_TYPE
:
12118 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
12123 Type deduction may fail for any of the following
12126 -- Attempting to create a pointer to reference type.
12127 -- Attempting to create a reference to a reference type or
12128 a reference to void.
12130 Core issue 106 says that creating a reference to a reference
12131 during instantiation is no longer a cause for failure. We
12132 only enforce this check in strict C++98 mode. */
12133 if ((TREE_CODE (type
) == REFERENCE_TYPE
12134 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
12135 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
12137 static location_t last_loc
;
12139 /* We keep track of the last time we issued this error
12140 message to avoid spewing a ton of messages during a
12141 single bad template instantiation. */
12142 if (complain
& tf_error
12143 && last_loc
!= input_location
)
12145 if (VOID_TYPE_P (type
))
12146 error ("forming reference to void");
12147 else if (code
== POINTER_TYPE
)
12148 error ("forming pointer to reference type %qT", type
);
12150 error ("forming reference to reference type %qT", type
);
12151 last_loc
= input_location
;
12154 return error_mark_node
;
12156 else if (TREE_CODE (type
) == FUNCTION_TYPE
12157 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
12158 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12160 if (complain
& tf_error
)
12162 if (code
== POINTER_TYPE
)
12163 error ("forming pointer to qualified function type %qT",
12166 error ("forming reference to qualified function type %qT",
12169 return error_mark_node
;
12171 else if (code
== POINTER_TYPE
)
12173 r
= build_pointer_type (type
);
12174 if (TREE_CODE (type
) == METHOD_TYPE
)
12175 r
= build_ptrmemfunc_type (r
);
12177 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12178 /* In C++0x, during template argument substitution, when there is an
12179 attempt to create a reference to a reference type, reference
12180 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12182 "If a template-argument for a template-parameter T names a type
12183 that is a reference to a type A, an attempt to create the type
12184 'lvalue reference to cv T' creates the type 'lvalue reference to
12185 A,' while an attempt to create the type type rvalue reference to
12186 cv T' creates the type T"
12188 r
= cp_build_reference_type
12190 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12192 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12193 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12195 if (cxx_dialect
>= cxx14
12196 && !(TREE_CODE (t
) == REFERENCE_TYPE
&& REFERENCE_VLA_OK (t
))
12197 && array_of_runtime_bound_p (type
)
12198 && (flag_iso
|| warn_vla
> 0))
12200 if (complain
& tf_warning_or_error
)
12202 (input_location
, OPT_Wvla
,
12203 code
== REFERENCE_TYPE
12204 ? G_("cannot declare reference to array of runtime bound")
12205 : G_("cannot declare pointer to array of runtime bound"));
12207 r
= error_mark_node
;
12210 if (r
!= error_mark_node
)
12211 /* Will this ever be needed for TYPE_..._TO values? */
12218 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12219 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12223 Type deduction may fail for any of the following
12226 -- Attempting to create "pointer to member of T" when T
12227 is not a class type. */
12228 if (complain
& tf_error
)
12229 error ("creating pointer to member of non-class type %qT", r
);
12230 return error_mark_node
;
12232 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12234 if (complain
& tf_error
)
12235 error ("creating pointer to member reference type %qT", type
);
12236 return error_mark_node
;
12238 if (VOID_TYPE_P (type
))
12240 if (complain
& tf_error
)
12241 error ("creating pointer to member of type void");
12242 return error_mark_node
;
12244 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12245 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12247 /* The type of the implicit object parameter gets its
12248 cv-qualifiers from the FUNCTION_TYPE. */
12251 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12252 type_memfn_rqual (type
));
12253 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12254 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12258 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12262 case FUNCTION_TYPE
:
12267 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12268 if (fntype
== error_mark_node
)
12269 return error_mark_node
;
12271 /* Substitute the exception specification. */
12272 specs
= tsubst_exception_specification (t
, args
, complain
,
12273 in_decl
, /*defer_ok*/true);
12274 if (specs
== error_mark_node
)
12275 return error_mark_node
;
12277 fntype
= build_exception_variant (fntype
, specs
);
12282 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12283 if (domain
== error_mark_node
)
12284 return error_mark_node
;
12286 /* As an optimization, we avoid regenerating the array type if
12287 it will obviously be the same as T. */
12288 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12291 /* These checks should match the ones in create_array_type_for_decl.
12295 The deduction may fail for any of the following reasons:
12297 -- Attempting to create an array with an element type that
12298 is void, a function type, or a reference type, or [DR337]
12299 an abstract class type. */
12300 if (VOID_TYPE_P (type
)
12301 || TREE_CODE (type
) == FUNCTION_TYPE
12302 || (TREE_CODE (type
) == ARRAY_TYPE
12303 && TYPE_DOMAIN (type
) == NULL_TREE
)
12304 || TREE_CODE (type
) == REFERENCE_TYPE
)
12306 if (complain
& tf_error
)
12307 error ("creating array of %qT", type
);
12308 return error_mark_node
;
12311 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12312 return error_mark_node
;
12314 r
= build_cplus_array_type (type
, domain
);
12316 if (TYPE_USER_ALIGN (t
))
12318 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12319 TYPE_USER_ALIGN (r
) = 1;
12325 case TYPENAME_TYPE
:
12327 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12328 in_decl
, /*entering_scope=*/1);
12329 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12330 complain
, in_decl
);
12332 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12333 return error_mark_node
;
12335 if (!MAYBE_CLASS_TYPE_P (ctx
))
12337 if (complain
& tf_error
)
12338 error ("%qT is not a class, struct, or union type", ctx
);
12339 return error_mark_node
;
12341 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12343 /* Normally, make_typename_type does not require that the CTX
12344 have complete type in order to allow things like:
12346 template <class T> struct S { typename S<T>::X Y; };
12348 But, such constructs have already been resolved by this
12349 point, so here CTX really should have complete type, unless
12350 it's a partial instantiation. */
12351 ctx
= complete_type (ctx
);
12352 if (!COMPLETE_TYPE_P (ctx
))
12354 if (complain
& tf_error
)
12355 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12356 return error_mark_node
;
12360 f
= make_typename_type (ctx
, f
, typename_type
,
12361 complain
| tf_keep_type_decl
);
12362 if (f
== error_mark_node
)
12364 if (TREE_CODE (f
) == TYPE_DECL
)
12366 complain
|= tf_ignore_bad_quals
;
12370 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12372 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12374 if (complain
& tf_error
)
12375 error ("%qT resolves to %qT, which is not an enumeration type",
12378 return error_mark_node
;
12380 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12382 if (complain
& tf_error
)
12383 error ("%qT resolves to %qT, which is is not a class type",
12386 return error_mark_node
;
12390 return cp_build_qualified_type_real
12391 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12394 case UNBOUND_CLASS_TEMPLATE
:
12396 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12397 in_decl
, /*entering_scope=*/1);
12398 tree name
= TYPE_IDENTIFIER (t
);
12399 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12401 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12402 return error_mark_node
;
12405 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12406 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12413 ++cp_unevaluated_operand
;
12414 ++c_inhibit_evaluation_warnings
;
12416 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12418 /*integral_constant_expression_p=*/false);
12420 --cp_unevaluated_operand
;
12421 --c_inhibit_evaluation_warnings
;
12423 type
= finish_typeof (type
);
12424 return cp_build_qualified_type_real (type
,
12426 | cp_type_quals (type
),
12430 case DECLTYPE_TYPE
:
12434 ++cp_unevaluated_operand
;
12435 ++c_inhibit_evaluation_warnings
;
12437 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12438 complain
|tf_decltype
, in_decl
,
12439 /*function_p*/false,
12440 /*integral_constant_expression*/false);
12442 --cp_unevaluated_operand
;
12443 --c_inhibit_evaluation_warnings
;
12445 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12446 type
= lambda_capture_field_type (type
,
12447 DECLTYPE_FOR_INIT_CAPTURE (t
));
12448 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12449 type
= lambda_proxy_type (type
);
12452 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12453 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12455 /* In a template ~id could be either a complement expression
12456 or an unqualified-id naming a destructor; if instantiating
12457 it produces an expression, it's not an id-expression or
12460 type
= finish_decltype_type (type
, id
, complain
);
12462 return cp_build_qualified_type_real (type
,
12464 | cp_type_quals (type
),
12465 complain
| tf_ignore_bad_quals
);
12468 case UNDERLYING_TYPE
:
12470 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12471 complain
, in_decl
);
12472 return finish_underlying_type (type
);
12475 case TYPE_ARGUMENT_PACK
:
12476 case NONTYPE_ARGUMENT_PACK
:
12478 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12480 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12484 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12486 /* For template nontype argument packs, also substitute into
12488 if (code
== NONTYPE_ARGUMENT_PACK
)
12489 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12508 /* We should use one of the expression tsubsts for these codes. */
12509 gcc_unreachable ();
12512 sorry ("use of %qs in template", get_tree_code_name (code
));
12513 return error_mark_node
;
12517 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12518 type of the expression on the left-hand side of the "." or "->"
12522 tsubst_baselink (tree baselink
, tree object_type
,
12523 tree args
, tsubst_flags_t complain
, tree in_decl
)
12526 tree qualifying_scope
;
12529 tree template_args
= 0;
12530 bool template_id_p
= false;
12531 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12533 /* A baselink indicates a function from a base class. Both the
12534 BASELINK_ACCESS_BINFO and the base class referenced may
12535 indicate bases of the template class, rather than the
12536 instantiated class. In addition, lookups that were not
12537 ambiguous before may be ambiguous now. Therefore, we perform
12538 the lookup again. */
12539 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12540 qualifying_scope
= tsubst (qualifying_scope
, args
,
12541 complain
, in_decl
);
12542 fns
= BASELINK_FUNCTIONS (baselink
);
12543 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12544 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12546 template_id_p
= true;
12547 template_args
= TREE_OPERAND (fns
, 1);
12548 fns
= TREE_OPERAND (fns
, 0);
12550 template_args
= tsubst_template_args (template_args
, args
,
12551 complain
, in_decl
);
12553 name
= DECL_NAME (get_first_fn (fns
));
12554 if (IDENTIFIER_TYPENAME_P (name
))
12555 name
= mangle_conv_op_name_for_type (optype
);
12556 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12558 return error_mark_node
;
12560 /* If lookup found a single function, mark it as used at this
12561 point. (If it lookup found multiple functions the one selected
12562 later by overload resolution will be marked as used at that
12564 if (BASELINK_P (baselink
))
12565 fns
= BASELINK_FUNCTIONS (baselink
);
12566 if (!template_id_p
&& !really_overloaded_fn (fns
))
12567 mark_used (OVL_CURRENT (fns
));
12569 /* Add back the template arguments, if present. */
12570 if (BASELINK_P (baselink
) && template_id_p
)
12571 BASELINK_FUNCTIONS (baselink
)
12572 = build_nt (TEMPLATE_ID_EXPR
,
12573 BASELINK_FUNCTIONS (baselink
),
12575 /* Update the conversion operator type. */
12576 BASELINK_OPTYPE (baselink
) = optype
;
12579 object_type
= current_class_type
;
12582 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12588 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12589 true if the qualified-id will be a postfix-expression in-and-of
12590 itself; false if more of the postfix-expression follows the
12591 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12595 tsubst_qualified_id (tree qualified_id
, tree args
,
12596 tsubst_flags_t complain
, tree in_decl
,
12597 bool done
, bool address_p
)
12603 tree template_args
;
12604 location_t loc
= UNKNOWN_LOCATION
;
12606 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12608 /* Figure out what name to look up. */
12609 name
= TREE_OPERAND (qualified_id
, 1);
12610 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12612 is_template
= true;
12613 loc
= EXPR_LOCATION (name
);
12614 template_args
= TREE_OPERAND (name
, 1);
12616 template_args
= tsubst_template_args (template_args
, args
,
12617 complain
, in_decl
);
12618 name
= TREE_OPERAND (name
, 0);
12622 is_template
= false;
12623 template_args
= NULL_TREE
;
12626 /* Substitute into the qualifying scope. When there are no ARGS, we
12627 are just trying to simplify a non-dependent expression. In that
12628 case the qualifying scope may be dependent, and, in any case,
12629 substituting will not help. */
12630 scope
= TREE_OPERAND (qualified_id
, 0);
12633 scope
= tsubst (scope
, args
, complain
, in_decl
);
12634 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12639 if (dependent_scope_p (scope
))
12642 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12643 return build_qualified_name (NULL_TREE
, scope
, expr
,
12644 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12647 if (!BASELINK_P (name
) && !DECL_P (expr
))
12649 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12651 /* A BIT_NOT_EXPR is used to represent a destructor. */
12652 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12654 error ("qualifying type %qT does not match destructor name ~%qT",
12655 scope
, TREE_OPERAND (expr
, 0));
12656 expr
= error_mark_node
;
12659 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12660 /*is_type_p=*/0, false);
12663 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12664 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12665 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12667 if (complain
& tf_error
)
12669 error ("dependent-name %qE is parsed as a non-type, but "
12670 "instantiation yields a type", qualified_id
);
12671 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12673 return error_mark_node
;
12679 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12681 /* Remember that there was a reference to this entity. */
12685 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12687 if (complain
& tf_error
)
12688 qualified_name_lookup_error (scope
,
12689 TREE_OPERAND (qualified_id
, 1),
12690 expr
, input_location
);
12691 return error_mark_node
;
12695 expr
= lookup_template_function (expr
, template_args
);
12697 if (expr
== error_mark_node
&& complain
& tf_error
)
12698 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12699 expr
, input_location
);
12700 else if (TYPE_P (scope
))
12702 expr
= (adjust_result_of_qualified_name_lookup
12703 (expr
, scope
, current_nonlambda_class_type ()));
12704 expr
= (finish_qualified_id_expr
12705 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12706 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12707 /*template_arg_p=*/false, complain
));
12710 /* Expressions do not generally have reference type. */
12711 if (TREE_CODE (expr
) != SCOPE_REF
12712 /* However, if we're about to form a pointer-to-member, we just
12713 want the referenced member referenced. */
12714 && TREE_CODE (expr
) != OFFSET_REF
)
12715 expr
= convert_from_reference (expr
);
12720 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12721 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12725 tsubst_init (tree init
, tree decl
, tree args
,
12726 tsubst_flags_t complain
, tree in_decl
)
12731 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12735 /* If we had an initializer but it
12736 instantiated to nothing,
12737 value-initialize the object. This will
12738 only occur when the initializer was a
12739 pack expansion where the parameter packs
12740 used in that expansion were of length
12742 init
= build_value_init (TREE_TYPE (decl
),
12744 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12745 init
= get_target_expr_sfinae (init
, complain
);
12751 /* Like tsubst, but deals with expressions. This function just replaces
12752 template parms; to finish processing the resultant expression, use
12753 tsubst_copy_and_build or tsubst_expr. */
12756 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12758 enum tree_code code
;
12761 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12764 code
= TREE_CODE (t
);
12769 r
= retrieve_local_specialization (t
);
12771 if (r
== NULL_TREE
)
12773 /* We get here for a use of 'this' in an NSDMI. */
12774 if (DECL_NAME (t
) == this_identifier
12775 && current_function_decl
12776 && DECL_CONSTRUCTOR_P (current_function_decl
))
12777 return current_class_ptr
;
12779 /* This can happen for a parameter name used later in a function
12780 declaration (such as in a late-specified return type). Just
12781 make a dummy decl, since it's only used for its type. */
12782 gcc_assert (cp_unevaluated_operand
!= 0);
12783 r
= tsubst_decl (t
, args
, complain
);
12784 /* Give it the template pattern as its context; its true context
12785 hasn't been instantiated yet and this is good enough for
12787 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12790 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12791 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12800 if (DECL_TEMPLATE_PARM_P (t
))
12801 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12802 /* There is no need to substitute into namespace-scope
12804 if (DECL_NAMESPACE_SCOPE_P (t
))
12806 /* If ARGS is NULL, then T is known to be non-dependent. */
12807 if (args
== NULL_TREE
)
12808 return scalar_constant_value (t
);
12810 /* Unfortunately, we cannot just call lookup_name here.
12813 template <int I> int f() {
12815 struct S { void g() { E e = a; } };
12818 When we instantiate f<7>::S::g(), say, lookup_name is not
12819 clever enough to find f<7>::a. */
12821 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12822 /*entering_scope=*/0);
12824 for (v
= TYPE_VALUES (enum_type
);
12826 v
= TREE_CHAIN (v
))
12827 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12828 return TREE_VALUE (v
);
12830 /* We didn't find the name. That should never happen; if
12831 name-lookup found it during preliminary parsing, we
12832 should find it again here during instantiation. */
12833 gcc_unreachable ();
12838 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12840 /* Check for a local specialization set up by
12841 tsubst_pack_expansion. */
12842 if (tree r
= retrieve_local_specialization (t
))
12844 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12845 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12849 /* When retrieving a capture pack from a generic lambda, remove the
12850 lambda call op's own template argument list from ARGS. Only the
12851 template arguments active for the closure type should be used to
12852 retrieve the pack specialization. */
12853 if (LAMBDA_FUNCTION_P (current_function_decl
)
12854 && (template_class_depth (DECL_CONTEXT (t
))
12855 != TMPL_ARGS_DEPTH (args
)))
12856 args
= strip_innermost_template_args (args
, 1);
12858 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12859 tsubst_decl put in the hash table. */
12860 return retrieve_specialization (t
, args
, 0);
12863 if (DECL_CONTEXT (t
))
12867 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12868 /*entering_scope=*/1);
12869 if (ctx
!= DECL_CONTEXT (t
))
12871 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
12874 if (complain
& tf_error
)
12875 error ("using invalid field %qD", t
);
12876 return error_mark_node
;
12885 case FUNCTION_DECL
:
12886 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
12887 r
= tsubst (t
, args
, complain
, in_decl
);
12888 else if (local_variable_p (t
))
12890 r
= retrieve_local_specialization (t
);
12891 if (r
== NULL_TREE
)
12893 /* First try name lookup to find the instantiation. */
12894 r
= lookup_name (DECL_NAME (t
));
12897 /* Make sure that the one we found is the one we want. */
12898 tree ctx
= tsubst (DECL_CONTEXT (t
), args
,
12899 complain
, in_decl
);
12900 if (ctx
!= DECL_CONTEXT (r
))
12908 /* This can happen for a variable used in a
12909 late-specified return type of a local lambda, or for a
12910 local static or constant. Building a new VAR_DECL
12911 should be OK in all those cases. */
12912 r
= tsubst_decl (t
, args
, complain
);
12913 if (decl_maybe_constant_var_p (r
))
12915 /* We can't call cp_finish_decl, so handle the
12916 initializer by hand. */
12917 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
12918 complain
, in_decl
);
12919 if (!processing_template_decl
)
12920 init
= maybe_constant_init (init
);
12921 if (processing_template_decl
12922 ? potential_constant_expression (init
)
12923 : reduced_constant_expression_p (init
))
12924 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
12925 = TREE_CONSTANT (r
) = true;
12926 DECL_INITIAL (r
) = init
;
12928 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
12929 || decl_constant_var_p (r
)
12930 || errorcount
|| sorrycount
);
12931 if (!processing_template_decl
)
12933 if (TREE_STATIC (r
))
12934 rest_of_decl_compilation (r
, toplevel_bindings_p (),
12936 else if (decl_constant_var_p (r
))
12937 /* A use of a local constant decays to its value.
12938 FIXME update for core DR 696. */
12939 r
= scalar_constant_value (r
);
12942 /* Remember this for subsequent uses. */
12943 if (local_specializations
)
12944 register_local_specialization (r
, t
);
12952 case NAMESPACE_DECL
:
12956 /* An OVERLOAD will always be a non-dependent overload set; an
12957 overload set from function scope will just be represented with an
12958 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12959 gcc_assert (!uses_template_parms (t
));
12963 return tsubst_baselink (t
, current_nonlambda_class_type (),
12964 args
, complain
, in_decl
);
12966 case TEMPLATE_DECL
:
12967 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12968 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
12969 args
, complain
, in_decl
);
12970 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
12971 return tsubst (t
, args
, complain
, in_decl
);
12972 else if (DECL_CLASS_SCOPE_P (t
)
12973 && uses_template_parms (DECL_CONTEXT (t
)))
12975 /* Template template argument like the following example need
12978 template <template <class> class TT> struct C {};
12979 template <class T> struct D {
12980 template <class U> struct E {};
12985 We are processing the template argument `E' in #1 for
12986 the template instantiation #2. Originally, `E' is a
12987 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12988 have to substitute this with one having context `D<int>'. */
12990 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
12991 return lookup_field (context
, DECL_NAME(t
), 0, false);
12994 /* Ordinary template template argument. */
12998 case REINTERPRET_CAST_EXPR
:
12999 case CONST_CAST_EXPR
:
13000 case STATIC_CAST_EXPR
:
13001 case DYNAMIC_CAST_EXPR
:
13002 case IMPLICIT_CONV_EXPR
:
13006 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13007 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13008 return build1 (code
, type
, op0
);
13012 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
13015 tree expanded
, op
= TREE_OPERAND (t
, 0);
13018 if (SIZEOF_EXPR_TYPE_P (t
))
13019 op
= TREE_TYPE (op
);
13021 ++cp_unevaluated_operand
;
13022 ++c_inhibit_evaluation_warnings
;
13023 /* We only want to compute the number of arguments. */
13024 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
13025 --cp_unevaluated_operand
;
13026 --c_inhibit_evaluation_warnings
;
13028 if (TREE_CODE (expanded
) == TREE_VEC
)
13029 len
= TREE_VEC_LENGTH (expanded
);
13031 if (expanded
== error_mark_node
)
13032 return error_mark_node
;
13033 else if (PACK_EXPANSION_P (expanded
)
13034 || (TREE_CODE (expanded
) == TREE_VEC
13036 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
13038 if (TREE_CODE (expanded
) == TREE_VEC
)
13039 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
13041 if (TYPE_P (expanded
))
13042 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
13043 complain
& tf_error
);
13045 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
13046 complain
& tf_error
);
13049 return build_int_cst (size_type_node
, len
);
13051 if (SIZEOF_EXPR_TYPE_P (t
))
13053 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
13054 args
, complain
, in_decl
);
13055 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
13056 r
= build1 (SIZEOF_EXPR
,
13057 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
13058 SIZEOF_EXPR_TYPE_P (r
) = 1;
13065 case TRUTH_NOT_EXPR
:
13068 case UNARY_PLUS_EXPR
: /* Unary + */
13070 case AT_ENCODE_EXPR
:
13074 case REALPART_EXPR
:
13075 case IMAGPART_EXPR
:
13078 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13079 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13080 return build1 (code
, type
, op0
);
13083 case COMPONENT_REF
:
13088 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13089 name
= TREE_OPERAND (t
, 1);
13090 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
13092 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13093 complain
, in_decl
);
13094 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13096 else if (TREE_CODE (name
) == SCOPE_REF
13097 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
13099 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13100 complain
, in_decl
);
13101 name
= TREE_OPERAND (name
, 1);
13102 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13103 complain
, in_decl
);
13104 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13105 name
= build_qualified_name (/*type=*/NULL_TREE
,
13107 /*template_p=*/false);
13109 else if (BASELINK_P (name
))
13110 name
= tsubst_baselink (name
,
13111 non_reference (TREE_TYPE (object
)),
13115 name
= tsubst_copy (name
, args
, complain
, in_decl
);
13116 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
13122 case TRUNC_DIV_EXPR
:
13123 case CEIL_DIV_EXPR
:
13124 case FLOOR_DIV_EXPR
:
13125 case ROUND_DIV_EXPR
:
13126 case EXACT_DIV_EXPR
:
13130 case TRUNC_MOD_EXPR
:
13131 case FLOOR_MOD_EXPR
:
13132 case TRUTH_ANDIF_EXPR
:
13133 case TRUTH_ORIF_EXPR
:
13134 case TRUTH_AND_EXPR
:
13135 case TRUTH_OR_EXPR
:
13148 case COMPOUND_EXPR
:
13151 case PREDECREMENT_EXPR
:
13152 case PREINCREMENT_EXPR
:
13153 case POSTDECREMENT_EXPR
:
13154 case POSTINCREMENT_EXPR
:
13156 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13157 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13158 return build_nt (code
, op0
, op1
);
13163 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13164 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13165 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
13166 QUALIFIED_NAME_IS_TEMPLATE (t
));
13171 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13172 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13173 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13178 int n
= VL_EXP_OPERAND_LENGTH (t
);
13179 tree result
= build_vl_exp (CALL_EXPR
, n
);
13181 for (i
= 0; i
< n
; i
++)
13182 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13183 complain
, in_decl
);
13189 case PSEUDO_DTOR_EXPR
:
13190 case VEC_PERM_EXPR
:
13192 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13193 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13194 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13195 r
= build_nt (code
, op0
, op1
, op2
);
13196 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13202 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13203 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13204 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13205 r
= build_nt (code
, op0
, op1
, op2
);
13206 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13212 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13213 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13214 r
= build_nt (code
, op0
, op1
);
13215 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13216 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13220 case TEMPLATE_ID_EXPR
:
13222 /* Substituted template arguments */
13223 tree fn
= TREE_OPERAND (t
, 0);
13224 tree targs
= TREE_OPERAND (t
, 1);
13226 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13228 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13230 return lookup_template_function (fn
, targs
);
13235 tree purpose
, value
, chain
;
13237 if (t
== void_list_node
)
13240 purpose
= TREE_PURPOSE (t
);
13242 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13243 value
= TREE_VALUE (t
);
13245 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13246 chain
= TREE_CHAIN (t
);
13247 if (chain
&& chain
!= void_type_node
)
13248 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13249 if (purpose
== TREE_PURPOSE (t
)
13250 && value
== TREE_VALUE (t
)
13251 && chain
== TREE_CHAIN (t
))
13253 return tree_cons (purpose
, value
, chain
);
13258 case ENUMERAL_TYPE
:
13260 case TEMPLATE_TYPE_PARM
:
13261 case TEMPLATE_TEMPLATE_PARM
:
13262 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13263 case TEMPLATE_PARM_INDEX
:
13265 case REFERENCE_TYPE
:
13267 case FUNCTION_TYPE
:
13270 case TYPENAME_TYPE
:
13271 case UNBOUND_CLASS_TEMPLATE
:
13273 case DECLTYPE_TYPE
:
13275 return tsubst (t
, args
, complain
, in_decl
);
13279 /* Fall through. */
13280 case IDENTIFIER_NODE
:
13281 if (IDENTIFIER_TYPENAME_P (t
))
13283 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13284 return mangle_conv_op_name_for_type (new_type
);
13290 /* This is handled by tsubst_copy_and_build. */
13291 gcc_unreachable ();
13295 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13296 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13297 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13300 case CLEANUP_POINT_EXPR
:
13301 /* We shouldn't have built any of these during initial template
13302 generation. Instead, they should be built during instantiation
13303 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13304 gcc_unreachable ();
13308 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13309 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13310 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13311 r
= build2 (code
, type
, op0
, op1
);
13312 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13313 mark_used (TREE_OPERAND (r
, 1));
13317 case EXPR_PACK_EXPANSION
:
13318 error ("invalid use of pack expansion expression");
13319 return error_mark_node
;
13321 case NONTYPE_ARGUMENT_PACK
:
13322 error ("use %<...%> to expand argument pack");
13323 return error_mark_node
;
13326 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13334 /* Instantiate any typedefs in the type. */
13335 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13336 r
= fold_convert (type
, t
);
13337 gcc_assert (TREE_CODE (r
) == code
);
13342 /* These can sometimes show up in a partial instantiation, but never
13343 involve template parms. */
13344 gcc_assert (!uses_template_parms (t
));
13348 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13349 gcc_checking_assert (false);
13354 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13357 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13358 tree args
, tsubst_flags_t complain
, tree in_decl
)
13360 tree new_clauses
= NULL
, nc
, oc
;
13362 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13364 nc
= copy_node (oc
);
13365 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13368 switch (OMP_CLAUSE_CODE (nc
))
13370 case OMP_CLAUSE_LASTPRIVATE
:
13371 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13373 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13374 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13375 in_decl
, /*integral_constant_expression_p=*/false);
13376 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13377 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13380 case OMP_CLAUSE_PRIVATE
:
13381 case OMP_CLAUSE_SHARED
:
13382 case OMP_CLAUSE_FIRSTPRIVATE
:
13383 case OMP_CLAUSE_COPYIN
:
13384 case OMP_CLAUSE_COPYPRIVATE
:
13385 case OMP_CLAUSE_IF
:
13386 case OMP_CLAUSE_NUM_THREADS
:
13387 case OMP_CLAUSE_SCHEDULE
:
13388 case OMP_CLAUSE_COLLAPSE
:
13389 case OMP_CLAUSE_FINAL
:
13390 case OMP_CLAUSE_DEPEND
:
13391 case OMP_CLAUSE_FROM
:
13392 case OMP_CLAUSE_TO
:
13393 case OMP_CLAUSE_UNIFORM
:
13394 case OMP_CLAUSE_MAP
:
13395 case OMP_CLAUSE_DEVICE
:
13396 case OMP_CLAUSE_DIST_SCHEDULE
:
13397 case OMP_CLAUSE_NUM_TEAMS
:
13398 case OMP_CLAUSE_THREAD_LIMIT
:
13399 case OMP_CLAUSE_SAFELEN
:
13400 case OMP_CLAUSE_SIMDLEN
:
13401 OMP_CLAUSE_OPERAND (nc
, 0)
13402 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13403 in_decl
, /*integral_constant_expression_p=*/false);
13405 case OMP_CLAUSE_REDUCTION
:
13406 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13408 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13409 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13411 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13412 complain
, in_decl
);
13413 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13414 = build_qualified_name (NULL_TREE
, scope
,
13415 TREE_OPERAND (placeholder
, 1),
13419 gcc_assert (identifier_p (placeholder
));
13421 OMP_CLAUSE_OPERAND (nc
, 0)
13422 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13423 in_decl
, /*integral_constant_expression_p=*/false);
13425 case OMP_CLAUSE_LINEAR
:
13426 case OMP_CLAUSE_ALIGNED
:
13427 OMP_CLAUSE_OPERAND (nc
, 0)
13428 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13429 in_decl
, /*integral_constant_expression_p=*/false);
13430 OMP_CLAUSE_OPERAND (nc
, 1)
13431 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13432 in_decl
, /*integral_constant_expression_p=*/false);
13435 case OMP_CLAUSE_NOWAIT
:
13436 case OMP_CLAUSE_ORDERED
:
13437 case OMP_CLAUSE_DEFAULT
:
13438 case OMP_CLAUSE_UNTIED
:
13439 case OMP_CLAUSE_MERGEABLE
:
13440 case OMP_CLAUSE_INBRANCH
:
13441 case OMP_CLAUSE_NOTINBRANCH
:
13442 case OMP_CLAUSE_PROC_BIND
:
13443 case OMP_CLAUSE_FOR
:
13444 case OMP_CLAUSE_PARALLEL
:
13445 case OMP_CLAUSE_SECTIONS
:
13446 case OMP_CLAUSE_TASKGROUP
:
13449 gcc_unreachable ();
13453 new_clauses
= nreverse (new_clauses
);
13455 new_clauses
= finish_omp_clauses (new_clauses
);
13456 return new_clauses
;
13459 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13462 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13465 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13467 tree purpose
, value
, chain
;
13472 if (TREE_CODE (t
) != TREE_LIST
)
13473 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13474 /*function_p=*/false,
13475 /*integral_constant_expression_p=*/false);
13477 if (t
== void_list_node
)
13480 purpose
= TREE_PURPOSE (t
);
13482 purpose
= RECUR (purpose
);
13483 value
= TREE_VALUE (t
);
13486 if (TREE_CODE (value
) != LABEL_DECL
)
13487 value
= RECUR (value
);
13490 value
= lookup_label (DECL_NAME (value
));
13491 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13492 TREE_USED (value
) = 1;
13495 chain
= TREE_CHAIN (t
);
13496 if (chain
&& chain
!= void_type_node
)
13497 chain
= RECUR (chain
);
13498 return tree_cons (purpose
, value
, chain
);
13502 /* Substitute one OMP_FOR iterator. */
13505 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13506 tree condv
, tree incrv
, tree
*clauses
,
13507 tree args
, tsubst_flags_t complain
, tree in_decl
,
13508 bool integral_constant_expression_p
)
13510 #define RECUR(NODE) \
13511 tsubst_expr ((NODE), args, complain, in_decl, \
13512 integral_constant_expression_p)
13513 tree decl
, init
, cond
, incr
;
13515 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13516 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13517 decl
= TREE_OPERAND (init
, 0);
13518 init
= TREE_OPERAND (init
, 1);
13519 tree decl_expr
= NULL_TREE
;
13520 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13522 /* We need to jump through some hoops to handle declarations in the
13523 for-init-statement, since we might need to handle auto deduction,
13524 but we need to keep control of initialization. */
13526 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13527 decl
= tsubst_decl (decl
, args
, complain
);
13530 decl
= RECUR (decl
);
13531 init
= RECUR (init
);
13533 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13534 if (auto_node
&& init
)
13536 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13538 gcc_assert (!type_dependent_expression_p (decl
));
13540 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13544 /* Declare the variable, but don't let that initialize it. */
13545 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13546 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13548 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13551 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13552 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13553 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13555 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13556 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13557 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13558 NOP_EXPR
, rhs
, complain
);
13561 incr
= RECUR (incr
);
13562 TREE_VEC_ELT (declv
, i
) = decl
;
13563 TREE_VEC_ELT (initv
, i
) = init
;
13564 TREE_VEC_ELT (condv
, i
) = cond
;
13565 TREE_VEC_ELT (incrv
, i
) = incr
;
13571 /* Declare and initialize the variable. */
13578 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13580 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13581 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13582 && OMP_CLAUSE_DECL (c
) == decl
)
13584 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13585 && OMP_CLAUSE_DECL (c
) == decl
)
13586 error ("iteration variable %qD should not be firstprivate", decl
);
13587 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13588 && OMP_CLAUSE_DECL (c
) == decl
)
13589 error ("iteration variable %qD should not be reduction", decl
);
13593 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13594 OMP_CLAUSE_DECL (c
) = decl
;
13595 c
= finish_omp_clauses (c
);
13598 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13603 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13604 if (COMPARISON_CLASS_P (cond
))
13606 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13607 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13608 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13611 cond
= RECUR (cond
);
13612 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13613 switch (TREE_CODE (incr
))
13615 case PREINCREMENT_EXPR
:
13616 case PREDECREMENT_EXPR
:
13617 case POSTINCREMENT_EXPR
:
13618 case POSTDECREMENT_EXPR
:
13619 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13620 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13623 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13624 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13626 tree rhs
= TREE_OPERAND (incr
, 1);
13627 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13628 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13629 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13630 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13631 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13635 incr
= RECUR (incr
);
13638 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13639 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13641 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13642 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13643 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13644 TREE_TYPE (decl
), lhs
,
13645 RECUR (TREE_OPERAND (incr
, 2))));
13647 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13648 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13649 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13651 tree rhs
= TREE_OPERAND (incr
, 2);
13652 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13653 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13654 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13655 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13656 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13660 incr
= RECUR (incr
);
13663 incr
= RECUR (incr
);
13667 TREE_VEC_ELT (declv
, i
) = decl
;
13668 TREE_VEC_ELT (initv
, i
) = init
;
13669 TREE_VEC_ELT (condv
, i
) = cond
;
13670 TREE_VEC_ELT (incrv
, i
) = incr
;
13674 /* Like tsubst_copy for expressions, etc. but also does semantic
13678 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13679 bool integral_constant_expression_p
)
13681 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13682 #define RECUR(NODE) \
13683 tsubst_expr ((NODE), args, complain, in_decl, \
13684 integral_constant_expression_p)
13690 if (t
== NULL_TREE
|| t
== error_mark_node
)
13693 loc
= input_location
;
13694 if (EXPR_HAS_LOCATION (t
))
13695 input_location
= EXPR_LOCATION (t
);
13696 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13697 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13699 switch (TREE_CODE (t
))
13701 case STATEMENT_LIST
:
13703 tree_stmt_iterator i
;
13704 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13705 RECUR (tsi_stmt (i
));
13709 case CTOR_INITIALIZER
:
13710 finish_mem_initializers (tsubst_initializer_list
13711 (TREE_OPERAND (t
, 0), args
));
13715 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13719 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13720 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13721 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13723 finish_expr_stmt (tmp
);
13727 do_using_directive (USING_STMT_NAMESPACE (t
));
13732 tree decl
, pattern_decl
;
13735 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13736 if (TREE_CODE (decl
) == LABEL_DECL
)
13737 finish_label_decl (DECL_NAME (decl
));
13738 else if (TREE_CODE (decl
) == USING_DECL
)
13740 tree scope
= USING_DECL_SCOPE (decl
);
13741 tree name
= DECL_NAME (decl
);
13744 scope
= tsubst (scope
, args
, complain
, in_decl
);
13745 decl
= lookup_qualified_name (scope
, name
,
13746 /*is_type_p=*/false,
13747 /*complain=*/false);
13748 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13749 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13751 do_local_using_decl (decl
, scope
, name
);
13753 else if (DECL_PACK_P (decl
))
13755 /* Don't build up decls for a variadic capture proxy, we'll
13756 instantiate the elements directly as needed. */
13761 init
= DECL_INITIAL (decl
);
13762 decl
= tsubst (decl
, args
, complain
, in_decl
);
13763 if (decl
!= error_mark_node
)
13765 /* By marking the declaration as instantiated, we avoid
13766 trying to instantiate it. Since instantiate_decl can't
13767 handle local variables, and since we've already done
13768 all that needs to be done, that's the right thing to
13771 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13773 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13774 /* Anonymous aggregates are a special case. */
13775 finish_anon_union (decl
);
13776 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13778 DECL_CONTEXT (decl
) = current_function_decl
;
13779 if (DECL_NAME (decl
) == this_identifier
)
13781 tree lam
= DECL_CONTEXT (current_function_decl
);
13782 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13783 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13785 insert_capture_proxy (decl
);
13787 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13788 /* We already did a pushtag. */;
13789 else if (TREE_CODE (decl
) == FUNCTION_DECL
13790 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13791 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13793 DECL_CONTEXT (decl
) = NULL_TREE
;
13795 DECL_CONTEXT (decl
) = current_function_decl
;
13796 cp_check_omp_declare_reduction (decl
);
13800 int const_init
= false;
13801 maybe_push_decl (decl
);
13803 && DECL_PRETTY_FUNCTION_P (decl
))
13805 /* For __PRETTY_FUNCTION__ we have to adjust the
13807 const char *const name
13808 = cxx_printable_name (current_function_decl
, 2);
13809 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13812 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
13815 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13817 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13826 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13827 RECUR (FOR_INIT_STMT (t
));
13828 finish_for_init_stmt (stmt
);
13829 tmp
= RECUR (FOR_COND (t
));
13830 finish_for_cond (tmp
, stmt
, false);
13831 tmp
= RECUR (FOR_EXPR (t
));
13832 finish_for_expr (tmp
, stmt
);
13833 RECUR (FOR_BODY (t
));
13834 finish_for_stmt (stmt
);
13837 case RANGE_FOR_STMT
:
13840 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13841 decl
= RANGE_FOR_DECL (t
);
13842 decl
= tsubst (decl
, args
, complain
, in_decl
);
13843 maybe_push_decl (decl
);
13844 expr
= RECUR (RANGE_FOR_EXPR (t
));
13845 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13846 RECUR (RANGE_FOR_BODY (t
));
13847 finish_for_stmt (stmt
);
13852 stmt
= begin_while_stmt ();
13853 tmp
= RECUR (WHILE_COND (t
));
13854 finish_while_stmt_cond (tmp
, stmt
, false);
13855 RECUR (WHILE_BODY (t
));
13856 finish_while_stmt (stmt
);
13860 stmt
= begin_do_stmt ();
13861 RECUR (DO_BODY (t
));
13862 finish_do_body (stmt
);
13863 tmp
= RECUR (DO_COND (t
));
13864 finish_do_stmt (tmp
, stmt
, false);
13868 stmt
= begin_if_stmt ();
13869 tmp
= RECUR (IF_COND (t
));
13870 finish_if_stmt_cond (tmp
, stmt
);
13871 RECUR (THEN_CLAUSE (t
));
13872 finish_then_clause (stmt
);
13874 if (ELSE_CLAUSE (t
))
13876 begin_else_clause (stmt
);
13877 RECUR (ELSE_CLAUSE (t
));
13878 finish_else_clause (stmt
);
13881 finish_if_stmt (stmt
);
13885 if (BIND_EXPR_BODY_BLOCK (t
))
13886 stmt
= begin_function_body ();
13888 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
13889 ? BCS_TRY_BLOCK
: 0);
13891 RECUR (BIND_EXPR_BODY (t
));
13893 if (BIND_EXPR_BODY_BLOCK (t
))
13894 finish_function_body (stmt
);
13896 finish_compound_stmt (stmt
);
13900 finish_break_stmt ();
13903 case CONTINUE_STMT
:
13904 finish_continue_stmt ();
13908 stmt
= begin_switch_stmt ();
13909 tmp
= RECUR (SWITCH_STMT_COND (t
));
13910 finish_switch_cond (tmp
, stmt
);
13911 RECUR (SWITCH_STMT_BODY (t
));
13912 finish_switch_stmt (stmt
);
13915 case CASE_LABEL_EXPR
:
13917 tree low
= RECUR (CASE_LOW (t
));
13918 tree high
= RECUR (CASE_HIGH (t
));
13919 finish_case_label (EXPR_LOCATION (t
), low
, high
);
13925 tree decl
= LABEL_EXPR_LABEL (t
);
13928 label
= finish_label_stmt (DECL_NAME (decl
));
13929 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13930 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13935 tmp
= GOTO_DESTINATION (t
);
13936 if (TREE_CODE (tmp
) != LABEL_DECL
)
13937 /* Computed goto's must be tsubst'd into. On the other hand,
13938 non-computed gotos must not be; the identifier in question
13939 will have no binding. */
13942 tmp
= DECL_NAME (tmp
);
13943 finish_goto_stmt (tmp
);
13948 tree string
= RECUR (ASM_STRING (t
));
13949 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
13950 complain
, in_decl
);
13951 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
13952 complain
, in_decl
);
13953 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
13954 complain
, in_decl
);
13955 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
13956 complain
, in_decl
);
13957 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
13959 tree asm_expr
= tmp
;
13960 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
13961 asm_expr
= TREE_OPERAND (asm_expr
, 0);
13962 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
13969 stmt
= begin_try_block ();
13970 RECUR (TRY_STMTS (t
));
13971 finish_cleanup_try_block (stmt
);
13972 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
13976 tree compound_stmt
= NULL_TREE
;
13978 if (FN_TRY_BLOCK_P (t
))
13979 stmt
= begin_function_try_block (&compound_stmt
);
13981 stmt
= begin_try_block ();
13983 RECUR (TRY_STMTS (t
));
13985 if (FN_TRY_BLOCK_P (t
))
13986 finish_function_try_block (stmt
);
13988 finish_try_block (stmt
);
13990 RECUR (TRY_HANDLERS (t
));
13991 if (FN_TRY_BLOCK_P (t
))
13992 finish_function_handler_sequence (stmt
, compound_stmt
);
13994 finish_handler_sequence (stmt
);
14000 tree decl
= HANDLER_PARMS (t
);
14004 decl
= tsubst (decl
, args
, complain
, in_decl
);
14005 /* Prevent instantiate_decl from trying to instantiate
14006 this variable. We've already done all that needs to be
14008 if (decl
!= error_mark_node
)
14009 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
14011 stmt
= begin_handler ();
14012 finish_handler_parms (decl
, stmt
);
14013 RECUR (HANDLER_BODY (t
));
14014 finish_handler (stmt
);
14019 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
14020 if (CLASS_TYPE_P (tmp
))
14022 /* Local classes are not independent templates; they are
14023 instantiated along with their containing function. And this
14024 way we don't have to deal with pushing out of one local class
14025 to instantiate a member of another local class. */
14027 /* Closures are handled by the LAMBDA_EXPR. */
14028 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
14029 complete_type (tmp
);
14030 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
14031 if (!DECL_ARTIFICIAL (fn
))
14032 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
14036 case STATIC_ASSERT
:
14040 ++c_inhibit_evaluation_warnings
;
14042 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
14045 /*integral_constant_expression_p=*/true);
14046 --c_inhibit_evaluation_warnings
;
14048 finish_static_assert (condition
,
14049 STATIC_ASSERT_MESSAGE (t
),
14050 STATIC_ASSERT_SOURCE_LOCATION (t
),
14051 /*member_p=*/false);
14056 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
14057 args
, complain
, in_decl
);
14058 stmt
= begin_omp_parallel ();
14059 RECUR (OMP_PARALLEL_BODY (t
));
14060 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
14061 = OMP_PARALLEL_COMBINED (t
);
14065 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
14066 args
, complain
, in_decl
);
14067 stmt
= begin_omp_task ();
14068 RECUR (OMP_TASK_BODY (t
));
14069 finish_omp_task (tmp
, stmt
);
14076 case OMP_DISTRIBUTE
:
14078 tree clauses
, body
, pre_body
;
14079 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
14080 tree incrv
= NULL_TREE
;
14083 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
14084 args
, complain
, in_decl
);
14085 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14087 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14088 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14089 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14090 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14093 stmt
= begin_omp_structured_block ();
14095 pre_body
= push_stmt_list ();
14096 RECUR (OMP_FOR_PRE_BODY (t
));
14097 pre_body
= pop_stmt_list (pre_body
);
14099 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14100 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
14101 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
14102 &clauses
, args
, complain
, in_decl
,
14103 integral_constant_expression_p
);
14105 body
= push_stmt_list ();
14106 RECUR (OMP_FOR_BODY (t
));
14107 body
= pop_stmt_list (body
);
14109 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14110 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
14111 condv
, incrv
, body
, pre_body
, clauses
);
14114 t
= make_node (TREE_CODE (t
));
14115 TREE_TYPE (t
) = void_type_node
;
14116 OMP_FOR_BODY (t
) = body
;
14117 OMP_FOR_PRE_BODY (t
) = pre_body
;
14118 OMP_FOR_CLAUSES (t
) = clauses
;
14119 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
14123 add_stmt (finish_omp_structured_block (stmt
));
14130 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14131 args
, complain
, in_decl
);
14132 stmt
= push_stmt_list ();
14133 RECUR (OMP_BODY (t
));
14134 stmt
= pop_stmt_list (stmt
);
14137 OMP_BODY (t
) = stmt
;
14138 OMP_CLAUSES (t
) = tmp
;
14142 case OMP_TARGET_DATA
:
14144 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14145 args
, complain
, in_decl
);
14146 keep_next_level (true);
14147 stmt
= begin_omp_structured_block ();
14149 RECUR (OMP_BODY (t
));
14150 stmt
= finish_omp_structured_block (stmt
);
14153 OMP_BODY (t
) = stmt
;
14154 OMP_CLAUSES (t
) = tmp
;
14158 case OMP_TARGET_UPDATE
:
14159 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
14160 args
, complain
, in_decl
);
14162 OMP_CLAUSES (t
) = tmp
;
14169 case OMP_TASKGROUP
:
14171 stmt
= push_stmt_list ();
14172 RECUR (OMP_BODY (t
));
14173 stmt
= pop_stmt_list (stmt
);
14176 OMP_BODY (t
) = stmt
;
14181 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14182 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14184 tree op1
= TREE_OPERAND (t
, 1);
14185 tree rhs1
= NULL_TREE
;
14187 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14189 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14190 op1
= TREE_OPERAND (op1
, 1);
14192 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14193 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14194 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14195 NULL_TREE
, NULL_TREE
, rhs1
,
14196 OMP_ATOMIC_SEQ_CST (t
));
14200 tree op1
= TREE_OPERAND (t
, 1);
14201 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14202 tree rhs1
= NULL_TREE
;
14203 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14204 enum tree_code opcode
= NOP_EXPR
;
14205 if (code
== OMP_ATOMIC_READ
)
14207 v
= RECUR (TREE_OPERAND (op1
, 0));
14208 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14210 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14211 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14213 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14214 v
= RECUR (TREE_OPERAND (op1
, 0));
14215 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14216 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14218 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14219 op11
= TREE_OPERAND (op11
, 1);
14221 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14222 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14223 opcode
= TREE_CODE (op11
);
14224 if (opcode
== MODIFY_EXPR
)
14230 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14231 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14233 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14234 OMP_ATOMIC_SEQ_CST (t
));
14238 case TRANSACTION_EXPR
:
14241 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14242 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14244 if (TRANSACTION_EXPR_IS_STMT (t
))
14246 tree body
= TRANSACTION_EXPR_BODY (t
);
14247 tree noex
= NULL_TREE
;
14248 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14250 noex
= MUST_NOT_THROW_COND (body
);
14251 if (noex
== NULL_TREE
)
14252 noex
= boolean_true_node
;
14253 body
= TREE_OPERAND (body
, 0);
14255 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14257 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14261 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14262 RECUR (TRANSACTION_EXPR_BODY (t
)),
14269 case MUST_NOT_THROW_EXPR
:
14271 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14272 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14273 RETURN (build_must_not_throw_expr (op0
, cond
));
14276 case EXPR_PACK_EXPANSION
:
14277 error ("invalid use of pack expansion expression");
14278 RETURN (error_mark_node
);
14280 case NONTYPE_ARGUMENT_PACK
:
14281 error ("use %<...%> to expand argument pack");
14282 RETURN (error_mark_node
);
14284 case CILK_SPAWN_STMT
:
14285 cfun
->calls_cilk_spawn
= 1;
14286 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14288 case CILK_SYNC_STMT
:
14289 RETURN (build_cilk_sync ());
14291 case COMPOUND_EXPR
:
14292 tmp
= RECUR (TREE_OPERAND (t
, 0));
14293 if (tmp
== NULL_TREE
)
14294 /* If the first operand was a statement, we're done with it. */
14295 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14296 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14297 RECUR (TREE_OPERAND (t
, 1)),
14300 case ANNOTATE_EXPR
:
14301 tmp
= RECUR (TREE_OPERAND (t
, 0));
14302 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14303 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14306 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14308 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14309 /*function_p=*/false,
14310 integral_constant_expression_p
));
14313 RETURN (NULL_TREE
);
14315 input_location
= loc
;
14321 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14322 function. For description of the body see comment above
14323 cp_parser_omp_declare_reduction_exprs. */
14326 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14328 if (t
== NULL_TREE
|| t
== error_mark_node
)
14331 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14333 tree_stmt_iterator tsi
;
14336 memset (stmts
, 0, sizeof stmts
);
14337 for (i
= 0, tsi
= tsi_start (t
);
14338 i
< 7 && !tsi_end_p (tsi
);
14339 i
++, tsi_next (&tsi
))
14340 stmts
[i
] = tsi_stmt (tsi
);
14341 gcc_assert (tsi_end_p (tsi
));
14345 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14346 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14347 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14348 args
, complain
, in_decl
);
14349 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14350 args
, complain
, in_decl
);
14351 DECL_CONTEXT (omp_out
) = current_function_decl
;
14352 DECL_CONTEXT (omp_in
) = current_function_decl
;
14353 keep_next_level (true);
14354 tree block
= begin_omp_structured_block ();
14355 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14356 block
= finish_omp_structured_block (block
);
14357 block
= maybe_cleanup_point_expr_void (block
);
14358 add_decl_expr (omp_out
);
14359 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14360 TREE_NO_WARNING (omp_out
) = 1;
14361 add_decl_expr (omp_in
);
14362 finish_expr_stmt (block
);
14366 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14367 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14368 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14369 args
, complain
, in_decl
);
14370 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14371 args
, complain
, in_decl
);
14372 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14373 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14374 keep_next_level (true);
14375 tree block
= begin_omp_structured_block ();
14376 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14377 block
= finish_omp_structured_block (block
);
14378 block
= maybe_cleanup_point_expr_void (block
);
14379 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14380 add_decl_expr (omp_priv
);
14381 add_decl_expr (omp_orig
);
14382 finish_expr_stmt (block
);
14384 add_decl_expr (omp_orig
);
14388 /* T is a postfix-expression that is not being used in a function
14389 call. Return the substituted version of T. */
14392 tsubst_non_call_postfix_expression (tree t
, tree args
,
14393 tsubst_flags_t complain
,
14396 if (TREE_CODE (t
) == SCOPE_REF
)
14397 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14398 /*done=*/false, /*address_p=*/false);
14400 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14401 /*function_p=*/false,
14402 /*integral_constant_expression_p=*/false);
14407 /* Sentinel to disable certain warnings during template substitution. */
14409 struct warning_sentinel
{
14412 warning_sentinel(int& flag
, bool suppress
=true)
14413 : flag(flag
), val(flag
) { if (suppress
) flag
= 0; }
14414 ~warning_sentinel() { flag
= val
; }
14417 /* Like tsubst but deals with expressions and performs semantic
14418 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14421 tsubst_copy_and_build (tree t
,
14423 tsubst_flags_t complain
,
14426 bool integral_constant_expression_p
)
14428 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14429 #define RECUR(NODE) \
14430 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14431 /*function_p=*/false, \
14432 integral_constant_expression_p)
14437 if (t
== NULL_TREE
|| t
== error_mark_node
)
14440 loc
= input_location
;
14441 if (EXPR_HAS_LOCATION (t
))
14442 input_location
= EXPR_LOCATION (t
);
14444 /* N3276 decltype magic only applies to calls at the top level or on the
14445 right side of a comma. */
14446 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14447 complain
&= ~tf_decltype
;
14449 switch (TREE_CODE (t
))
14453 /* Fall through. */
14454 case IDENTIFIER_NODE
:
14458 bool non_integral_constant_expression_p
;
14459 const char *error_msg
;
14461 if (IDENTIFIER_TYPENAME_P (t
))
14463 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14464 t
= mangle_conv_op_name_for_type (new_type
);
14467 /* Look up the name. */
14468 decl
= lookup_name (t
);
14470 /* By convention, expressions use ERROR_MARK_NODE to indicate
14471 failure, not NULL_TREE. */
14472 if (decl
== NULL_TREE
)
14473 decl
= error_mark_node
;
14475 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14477 integral_constant_expression_p
,
14478 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14479 &non_integral_constant_expression_p
,
14480 /*template_p=*/false,
14482 /*address_p=*/false,
14483 /*template_arg_p=*/false,
14488 if (!function_p
&& identifier_p (decl
))
14490 if (complain
& tf_error
)
14491 unqualified_name_lookup_error (decl
);
14492 decl
= error_mark_node
;
14497 case TEMPLATE_ID_EXPR
:
14500 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14501 tree targs
= TREE_OPERAND (t
, 1);
14504 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14506 if (TREE_CODE (templ
) == COMPONENT_REF
)
14508 object
= TREE_OPERAND (templ
, 0);
14509 templ
= TREE_OPERAND (templ
, 1);
14512 object
= NULL_TREE
;
14513 templ
= lookup_template_function (templ
, targs
);
14516 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14517 object
, templ
, NULL_TREE
));
14519 RETURN (baselink_for_fns (templ
));
14524 tree r
= RECUR (TREE_OPERAND (t
, 0));
14526 if (REFERENCE_REF_P (t
))
14528 /* A type conversion to reference type will be enclosed in
14529 such an indirect ref, but the substitution of the cast
14530 will have also added such an indirect ref. */
14531 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14532 r
= convert_from_reference (r
);
14535 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14536 complain
|decltype_flag
);
14542 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14543 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14544 RETURN (build_nop (type
, op0
));
14547 case IMPLICIT_CONV_EXPR
:
14549 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14550 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14551 int flags
= LOOKUP_IMPLICIT
;
14552 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14553 flags
= LOOKUP_NORMAL
;
14554 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14560 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14561 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14562 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14566 case REINTERPRET_CAST_EXPR
:
14567 case CONST_CAST_EXPR
:
14568 case DYNAMIC_CAST_EXPR
:
14569 case STATIC_CAST_EXPR
:
14572 tree op
, r
= NULL_TREE
;
14574 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14575 if (integral_constant_expression_p
14576 && !cast_valid_in_integral_constant_expression_p (type
))
14578 if (complain
& tf_error
)
14579 error ("a cast to a type other than an integral or "
14580 "enumeration type cannot appear in a constant-expression");
14581 RETURN (error_mark_node
);
14584 op
= RECUR (TREE_OPERAND (t
, 0));
14586 warning_sentinel
s(warn_useless_cast
);
14587 switch (TREE_CODE (t
))
14590 r
= build_functional_cast (type
, op
, complain
);
14592 case REINTERPRET_CAST_EXPR
:
14593 r
= build_reinterpret_cast (type
, op
, complain
);
14595 case CONST_CAST_EXPR
:
14596 r
= build_const_cast (type
, op
, complain
);
14598 case DYNAMIC_CAST_EXPR
:
14599 r
= build_dynamic_cast (type
, op
, complain
);
14601 case STATIC_CAST_EXPR
:
14602 r
= build_static_cast (type
, op
, complain
);
14605 gcc_unreachable ();
14611 case POSTDECREMENT_EXPR
:
14612 case POSTINCREMENT_EXPR
:
14613 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14614 args
, complain
, in_decl
);
14615 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14616 complain
|decltype_flag
));
14618 case PREDECREMENT_EXPR
:
14619 case PREINCREMENT_EXPR
:
14623 case TRUTH_NOT_EXPR
:
14624 case UNARY_PLUS_EXPR
: /* Unary + */
14625 case REALPART_EXPR
:
14626 case IMAGPART_EXPR
:
14627 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14628 RECUR (TREE_OPERAND (t
, 0)),
14629 complain
|decltype_flag
));
14631 case FIX_TRUNC_EXPR
:
14632 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14636 op1
= TREE_OPERAND (t
, 0);
14637 if (TREE_CODE (op1
) == LABEL_DECL
)
14638 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14639 EXPR_LOCATION (op1
)));
14640 if (TREE_CODE (op1
) == SCOPE_REF
)
14641 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14642 /*done=*/true, /*address_p=*/true);
14644 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14646 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14647 complain
|decltype_flag
));
14652 case TRUNC_DIV_EXPR
:
14653 case CEIL_DIV_EXPR
:
14654 case FLOOR_DIV_EXPR
:
14655 case ROUND_DIV_EXPR
:
14656 case EXACT_DIV_EXPR
:
14660 case TRUNC_MOD_EXPR
:
14661 case FLOOR_MOD_EXPR
:
14662 case TRUTH_ANDIF_EXPR
:
14663 case TRUTH_ORIF_EXPR
:
14664 case TRUTH_AND_EXPR
:
14665 case TRUTH_OR_EXPR
:
14681 warning_sentinel
s1(warn_type_limits
);
14682 warning_sentinel
s2(warn_div_by_zero
);
14683 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14684 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14685 tree r
= build_x_binary_op
14686 (input_location
, TREE_CODE (t
),
14688 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14690 : TREE_CODE (TREE_OPERAND (t
, 0))),
14692 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14694 : TREE_CODE (TREE_OPERAND (t
, 1))),
14696 complain
|decltype_flag
);
14697 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14698 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14703 case POINTER_PLUS_EXPR
:
14705 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14706 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14707 return fold_build_pointer_plus (op0
, op1
);
14711 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14712 /*address_p=*/false));
14714 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14715 args
, complain
, in_decl
);
14716 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14717 RECUR (TREE_OPERAND (t
, 1)),
14718 complain
|decltype_flag
));
14720 case ARRAY_NOTATION_REF
:
14722 tree start_index
, length
, stride
;
14723 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14724 args
, complain
, in_decl
);
14725 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14726 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14727 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14728 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14729 length
, stride
, TREE_TYPE (op1
)));
14732 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14733 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14740 op1
= TREE_OPERAND (t
, 0);
14741 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14742 op1
= TREE_TYPE (op1
);
14745 /* When there are no ARGS, we are trying to evaluate a
14746 non-dependent expression from the parser. Trying to do
14747 the substitutions may not work. */
14749 op1
= TREE_TYPE (op1
);
14753 ++cp_unevaluated_operand
;
14754 ++c_inhibit_evaluation_warnings
;
14756 op1
= tsubst (op1
, args
, complain
, in_decl
);
14758 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14759 /*function_p=*/false,
14760 /*integral_constant_expression_p=*/
14762 --cp_unevaluated_operand
;
14763 --c_inhibit_evaluation_warnings
;
14766 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14767 complain
& tf_error
);
14769 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14770 complain
& tf_error
);
14771 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14773 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14775 if (!processing_template_decl
&& TYPE_P (op1
))
14777 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14778 build1 (NOP_EXPR
, op1
, error_mark_node
));
14779 SIZEOF_EXPR_TYPE_P (r
) = 1;
14782 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14783 TREE_SIDE_EFFECTS (r
) = 0;
14784 TREE_READONLY (r
) = 1;
14786 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14791 case AT_ENCODE_EXPR
:
14793 op1
= TREE_OPERAND (t
, 0);
14794 ++cp_unevaluated_operand
;
14795 ++c_inhibit_evaluation_warnings
;
14796 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14797 /*function_p=*/false,
14798 /*integral_constant_expression_p=*/false);
14799 --cp_unevaluated_operand
;
14800 --c_inhibit_evaluation_warnings
;
14801 RETURN (objc_build_encode_expr (op1
));
14804 case NOEXCEPT_EXPR
:
14805 op1
= TREE_OPERAND (t
, 0);
14806 ++cp_unevaluated_operand
;
14807 ++c_inhibit_evaluation_warnings
;
14808 ++cp_noexcept_operand
;
14809 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14810 /*function_p=*/false,
14811 /*integral_constant_expression_p=*/false);
14812 --cp_unevaluated_operand
;
14813 --c_inhibit_evaluation_warnings
;
14814 --cp_noexcept_operand
;
14815 RETURN (finish_noexcept_expr (op1
, complain
));
14819 warning_sentinel
s(warn_div_by_zero
);
14820 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
14821 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
14822 tree r
= build_x_modify_expr
14823 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
14824 complain
|decltype_flag
);
14825 /* TREE_NO_WARNING must be set if either the expression was
14826 parenthesized or it uses an operator such as >>= rather
14827 than plain assignment. In the former case, it was already
14828 set and must be copied. In the latter case,
14829 build_x_modify_expr sets it and it must not be reset
14831 if (TREE_NO_WARNING (t
))
14832 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14838 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14839 args
, complain
, in_decl
);
14840 /* Remember that there was a reference to this entity. */
14843 RETURN (build_x_arrow (input_location
, op1
, complain
));
14847 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14848 tree init
= RECUR (TREE_OPERAND (t
, 3));
14849 vec
<tree
, va_gc
> *placement_vec
;
14850 vec
<tree
, va_gc
> *init_vec
;
14853 if (placement
== NULL_TREE
)
14854 placement_vec
= NULL
;
14857 placement_vec
= make_tree_vector ();
14858 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14859 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14862 /* If there was an initializer in the original tree, but it
14863 instantiated to an empty list, then we should pass a
14864 non-NULL empty vector to tell build_new that it was an
14865 empty initializer() rather than no initializer. This can
14866 only happen when the initializer is a pack expansion whose
14867 parameter packs are of length zero. */
14868 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
14872 init_vec
= make_tree_vector ();
14873 if (init
== void_node
)
14874 gcc_assert (init_vec
!= NULL
);
14877 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
14878 vec_safe_push (init_vec
, TREE_VALUE (init
));
14882 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14883 tree op2
= RECUR (TREE_OPERAND (t
, 2));
14884 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
14885 NEW_EXPR_USE_GLOBAL (t
),
14888 if (placement_vec
!= NULL
)
14889 release_tree_vector (placement_vec
);
14890 if (init_vec
!= NULL
)
14891 release_tree_vector (init_vec
);
14898 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14899 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14900 RETURN (delete_sanity (op0
, op1
,
14901 DELETE_EXPR_USE_VEC (t
),
14902 DELETE_EXPR_USE_GLOBAL (t
),
14906 case COMPOUND_EXPR
:
14908 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
14909 complain
& ~tf_decltype
, in_decl
,
14910 /*function_p=*/false,
14911 integral_constant_expression_p
);
14912 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
14914 RECUR (TREE_OPERAND (t
, 1)),
14915 complain
|decltype_flag
));
14921 vec
<tree
, va_gc
> *call_args
;
14922 unsigned int nargs
, i
;
14927 function
= CALL_EXPR_FN (t
);
14928 /* When we parsed the expression, we determined whether or
14929 not Koenig lookup should be performed. */
14930 koenig_p
= KOENIG_LOOKUP_P (t
);
14931 if (TREE_CODE (function
) == SCOPE_REF
)
14933 qualified_p
= true;
14934 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
14936 /*address_p=*/false);
14938 else if (koenig_p
&& identifier_p (function
))
14940 /* Do nothing; calling tsubst_copy_and_build on an identifier
14941 would incorrectly perform unqualified lookup again.
14943 Note that we can also have an IDENTIFIER_NODE if the earlier
14944 unqualified lookup found a member function; in that case
14945 koenig_p will be false and we do want to do the lookup
14946 again to find the instantiated member function.
14948 FIXME but doing that causes c++/15272, so we need to stop
14949 using IDENTIFIER_NODE in that situation. */
14950 qualified_p
= false;
14954 if (TREE_CODE (function
) == COMPONENT_REF
)
14956 tree op
= TREE_OPERAND (function
, 1);
14958 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
14959 || (BASELINK_P (op
)
14960 && BASELINK_QUALIFIED_P (op
)));
14963 qualified_p
= false;
14965 if (TREE_CODE (function
) == ADDR_EXPR
14966 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
14967 /* Avoid error about taking the address of a constructor. */
14968 function
= TREE_OPERAND (function
, 0);
14970 function
= tsubst_copy_and_build (function
, args
, complain
,
14973 integral_constant_expression_p
);
14975 if (BASELINK_P (function
))
14976 qualified_p
= true;
14979 nargs
= call_expr_nargs (t
);
14980 call_args
= make_tree_vector ();
14981 for (i
= 0; i
< nargs
; ++i
)
14983 tree arg
= CALL_EXPR_ARG (t
, i
);
14985 if (!PACK_EXPANSION_P (arg
))
14986 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
14989 /* Expand the pack expansion and push each entry onto
14991 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
14992 if (TREE_CODE (arg
) == TREE_VEC
)
14994 unsigned int len
, j
;
14996 len
= TREE_VEC_LENGTH (arg
);
14997 for (j
= 0; j
< len
; ++j
)
14999 tree value
= TREE_VEC_ELT (arg
, j
);
15000 if (value
!= NULL_TREE
)
15001 value
= convert_from_reference (value
);
15002 vec_safe_push (call_args
, value
);
15007 /* A partial substitution. Add one entry. */
15008 vec_safe_push (call_args
, arg
);
15013 /* We do not perform argument-dependent lookup if normal
15014 lookup finds a non-function, in accordance with the
15015 expected resolution of DR 218. */
15017 && ((is_overloaded_fn (function
)
15018 /* If lookup found a member function, the Koenig lookup is
15019 not appropriate, even if an unqualified-name was used
15020 to denote the function. */
15021 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
15022 || identifier_p (function
))
15023 /* Only do this when substitution turns a dependent call
15024 into a non-dependent call. */
15025 && type_dependent_expression_p_push (t
)
15026 && !any_type_dependent_arguments_p (call_args
))
15027 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
15029 if (identifier_p (function
)
15030 && !any_type_dependent_arguments_p (call_args
))
15032 if (koenig_p
&& (complain
& tf_warning_or_error
))
15034 /* For backwards compatibility and good diagnostics, try
15035 the unqualified lookup again if we aren't in SFINAE
15037 tree unq
= (tsubst_copy_and_build
15038 (function
, args
, complain
, in_decl
, true,
15039 integral_constant_expression_p
));
15040 if (unq
== error_mark_node
)
15041 RETURN (error_mark_node
);
15043 if (unq
!= function
)
15046 if (INDIRECT_REF_P (fn
))
15047 fn
= TREE_OPERAND (fn
, 0);
15048 if (TREE_CODE (fn
) == COMPONENT_REF
)
15049 fn
= TREE_OPERAND (fn
, 1);
15050 if (is_overloaded_fn (fn
))
15051 fn
= get_first_fn (fn
);
15052 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
15053 "%qD was not declared in this scope, "
15054 "and no declarations were found by "
15055 "argument-dependent lookup at the point "
15056 "of instantiation", function
))
15059 /* Can't say anything more. */;
15060 else if (DECL_CLASS_SCOPE_P (fn
))
15062 location_t loc
= EXPR_LOC_OR_LOC (t
,
15065 "declarations in dependent base %qT are "
15066 "not found by unqualified lookup",
15067 DECL_CLASS_CONTEXT (fn
));
15068 if (current_class_ptr
)
15070 "use %<this->%D%> instead", function
);
15073 "use %<%T::%D%> instead",
15074 current_class_name
, function
);
15077 inform (0, "%q+D declared here, later in the "
15078 "translation unit", fn
);
15083 if (identifier_p (function
))
15085 if (complain
& tf_error
)
15086 unqualified_name_lookup_error (function
);
15087 release_tree_vector (call_args
);
15088 RETURN (error_mark_node
);
15092 /* Remember that there was a reference to this entity. */
15093 if (DECL_P (function
))
15094 mark_used (function
);
15096 /* Put back tf_decltype for the actual call. */
15097 complain
|= decltype_flag
;
15099 if (TREE_CODE (function
) == OFFSET_REF
)
15100 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
15102 else if (TREE_CODE (function
) == COMPONENT_REF
)
15104 tree instance
= TREE_OPERAND (function
, 0);
15105 tree fn
= TREE_OPERAND (function
, 1);
15107 if (processing_template_decl
15108 && (type_dependent_expression_p (instance
)
15109 || (!BASELINK_P (fn
)
15110 && TREE_CODE (fn
) != FIELD_DECL
)
15111 || type_dependent_expression_p (fn
)
15112 || any_type_dependent_arguments_p (call_args
)))
15113 ret
= build_nt_call_vec (function
, call_args
);
15114 else if (!BASELINK_P (fn
))
15115 ret
= finish_call_expr (function
, &call_args
,
15116 /*disallow_virtual=*/false,
15117 /*koenig_p=*/false,
15120 ret
= (build_new_method_call
15122 &call_args
, NULL_TREE
,
15123 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
15128 ret
= finish_call_expr (function
, &call_args
,
15129 /*disallow_virtual=*/qualified_p
,
15133 release_tree_vector (call_args
);
15140 tree cond
= RECUR (TREE_OPERAND (t
, 0));
15141 tree folded_cond
= fold_non_dependent_expr (cond
);
15144 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
15146 if (integer_zerop (folded_cond
))
15148 ++c_inhibit_evaluation_warnings
;
15149 exp1
= RECUR (TREE_OPERAND (t
, 1));
15150 --c_inhibit_evaluation_warnings
;
15151 exp2
= RECUR (TREE_OPERAND (t
, 2));
15155 exp1
= RECUR (TREE_OPERAND (t
, 1));
15156 ++c_inhibit_evaluation_warnings
;
15157 exp2
= RECUR (TREE_OPERAND (t
, 2));
15158 --c_inhibit_evaluation_warnings
;
15160 cond
= folded_cond
;
15164 exp1
= RECUR (TREE_OPERAND (t
, 1));
15165 exp2
= RECUR (TREE_OPERAND (t
, 2));
15168 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
15169 cond
, exp1
, exp2
, complain
));
15172 case PSEUDO_DTOR_EXPR
:
15174 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15175 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15176 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15177 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
15183 tree purpose
, value
, chain
;
15185 if (t
== void_list_node
)
15188 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15189 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15191 /* We have pack expansions, so expand those and
15192 create a new list out of it. */
15193 tree purposevec
= NULL_TREE
;
15194 tree valuevec
= NULL_TREE
;
15198 /* Expand the argument expressions. */
15199 if (TREE_PURPOSE (t
))
15200 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15201 complain
, in_decl
);
15202 if (TREE_VALUE (t
))
15203 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15204 complain
, in_decl
);
15206 /* Build the rest of the list. */
15207 chain
= TREE_CHAIN (t
);
15208 if (chain
&& chain
!= void_type_node
)
15209 chain
= RECUR (chain
);
15211 /* Determine the number of arguments. */
15212 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15214 len
= TREE_VEC_LENGTH (purposevec
);
15215 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15217 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15218 len
= TREE_VEC_LENGTH (valuevec
);
15221 /* Since we only performed a partial substitution into
15222 the argument pack, we only RETURN (a single list
15224 if (purposevec
== TREE_PURPOSE (t
)
15225 && valuevec
== TREE_VALUE (t
)
15226 && chain
== TREE_CHAIN (t
))
15229 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15232 /* Convert the argument vectors into a TREE_LIST */
15236 /* Grab the Ith values. */
15238 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15241 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15244 /* Build the list (backwards). */
15245 chain
= tree_cons (purpose
, value
, chain
);
15251 purpose
= TREE_PURPOSE (t
);
15253 purpose
= RECUR (purpose
);
15254 value
= TREE_VALUE (t
);
15256 value
= RECUR (value
);
15257 chain
= TREE_CHAIN (t
);
15258 if (chain
&& chain
!= void_type_node
)
15259 chain
= RECUR (chain
);
15260 if (purpose
== TREE_PURPOSE (t
)
15261 && value
== TREE_VALUE (t
)
15262 && chain
== TREE_CHAIN (t
))
15264 RETURN (tree_cons (purpose
, value
, chain
));
15267 case COMPONENT_REF
:
15274 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15275 args
, complain
, in_decl
);
15276 /* Remember that there was a reference to this entity. */
15277 if (DECL_P (object
))
15278 mark_used (object
);
15279 object_type
= TREE_TYPE (object
);
15281 member
= TREE_OPERAND (t
, 1);
15282 if (BASELINK_P (member
))
15283 member
= tsubst_baselink (member
,
15284 non_reference (TREE_TYPE (object
)),
15285 args
, complain
, in_decl
);
15287 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15288 if (member
== error_mark_node
)
15289 RETURN (error_mark_node
);
15291 if (type_dependent_expression_p (object
))
15292 /* We can't do much here. */;
15293 else if (!CLASS_TYPE_P (object_type
))
15295 if (scalarish_type_p (object_type
))
15297 tree s
= NULL_TREE
;
15298 tree dtor
= member
;
15300 if (TREE_CODE (dtor
) == SCOPE_REF
)
15302 s
= TREE_OPERAND (dtor
, 0);
15303 dtor
= TREE_OPERAND (dtor
, 1);
15305 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15307 dtor
= TREE_OPERAND (dtor
, 0);
15309 RETURN (finish_pseudo_destructor_expr
15310 (object
, s
, dtor
, input_location
));
15314 else if (TREE_CODE (member
) == SCOPE_REF
15315 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15317 /* Lookup the template functions now that we know what the
15319 tree scope
= TREE_OPERAND (member
, 0);
15320 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15321 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15322 member
= lookup_qualified_name (scope
, tmpl
,
15323 /*is_type_p=*/false,
15324 /*complain=*/false);
15325 if (BASELINK_P (member
))
15327 BASELINK_FUNCTIONS (member
)
15328 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15330 member
= (adjust_result_of_qualified_name_lookup
15331 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15336 qualified_name_lookup_error (scope
, tmpl
, member
,
15338 RETURN (error_mark_node
);
15341 else if (TREE_CODE (member
) == SCOPE_REF
15342 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15343 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15345 if (complain
& tf_error
)
15347 if (TYPE_P (TREE_OPERAND (member
, 0)))
15348 error ("%qT is not a class or namespace",
15349 TREE_OPERAND (member
, 0));
15351 error ("%qD is not a class or namespace",
15352 TREE_OPERAND (member
, 0));
15354 RETURN (error_mark_node
);
15356 else if (TREE_CODE (member
) == FIELD_DECL
)
15358 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15359 if (TREE_CODE (r
) == COMPONENT_REF
)
15360 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15364 r
= finish_class_member_access_expr (object
, member
,
15365 /*template_p=*/false,
15367 if (TREE_CODE (r
) == COMPONENT_REF
)
15368 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15373 RETURN (build_throw
15374 (RECUR (TREE_OPERAND (t
, 0))));
15378 vec
<constructor_elt
, va_gc
> *n
;
15379 constructor_elt
*ce
;
15380 unsigned HOST_WIDE_INT idx
;
15381 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15382 bool process_index_p
;
15384 bool need_copy_p
= false;
15387 if (type
== error_mark_node
)
15388 RETURN (error_mark_node
);
15390 /* digest_init will do the wrong thing if we let it. */
15391 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15394 /* We do not want to process the index of aggregate
15395 initializers as they are identifier nodes which will be
15396 looked up by digest_init. */
15397 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15399 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15400 newlen
= vec_safe_length (n
);
15401 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15403 if (ce
->index
&& process_index_p
15404 /* An identifier index is looked up in the type
15405 being initialized, not the current scope. */
15406 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15407 ce
->index
= RECUR (ce
->index
);
15409 if (PACK_EXPANSION_P (ce
->value
))
15411 /* Substitute into the pack expansion. */
15412 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15415 if (ce
->value
== error_mark_node
15416 || PACK_EXPANSION_P (ce
->value
))
15418 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15419 /* Just move the argument into place. */
15420 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15423 /* Update the length of the final CONSTRUCTOR
15424 arguments vector, and note that we will need to
15426 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15427 need_copy_p
= true;
15431 ce
->value
= RECUR (ce
->value
);
15436 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15438 vec_alloc (n
, newlen
);
15439 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15441 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15443 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15444 for (i
= 0; i
< len
; ++i
)
15445 CONSTRUCTOR_APPEND_ELT (n
, 0,
15446 TREE_VEC_ELT (ce
->value
, i
));
15449 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15453 r
= build_constructor (init_list_type_node
, n
);
15454 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15456 if (TREE_HAS_CONSTRUCTOR (t
))
15457 RETURN (finish_compound_literal (type
, r
, complain
));
15459 TREE_TYPE (r
) = type
;
15465 tree operand_0
= TREE_OPERAND (t
, 0);
15466 if (TYPE_P (operand_0
))
15468 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15469 RETURN (get_typeid (operand_0
, complain
));
15473 operand_0
= RECUR (operand_0
);
15474 RETURN (build_typeid (operand_0
, complain
));
15481 else if (DECL_PACK_P (t
))
15483 /* We don't build decls for an instantiation of a
15484 variadic capture proxy, we instantiate the elements
15486 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15487 return RECUR (DECL_VALUE_EXPR (t
));
15493 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15494 /* ??? We're doing a subset of finish_id_expression here. */
15496 && !processing_template_decl
15497 && !cp_unevaluated_operand
15498 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
15499 && DECL_THREAD_LOCAL_P (r
))
15501 if (tree wrap
= get_tls_wrapper_fn (r
))
15502 /* Replace an evaluated use of the thread_local variable with
15503 a call to its wrapper. */
15504 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
15506 else if (outer_automatic_var_p (r
))
15507 r
= process_outer_var_ref (r
, complain
);
15509 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15510 /* If the original type was a reference, we'll be wrapped in
15511 the appropriate INDIRECT_REF. */
15512 r
= convert_from_reference (r
);
15518 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15519 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15520 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15523 case OFFSETOF_EXPR
:
15524 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0)),
15525 EXPR_LOCATION (t
)));
15529 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15530 complain
, in_decl
);
15532 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15533 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
15534 type2
= RECUR (type2
);
15536 type2
= tsubst (type2
, args
, complain
, in_decl
);
15538 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15543 tree old_stmt_expr
= cur_stmt_expr
;
15544 tree stmt_expr
= begin_stmt_expr ();
15546 cur_stmt_expr
= stmt_expr
;
15547 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15548 integral_constant_expression_p
);
15549 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15550 cur_stmt_expr
= old_stmt_expr
;
15552 /* If the resulting list of expression statement is empty,
15553 fold it further into void_node. */
15554 if (empty_expr_stmt_p (stmt_expr
))
15555 stmt_expr
= void_node
;
15557 RETURN (stmt_expr
);
15562 tree r
= build_lambda_expr ();
15564 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15565 LAMBDA_EXPR_CLOSURE (r
) = type
;
15566 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15568 LAMBDA_EXPR_LOCATION (r
)
15569 = LAMBDA_EXPR_LOCATION (t
);
15570 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15571 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15572 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15573 LAMBDA_EXPR_DISCRIMINATOR (r
)
15574 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15575 /* For a function scope, we want to use tsubst so that we don't
15576 complain about referring to an auto function before its return
15577 type has been deduced. Otherwise, we want to use tsubst_copy so
15578 that we look up the existing field/parameter/variable rather
15579 than build a new one. */
15580 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15581 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15582 scope
= tsubst (scope
, args
, complain
, in_decl
);
15583 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15585 /* Look up the parameter we want directly, as tsubst_copy
15586 doesn't do what we need. */
15587 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15588 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15589 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15590 parm
= DECL_CHAIN (parm
);
15592 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15593 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15594 DECL_CONTEXT (scope
) = fn
;
15597 scope
= RECUR (scope
);
15598 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15599 LAMBDA_EXPR_RETURN_TYPE (r
)
15600 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15602 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15603 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15605 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15606 determine_visibility (TYPE_NAME (type
));
15607 /* Now that we know visibility, instantiate the type so we have a
15608 declaration of the op() for later calls to lambda_function. */
15609 complete_type (type
);
15611 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15613 RETURN (build_lambda_object (r
));
15617 /* We can get here for a constant initializer of non-dependent type.
15618 FIXME stop folding in cp_parser_initializer_clause. */
15620 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15625 case TRANSACTION_EXPR
:
15626 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15627 integral_constant_expression_p
));
15630 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15632 case VEC_PERM_EXPR
:
15634 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15635 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15636 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15637 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15642 /* Handle Objective-C++ constructs, if appropriate. */
15645 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15646 in_decl
, /*function_p=*/false);
15650 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15656 input_location
= loc
;
15660 /* Verify that the instantiated ARGS are valid. For type arguments,
15661 make sure that the type's linkage is ok. For non-type arguments,
15662 make sure they are constants if they are integral or enumerations.
15663 Emit an error under control of COMPLAIN, and return TRUE on error. */
15666 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15668 if (dependent_template_arg_p (t
))
15670 if (ARGUMENT_PACK_P (t
))
15672 tree vec
= ARGUMENT_PACK_ARGS (t
);
15673 int len
= TREE_VEC_LENGTH (vec
);
15674 bool result
= false;
15677 for (i
= 0; i
< len
; ++i
)
15678 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15682 else if (TYPE_P (t
))
15684 /* [basic.link]: A name with no linkage (notably, the name
15685 of a class or enumeration declared in a local scope)
15686 shall not be used to declare an entity with linkage.
15687 This implies that names with no linkage cannot be used as
15690 DR 757 relaxes this restriction for C++0x. */
15691 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15692 : no_linkage_check (t
, /*relaxed_p=*/false));
15696 /* DR 488 makes use of a type with no linkage cause
15697 type deduction to fail. */
15698 if (complain
& tf_error
)
15700 if (TYPE_ANONYMOUS_P (nt
))
15701 error ("%qT is/uses anonymous type", t
);
15703 error ("template argument for %qD uses local type %qT",
15708 /* In order to avoid all sorts of complications, we do not
15709 allow variably-modified types as template arguments. */
15710 else if (variably_modified_type_p (t
, NULL_TREE
))
15712 if (complain
& tf_error
)
15713 error ("%qT is a variably modified type", t
);
15717 /* Class template and alias template arguments should be OK. */
15718 else if (DECL_TYPE_TEMPLATE_P (t
))
15720 /* A non-type argument of integral or enumerated type must be a
15722 else if (TREE_TYPE (t
)
15723 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15724 && !TREE_CONSTANT (t
))
15726 if (complain
& tf_error
)
15727 error ("integral expression %qE is not constant", t
);
15734 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15736 int ix
, len
= DECL_NTPARMS (tmpl
);
15737 bool result
= false;
15739 for (ix
= 0; ix
!= len
; ix
++)
15741 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15744 if (result
&& (complain
& tf_error
))
15745 error (" trying to instantiate %qD", tmpl
);
15749 /* We're out of SFINAE context now, so generate diagnostics for the access
15750 errors we saw earlier when instantiating D from TMPL and ARGS. */
15753 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15755 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15756 tree type
= TREE_TYPE (pattern
);
15757 location_t loc
= input_location
;
15759 push_access_scope (d
);
15760 push_deferring_access_checks (dk_no_deferred
);
15761 input_location
= DECL_SOURCE_LOCATION (pattern
);
15762 tsubst (type
, args
, tf_warning_or_error
, d
);
15763 input_location
= loc
;
15764 pop_deferring_access_checks ();
15765 pop_access_scope (d
);
15768 /* Instantiate the indicated variable, function, or alias template TMPL with
15769 the template arguments in TARG_PTR. */
15772 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15774 tree targ_ptr
= orig_args
;
15778 bool access_ok
= true;
15780 if (tmpl
== error_mark_node
)
15781 return error_mark_node
;
15783 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15785 /* If this function is a clone, handle it specially. */
15786 if (DECL_CLONED_FUNCTION_P (tmpl
))
15791 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15792 DECL_CLONED_FUNCTION. */
15793 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15794 targ_ptr
, complain
);
15795 if (spec
== error_mark_node
)
15796 return error_mark_node
;
15798 /* Look for the clone. */
15799 FOR_EACH_CLONE (clone
, spec
)
15800 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15802 /* We should always have found the clone by now. */
15803 gcc_unreachable ();
15807 if (targ_ptr
== error_mark_node
)
15808 return error_mark_node
;
15810 /* Check to see if we already have this specialization. */
15811 gen_tmpl
= most_general_template (tmpl
);
15812 if (tmpl
!= gen_tmpl
)
15813 /* The TMPL is a partial instantiation. To get a full set of
15814 arguments we must add the arguments used to perform the
15815 partial instantiation. */
15816 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15819 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15820 but it doesn't seem to be on the hot path. */
15821 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15823 gcc_assert (tmpl
== gen_tmpl
15824 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15826 || fndecl
== NULL_TREE
);
15828 if (spec
!= NULL_TREE
)
15830 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15832 if (complain
& tf_error
)
15833 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15834 return error_mark_node
;
15839 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15841 return error_mark_node
;
15843 /* We are building a FUNCTION_DECL, during which the access of its
15844 parameters and return types have to be checked. However this
15845 FUNCTION_DECL which is the desired context for access checking
15846 is not built yet. We solve this chicken-and-egg problem by
15847 deferring all checks until we have the FUNCTION_DECL. */
15848 push_deferring_access_checks (dk_deferred
);
15850 /* Instantiation of the function happens in the context of the function
15851 template, not the context of the overload resolution we're doing. */
15852 push_to_top_level ();
15853 /* If there are dependent arguments, e.g. because we're doing partial
15854 ordering, make sure processing_template_decl stays set. */
15855 if (uses_template_parms (targ_ptr
))
15856 ++processing_template_decl
;
15857 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15859 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15860 complain
, gen_tmpl
, true);
15861 push_nested_class (ctx
);
15863 /* Substitute template parameters to obtain the specialization. */
15864 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
15865 targ_ptr
, complain
, gen_tmpl
);
15866 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15867 pop_nested_class ();
15868 pop_from_top_level ();
15870 if (fndecl
== error_mark_node
)
15872 pop_deferring_access_checks ();
15873 return error_mark_node
;
15876 /* The DECL_TI_TEMPLATE should always be the immediate parent
15877 template, not the most general template. */
15878 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
15880 /* Now we know the specialization, compute access previously
15882 push_access_scope (fndecl
);
15883 if (!perform_deferred_access_checks (complain
))
15885 pop_access_scope (fndecl
);
15886 pop_deferring_access_checks ();
15888 /* If we've just instantiated the main entry point for a function,
15889 instantiate all the alternate entry points as well. We do this
15890 by cloning the instantiation of the main entry point, not by
15891 instantiating the template clones. */
15892 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
15893 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
15897 if (!(complain
& tf_error
))
15899 /* Remember to reinstantiate when we're out of SFINAE so the user
15900 can see the errors. */
15901 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
15903 return error_mark_node
;
15908 /* Wrapper for instantiate_template_1. */
15911 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15914 timevar_push (TV_TEMPLATE_INST
);
15915 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
15916 timevar_pop (TV_TEMPLATE_INST
);
15920 /* Instantiate the alias template TMPL with ARGS. Also push a template
15921 instantiation level, which instantiate_template doesn't do because
15922 functions and variables have sufficient context established by the
15926 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
15928 struct pending_template
*old_last_pend
= last_pending_template
;
15929 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15930 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
15931 return error_mark_node
;
15932 tree tinst
= build_tree_list (tmpl
, args
);
15933 if (!push_tinst_level (tinst
))
15936 return error_mark_node
;
15940 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
15941 args
, tmpl
, complain
,
15942 /*require_all_args=*/true,
15943 /*use_default_args=*/true);
15945 tree r
= instantiate_template (tmpl
, args
, complain
);
15946 pop_tinst_level ();
15947 /* We can't free this if a pending_template entry or last_error_tinst_level
15948 is pointing at it. */
15949 if (last_pending_template
== old_last_pend
15950 && last_error_tinst_level
== old_error_tinst
)
15956 /* PARM is a template parameter pack for FN. Returns true iff
15957 PARM is used in a deducible way in the argument list of FN. */
15960 pack_deducible_p (tree parm
, tree fn
)
15962 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
15963 for (; t
; t
= TREE_CHAIN (t
))
15965 tree type
= TREE_VALUE (t
);
15967 if (!PACK_EXPANSION_P (type
))
15969 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
15970 packs
; packs
= TREE_CHAIN (packs
))
15971 if (template_args_equal (TREE_VALUE (packs
), parm
))
15973 /* The template parameter pack is used in a function parameter
15974 pack. If this is the end of the parameter list, the
15975 template parameter pack is deducible. */
15976 if (TREE_CHAIN (t
) == void_list_node
)
15979 /* Otherwise, not. Well, it could be deduced from
15980 a non-pack parameter, but doing so would end up with
15981 a deduction mismatch, so don't bother. */
15985 /* The template parameter pack isn't used in any function parameter
15986 packs, but it might be used deeper, e.g. tuple<Args...>. */
15990 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
15991 NARGS elements of the arguments that are being used when calling
15992 it. TARGS is a vector into which the deduced template arguments
15995 Returns either a FUNCTION_DECL for the matching specialization of FN or
15996 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
15997 true, diagnostics will be printed to explain why it failed.
15999 If FN is a conversion operator, or we are trying to produce a specific
16000 specialization, RETURN_TYPE is the return type desired.
16002 The EXPLICIT_TARGS are explicit template arguments provided via a
16005 The parameter STRICT is one of:
16008 We are deducing arguments for a function call, as in
16009 [temp.deduct.call].
16012 We are deducing arguments for a conversion function, as in
16013 [temp.deduct.conv].
16016 We are deducing arguments when doing an explicit instantiation
16017 as in [temp.explicit], when determining an explicit specialization
16018 as in [temp.expl.spec], or when taking the address of a function
16019 template, as in [temp.deduct.funcaddr]. */
16022 fn_type_unification (tree fn
,
16023 tree explicit_targs
,
16026 unsigned int nargs
,
16028 unification_kind_t strict
,
16035 tree decl
= NULL_TREE
;
16036 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
16038 static int deduction_depth
;
16039 struct pending_template
*old_last_pend
= last_pending_template
;
16040 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16041 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
16043 tree r
= error_mark_node
;
16046 complain
|= tf_decltype
;
16048 /* In C++0x, it's possible to have a function template whose type depends
16049 on itself recursively. This is most obvious with decltype, but can also
16050 occur with enumeration scope (c++/48969). So we need to catch infinite
16051 recursion and reject the substitution at deduction time; this function
16052 will return error_mark_node for any repeated substitution.
16054 This also catches excessive recursion such as when f<N> depends on
16055 f<N-1> across all integers, and returns error_mark_node for all the
16056 substitutions back up to the initial one.
16058 This is, of course, not reentrant. */
16059 if (excessive_deduction_depth
)
16060 return error_mark_node
;
16061 tinst
= build_tree_list (fn
, NULL_TREE
);
16064 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
16066 fntype
= TREE_TYPE (fn
);
16067 if (explicit_targs
)
16071 The specified template arguments must match the template
16072 parameters in kind (i.e., type, nontype, template), and there
16073 must not be more arguments than there are parameters;
16074 otherwise type deduction fails.
16076 Nontype arguments must match the types of the corresponding
16077 nontype template parameters, or must be convertible to the
16078 types of the corresponding nontype parameters as specified in
16079 _temp.arg.nontype_, otherwise type deduction fails.
16081 All references in the function type of the function template
16082 to the corresponding template parameters are replaced by the
16083 specified template argument values. If a substitution in a
16084 template parameter or in the function type of the function
16085 template results in an invalid type, type deduction fails. */
16086 int i
, len
= TREE_VEC_LENGTH (tparms
);
16087 location_t loc
= input_location
;
16088 bool incomplete
= false;
16090 /* Adjust any explicit template arguments before entering the
16091 substitution context. */
16093 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
16095 /*require_all_args=*/false,
16096 /*use_default_args=*/false));
16097 if (explicit_targs
== error_mark_node
)
16100 /* Substitute the explicit args into the function type. This is
16101 necessary so that, for instance, explicitly declared function
16102 arguments can match null pointed constants. If we were given
16103 an incomplete set of explicit args, we must not do semantic
16104 processing during substitution as we could create partial
16106 for (i
= 0; i
< len
; i
++)
16108 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16109 bool parameter_pack
= false;
16110 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
16112 /* Dig out the actual parm. */
16113 if (TREE_CODE (parm
) == TYPE_DECL
16114 || TREE_CODE (parm
) == TEMPLATE_DECL
)
16116 parm
= TREE_TYPE (parm
);
16117 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
16119 else if (TREE_CODE (parm
) == PARM_DECL
)
16121 parm
= DECL_INITIAL (parm
);
16122 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
16125 if (!parameter_pack
&& targ
== NULL_TREE
)
16126 /* No explicit argument for this template parameter. */
16129 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
16131 /* Mark the argument pack as "incomplete". We could
16132 still deduce more arguments during unification.
16133 We remove this mark in type_unification_real. */
16136 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
16137 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
16138 = ARGUMENT_PACK_ARGS (targ
);
16141 /* We have some incomplete argument packs. */
16146 TREE_VALUE (tinst
) = explicit_targs
;
16147 if (!push_tinst_level (tinst
))
16149 excessive_deduction_depth
= true;
16152 processing_template_decl
+= incomplete
;
16153 input_location
= DECL_SOURCE_LOCATION (fn
);
16154 /* Ignore any access checks; we'll see them again in
16155 instantiate_template and they might have the wrong
16156 access path at this point. */
16157 push_deferring_access_checks (dk_deferred
);
16158 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
16159 complain
| tf_partial
, NULL_TREE
);
16160 pop_deferring_access_checks ();
16161 input_location
= loc
;
16162 processing_template_decl
-= incomplete
;
16163 pop_tinst_level ();
16165 if (fntype
== error_mark_node
)
16168 /* Place the explicitly specified arguments in TARGS. */
16169 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
16170 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
16173 /* Never do unification on the 'this' parameter. */
16174 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
16180 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
16181 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
16182 new_args
[0] = return_type
;
16183 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
16188 /* We allow incomplete unification without an error message here
16189 because the standard doesn't seem to explicitly prohibit it. Our
16190 callers must be ready to deal with unification failures in any
16193 TREE_VALUE (tinst
) = targs
;
16194 /* If we aren't explaining yet, push tinst context so we can see where
16195 any errors (e.g. from class instantiations triggered by instantiation
16196 of default template arguments) come from. If we are explaining, this
16197 context is redundant. */
16198 if (!explain_p
&& !push_tinst_level (tinst
))
16200 excessive_deduction_depth
= true;
16204 /* type_unification_real will pass back any access checks from default
16205 template argument substitution. */
16206 vec
<deferred_access_check
, va_gc
> *checks
;
16209 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16210 targs
, parms
, args
, nargs
, /*subr=*/0,
16211 strict
, flags
, &checks
, explain_p
);
16213 pop_tinst_level ();
16217 /* Now that we have bindings for all of the template arguments,
16218 ensure that the arguments deduced for the template template
16219 parameters have compatible template parameter lists. We cannot
16220 check this property before we have deduced all template
16221 arguments, because the template parameter types of a template
16222 template parameter might depend on prior template parameters
16223 deduced after the template template parameter. The following
16224 ill-formed example illustrates this issue:
16226 template<typename T, template<T> class C> void f(C<5>, T);
16228 template<int N> struct X {};
16231 f(X<5>(), 5l); // error: template argument deduction fails
16234 The template parameter list of 'C' depends on the template type
16235 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16236 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16237 time that we deduce 'C'. */
16238 if (!template_template_parm_bindings_ok_p
16239 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16241 unify_inconsistent_template_template_parameters (explain_p
);
16245 /* All is well so far. Now, check:
16249 When all template arguments have been deduced, all uses of
16250 template parameters in nondeduced contexts are replaced with
16251 the corresponding deduced argument values. If the
16252 substitution results in an invalid type, as described above,
16253 type deduction fails. */
16254 TREE_VALUE (tinst
) = targs
;
16255 if (!push_tinst_level (tinst
))
16257 excessive_deduction_depth
= true;
16261 /* Also collect access checks from the instantiation. */
16262 reopen_deferring_access_checks (checks
);
16264 decl
= instantiate_template (fn
, targs
, complain
);
16266 checks
= get_deferred_access_checks ();
16267 pop_deferring_access_checks ();
16269 pop_tinst_level ();
16271 if (decl
== error_mark_node
)
16274 /* Now perform any access checks encountered during substitution. */
16275 push_access_scope (decl
);
16276 ok
= perform_access_checks (checks
, complain
);
16277 pop_access_scope (decl
);
16281 /* If we're looking for an exact match, check that what we got
16282 is indeed an exact match. It might not be if some template
16283 parameters are used in non-deduced contexts. But don't check
16284 for an exact match if we have dependent template arguments;
16285 in that case we're doing partial ordering, and we already know
16286 that we have two candidates that will provide the actual type. */
16287 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16289 tree substed
= TREE_TYPE (decl
);
16293 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16295 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16296 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16297 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16299 unify_type_mismatch (explain_p
, args
[i
],
16300 TREE_VALUE (sarg
));
16309 if (excessive_deduction_depth
)
16311 if (deduction_depth
== 0)
16312 /* Reset once we're all the way out. */
16313 excessive_deduction_depth
= false;
16316 /* We can't free this if a pending_template entry or last_error_tinst_level
16317 is pointing at it. */
16318 if (last_pending_template
== old_last_pend
16319 && last_error_tinst_level
== old_error_tinst
)
16325 /* Adjust types before performing type deduction, as described in
16326 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16327 sections are symmetric. PARM is the type of a function parameter
16328 or the return type of the conversion function. ARG is the type of
16329 the argument passed to the call, or the type of the value
16330 initialized with the result of the conversion function.
16331 ARG_EXPR is the original argument expression, which may be null. */
16334 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16348 /* Swap PARM and ARG throughout the remainder of this
16349 function; the handling is precisely symmetric since PARM
16350 will initialize ARG rather than vice versa. */
16358 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16359 too, but here handle it by stripping the reference from PARM
16360 rather than by adding it to ARG. */
16361 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16362 && TYPE_REF_IS_RVALUE (*parm
)
16363 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16364 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16365 && TREE_CODE (*arg
) == REFERENCE_TYPE
16366 && !TYPE_REF_IS_RVALUE (*arg
))
16367 *parm
= TREE_TYPE (*parm
);
16368 /* Nothing else to do in this case. */
16372 gcc_unreachable ();
16375 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16377 /* [temp.deduct.call]
16379 If P is not a reference type:
16381 --If A is an array type, the pointer type produced by the
16382 array-to-pointer standard conversion (_conv.array_) is
16383 used in place of A for type deduction; otherwise,
16385 --If A is a function type, the pointer type produced by
16386 the function-to-pointer standard conversion
16387 (_conv.func_) is used in place of A for type deduction;
16390 --If A is a cv-qualified type, the top level
16391 cv-qualifiers of A's type are ignored for type
16393 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16394 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16395 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16396 *arg
= build_pointer_type (*arg
);
16398 *arg
= TYPE_MAIN_VARIANT (*arg
);
16401 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16402 of the form T&&, where T is a template parameter, and the argument
16403 is an lvalue, T is deduced as A& */
16404 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16405 && TYPE_REF_IS_RVALUE (*parm
)
16406 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16407 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16408 && (arg_expr
? real_lvalue_p (arg_expr
)
16409 /* try_one_overload doesn't provide an arg_expr, but
16410 functions are always lvalues. */
16411 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16412 *arg
= build_reference_type (*arg
);
16414 /* [temp.deduct.call]
16416 If P is a cv-qualified type, the top level cv-qualifiers
16417 of P's type are ignored for type deduction. If P is a
16418 reference type, the type referred to by P is used for
16420 *parm
= TYPE_MAIN_VARIANT (*parm
);
16421 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16423 *parm
= TREE_TYPE (*parm
);
16424 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16427 /* DR 322. For conversion deduction, remove a reference type on parm
16428 too (which has been swapped into ARG). */
16429 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16430 *arg
= TREE_TYPE (*arg
);
16435 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16436 template which does contain any deducible template parameters; check if
16437 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16438 unify_one_argument. */
16441 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16442 int flags
, bool explain_p
)
16447 type
= TREE_TYPE (arg
);
16451 if (same_type_p (parm
, type
))
16452 return unify_success (explain_p
);
16454 if (strict
== DEDUCE_CONV
)
16456 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16457 explain_p
? tf_warning_or_error
: tf_none
))
16458 return unify_success (explain_p
);
16460 else if (strict
!= DEDUCE_EXACT
)
16462 if (can_convert_arg (parm
, type
,
16463 TYPE_P (arg
) ? NULL_TREE
: arg
,
16464 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16465 return unify_success (explain_p
);
16468 if (strict
== DEDUCE_EXACT
)
16469 return unify_type_mismatch (explain_p
, parm
, arg
);
16471 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16474 static bool uses_deducible_template_parms (tree type
);
16476 /* Returns true iff the expression EXPR is one from which a template
16477 argument can be deduced. In other words, if it's an undecorated
16478 use of a template non-type parameter. */
16481 deducible_expression (tree expr
)
16483 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16486 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16487 deducible way; that is, if it has a max value of <PARM> - 1. */
16490 deducible_array_bound (tree domain
)
16492 if (domain
== NULL_TREE
)
16495 tree max
= TYPE_MAX_VALUE (domain
);
16496 if (TREE_CODE (max
) != MINUS_EXPR
)
16499 return deducible_expression (TREE_OPERAND (max
, 0));
16502 /* Returns true iff the template arguments ARGS use a template parameter
16503 in a deducible way. */
16506 deducible_template_args (tree args
)
16508 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16511 tree elt
= TREE_VEC_ELT (args
, i
);
16512 if (ARGUMENT_PACK_P (elt
))
16513 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16516 if (PACK_EXPANSION_P (elt
))
16517 elt
= PACK_EXPANSION_PATTERN (elt
);
16518 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16520 else if (TYPE_P (elt
))
16521 deducible
= uses_deducible_template_parms (elt
);
16523 deducible
= deducible_expression (elt
);
16531 /* Returns true iff TYPE contains any deducible references to template
16532 parameters, as per 14.8.2.5. */
16535 uses_deducible_template_parms (tree type
)
16537 if (PACK_EXPANSION_P (type
))
16538 type
= PACK_EXPANSION_PATTERN (type
);
16545 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16546 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16552 if (POINTER_TYPE_P (type
))
16553 return uses_deducible_template_parms (TREE_TYPE (type
));
16555 /* T[integer-constant ]
16557 if (TREE_CODE (type
) == ARRAY_TYPE
)
16558 return (uses_deducible_template_parms (TREE_TYPE (type
))
16559 || deducible_array_bound (TYPE_DOMAIN (type
)));
16571 if (TYPE_PTRMEM_P (type
))
16572 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16573 || (uses_deducible_template_parms
16574 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16576 /* template-name <T> (where template-name refers to a class template)
16577 template-name <i> (where template-name refers to a class template) */
16578 if (CLASS_TYPE_P (type
)
16579 && CLASSTYPE_TEMPLATE_INFO (type
)
16580 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16581 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16582 (CLASSTYPE_TI_ARGS (type
)));
16587 if (TREE_CODE (type
) == FUNCTION_TYPE
16588 || TREE_CODE (type
) == METHOD_TYPE
)
16590 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16592 tree parm
= TYPE_ARG_TYPES (type
);
16593 if (TREE_CODE (type
) == METHOD_TYPE
)
16594 parm
= TREE_CHAIN (parm
);
16595 for (; parm
; parm
= TREE_CHAIN (parm
))
16596 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16603 /* Subroutine of type_unification_real and unify_pack_expansion to
16604 handle unification of a single P/A pair. Parameters are as
16605 for those functions. */
16608 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16609 int subr
, unification_kind_t strict
, int flags
,
16612 tree arg_expr
= NULL_TREE
;
16615 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16616 return unify_invalid (explain_p
);
16617 if (arg
== unknown_type_node
)
16618 /* We can't deduce anything from this, but we might get all the
16619 template args from other function args. */
16620 return unify_success (explain_p
);
16622 /* Implicit conversions (Clause 4) will be performed on a function
16623 argument to convert it to the type of the corresponding function
16624 parameter if the parameter type contains no template-parameters that
16625 participate in template argument deduction. */
16626 if (TYPE_P (parm
) && !uses_template_parms (parm
))
16627 /* For function parameters that contain no template-parameters at all,
16628 we have historically checked for convertibility in order to shortcut
16629 consideration of this candidate. */
16630 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
16632 else if (strict
== DEDUCE_CALL
16633 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16634 /* For function parameters with only non-deducible template parameters,
16636 return unify_success (explain_p
);
16641 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16642 | UNIFY_ALLOW_MORE_CV_QUAL
16643 | UNIFY_ALLOW_DERIVED
);
16647 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16651 arg_strict
= UNIFY_ALLOW_NONE
;
16655 gcc_unreachable ();
16658 /* We only do these transformations if this is the top-level
16659 parameter_type_list in a call or declaration matching; in other
16660 situations (nested function declarators, template argument lists) we
16661 won't be comparing a type to an expression, and we don't do any type
16667 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16668 if (type_unknown_p (arg
))
16670 /* [temp.deduct.type] A template-argument can be
16671 deduced from a pointer to function or pointer
16672 to member function argument if the set of
16673 overloaded functions does not contain function
16674 templates and at most one of a set of
16675 overloaded functions provides a unique
16678 if (resolve_overloaded_unification
16679 (tparms
, targs
, parm
, arg
, strict
,
16680 arg_strict
, explain_p
))
16681 return unify_success (explain_p
);
16682 return unify_overload_resolution_failure (explain_p
, arg
);
16686 arg
= unlowered_expr_type (arg
);
16687 if (arg
== error_mark_node
)
16688 return unify_invalid (explain_p
);
16692 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16695 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16696 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
16697 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16699 /* For deduction from an init-list we need the actual list. */
16700 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16702 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16705 /* Most parms like fn_type_unification.
16707 If SUBR is 1, we're being called recursively (to unify the
16708 arguments of a function or method parameter of a function
16711 CHECKS is a pointer to a vector of access checks encountered while
16712 substituting default template arguments. */
16715 type_unification_real (tree tparms
,
16719 unsigned int xnargs
,
16721 unification_kind_t strict
,
16723 vec
<deferred_access_check
, va_gc
> **checks
,
16728 int ntparms
= TREE_VEC_LENGTH (tparms
);
16729 int saw_undeduced
= 0;
16732 unsigned int nargs
;
16735 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16736 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16737 gcc_assert (ntparms
> 0);
16739 /* Reset the number of non-defaulted template arguments contained
16741 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16749 while (parms
&& parms
!= void_list_node
16752 parm
= TREE_VALUE (parms
);
16754 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16755 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16756 /* For a function parameter pack that occurs at the end of the
16757 parameter-declaration-list, the type A of each remaining
16758 argument of the call is compared with the type P of the
16759 declarator-id of the function parameter pack. */
16762 parms
= TREE_CHAIN (parms
);
16764 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16765 /* For a function parameter pack that does not occur at the
16766 end of the parameter-declaration-list, the type of the
16767 parameter pack is a non-deduced context. */
16773 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16779 && parms
!= void_list_node
16780 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16782 /* Unify the remaining arguments with the pack expansion type. */
16784 tree parmvec
= make_tree_vec (1);
16786 /* Allocate a TREE_VEC and copy in all of the arguments */
16787 argvec
= make_tree_vec (nargs
- ia
);
16788 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16789 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16791 /* Copy the parameter into parmvec. */
16792 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16793 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16794 /*subr=*/subr
, explain_p
))
16797 /* Advance to the end of the list of parameters. */
16798 parms
= TREE_CHAIN (parms
);
16801 /* Fail if we've reached the end of the parm list, and more args
16802 are present, and the parm list isn't variadic. */
16803 if (ia
< nargs
&& parms
== void_list_node
)
16804 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16805 /* Fail if parms are left and they don't have default values and
16806 they aren't all deduced as empty packs (c++/57397). This is
16807 consistent with sufficient_parms_p. */
16808 if (parms
&& parms
!= void_list_node
16809 && TREE_PURPOSE (parms
) == NULL_TREE
)
16811 unsigned int count
= nargs
;
16816 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
16819 p
= TREE_CHAIN (p
);
16821 while (p
&& p
!= void_list_node
);
16822 if (count
!= nargs
)
16823 return unify_too_few_arguments (explain_p
, ia
, count
,
16829 tsubst_flags_t complain
= (explain_p
16830 ? tf_warning_or_error
16833 for (i
= 0; i
< ntparms
; i
++)
16835 tree targ
= TREE_VEC_ELT (targs
, i
);
16836 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16838 /* Clear the "incomplete" flags on all argument packs now so that
16839 substituting them into later default arguments works. */
16840 if (targ
&& ARGUMENT_PACK_P (targ
))
16842 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16843 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16846 if (targ
|| tparm
== error_mark_node
)
16848 tparm
= TREE_VALUE (tparm
);
16850 /* If this is an undeduced nontype parameter that depends on
16851 a type parameter, try another pass; its type may have been
16852 deduced from a later argument than the one from which
16853 this parameter can be deduced. */
16854 if (TREE_CODE (tparm
) == PARM_DECL
16855 && uses_template_parms (TREE_TYPE (tparm
))
16856 && !saw_undeduced
++)
16859 /* Core issue #226 (C++0x) [temp.deduct]:
16861 If a template argument has not been deduced, its
16862 default template argument, if any, is used.
16864 When we are in C++98 mode, TREE_PURPOSE will either
16865 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16866 to explicitly check cxx_dialect here. */
16867 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
16869 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16870 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
16871 reopen_deferring_access_checks (*checks
);
16872 location_t save_loc
= input_location
;
16874 input_location
= DECL_SOURCE_LOCATION (parm
);
16875 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
16876 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
16878 input_location
= save_loc
;
16879 *checks
= get_deferred_access_checks ();
16880 pop_deferring_access_checks ();
16881 if (arg
== error_mark_node
)
16885 TREE_VEC_ELT (targs
, i
) = arg
;
16886 /* The position of the first default template argument,
16887 is also the number of non-defaulted arguments in TARGS.
16889 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16890 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
16895 /* If the type parameter is a parameter pack, then it will
16896 be deduced to an empty parameter pack. */
16897 if (template_parameter_pack_p (tparm
))
16901 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
16903 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
16904 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
16905 TREE_CONSTANT (arg
) = 1;
16908 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16910 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
16912 TREE_VEC_ELT (targs
, i
) = arg
;
16916 return unify_parameter_deduction_failure (explain_p
, tparm
);
16919 #ifdef ENABLE_CHECKING
16920 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16921 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
16924 return unify_success (explain_p
);
16927 /* Subroutine of type_unification_real. Args are like the variables
16928 at the call site. ARG is an overloaded function (or template-id);
16929 we try deducing template args from each of the overloads, and if
16930 only one succeeds, we go with that. Modifies TARGS and returns
16931 true on success. */
16934 resolve_overloaded_unification (tree tparms
,
16938 unification_kind_t strict
,
16942 tree tempargs
= copy_node (targs
);
16944 tree goodfn
= NULL_TREE
;
16947 if (TREE_CODE (arg
) == ADDR_EXPR
)
16949 arg
= TREE_OPERAND (arg
, 0);
16955 if (TREE_CODE (arg
) == COMPONENT_REF
)
16956 /* Handle `&x' where `x' is some static or non-static member
16958 arg
= TREE_OPERAND (arg
, 1);
16960 if (TREE_CODE (arg
) == OFFSET_REF
)
16961 arg
= TREE_OPERAND (arg
, 1);
16963 /* Strip baselink information. */
16964 if (BASELINK_P (arg
))
16965 arg
= BASELINK_FUNCTIONS (arg
);
16967 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
16969 /* If we got some explicit template args, we need to plug them into
16970 the affected templates before we try to unify, in case the
16971 explicit args will completely resolve the templates in question. */
16974 tree expl_subargs
= TREE_OPERAND (arg
, 1);
16975 arg
= TREE_OPERAND (arg
, 0);
16977 for (; arg
; arg
= OVL_NEXT (arg
))
16979 tree fn
= OVL_CURRENT (arg
);
16980 tree subargs
, elem
;
16982 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16985 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16986 expl_subargs
, NULL_TREE
, tf_none
,
16987 /*require_all_args=*/true,
16988 /*use_default_args=*/true);
16989 if (subargs
!= error_mark_node
16990 && !any_dependent_template_arguments_p (subargs
))
16992 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
16993 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16994 elem
, strict
, sub_strict
, addr_p
, explain_p
)
16995 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
17004 /* If no templates (or more than one) are fully resolved by the
17005 explicit arguments, this template-id is a non-deduced context; it
17006 could still be OK if we deduce all template arguments for the
17007 enclosing call through other arguments. */
17011 else if (TREE_CODE (arg
) != OVERLOAD
17012 && TREE_CODE (arg
) != FUNCTION_DECL
)
17013 /* If ARG is, for example, "(0, &f)" then its type will be unknown
17014 -- but the deduction does not succeed because the expression is
17015 not just the function on its own. */
17018 for (; arg
; arg
= OVL_NEXT (arg
))
17019 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
17020 TREE_TYPE (OVL_CURRENT (arg
)),
17021 strict
, sub_strict
, addr_p
, explain_p
)
17022 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
17024 goodfn
= OVL_CURRENT (arg
);
17028 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17029 to function or pointer to member function argument if the set of
17030 overloaded functions does not contain function templates and at most
17031 one of a set of overloaded functions provides a unique match.
17033 So if we found multiple possibilities, we return success but don't
17034 deduce anything. */
17038 int i
= TREE_VEC_LENGTH (targs
);
17040 if (TREE_VEC_ELT (tempargs
, i
))
17042 tree old
= TREE_VEC_ELT (targs
, i
);
17043 tree new_
= TREE_VEC_ELT (tempargs
, i
);
17044 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
17045 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
17046 /* Don't forget explicit template arguments in a pack. */
17047 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
17048 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
17049 TREE_VEC_ELT (targs
, i
) = new_
;
17058 /* Core DR 115: In contexts where deduction is done and fails, or in
17059 contexts where deduction is not done, if a template argument list is
17060 specified and it, along with any default template arguments, identifies
17061 a single function template specialization, then the template-id is an
17062 lvalue for the function template specialization. */
17065 resolve_nondeduced_context (tree orig_expr
)
17067 tree expr
, offset
, baselink
;
17070 if (!type_unknown_p (orig_expr
))
17075 offset
= NULL_TREE
;
17076 baselink
= NULL_TREE
;
17078 if (TREE_CODE (expr
) == ADDR_EXPR
)
17080 expr
= TREE_OPERAND (expr
, 0);
17083 if (TREE_CODE (expr
) == OFFSET_REF
)
17086 expr
= TREE_OPERAND (expr
, 1);
17088 if (BASELINK_P (expr
))
17091 expr
= BASELINK_FUNCTIONS (expr
);
17094 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
17097 tree goodfn
= NULL_TREE
;
17099 /* If we got some explicit template args, we need to plug them into
17100 the affected templates before we try to unify, in case the
17101 explicit args will completely resolve the templates in question. */
17103 tree expl_subargs
= TREE_OPERAND (expr
, 1);
17104 tree arg
= TREE_OPERAND (expr
, 0);
17105 tree badfn
= NULL_TREE
;
17106 tree badargs
= NULL_TREE
;
17108 for (; arg
; arg
= OVL_NEXT (arg
))
17110 tree fn
= OVL_CURRENT (arg
);
17111 tree subargs
, elem
;
17113 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17116 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17117 expl_subargs
, NULL_TREE
, tf_none
,
17118 /*require_all_args=*/true,
17119 /*use_default_args=*/true);
17120 if (subargs
!= error_mark_node
17121 && !any_dependent_template_arguments_p (subargs
))
17123 elem
= instantiate_template (fn
, subargs
, tf_none
);
17124 if (elem
== error_mark_node
)
17129 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
17138 mark_used (goodfn
);
17141 expr
= build_baselink (BASELINK_BINFO (baselink
),
17142 BASELINK_ACCESS_BINFO (baselink
),
17143 expr
, BASELINK_OPTYPE (baselink
));
17147 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
17148 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
17151 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
17154 else if (good
== 0 && badargs
)
17155 /* There were no good options and at least one bad one, so let the
17156 user know what the problem is. */
17157 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
17162 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17163 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17164 different overloads deduce different arguments for a given parm.
17165 ADDR_P is true if the expression for which deduction is being
17166 performed was of the form "& fn" rather than simply "fn".
17168 Returns 1 on success. */
17171 try_one_overload (tree tparms
,
17176 unification_kind_t strict
,
17185 if (arg
== error_mark_node
)
17188 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17189 to function or pointer to member function argument if the set of
17190 overloaded functions does not contain function templates and at most
17191 one of a set of overloaded functions provides a unique match.
17193 So if this is a template, just return success. */
17195 if (uses_template_parms (arg
))
17198 if (TREE_CODE (arg
) == METHOD_TYPE
)
17199 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
17201 arg
= build_pointer_type (arg
);
17203 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
17205 /* We don't copy orig_targs for this because if we have already deduced
17206 some template args from previous args, unify would complain when we
17207 try to deduce a template parameter for the same argument, even though
17208 there isn't really a conflict. */
17209 nargs
= TREE_VEC_LENGTH (targs
);
17210 tempargs
= make_tree_vec (nargs
);
17212 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
17215 /* First make sure we didn't deduce anything that conflicts with
17216 explicitly specified args. */
17217 for (i
= nargs
; i
--; )
17219 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17220 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17224 else if (uses_template_parms (elt
))
17225 /* Since we're unifying against ourselves, we will fill in
17226 template args used in the function parm list with our own
17227 template parms. Discard them. */
17228 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17229 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17233 for (i
= nargs
; i
--; )
17235 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17238 TREE_VEC_ELT (targs
, i
) = elt
;
17244 /* PARM is a template class (perhaps with unbound template
17245 parameters). ARG is a fully instantiated type. If ARG can be
17246 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17247 TARGS are as for unify. */
17250 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17253 tree copy_of_targs
;
17255 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17256 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17257 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17260 /* We need to make a new template argument vector for the call to
17261 unify. If we used TARGS, we'd clutter it up with the result of
17262 the attempted unification, even if this class didn't work out.
17263 We also don't want to commit ourselves to all the unifications
17264 we've already done, since unification is supposed to be done on
17265 an argument-by-argument basis. In other words, consider the
17266 following pathological case:
17268 template <int I, int J, int K>
17271 template <int I, int J>
17272 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17274 template <int I, int J, int K>
17275 void f(S<I, J, K>, S<I, I, I>);
17284 Now, by the time we consider the unification involving `s2', we
17285 already know that we must have `f<0, 0, 0>'. But, even though
17286 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17287 because there are two ways to unify base classes of S<0, 1, 2>
17288 with S<I, I, I>. If we kept the already deduced knowledge, we
17289 would reject the possibility I=1. */
17290 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17292 /* If unification failed, we're done. */
17293 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17294 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17300 /* Given a template type PARM and a class type ARG, find the unique
17301 base type in ARG that is an instance of PARM. We do not examine
17302 ARG itself; only its base-classes. If there is not exactly one
17303 appropriate base class, return NULL_TREE. PARM may be the type of
17304 a partial specialization, as well as a plain template type. Used
17307 static enum template_base_result
17308 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17309 bool explain_p
, tree
*result
)
17311 tree rval
= NULL_TREE
;
17314 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17316 binfo
= TYPE_BINFO (complete_type (arg
));
17319 /* The type could not be completed. */
17320 *result
= NULL_TREE
;
17321 return tbr_incomplete_type
;
17324 /* Walk in inheritance graph order. The search order is not
17325 important, and this avoids multiple walks of virtual bases. */
17326 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17328 tree r
= try_class_unification (tparms
, targs
, parm
,
17329 BINFO_TYPE (binfo
), explain_p
);
17333 /* If there is more than one satisfactory baseclass, then:
17337 If they yield more than one possible deduced A, the type
17341 if (rval
&& !same_type_p (r
, rval
))
17343 *result
= NULL_TREE
;
17344 return tbr_ambiguous_baseclass
;
17352 return tbr_success
;
17355 /* Returns the level of DECL, which declares a template parameter. */
17358 template_decl_level (tree decl
)
17360 switch (TREE_CODE (decl
))
17363 case TEMPLATE_DECL
:
17364 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17367 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17370 gcc_unreachable ();
17375 /* Decide whether ARG can be unified with PARM, considering only the
17376 cv-qualifiers of each type, given STRICT as documented for unify.
17377 Returns nonzero iff the unification is OK on that basis. */
17380 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17382 int arg_quals
= cp_type_quals (arg
);
17383 int parm_quals
= cp_type_quals (parm
);
17385 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17386 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17388 /* Although a CVR qualifier is ignored when being applied to a
17389 substituted template parameter ([8.3.2]/1 for example), that
17390 does not allow us to unify "const T" with "int&" because both
17391 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17392 It is ok when we're allowing additional CV qualifiers
17393 at the outer level [14.8.2.1]/3,1st bullet. */
17394 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17395 || TREE_CODE (arg
) == FUNCTION_TYPE
17396 || TREE_CODE (arg
) == METHOD_TYPE
)
17397 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17400 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17401 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17405 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17406 && (arg_quals
& parm_quals
) != parm_quals
)
17409 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17410 && (parm_quals
& arg_quals
) != arg_quals
)
17416 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17418 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17420 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17421 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17422 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17424 *index
= TEMPLATE_TYPE_IDX (parm
);
17425 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17429 *index
= TEMPLATE_PARM_IDX (parm
);
17430 *level
= TEMPLATE_PARM_LEVEL (parm
);
17434 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17436 if (unify (TP, TA, P, A, S, EP)) \
17440 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17441 expansion at the end of PACKED_PARMS. Returns 0 if the type
17442 deduction succeeds, 1 otherwise. STRICT is the same as in
17443 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17444 call argument list. We'll need to adjust the arguments to make them
17445 types. SUBR tells us if this is from a recursive call to
17446 type_unification_real, or for comparing two template argument
17450 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17451 tree packed_args
, unification_kind_t strict
,
17452 bool subr
, bool explain_p
)
17455 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17456 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17457 tree pack
, packs
= NULL_TREE
;
17458 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17460 packed_args
= expand_template_argument_pack (packed_args
);
17462 int len
= TREE_VEC_LENGTH (packed_args
);
17464 /* Determine the parameter packs we will be deducing from the
17465 pattern, and record their current deductions. */
17466 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17467 pack
; pack
= TREE_CHAIN (pack
))
17469 tree parm_pack
= TREE_VALUE (pack
);
17472 /* Determine the index and level of this parameter pack. */
17473 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17475 /* Keep track of the parameter packs and their corresponding
17477 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17478 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17481 /* Loop through all of the arguments that have not yet been
17482 unified and unify each with the pattern. */
17483 for (i
= start
; i
< len
; i
++)
17486 bool any_explicit
= false;
17487 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17489 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17490 or the element of its argument pack at the current index if
17491 this argument was explicitly specified. */
17492 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17496 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17499 if (TREE_VALUE (pack
)
17500 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17501 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17503 any_explicit
= true;
17504 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17506 TMPL_ARG (targs
, level
, idx
) = arg
;
17509 /* If we had explicit template arguments, substitute them into the
17510 pattern before deduction. */
17513 /* Some arguments might still be unspecified or dependent. */
17515 ++processing_template_decl
;
17516 dependent
= any_dependent_template_arguments_p (targs
);
17518 --processing_template_decl
;
17519 parm
= tsubst (pattern
, targs
,
17520 explain_p
? tf_warning_or_error
: tf_none
,
17523 --processing_template_decl
;
17524 if (parm
== error_mark_node
)
17530 /* Unify the pattern with the current argument. */
17531 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17532 LOOKUP_IMPLICIT
, explain_p
))
17535 /* For each parameter pack, collect the deduced value. */
17536 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17539 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17541 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17542 TMPL_ARG (targs
, level
, idx
);
17546 /* Verify that the results of unification with the parameter packs
17547 produce results consistent with what we've seen before, and make
17548 the deduced argument packs available. */
17549 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17551 tree old_pack
= TREE_VALUE (pack
);
17552 tree new_args
= TREE_TYPE (pack
);
17553 int i
, len
= TREE_VEC_LENGTH (new_args
);
17555 bool nondeduced_p
= false;
17557 /* By default keep the original deduced argument pack.
17558 If necessary, more specific code is going to update the
17559 resulting deduced argument later down in this function. */
17560 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17561 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17563 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17564 actually deduce anything. */
17565 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17566 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17567 nondeduced_p
= true;
17571 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17573 /* If we had fewer function args than explicit template args,
17574 just use the explicits. */
17575 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17576 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17577 if (len
< explicit_len
)
17578 new_args
= explicit_args
;
17584 /* Build the deduced *_ARGUMENT_PACK. */
17585 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17587 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17588 TREE_TYPE (result
) =
17589 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17590 TREE_CONSTANT (result
) = 1;
17593 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17595 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17597 /* Note the deduced argument packs for this parameter
17599 TMPL_ARG (targs
, level
, idx
) = result
;
17601 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17602 && (ARGUMENT_PACK_ARGS (old_pack
)
17603 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17605 /* We only had the explicitly-provided arguments before, but
17606 now we have a complete set of arguments. */
17607 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17609 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17610 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17611 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17615 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17616 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17618 if (!comp_template_args_with_info (old_args
, new_args
,
17619 &bad_old_arg
, &bad_new_arg
))
17620 /* Inconsistent unification of this parameter pack. */
17621 return unify_parameter_pack_inconsistent (explain_p
,
17627 return unify_success (explain_p
);
17630 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17631 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17632 parameters and return value are as for unify. */
17635 unify_array_domain (tree tparms
, tree targs
,
17636 tree parm_dom
, tree arg_dom
,
17644 /* Our representation of array types uses "N - 1" as the
17645 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17646 not an integer constant. We cannot unify arbitrarily
17647 complex expressions, so we eliminate the MINUS_EXPRs
17649 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17650 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17653 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17654 parm_max
= TREE_OPERAND (parm_max
, 0);
17656 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17657 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17660 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17661 trying to unify the type of a variable with the type
17662 of a template parameter. For example:
17664 template <unsigned int N>
17665 void f (char (&) [N]);
17672 Here, the type of the ARG will be "int [g(i)]", and
17673 may be a SAVE_EXPR, etc. */
17674 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17675 return unify_vla_arg (explain_p
, arg_dom
);
17676 arg_max
= TREE_OPERAND (arg_max
, 0);
17679 /* If only one of the bounds used a MINUS_EXPR, compensate
17680 by adding one to the other bound. */
17681 if (parm_cst
&& !arg_cst
)
17682 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17686 else if (arg_cst
&& !parm_cst
)
17687 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17692 return unify (tparms
, targs
, parm_max
, arg_max
,
17693 UNIFY_ALLOW_INTEGER
, explain_p
);
17696 /* Deduce the value of template parameters. TPARMS is the (innermost)
17697 set of template parameters to a template. TARGS is the bindings
17698 for those template parameters, as determined thus far; TARGS may
17699 include template arguments for outer levels of template parameters
17700 as well. PARM is a parameter to a template function, or a
17701 subcomponent of that parameter; ARG is the corresponding argument.
17702 This function attempts to match PARM with ARG in a manner
17703 consistent with the existing assignments in TARGS. If more values
17704 are deduced, then TARGS is updated.
17706 Returns 0 if the type deduction succeeds, 1 otherwise. The
17707 parameter STRICT is a bitwise or of the following flags:
17710 Require an exact match between PARM and ARG.
17711 UNIFY_ALLOW_MORE_CV_QUAL:
17712 Allow the deduced ARG to be more cv-qualified (by qualification
17713 conversion) than ARG.
17714 UNIFY_ALLOW_LESS_CV_QUAL:
17715 Allow the deduced ARG to be less cv-qualified than ARG.
17716 UNIFY_ALLOW_DERIVED:
17717 Allow the deduced ARG to be a template base class of ARG,
17718 or a pointer to a template base class of the type pointed to by
17720 UNIFY_ALLOW_INTEGER:
17721 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17722 case for more information.
17723 UNIFY_ALLOW_OUTER_LEVEL:
17724 This is the outermost level of a deduction. Used to determine validity
17725 of qualification conversions. A valid qualification conversion must
17726 have const qualified pointers leading up to the inner type which
17727 requires additional CV quals, except at the outer level, where const
17728 is not required [conv.qual]. It would be normal to set this flag in
17729 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17730 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17731 This is the outermost level of a deduction, and PARM can be more CV
17732 qualified at this point.
17733 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17734 This is the outermost level of a deduction, and PARM can be less CV
17735 qualified at this point. */
17738 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17744 int strict_in
= strict
;
17746 /* I don't think this will do the right thing with respect to types.
17747 But the only case I've seen it in so far has been array bounds, where
17748 signedness is the only information lost, and I think that will be
17750 while (TREE_CODE (parm
) == NOP_EXPR
)
17751 parm
= TREE_OPERAND (parm
, 0);
17753 if (arg
== error_mark_node
)
17754 return unify_invalid (explain_p
);
17755 if (arg
== unknown_type_node
17756 || arg
== init_list_type_node
)
17757 /* We can't deduce anything from this, but we might get all the
17758 template args from other function args. */
17759 return unify_success (explain_p
);
17761 /* If PARM uses template parameters, then we can't bail out here,
17762 even if ARG == PARM, since we won't record unifications for the
17763 template parameters. We might need them if we're trying to
17764 figure out which of two things is more specialized. */
17765 if (arg
== parm
&& !uses_template_parms (parm
))
17766 return unify_success (explain_p
);
17768 /* Handle init lists early, so the rest of the function can assume
17769 we're dealing with a type. */
17770 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17774 tree orig_parm
= parm
;
17776 /* Replace T with std::initializer_list<T> for deduction. */
17777 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17778 && flag_deduce_init_list
)
17779 parm
= listify (parm
);
17781 if (!is_std_init_list (parm
)
17782 && TREE_CODE (parm
) != ARRAY_TYPE
)
17783 /* We can only deduce from an initializer list argument if the
17784 parameter is std::initializer_list or an array; otherwise this
17785 is a non-deduced context. */
17786 return unify_success (explain_p
);
17788 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17789 elttype
= TREE_TYPE (parm
);
17791 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17793 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
17795 int elt_strict
= strict
;
17797 if (elt
== error_mark_node
)
17798 return unify_invalid (explain_p
);
17800 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
17802 tree type
= TREE_TYPE (elt
);
17803 /* It should only be possible to get here for a call. */
17804 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
17805 elt_strict
|= maybe_adjust_types_for_deduction
17806 (DEDUCE_CALL
, &elttype
, &type
, elt
);
17810 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
17814 if (TREE_CODE (parm
) == ARRAY_TYPE
17815 && deducible_array_bound (TYPE_DOMAIN (parm
)))
17817 /* Also deduce from the length of the initializer list. */
17818 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
17819 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
17820 if (idx
== error_mark_node
)
17821 return unify_invalid (explain_p
);
17822 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17826 /* If the std::initializer_list<T> deduction worked, replace the
17827 deduced A with std::initializer_list<A>. */
17828 if (orig_parm
!= parm
)
17830 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
17831 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17832 targ
= listify (targ
);
17833 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
17835 return unify_success (explain_p
);
17838 /* Immediately reject some pairs that won't unify because of
17839 cv-qualification mismatches. */
17840 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17842 /* It is the elements of the array which hold the cv quals of an array
17843 type, and the elements might be template type parms. We'll check
17844 when we recurse. */
17845 && TREE_CODE (arg
) != ARRAY_TYPE
17846 /* We check the cv-qualifiers when unifying with template type
17847 parameters below. We want to allow ARG `const T' to unify with
17848 PARM `T' for example, when computing which of two templates
17849 is more specialized, for example. */
17850 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
17851 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
17852 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17854 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
17855 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
17856 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
17857 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
17858 strict
&= ~UNIFY_ALLOW_DERIVED
;
17859 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17860 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
17862 switch (TREE_CODE (parm
))
17864 case TYPENAME_TYPE
:
17866 case UNBOUND_CLASS_TEMPLATE
:
17867 /* In a type which contains a nested-name-specifier, template
17868 argument values cannot be deduced for template parameters used
17869 within the nested-name-specifier. */
17870 return unify_success (explain_p
);
17872 case TEMPLATE_TYPE_PARM
:
17873 case TEMPLATE_TEMPLATE_PARM
:
17874 case BOUND_TEMPLATE_TEMPLATE_PARM
:
17875 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17876 if (error_operand_p (tparm
))
17877 return unify_invalid (explain_p
);
17879 if (TEMPLATE_TYPE_LEVEL (parm
)
17880 != template_decl_level (tparm
))
17881 /* The PARM is not one we're trying to unify. Just check
17882 to see if it matches ARG. */
17884 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17885 && (is_auto (parm
) ? is_auto (arg
)
17886 : same_type_p (parm
, arg
)))
17887 return unify_success (explain_p
);
17889 return unify_type_mismatch (explain_p
, parm
, arg
);
17891 idx
= TEMPLATE_TYPE_IDX (parm
);
17892 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17893 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
17894 if (error_operand_p (tparm
))
17895 return unify_invalid (explain_p
);
17897 /* Check for mixed types and values. */
17898 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17899 && TREE_CODE (tparm
) != TYPE_DECL
)
17900 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17901 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
17902 gcc_unreachable ();
17904 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17906 /* ARG must be constructed from a template class or a template
17907 template parameter. */
17908 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
17909 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
17910 return unify_template_deduction_failure (explain_p
, parm
, arg
);
17912 tree parmvec
= TYPE_TI_ARGS (parm
);
17913 /* An alias template name is never deduced. */
17914 if (TYPE_ALIAS_P (arg
))
17915 arg
= strip_typedefs (arg
);
17916 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
17917 tree full_argvec
= add_to_template_args (targs
, argvec
);
17919 = DECL_INNERMOST_TEMPLATE_PARMS
17920 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
17922 int parm_variadic_p
= 0;
17924 /* The resolution to DR150 makes clear that default
17925 arguments for an N-argument may not be used to bind T
17926 to a template template parameter with fewer than N
17927 parameters. It is not safe to permit the binding of
17928 default arguments as an extension, as that may change
17929 the meaning of a conforming program. Consider:
17931 struct Dense { static const unsigned int dim = 1; };
17933 template <template <typename> class View,
17935 void operator+(float, View<Block> const&);
17937 template <typename Block,
17938 unsigned int Dim = Block::dim>
17939 struct Lvalue_proxy { operator float() const; };
17943 Lvalue_proxy<Dense> p;
17948 Here, if Lvalue_proxy is permitted to bind to View, then
17949 the global operator+ will be used; if they are not, the
17950 Lvalue_proxy will be converted to float. */
17951 if (coerce_template_parms (parm_parms
,
17953 TYPE_TI_TEMPLATE (parm
),
17955 ? tf_warning_or_error
17957 /*require_all_args=*/true,
17958 /*use_default_args=*/false)
17959 == error_mark_node
)
17962 /* Deduce arguments T, i from TT<T> or TT<i>.
17963 We check each element of PARMVEC and ARGVEC individually
17964 rather than the whole TREE_VEC since they can have
17965 different number of elements. */
17967 parmvec
= expand_template_argument_pack (parmvec
);
17968 argvec
= expand_template_argument_pack (argvec
);
17970 len
= TREE_VEC_LENGTH (parmvec
);
17972 /* Check if the parameters end in a pack, making them
17975 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
17976 parm_variadic_p
= 1;
17978 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17979 /* If the template argument list of P contains a pack
17980 expansion that is not the last template argument, the
17981 entire template argument list is a non-deduced
17983 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
17984 return unify_success (explain_p
);
17986 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
17987 return unify_too_few_arguments (explain_p
,
17988 TREE_VEC_LENGTH (argvec
), len
);
17990 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17992 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17993 TREE_VEC_ELT (parmvec
, i
),
17994 TREE_VEC_ELT (argvec
, i
),
17995 UNIFY_ALLOW_NONE
, explain_p
);
17998 if (parm_variadic_p
17999 && unify_pack_expansion (tparms
, targs
,
18002 /*subr=*/true, explain_p
))
18005 arg
= TYPE_TI_TEMPLATE (arg
);
18007 /* Fall through to deduce template name. */
18010 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18011 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18013 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
18015 /* Simple cases: Value already set, does match or doesn't. */
18016 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
18017 return unify_success (explain_p
);
18019 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18023 /* If PARM is `const T' and ARG is only `int', we don't have
18024 a match unless we are allowing additional qualification.
18025 If ARG is `const int' and PARM is just `T' that's OK;
18026 that binds `const int' to `T'. */
18027 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
18029 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18031 /* Consider the case where ARG is `const volatile int' and
18032 PARM is `const T'. Then, T should be `volatile int'. */
18033 arg
= cp_build_qualified_type_real
18034 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
18035 if (arg
== error_mark_node
)
18036 return unify_invalid (explain_p
);
18038 /* Simple cases: Value already set, does match or doesn't. */
18039 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
18040 return unify_success (explain_p
);
18042 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18044 /* Make sure that ARG is not a variable-sized array. (Note
18045 that were talking about variable-sized arrays (like
18046 `int[n]'), rather than arrays of unknown size (like
18047 `int[]').) We'll get very confused by such a type since
18048 the bound of the array is not constant, and therefore
18049 not mangleable. Besides, such types are not allowed in
18050 ISO C++, so we can do as we please here. We do allow
18051 them for 'auto' deduction, since that isn't ABI-exposed. */
18052 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
18053 return unify_vla_arg (explain_p
, arg
);
18055 /* Strip typedefs as in convert_template_argument. */
18056 arg
= canonicalize_type_argument (arg
, tf_none
);
18059 /* If ARG is a parameter pack or an expansion, we cannot unify
18060 against it unless PARM is also a parameter pack. */
18061 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18062 && !template_parameter_pack_p (parm
))
18063 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18065 /* If the argument deduction results is a METHOD_TYPE,
18066 then there is a problem.
18067 METHOD_TYPE doesn't map to any real C++ type the result of
18068 the deduction can not be of that type. */
18069 if (TREE_CODE (arg
) == METHOD_TYPE
)
18070 return unify_method_type_error (explain_p
, arg
);
18072 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18073 return unify_success (explain_p
);
18075 case TEMPLATE_PARM_INDEX
:
18076 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18077 if (error_operand_p (tparm
))
18078 return unify_invalid (explain_p
);
18080 if (TEMPLATE_PARM_LEVEL (parm
)
18081 != template_decl_level (tparm
))
18083 /* The PARM is not one we're trying to unify. Just check
18084 to see if it matches ARG. */
18085 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
18086 && cp_tree_equal (parm
, arg
));
18088 unify_expression_unequal (explain_p
, parm
, arg
);
18092 idx
= TEMPLATE_PARM_IDX (parm
);
18093 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18097 int x
= !cp_tree_equal (targ
, arg
);
18099 unify_inconsistency (explain_p
, parm
, targ
, arg
);
18103 /* [temp.deduct.type] If, in the declaration of a function template
18104 with a non-type template-parameter, the non-type
18105 template-parameter is used in an expression in the function
18106 parameter-list and, if the corresponding template-argument is
18107 deduced, the template-argument type shall match the type of the
18108 template-parameter exactly, except that a template-argument
18109 deduced from an array bound may be of any integral type.
18110 The non-type parameter might use already deduced type parameters. */
18111 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
18112 if (!TREE_TYPE (arg
))
18113 /* Template-parameter dependent expression. Just accept it for now.
18114 It will later be processed in convert_template_argument. */
18116 else if (same_type_p (TREE_TYPE (arg
), tparm
))
18118 else if ((strict
& UNIFY_ALLOW_INTEGER
)
18119 && CP_INTEGRAL_TYPE_P (tparm
))
18120 /* Convert the ARG to the type of PARM; the deduced non-type
18121 template argument must exactly match the types of the
18122 corresponding parameter. */
18123 arg
= fold (build_nop (tparm
, arg
));
18124 else if (uses_template_parms (tparm
))
18125 /* We haven't deduced the type of this parameter yet. Try again
18127 return unify_success (explain_p
);
18129 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
18131 /* If ARG is a parameter pack or an expansion, we cannot unify
18132 against it unless PARM is also a parameter pack. */
18133 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18134 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
18135 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18137 arg
= strip_typedefs_expr (arg
);
18138 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18139 return unify_success (explain_p
);
18143 /* A pointer-to-member constant can be unified only with
18144 another constant. */
18145 if (TREE_CODE (arg
) != PTRMEM_CST
)
18146 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
18148 /* Just unify the class member. It would be useless (and possibly
18149 wrong, depending on the strict flags) to unify also
18150 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18151 arg refer to the same variable, even if through different
18152 classes. For instance:
18154 struct A { int x; };
18157 Unification of &A::x and &B::x must succeed. */
18158 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
18159 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
18164 if (!TYPE_PTR_P (arg
))
18165 return unify_type_mismatch (explain_p
, parm
, arg
);
18167 /* [temp.deduct.call]
18169 A can be another pointer or pointer to member type that can
18170 be converted to the deduced A via a qualification
18171 conversion (_conv.qual_).
18173 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18174 This will allow for additional cv-qualification of the
18175 pointed-to types if appropriate. */
18177 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
18178 /* The derived-to-base conversion only persists through one
18179 level of pointers. */
18180 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
18182 return unify (tparms
, targs
, TREE_TYPE (parm
),
18183 TREE_TYPE (arg
), strict
, explain_p
);
18186 case REFERENCE_TYPE
:
18187 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
18188 return unify_type_mismatch (explain_p
, parm
, arg
);
18189 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18190 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18193 if (TREE_CODE (arg
) != ARRAY_TYPE
)
18194 return unify_type_mismatch (explain_p
, parm
, arg
);
18195 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
18196 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
18197 return unify_type_mismatch (explain_p
, parm
, arg
);
18198 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18199 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18200 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
18201 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18202 TYPE_DOMAIN (arg
), explain_p
);
18203 return unify_success (explain_p
);
18210 case ENUMERAL_TYPE
:
18213 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18214 return unify_type_mismatch (explain_p
, parm
, arg
);
18216 /* We have already checked cv-qualification at the top of the
18218 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
18219 return unify_type_mismatch (explain_p
, parm
, arg
);
18221 /* As far as unification is concerned, this wins. Later checks
18222 will invalidate it if necessary. */
18223 return unify_success (explain_p
);
18225 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18226 /* Type INTEGER_CST can come from ordinary constant template args. */
18228 while (TREE_CODE (arg
) == NOP_EXPR
)
18229 arg
= TREE_OPERAND (arg
, 0);
18231 if (TREE_CODE (arg
) != INTEGER_CST
)
18232 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18233 return (tree_int_cst_equal (parm
, arg
)
18234 ? unify_success (explain_p
)
18235 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18239 int i
, len
, argslen
;
18240 int parm_variadic_p
= 0;
18242 if (TREE_CODE (arg
) != TREE_VEC
)
18243 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18245 len
= TREE_VEC_LENGTH (parm
);
18246 argslen
= TREE_VEC_LENGTH (arg
);
18248 /* Check for pack expansions in the parameters. */
18249 for (i
= 0; i
< len
; ++i
)
18251 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18254 /* We can unify against something with a trailing
18256 parm_variadic_p
= 1;
18258 /* [temp.deduct.type]/9: If the template argument list of
18259 P contains a pack expansion that is not the last
18260 template argument, the entire template argument list
18261 is a non-deduced context. */
18262 return unify_success (explain_p
);
18266 /* If we don't have enough arguments to satisfy the parameters
18267 (not counting the pack expression at the end), or we have
18268 too many arguments for a parameter list that doesn't end in
18269 a pack expression, we can't unify. */
18270 if (parm_variadic_p
18271 ? argslen
< len
- parm_variadic_p
18273 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18275 /* Unify all of the parameters that precede the (optional)
18276 pack expression. */
18277 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18279 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18280 TREE_VEC_ELT (parm
, i
),
18281 TREE_VEC_ELT (arg
, i
),
18282 UNIFY_ALLOW_NONE
, explain_p
);
18284 if (parm_variadic_p
)
18285 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18287 /*subr=*/true, explain_p
);
18288 return unify_success (explain_p
);
18293 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18294 return unify_type_mismatch (explain_p
, parm
, arg
);
18296 if (TYPE_PTRMEMFUNC_P (parm
))
18298 if (!TYPE_PTRMEMFUNC_P (arg
))
18299 return unify_type_mismatch (explain_p
, parm
, arg
);
18301 return unify (tparms
, targs
,
18302 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18303 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18304 strict
, explain_p
);
18306 else if (TYPE_PTRMEMFUNC_P (arg
))
18307 return unify_type_mismatch (explain_p
, parm
, arg
);
18309 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18311 tree t
= NULL_TREE
;
18313 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18315 /* First, we try to unify the PARM and ARG directly. */
18316 t
= try_class_unification (tparms
, targs
,
18317 parm
, arg
, explain_p
);
18321 /* Fallback to the special case allowed in
18322 [temp.deduct.call]:
18324 If P is a class, and P has the form
18325 template-id, then A can be a derived class of
18326 the deduced A. Likewise, if P is a pointer to
18327 a class of the form template-id, A can be a
18328 pointer to a derived class pointed to by the
18330 enum template_base_result r
;
18331 r
= get_template_base (tparms
, targs
, parm
, arg
,
18335 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18338 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18339 && (CLASSTYPE_TI_TEMPLATE (parm
)
18340 == CLASSTYPE_TI_TEMPLATE (arg
)))
18341 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18342 Then, we should unify `int' and `U'. */
18345 /* There's no chance of unification succeeding. */
18346 return unify_type_mismatch (explain_p
, parm
, arg
);
18348 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18349 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18351 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18352 return unify_type_mismatch (explain_p
, parm
, arg
);
18353 return unify_success (explain_p
);
18356 case FUNCTION_TYPE
:
18358 unsigned int nargs
;
18363 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18364 return unify_type_mismatch (explain_p
, parm
, arg
);
18366 /* CV qualifications for methods can never be deduced, they must
18367 match exactly. We need to check them explicitly here,
18368 because type_unification_real treats them as any other
18369 cv-qualified parameter. */
18370 if (TREE_CODE (parm
) == METHOD_TYPE
18371 && (!check_cv_quals_for_unify
18373 class_of_this_parm (arg
),
18374 class_of_this_parm (parm
))))
18375 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18377 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18378 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18380 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18381 args
= XALLOCAVEC (tree
, nargs
);
18382 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18383 a
!= NULL_TREE
&& a
!= void_list_node
;
18384 a
= TREE_CHAIN (a
), ++i
)
18385 args
[i
] = TREE_VALUE (a
);
18388 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18389 args
, nargs
, 1, DEDUCE_EXACT
,
18390 LOOKUP_NORMAL
, NULL
, explain_p
);
18394 /* Unify a pointer to member with a pointer to member function, which
18395 deduces the type of the member as a function type. */
18396 if (TYPE_PTRMEMFUNC_P (arg
))
18398 /* Check top-level cv qualifiers */
18399 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18400 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18402 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18403 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18404 UNIFY_ALLOW_NONE
, explain_p
);
18406 /* Determine the type of the function we are unifying against. */
18407 tree fntype
= static_fn_type (arg
);
18409 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18412 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18413 return unify_type_mismatch (explain_p
, parm
, arg
);
18414 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18415 TYPE_OFFSET_BASETYPE (arg
),
18416 UNIFY_ALLOW_NONE
, explain_p
);
18417 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18418 strict
, explain_p
);
18421 if (DECL_TEMPLATE_PARM_P (parm
))
18422 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18423 if (arg
!= scalar_constant_value (parm
))
18424 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18425 return unify_success (explain_p
);
18428 case TEMPLATE_DECL
:
18429 /* Matched cases are handled by the ARG == PARM test above. */
18430 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18433 /* A non-type template parameter that is a variable should be a
18434 an integral constant, in which case, it whould have been
18435 folded into its (constant) value. So we should not be getting
18436 a variable here. */
18437 gcc_unreachable ();
18439 case TYPE_ARGUMENT_PACK
:
18440 case NONTYPE_ARGUMENT_PACK
:
18441 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18442 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18445 case DECLTYPE_TYPE
:
18446 case UNDERLYING_TYPE
:
18447 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18448 or UNDERLYING_TYPE nodes. */
18449 return unify_success (explain_p
);
18452 /* Unification fails if we hit an error node. */
18453 return unify_invalid (explain_p
);
18456 if (REFERENCE_REF_P (parm
))
18457 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18458 strict
, explain_p
);
18462 /* An unresolved overload is a nondeduced context. */
18463 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18464 return unify_success (explain_p
);
18465 gcc_assert (EXPR_P (parm
));
18467 /* We must be looking at an expression. This can happen with
18471 void foo(S<I>, S<I + 2>);
18473 This is a "nondeduced context":
18477 The nondeduced contexts are:
18479 --A type that is a template-id in which one or more of
18480 the template-arguments is an expression that references
18481 a template-parameter.
18483 In these cases, we assume deduction succeeded, but don't
18484 actually infer any unifications. */
18486 if (!uses_template_parms (parm
)
18487 && !template_args_equal (parm
, arg
))
18488 return unify_expression_unequal (explain_p
, parm
, arg
);
18490 return unify_success (explain_p
);
18493 #undef RECUR_AND_CHECK_FAILURE
18495 /* Note that DECL can be defined in this translation unit, if
18499 mark_definable (tree decl
)
18502 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18503 FOR_EACH_CLONE (clone
, decl
)
18504 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18507 /* Called if RESULT is explicitly instantiated, or is a member of an
18508 explicitly instantiated class. */
18511 mark_decl_instantiated (tree result
, int extern_p
)
18513 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18515 /* If this entity has already been written out, it's too late to
18516 make any modifications. */
18517 if (TREE_ASM_WRITTEN (result
))
18520 /* For anonymous namespace we don't need to do anything. */
18521 if (decl_anon_ns_mem_p (result
))
18523 gcc_assert (!TREE_PUBLIC (result
));
18527 if (TREE_CODE (result
) != FUNCTION_DECL
)
18528 /* The TREE_PUBLIC flag for function declarations will have been
18529 set correctly by tsubst. */
18530 TREE_PUBLIC (result
) = 1;
18532 /* This might have been set by an earlier implicit instantiation. */
18533 DECL_COMDAT (result
) = 0;
18536 DECL_NOT_REALLY_EXTERN (result
) = 0;
18539 mark_definable (result
);
18540 mark_needed (result
);
18541 /* Always make artificials weak. */
18542 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18543 comdat_linkage (result
);
18544 /* For WIN32 we also want to put explicit instantiations in
18545 linkonce sections. */
18546 else if (TREE_PUBLIC (result
))
18547 maybe_make_one_only (result
);
18550 /* If EXTERN_P, then this function will not be emitted -- unless
18551 followed by an explicit instantiation, at which point its linkage
18552 will be adjusted. If !EXTERN_P, then this function will be
18553 emitted here. In neither circumstance do we want
18554 import_export_decl to adjust the linkage. */
18555 DECL_INTERFACE_KNOWN (result
) = 1;
18558 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18559 important template arguments. If any are missing, we check whether
18560 they're important by using error_mark_node for substituting into any
18561 args that were used for partial ordering (the ones between ARGS and END)
18562 and seeing if it bubbles up. */
18565 check_undeduced_parms (tree targs
, tree args
, tree end
)
18567 bool found
= false;
18569 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18570 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18573 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18577 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18578 if (substed
== error_mark_node
)
18584 /* Given two function templates PAT1 and PAT2, return:
18586 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18587 -1 if PAT2 is more specialized than PAT1.
18588 0 if neither is more specialized.
18590 LEN indicates the number of parameters we should consider
18591 (defaulted parameters should not be considered).
18593 The 1998 std underspecified function template partial ordering, and
18594 DR214 addresses the issue. We take pairs of arguments, one from
18595 each of the templates, and deduce them against each other. One of
18596 the templates will be more specialized if all the *other*
18597 template's arguments deduce against its arguments and at least one
18598 of its arguments *does* *not* deduce against the other template's
18599 corresponding argument. Deduction is done as for class templates.
18600 The arguments used in deduction have reference and top level cv
18601 qualifiers removed. Iff both arguments were originally reference
18602 types *and* deduction succeeds in both directions, an lvalue reference
18603 wins against an rvalue reference and otherwise the template
18604 with the more cv-qualified argument wins for that pairing (if
18605 neither is more cv-qualified, they both are equal). Unlike regular
18606 deduction, after all the arguments have been deduced in this way,
18607 we do *not* verify the deduced template argument values can be
18608 substituted into non-deduced contexts.
18610 The logic can be a bit confusing here, because we look at deduce1 and
18611 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18612 can find template arguments for pat1 to make arg1 look like arg2, that
18613 means that arg2 is at least as specialized as arg1. */
18616 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18618 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18619 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18620 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18621 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18622 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18623 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18624 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18625 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18626 tree origs1
, origs2
;
18627 bool lose1
= false;
18628 bool lose2
= false;
18630 /* Remove the this parameter from non-static member functions. If
18631 one is a non-static member function and the other is not a static
18632 member function, remove the first parameter from that function
18633 also. This situation occurs for operator functions where we
18634 locate both a member function (with this pointer) and non-member
18635 operator (with explicit first operand). */
18636 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18638 len
--; /* LEN is the number of significant arguments for DECL1 */
18639 args1
= TREE_CHAIN (args1
);
18640 if (!DECL_STATIC_FUNCTION_P (decl2
))
18641 args2
= TREE_CHAIN (args2
);
18643 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18645 args2
= TREE_CHAIN (args2
);
18646 if (!DECL_STATIC_FUNCTION_P (decl1
))
18649 args1
= TREE_CHAIN (args1
);
18653 /* If only one is a conversion operator, they are unordered. */
18654 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18657 /* Consider the return type for a conversion function */
18658 if (DECL_CONV_FN_P (decl1
))
18660 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18661 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18665 processing_template_decl
++;
18671 /* Stop when an ellipsis is seen. */
18672 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18674 tree arg1
= TREE_VALUE (args1
);
18675 tree arg2
= TREE_VALUE (args2
);
18676 int deduce1
, deduce2
;
18682 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18683 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18685 /* When both arguments are pack expansions, we need only
18686 unify the patterns themselves. */
18687 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18688 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18690 /* This is the last comparison we need to do. */
18694 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18696 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18697 arg1
= TREE_TYPE (arg1
);
18698 quals1
= cp_type_quals (arg1
);
18701 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18703 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18704 arg2
= TREE_TYPE (arg2
);
18705 quals2
= cp_type_quals (arg2
);
18708 arg1
= TYPE_MAIN_VARIANT (arg1
);
18709 arg2
= TYPE_MAIN_VARIANT (arg2
);
18711 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18713 int i
, len2
= list_length (args2
);
18714 tree parmvec
= make_tree_vec (1);
18715 tree argvec
= make_tree_vec (len2
);
18718 /* Setup the parameter vector, which contains only ARG1. */
18719 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18721 /* Setup the argument vector, which contains the remaining
18723 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18724 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18726 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18727 argvec
, DEDUCE_EXACT
,
18728 /*subr=*/true, /*explain_p=*/false)
18731 /* We cannot deduce in the other direction, because ARG1 is
18732 a pack expansion but ARG2 is not. */
18735 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18737 int i
, len1
= list_length (args1
);
18738 tree parmvec
= make_tree_vec (1);
18739 tree argvec
= make_tree_vec (len1
);
18742 /* Setup the parameter vector, which contains only ARG1. */
18743 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18745 /* Setup the argument vector, which contains the remaining
18747 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18748 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18750 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18751 argvec
, DEDUCE_EXACT
,
18752 /*subr=*/true, /*explain_p=*/false)
18755 /* We cannot deduce in the other direction, because ARG2 is
18756 a pack expansion but ARG1 is not.*/
18762 /* The normal case, where neither argument is a pack
18764 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18765 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18767 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18768 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18772 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18773 arg2, then arg2 is not as specialized as arg1. */
18779 /* "If, for a given type, deduction succeeds in both directions
18780 (i.e., the types are identical after the transformations above)
18781 and both P and A were reference types (before being replaced with
18782 the type referred to above):
18783 - if the type from the argument template was an lvalue reference and
18784 the type from the parameter template was not, the argument type is
18785 considered to be more specialized than the other; otherwise,
18786 - if the type from the argument template is more cv-qualified
18787 than the type from the parameter template (as described above),
18788 the argument type is considered to be more specialized than the other;
18790 - neither type is more specialized than the other." */
18792 if (deduce1
&& deduce2
)
18794 if (ref1
&& ref2
&& ref1
!= ref2
)
18801 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
18803 if ((quals1
& quals2
) == quals2
)
18805 if ((quals1
& quals2
) == quals1
)
18810 if (lose1
&& lose2
)
18811 /* We've failed to deduce something in either direction.
18812 These must be unordered. */
18815 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18816 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18817 /* We have already processed all of the arguments in our
18818 handing of the pack expansion type. */
18821 args1
= TREE_CHAIN (args1
);
18822 args2
= TREE_CHAIN (args2
);
18825 /* "In most cases, all template parameters must have values in order for
18826 deduction to succeed, but for partial ordering purposes a template
18827 parameter may remain without a value provided it is not used in the
18828 types being used for partial ordering."
18830 Thus, if we are missing any of the targs1 we need to substitute into
18831 origs1, then pat2 is not as specialized as pat1. This can happen when
18832 there is a nondeduced context. */
18833 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
18835 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
18838 processing_template_decl
--;
18840 /* All things being equal, if the next argument is a pack expansion
18841 for one function but not for the other, prefer the
18842 non-variadic function. FIXME this is bogus; see c++/41958. */
18844 && args1
&& TREE_VALUE (args1
)
18845 && args2
&& TREE_VALUE (args2
))
18847 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
18848 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
18851 if (lose1
== lose2
)
18859 /* Determine which of two partial specializations of TMPL is more
18862 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18863 to the first partial specialization. The TREE_VALUE is the
18864 innermost set of template parameters for the partial
18865 specialization. PAT2 is similar, but for the second template.
18867 Return 1 if the first partial specialization is more specialized;
18868 -1 if the second is more specialized; 0 if neither is more
18871 See [temp.class.order] for information about determining which of
18872 two templates is more specialized. */
18875 more_specialized_class (tree tmpl
, tree pat1
, tree pat2
)
18880 bool any_deductions
= false;
18882 tmpl1
= TREE_TYPE (pat1
);
18883 tmpl2
= TREE_TYPE (pat2
);
18885 /* Just like what happens for functions, if we are ordering between
18886 different class template specializations, we may encounter dependent
18887 types in the arguments, and we need our dependency check functions
18888 to behave correctly. */
18889 ++processing_template_decl
;
18890 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat1
),
18891 CLASSTYPE_TI_ARGS (tmpl1
),
18892 CLASSTYPE_TI_ARGS (tmpl2
));
18896 any_deductions
= true;
18899 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat2
),
18900 CLASSTYPE_TI_ARGS (tmpl2
),
18901 CLASSTYPE_TI_ARGS (tmpl1
));
18905 any_deductions
= true;
18907 --processing_template_decl
;
18909 /* In the case of a tie where at least one of the class templates
18910 has a parameter pack at the end, the template with the most
18911 non-packed parameters wins. */
18914 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
18915 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
18917 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
18918 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
18919 int len1
= TREE_VEC_LENGTH (args1
);
18920 int len2
= TREE_VEC_LENGTH (args2
);
18922 /* We don't count the pack expansion at the end. */
18923 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
18925 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
18930 else if (len1
< len2
)
18937 /* Return the template arguments that will produce the function signature
18938 DECL from the function template FN, with the explicit template
18939 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18940 also match. Return NULL_TREE if no satisfactory arguments could be
18944 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
18946 int ntparms
= DECL_NTPARMS (fn
);
18947 tree targs
= make_tree_vec (ntparms
);
18948 tree decl_type
= TREE_TYPE (decl
);
18949 tree decl_arg_types
;
18951 unsigned int nargs
, ix
;
18954 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
18956 /* Never do unification on the 'this' parameter. */
18957 decl_arg_types
= skip_artificial_parms_for (decl
,
18958 TYPE_ARG_TYPES (decl_type
));
18960 nargs
= list_length (decl_arg_types
);
18961 args
= XALLOCAVEC (tree
, nargs
);
18962 for (arg
= decl_arg_types
, ix
= 0;
18963 arg
!= NULL_TREE
&& arg
!= void_list_node
;
18964 arg
= TREE_CHAIN (arg
), ++ix
)
18965 args
[ix
] = TREE_VALUE (arg
);
18967 if (fn_type_unification (fn
, explicit_args
, targs
,
18969 (check_rettype
|| DECL_CONV_FN_P (fn
)
18970 ? TREE_TYPE (decl_type
) : NULL_TREE
),
18971 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
18973 == error_mark_node
)
18979 /* Return the innermost template arguments that, when applied to a partial
18980 specialization of TMPL whose innermost template parameters are
18981 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
18984 For example, suppose we have:
18986 template <class T, class U> struct S {};
18987 template <class T> struct S<T*, int> {};
18989 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
18990 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
18991 int}. The resulting vector will be {double}, indicating that `T'
18992 is bound to `double'. */
18995 get_class_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
18997 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
18999 tree innermost_deduced_args
;
19001 innermost_deduced_args
= make_tree_vec (ntparms
);
19002 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19004 deduced_args
= copy_node (args
);
19005 SET_TMPL_ARGS_LEVEL (deduced_args
,
19006 TMPL_ARGS_DEPTH (deduced_args
),
19007 innermost_deduced_args
);
19010 deduced_args
= innermost_deduced_args
;
19012 if (unify (tparms
, deduced_args
,
19013 INNERMOST_TEMPLATE_ARGS (spec_args
),
19014 INNERMOST_TEMPLATE_ARGS (args
),
19015 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
19018 for (i
= 0; i
< ntparms
; ++i
)
19019 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
19022 /* Verify that nondeduced template arguments agree with the type
19023 obtained from argument deduction.
19027 struct A { typedef int X; };
19028 template <class T, class U> struct C {};
19029 template <class T> struct C<T, typename T::X> {};
19031 Then with the instantiation `C<A, int>', we can deduce that
19032 `T' is `A' but unify () does not check whether `typename T::X'
19034 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
19035 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19037 tf_none
, false, false);
19038 if (spec_args
== error_mark_node
19039 /* We only need to check the innermost arguments; the other
19040 arguments will always agree. */
19041 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
19042 INNERMOST_TEMPLATE_ARGS (args
)))
19045 /* Now that we have bindings for all of the template arguments,
19046 ensure that the arguments deduced for the template template
19047 parameters have compatible template parameter lists. See the use
19048 of template_template_parm_bindings_ok_p in fn_type_unification
19049 for more information. */
19050 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
19053 return deduced_args
;
19056 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19057 Return the TREE_LIST node with the most specialized template, if
19058 any. If there is no most specialized template, the error_mark_node
19061 Note that this function does not look at, or modify, the
19062 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19063 returned is one of the elements of INSTANTIATIONS, callers may
19064 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19065 and retrieve it from the value returned. */
19068 most_specialized_instantiation (tree templates
)
19072 ++processing_template_decl
;
19075 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
19079 if (get_bindings (TREE_VALUE (champ
),
19080 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19081 NULL_TREE
, /*check_ret=*/true))
19084 if (get_bindings (TREE_VALUE (fn
),
19085 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19086 NULL_TREE
, /*check_ret=*/true))
19093 /* Equally specialized, move to next function. If there
19094 is no next function, nothing's most specialized. */
19095 fn
= TREE_CHAIN (fn
);
19103 /* Now verify that champ is better than everything earlier in the
19104 instantiation list. */
19105 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
19106 if (get_bindings (TREE_VALUE (champ
),
19107 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19108 NULL_TREE
, /*check_ret=*/true)
19109 || !get_bindings (TREE_VALUE (fn
),
19110 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19111 NULL_TREE
, /*check_ret=*/true))
19117 processing_template_decl
--;
19120 return error_mark_node
;
19125 /* If DECL is a specialization of some template, return the most
19126 general such template. Otherwise, returns NULL_TREE.
19128 For example, given:
19130 template <class T> struct S { template <class U> void f(U); };
19132 if TMPL is `template <class U> void S<int>::f(U)' this will return
19133 the full template. This function will not trace past partial
19134 specializations, however. For example, given in addition:
19136 template <class T> struct S<T*> { template <class U> void f(U); };
19138 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19139 `template <class T> template <class U> S<T*>::f(U)'. */
19142 most_general_template (tree decl
)
19144 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19146 if (tree tinfo
= get_template_info (decl
))
19147 decl
= TI_TEMPLATE (tinfo
);
19148 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19149 template friend, or a FIELD_DECL for a capture pack. */
19150 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19154 /* Look for more and more general templates. */
19155 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
19157 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19158 (See cp-tree.h for details.) */
19159 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
19162 if (CLASS_TYPE_P (TREE_TYPE (decl
))
19163 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
19166 /* Stop if we run into an explicitly specialized class template. */
19167 if (!DECL_NAMESPACE_SCOPE_P (decl
)
19168 && DECL_CONTEXT (decl
)
19169 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
19172 decl
= DECL_TI_TEMPLATE (decl
);
19178 /* Return the most specialized of the class template partial
19179 specializations which can produce TYPE, a specialization of some class
19180 template. The value returned is actually a TREE_LIST; the TREE_TYPE is
19181 a _TYPE node corresponding to the partial specialization, while the
19182 TREE_PURPOSE is the set of template arguments that must be
19183 substituted into the TREE_TYPE in order to generate TYPE.
19185 If the choice of partial specialization is ambiguous, a diagnostic
19186 is issued, and the error_mark_node is returned. If there are no
19187 partial specializations matching TYPE, then NULL_TREE is
19188 returned, indicating that the primary template should be used. */
19191 most_specialized_class (tree type
, tsubst_flags_t complain
)
19193 tree list
= NULL_TREE
;
19198 tree outer_args
= NULL_TREE
;
19200 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
19201 tree main_tmpl
= most_general_template (tmpl
);
19202 tree args
= CLASSTYPE_TI_ARGS (type
);
19204 /* For determining which partial specialization to use, only the
19205 innermost args are interesting. */
19206 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19208 outer_args
= strip_innermost_template_args (args
, 1);
19209 args
= INNERMOST_TEMPLATE_ARGS (args
);
19212 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
19214 tree partial_spec_args
;
19216 tree spec_tmpl
= TREE_VALUE (t
);
19217 tree orig_parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19219 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
19221 ++processing_template_decl
;
19225 /* Discard the outer levels of args, and then substitute in the
19226 template args from the enclosing class. */
19227 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19228 partial_spec_args
= tsubst_template_args
19229 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19231 /* And the same for the partial specialization TEMPLATE_DECL. */
19232 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19235 partial_spec_args
=
19236 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19239 /*require_all_args=*/true,
19240 /*use_default_args=*/true);
19242 --processing_template_decl
;
19244 if (partial_spec_args
== error_mark_node
)
19245 return error_mark_node
;
19246 if (spec_tmpl
== error_mark_node
)
19247 return error_mark_node
;
19249 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19250 spec_args
= get_class_bindings (tmpl
, parms
,
19256 spec_args
= add_to_template_args (outer_args
, spec_args
);
19257 list
= tree_cons (spec_args
, orig_parms
, list
);
19258 TREE_TYPE (list
) = TREE_TYPE (t
);
19265 ambiguous_p
= false;
19268 t
= TREE_CHAIN (t
);
19269 for (; t
; t
= TREE_CHAIN (t
))
19271 fate
= more_specialized_class (tmpl
, champ
, t
);
19278 t
= TREE_CHAIN (t
);
19281 ambiguous_p
= true;
19290 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19292 fate
= more_specialized_class (tmpl
, champ
, t
);
19295 ambiguous_p
= true;
19303 char *spaces
= NULL
;
19304 if (!(complain
& tf_error
))
19305 return error_mark_node
;
19306 error ("ambiguous class template instantiation for %q#T", type
);
19307 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19308 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19310 error ("%s %+#T", spaces
? spaces
: str
, TREE_TYPE (t
));
19311 spaces
= spaces
? spaces
: get_spaces (str
);
19314 return error_mark_node
;
19320 /* Explicitly instantiate DECL. */
19323 do_decl_instantiation (tree decl
, tree storage
)
19325 tree result
= NULL_TREE
;
19328 if (!decl
|| decl
== error_mark_node
)
19329 /* An error occurred, for which grokdeclarator has already issued
19330 an appropriate message. */
19332 else if (! DECL_LANG_SPECIFIC (decl
))
19334 error ("explicit instantiation of non-template %q#D", decl
);
19338 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
19339 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
19341 if (VAR_P (decl
) && !var_templ
)
19343 /* There is an asymmetry here in the way VAR_DECLs and
19344 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19345 the latter, the DECL we get back will be marked as a
19346 template instantiation, and the appropriate
19347 DECL_TEMPLATE_INFO will be set up. This does not happen for
19348 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19349 should handle VAR_DECLs as it currently handles
19351 if (!DECL_CLASS_SCOPE_P (decl
))
19353 error ("%qD is not a static data member of a class template", decl
);
19356 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19357 if (!result
|| !VAR_P (result
))
19359 error ("no matching template for %qD found", decl
);
19362 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19364 error ("type %qT for explicit instantiation %qD does not match "
19365 "declared type %qT", TREE_TYPE (result
), decl
,
19370 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
19372 error ("explicit instantiation of %q#D", decl
);
19378 /* Check for various error cases. Note that if the explicit
19379 instantiation is valid the RESULT will currently be marked as an
19380 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19381 until we get here. */
19383 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19385 /* DR 259 [temp.spec].
19387 Both an explicit instantiation and a declaration of an explicit
19388 specialization shall not appear in a program unless the explicit
19389 instantiation follows a declaration of the explicit specialization.
19391 For a given set of template parameters, if an explicit
19392 instantiation of a template appears after a declaration of an
19393 explicit specialization for that template, the explicit
19394 instantiation has no effect. */
19397 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19401 No program shall explicitly instantiate any template more
19404 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19405 the first instantiation was `extern' and the second is not,
19406 and EXTERN_P for the opposite case. */
19407 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19408 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19409 /* If an "extern" explicit instantiation follows an ordinary
19410 explicit instantiation, the template is instantiated. */
19414 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19416 error ("no matching template for %qD found", result
);
19419 else if (!DECL_TEMPLATE_INFO (result
))
19421 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19425 if (storage
== NULL_TREE
)
19427 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19429 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19430 pedwarn (input_location
, OPT_Wpedantic
,
19431 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19436 error ("storage class %qD applied to template instantiation", storage
);
19438 check_explicit_instantiation_namespace (result
);
19439 mark_decl_instantiated (result
, extern_p
);
19441 instantiate_decl (result
, /*defer_ok=*/1,
19442 /*expl_inst_class_mem_p=*/false);
19446 mark_class_instantiated (tree t
, int extern_p
)
19448 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19449 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19450 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19451 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19454 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19455 rest_of_type_compilation (t
, 1);
19459 /* Called from do_type_instantiation through binding_table_foreach to
19460 do recursive instantiation for the type bound in ENTRY. */
19462 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19464 tree storage
= *(tree
*) data
;
19466 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19467 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19468 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19471 /* Called from do_type_instantiation to instantiate a member
19472 (a member function or a static member variable) of an
19473 explicitly instantiated class template. */
19475 instantiate_class_member (tree decl
, int extern_p
)
19477 mark_decl_instantiated (decl
, extern_p
);
19479 instantiate_decl (decl
, /*defer_ok=*/1,
19480 /*expl_inst_class_mem_p=*/true);
19483 /* Perform an explicit instantiation of template class T. STORAGE, if
19484 non-null, is the RID for extern, inline or static. COMPLAIN is
19485 nonzero if this is called from the parser, zero if called recursively,
19486 since the standard is unclear (as detailed below). */
19489 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19494 int previous_instantiation_extern_p
= 0;
19496 if (TREE_CODE (t
) == TYPE_DECL
)
19499 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19502 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19504 error ("explicit instantiation of non-class template %qD", tmpl
);
19506 error ("explicit instantiation of non-template type %qT", t
);
19512 if (!COMPLETE_TYPE_P (t
))
19514 if (complain
& tf_error
)
19515 error ("explicit instantiation of %q#T before definition of template",
19520 if (storage
!= NULL_TREE
)
19522 if (!in_system_header_at (input_location
))
19524 if (storage
== ridpointers
[(int) RID_EXTERN
])
19526 if (cxx_dialect
== cxx98
)
19527 pedwarn (input_location
, OPT_Wpedantic
,
19528 "ISO C++ 1998 forbids the use of %<extern%> on "
19529 "explicit instantiations");
19532 pedwarn (input_location
, OPT_Wpedantic
,
19533 "ISO C++ forbids the use of %qE"
19534 " on explicit instantiations", storage
);
19537 if (storage
== ridpointers
[(int) RID_INLINE
])
19539 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19541 else if (storage
== ridpointers
[(int) RID_STATIC
])
19545 error ("storage class %qD applied to template instantiation",
19551 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19553 /* DR 259 [temp.spec].
19555 Both an explicit instantiation and a declaration of an explicit
19556 specialization shall not appear in a program unless the explicit
19557 instantiation follows a declaration of the explicit specialization.
19559 For a given set of template parameters, if an explicit
19560 instantiation of a template appears after a declaration of an
19561 explicit specialization for that template, the explicit
19562 instantiation has no effect. */
19565 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19569 No program shall explicitly instantiate any template more
19572 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19573 instantiation was `extern'. If EXTERN_P then the second is.
19574 These cases are OK. */
19575 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19577 if (!previous_instantiation_extern_p
&& !extern_p
19578 && (complain
& tf_error
))
19579 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19581 /* If we've already instantiated the template, just return now. */
19582 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19586 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19587 mark_class_instantiated (t
, extern_p
);
19595 /* In contrast to implicit instantiation, where only the
19596 declarations, and not the definitions, of members are
19597 instantiated, we have here:
19601 The explicit instantiation of a class template specialization
19602 implies the instantiation of all of its members not
19603 previously explicitly specialized in the translation unit
19604 containing the explicit instantiation.
19606 Of course, we can't instantiate member template classes, since
19607 we don't have any arguments for them. Note that the standard
19608 is unclear on whether the instantiation of the members are
19609 *explicit* instantiations or not. However, the most natural
19610 interpretation is that it should be an explicit instantiation. */
19613 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19614 if (TREE_CODE (tmp
) == FUNCTION_DECL
19615 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19616 instantiate_class_member (tmp
, extern_p
);
19618 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19619 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19620 instantiate_class_member (tmp
, extern_p
);
19622 if (CLASSTYPE_NESTED_UTDS (t
))
19623 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19624 bt_instantiate_type_proc
, &storage
);
19628 /* Given a function DECL, which is a specialization of TMPL, modify
19629 DECL to be a re-instantiation of TMPL with the same template
19630 arguments. TMPL should be the template into which tsubst'ing
19631 should occur for DECL, not the most general template.
19633 One reason for doing this is a scenario like this:
19636 void f(const T&, int i);
19638 void g() { f(3, 7); }
19641 void f(const T& t, const int i) { }
19643 Note that when the template is first instantiated, with
19644 instantiate_template, the resulting DECL will have no name for the
19645 first parameter, and the wrong type for the second. So, when we go
19646 to instantiate the DECL, we regenerate it. */
19649 regenerate_decl_from_template (tree decl
, tree tmpl
)
19651 /* The arguments used to instantiate DECL, from the most general
19656 args
= DECL_TI_ARGS (decl
);
19657 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19659 /* Make sure that we can see identifiers, and compute access
19661 push_access_scope (decl
);
19663 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19671 args_depth
= TMPL_ARGS_DEPTH (args
);
19672 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19673 if (args_depth
> parms_depth
)
19674 args
= get_innermost_template_args (args
, parms_depth
);
19676 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19677 args
, tf_error
, NULL_TREE
,
19678 /*defer_ok*/false);
19679 if (specs
&& specs
!= error_mark_node
)
19680 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19683 /* Merge parameter declarations. */
19684 decl_parm
= skip_artificial_parms_for (decl
,
19685 DECL_ARGUMENTS (decl
));
19687 = skip_artificial_parms_for (code_pattern
,
19688 DECL_ARGUMENTS (code_pattern
));
19689 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19694 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19695 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19696 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19698 parm_type
= type_decays_to (parm_type
);
19699 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19700 TREE_TYPE (decl_parm
) = parm_type
;
19701 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19702 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19704 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19705 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19707 decl_parm
= DECL_CHAIN (decl_parm
);
19708 pattern_parm
= DECL_CHAIN (pattern_parm
);
19710 /* Merge any parameters that match with the function parameter
19712 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19715 tree expanded_types
;
19716 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19717 the parameters in this function parameter pack. */
19718 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19719 args
, tf_error
, NULL_TREE
);
19720 len
= TREE_VEC_LENGTH (expanded_types
);
19721 for (i
= 0; i
< len
; i
++)
19726 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19727 /* Rename the parameter to include the index. */
19728 DECL_NAME (decl_parm
) =
19729 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19730 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19731 parm_type
= type_decays_to (parm_type
);
19732 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19733 TREE_TYPE (decl_parm
) = parm_type
;
19734 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19735 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19737 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19738 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19740 decl_parm
= DECL_CHAIN (decl_parm
);
19743 /* Merge additional specifiers from the CODE_PATTERN. */
19744 if (DECL_DECLARED_INLINE_P (code_pattern
)
19745 && !DECL_DECLARED_INLINE_P (decl
))
19746 DECL_DECLARED_INLINE_P (decl
) = 1;
19748 else if (VAR_P (decl
))
19750 DECL_INITIAL (decl
) =
19751 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19752 tf_error
, DECL_TI_TEMPLATE (decl
),
19753 /*integral_constant_expression_p=*/false);
19754 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19755 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19756 tf_error
, DECL_TI_TEMPLATE (decl
));
19759 gcc_unreachable ();
19761 pop_access_scope (decl
);
19764 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19765 substituted to get DECL. */
19768 template_for_substitution (tree decl
)
19770 tree tmpl
= DECL_TI_TEMPLATE (decl
);
19772 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19773 for the instantiation. This is not always the most general
19774 template. Consider, for example:
19777 struct S { template <class U> void f();
19778 template <> void f<int>(); };
19780 and an instantiation of S<double>::f<int>. We want TD to be the
19781 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19782 while (/* An instantiation cannot have a definition, so we need a
19783 more general template. */
19784 DECL_TEMPLATE_INSTANTIATION (tmpl
)
19785 /* We must also deal with friend templates. Given:
19787 template <class T> struct S {
19788 template <class U> friend void f() {};
19791 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19792 so far as the language is concerned, but that's still
19793 where we get the pattern for the instantiation from. On
19794 other hand, if the definition comes outside the class, say:
19796 template <class T> struct S {
19797 template <class U> friend void f();
19799 template <class U> friend void f() {}
19801 we don't need to look any further. That's what the check for
19802 DECL_INITIAL is for. */
19803 || (TREE_CODE (decl
) == FUNCTION_DECL
19804 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
19805 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
19807 /* The present template, TD, should not be a definition. If it
19808 were a definition, we should be using it! Note that we
19809 cannot restructure the loop to just keep going until we find
19810 a template with a definition, since that might go too far if
19811 a specialization was declared, but not defined. */
19813 /* Fetch the more general template. */
19814 tmpl
= DECL_TI_TEMPLATE (tmpl
);
19820 /* Returns true if we need to instantiate this template instance even if we
19821 know we aren't going to emit it.. */
19824 always_instantiate_p (tree decl
)
19826 /* We always instantiate inline functions so that we can inline them. An
19827 explicit instantiation declaration prohibits implicit instantiation of
19828 non-inline functions. With high levels of optimization, we would
19829 normally inline non-inline functions -- but we're not allowed to do
19830 that for "extern template" functions. Therefore, we check
19831 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19832 return ((TREE_CODE (decl
) == FUNCTION_DECL
19833 && (DECL_DECLARED_INLINE_P (decl
)
19834 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
19835 /* And we need to instantiate static data members so that
19836 their initializers are available in integral constant
19839 && decl_maybe_constant_var_p (decl
)));
19842 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19843 instantiate it now, modifying TREE_TYPE (fn). */
19846 maybe_instantiate_noexcept (tree fn
)
19848 tree fntype
, spec
, noex
, clone
;
19850 /* Don't instantiate a noexcept-specification from template context. */
19851 if (processing_template_decl
)
19854 if (DECL_CLONED_FUNCTION_P (fn
))
19855 fn
= DECL_CLONED_FUNCTION (fn
);
19856 fntype
= TREE_TYPE (fn
);
19857 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
19859 if (!spec
|| !TREE_PURPOSE (spec
))
19862 noex
= TREE_PURPOSE (spec
);
19864 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
19866 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
19867 spec
= get_defaulted_eh_spec (fn
);
19868 else if (push_tinst_level (fn
))
19870 push_access_scope (fn
);
19871 push_deferring_access_checks (dk_no_deferred
);
19872 input_location
= DECL_SOURCE_LOCATION (fn
);
19873 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
19874 DEFERRED_NOEXCEPT_ARGS (noex
),
19875 tf_warning_or_error
, fn
,
19876 /*function_p=*/false,
19877 /*integral_constant_expression_p=*/true);
19878 pop_deferring_access_checks ();
19879 pop_access_scope (fn
);
19880 pop_tinst_level ();
19881 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
19882 if (spec
== error_mark_node
)
19883 spec
= noexcept_false_spec
;
19886 spec
= noexcept_false_spec
;
19888 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
19891 FOR_EACH_CLONE (clone
, fn
)
19893 if (TREE_TYPE (clone
) == fntype
)
19894 TREE_TYPE (clone
) = TREE_TYPE (fn
);
19896 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
19900 /* Produce the definition of D, a _DECL generated from a template. If
19901 DEFER_OK is nonzero, then we don't have to actually do the
19902 instantiation now; we just have to do it sometime. Normally it is
19903 an error if this is an explicit instantiation but D is undefined.
19904 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19905 explicitly instantiated class template. */
19908 instantiate_decl (tree d
, int defer_ok
,
19909 bool expl_inst_class_mem_p
)
19911 tree tmpl
= DECL_TI_TEMPLATE (d
);
19918 bool pattern_defined
;
19919 location_t saved_loc
= input_location
;
19920 int saved_unevaluated_operand
= cp_unevaluated_operand
;
19921 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
19927 /* This function should only be used to instantiate templates for
19928 functions and static member variables. */
19929 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
19931 /* Variables are never deferred; if instantiation is required, they
19932 are instantiated right away. That allows for better code in the
19933 case that an expression refers to the value of the variable --
19934 if the variable has a constant value the referring expression can
19935 take advantage of that fact. */
19937 || DECL_DECLARED_CONSTEXPR_P (d
))
19940 /* Don't instantiate cloned functions. Instead, instantiate the
19941 functions they cloned. */
19942 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
19943 d
= DECL_CLONED_FUNCTION (d
);
19945 if (DECL_TEMPLATE_INSTANTIATED (d
)
19946 || (TREE_CODE (d
) == FUNCTION_DECL
19947 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
19948 || DECL_TEMPLATE_SPECIALIZATION (d
))
19949 /* D has already been instantiated or explicitly specialized, so
19950 there's nothing for us to do here.
19952 It might seem reasonable to check whether or not D is an explicit
19953 instantiation, and, if so, stop here. But when an explicit
19954 instantiation is deferred until the end of the compilation,
19955 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
19956 the instantiation. */
19959 /* Check to see whether we know that this template will be
19960 instantiated in some other file, as with "extern template"
19962 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
19964 /* In general, we do not instantiate such templates. */
19965 if (external_p
&& !always_instantiate_p (d
))
19968 gen_tmpl
= most_general_template (tmpl
);
19969 gen_args
= DECL_TI_ARGS (d
);
19971 if (tmpl
!= gen_tmpl
)
19972 /* We should already have the extra args. */
19973 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
19974 == TMPL_ARGS_DEPTH (gen_args
));
19975 /* And what's in the hash table should match D. */
19976 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
19977 || spec
== NULL_TREE
);
19979 /* This needs to happen before any tsubsting. */
19980 if (! push_tinst_level (d
))
19983 timevar_push (TV_TEMPLATE_INST
);
19985 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
19986 for the instantiation. */
19987 td
= template_for_substitution (d
);
19988 code_pattern
= DECL_TEMPLATE_RESULT (td
);
19990 /* We should never be trying to instantiate a member of a class
19991 template or partial specialization. */
19992 gcc_assert (d
!= code_pattern
);
19994 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
19995 || DECL_TEMPLATE_SPECIALIZATION (td
))
19996 /* In the case of a friend template whose definition is provided
19997 outside the class, we may have too many arguments. Drop the
19998 ones we don't need. The same is true for specializations. */
19999 args
= get_innermost_template_args
20000 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
20004 if (TREE_CODE (d
) == FUNCTION_DECL
)
20006 deleted_p
= DECL_DELETED_FN (code_pattern
);
20007 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
20008 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
20014 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
20017 /* We may be in the middle of deferred access check. Disable it now. */
20018 push_deferring_access_checks (dk_no_deferred
);
20020 /* Unless an explicit instantiation directive has already determined
20021 the linkage of D, remember that a definition is available for
20023 if (pattern_defined
20024 && !DECL_INTERFACE_KNOWN (d
)
20025 && !DECL_NOT_REALLY_EXTERN (d
))
20026 mark_definable (d
);
20028 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
20029 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
20030 input_location
= DECL_SOURCE_LOCATION (d
);
20032 /* If D is a member of an explicitly instantiated class template,
20033 and no definition is available, treat it like an implicit
20035 if (!pattern_defined
&& expl_inst_class_mem_p
20036 && DECL_EXPLICIT_INSTANTIATION (d
))
20038 /* Leave linkage flags alone on instantiations with anonymous
20040 if (TREE_PUBLIC (d
))
20042 DECL_NOT_REALLY_EXTERN (d
) = 0;
20043 DECL_INTERFACE_KNOWN (d
) = 0;
20045 SET_DECL_IMPLICIT_INSTANTIATION (d
);
20048 /* Defer all other templates, unless we have been explicitly
20049 forbidden from doing so. */
20050 if (/* If there is no definition, we cannot instantiate the
20053 /* If it's OK to postpone instantiation, do so. */
20055 /* If this is a static data member that will be defined
20056 elsewhere, we don't want to instantiate the entire data
20057 member, but we do want to instantiate the initializer so that
20058 we can substitute that elsewhere. */
20059 || (external_p
&& VAR_P (d
))
20060 /* Handle here a deleted function too, avoid generating
20061 its body (c++/61080). */
20064 /* The definition of the static data member is now required so
20065 we must substitute the initializer. */
20067 && !DECL_INITIAL (d
)
20068 && DECL_INITIAL (code_pattern
))
20072 bool const_init
= false;
20073 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20075 ns
= decl_namespace_context (d
);
20076 push_nested_namespace (ns
);
20078 push_nested_class (DECL_CONTEXT (d
));
20079 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
20081 tf_warning_or_error
, NULL_TREE
,
20082 /*integral_constant_expression_p=*/false);
20083 /* If instantiating the initializer involved instantiating this
20084 again, don't call cp_finish_decl twice. */
20085 if (!DECL_INITIAL (d
))
20087 /* Make sure the initializer is still constant, in case of
20088 circular dependency (template/instantiate6.C). */
20090 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20091 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
20092 /*asmspec_tree=*/NULL_TREE
,
20093 LOOKUP_ONLYCONVERTING
);
20096 pop_nested_class ();
20097 pop_nested_namespace (ns
);
20100 /* We restore the source position here because it's used by
20101 add_pending_template. */
20102 input_location
= saved_loc
;
20104 if (at_eof
&& !pattern_defined
20105 && DECL_EXPLICIT_INSTANTIATION (d
)
20106 && DECL_NOT_REALLY_EXTERN (d
))
20109 The definition of a non-exported function template, a
20110 non-exported member function template, or a non-exported
20111 member function or static data member of a class template
20112 shall be present in every translation unit in which it is
20113 explicitly instantiated. */
20114 permerror (input_location
, "explicit instantiation of %qD "
20115 "but no definition available", d
);
20117 /* If we're in unevaluated context, we just wanted to get the
20118 constant value; this isn't an odr use, so don't queue
20119 a full instantiation. */
20120 if (cp_unevaluated_operand
!= 0)
20122 /* ??? Historically, we have instantiated inline functions, even
20123 when marked as "extern template". */
20124 if (!(external_p
&& VAR_P (d
)))
20125 add_pending_template (d
);
20128 /* Tell the repository that D is available in this translation unit
20129 -- and see if it is supposed to be instantiated here. */
20130 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
20132 /* In a PCH file, despite the fact that the repository hasn't
20133 requested instantiation in the PCH it is still possible that
20134 an instantiation will be required in a file that includes the
20137 add_pending_template (d
);
20138 /* Instantiate inline functions so that the inliner can do its
20139 job, even though we'll not be emitting a copy of this
20141 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
20145 fn_context
= decl_function_context (d
);
20146 nested
= (current_function_decl
!= NULL_TREE
);
20148 push_to_top_level ();
20152 push_function_context ();
20153 cp_unevaluated_operand
= 0;
20154 c_inhibit_evaluation_warnings
= 0;
20157 /* Mark D as instantiated so that recursive calls to
20158 instantiate_decl do not try to instantiate it again. */
20159 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
20161 /* Regenerate the declaration in case the template has been modified
20162 by a subsequent redeclaration. */
20163 regenerate_decl_from_template (d
, td
);
20165 /* We already set the file and line above. Reset them now in case
20166 they changed as a result of calling regenerate_decl_from_template. */
20167 input_location
= DECL_SOURCE_LOCATION (d
);
20172 bool const_init
= false;
20174 /* Clear out DECL_RTL; whatever was there before may not be right
20175 since we've reset the type of the declaration. */
20176 SET_DECL_RTL (d
, NULL
);
20177 DECL_IN_AGGR_P (d
) = 0;
20179 /* The initializer is placed in DECL_INITIAL by
20180 regenerate_decl_from_template so we don't need to
20181 push/pop_access_scope again here. Pull it out so that
20182 cp_finish_decl can process it. */
20183 init
= DECL_INITIAL (d
);
20184 DECL_INITIAL (d
) = NULL_TREE
;
20185 DECL_INITIALIZED_P (d
) = 0;
20187 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20188 initializer. That function will defer actual emission until
20189 we have a chance to determine linkage. */
20190 DECL_EXTERNAL (d
) = 0;
20192 /* Enter the scope of D so that access-checking works correctly. */
20193 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20195 push_nested_class (DECL_CONTEXT (d
));
20197 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20198 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
20201 pop_nested_class ();
20203 if (variable_template_p (td
))
20204 note_variable_template_instantiation (d
);
20206 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
20207 synthesize_method (d
);
20208 else if (TREE_CODE (d
) == FUNCTION_DECL
)
20210 hash_map
<tree
, tree
> *saved_local_specializations
;
20214 tree block
= NULL_TREE
;
20216 /* Save away the current list, in case we are instantiating one
20217 template from within the body of another. */
20218 saved_local_specializations
= local_specializations
;
20220 /* Set up the list of local specializations. */
20221 local_specializations
= new hash_map
<tree
, tree
>;
20223 /* Set up context. */
20224 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20225 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20226 block
= push_stmt_list ();
20228 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
20230 /* Some typedefs referenced from within the template code need to be
20231 access checked at template instantiation time, i.e now. These
20232 types were added to the template at parsing time. Let's get those
20233 and perform the access checks then. */
20234 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20237 /* Create substitution entries for the parameters. */
20238 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20239 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20240 spec_parm
= DECL_ARGUMENTS (d
);
20241 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20243 register_local_specialization (spec_parm
, tmpl_parm
);
20244 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20245 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20247 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20249 if (!DECL_PACK_P (tmpl_parm
))
20251 register_local_specialization (spec_parm
, tmpl_parm
);
20252 spec_parm
= DECL_CHAIN (spec_parm
);
20256 /* Register the (value) argument pack as a specialization of
20257 TMPL_PARM, then move on. */
20258 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20259 register_local_specialization (argpack
, tmpl_parm
);
20262 gcc_assert (!spec_parm
);
20264 /* Substitute into the body of the function. */
20265 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20266 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20267 tf_warning_or_error
, tmpl
);
20270 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20271 tf_warning_or_error
, tmpl
,
20272 /*integral_constant_expression_p=*/false);
20274 /* Set the current input_location to the end of the function
20275 so that finish_function knows where we are. */
20277 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20279 /* Remember if we saw an infinite loop in the template. */
20280 current_function_infinite_loop
20281 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20284 /* We don't need the local specializations any more. */
20285 delete local_specializations
;
20286 local_specializations
= saved_local_specializations
;
20288 /* Finish the function. */
20289 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20290 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20291 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20294 d
= finish_function (0);
20295 expand_or_defer_fn (d
);
20298 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20299 cp_check_omp_declare_reduction (d
);
20302 /* We're not deferring instantiation any more. */
20303 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20306 pop_from_top_level ();
20308 pop_function_context ();
20311 input_location
= saved_loc
;
20312 cp_unevaluated_operand
= saved_unevaluated_operand
;
20313 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20314 pop_deferring_access_checks ();
20315 pop_tinst_level ();
20317 timevar_pop (TV_TEMPLATE_INST
);
20322 /* Run through the list of templates that we wish we could
20323 instantiate, and instantiate any we can. RETRIES is the
20324 number of times we retry pending template instantiation. */
20327 instantiate_pending_templates (int retries
)
20330 location_t saved_loc
= input_location
;
20332 /* Instantiating templates may trigger vtable generation. This in turn
20333 may require further template instantiations. We place a limit here
20334 to avoid infinite loop. */
20335 if (pending_templates
&& retries
>= max_tinst_depth
)
20337 tree decl
= pending_templates
->tinst
->decl
;
20339 fatal_error ("template instantiation depth exceeds maximum of %d"
20340 " instantiating %q+D, possibly from virtual table generation"
20341 " (use -ftemplate-depth= to increase the maximum)",
20342 max_tinst_depth
, decl
);
20343 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20344 /* Pretend that we defined it. */
20345 DECL_INITIAL (decl
) = error_mark_node
;
20351 struct pending_template
**t
= &pending_templates
;
20352 struct pending_template
*last
= NULL
;
20356 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20357 bool complete
= false;
20359 if (TYPE_P (instantiation
))
20363 if (!COMPLETE_TYPE_P (instantiation
))
20365 instantiate_class_template (instantiation
);
20366 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20367 for (fn
= TYPE_METHODS (instantiation
);
20369 fn
= TREE_CHAIN (fn
))
20370 if (! DECL_ARTIFICIAL (fn
))
20371 instantiate_decl (fn
,
20373 /*expl_inst_class_mem_p=*/false);
20374 if (COMPLETE_TYPE_P (instantiation
))
20378 complete
= COMPLETE_TYPE_P (instantiation
);
20382 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20383 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20386 = instantiate_decl (instantiation
,
20388 /*expl_inst_class_mem_p=*/false);
20389 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20393 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20394 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20398 /* If INSTANTIATION has been instantiated, then we don't
20399 need to consider it again in the future. */
20407 current_tinst_level
= NULL
;
20409 last_pending_template
= last
;
20411 while (reconsider
);
20413 input_location
= saved_loc
;
20416 /* Substitute ARGVEC into T, which is a list of initializers for
20417 either base class or a non-static data member. The TREE_PURPOSEs
20418 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20419 instantiate_decl. */
20422 tsubst_initializer_list (tree t
, tree argvec
)
20424 tree inits
= NULL_TREE
;
20426 for (; t
; t
= TREE_CHAIN (t
))
20430 tree expanded_bases
= NULL_TREE
;
20431 tree expanded_arguments
= NULL_TREE
;
20434 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20439 /* Expand the base class expansion type into separate base
20441 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20442 tf_warning_or_error
,
20444 if (expanded_bases
== error_mark_node
)
20447 /* We'll be building separate TREE_LISTs of arguments for
20449 len
= TREE_VEC_LENGTH (expanded_bases
);
20450 expanded_arguments
= make_tree_vec (len
);
20451 for (i
= 0; i
< len
; i
++)
20452 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20454 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20455 expand each argument in the TREE_VALUE of t. */
20456 expr
= make_node (EXPR_PACK_EXPANSION
);
20457 PACK_EXPANSION_LOCAL_P (expr
) = true;
20458 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20459 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20461 if (TREE_VALUE (t
) == void_type_node
)
20462 /* VOID_TYPE_NODE is used to indicate
20463 value-initialization. */
20465 for (i
= 0; i
< len
; i
++)
20466 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20470 /* Substitute parameter packs into each argument in the
20472 in_base_initializer
= 1;
20473 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20475 tree expanded_exprs
;
20477 /* Expand the argument. */
20478 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20480 = tsubst_pack_expansion (expr
, argvec
,
20481 tf_warning_or_error
,
20483 if (expanded_exprs
== error_mark_node
)
20486 /* Prepend each of the expanded expressions to the
20487 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20488 for (i
= 0; i
< len
; i
++)
20490 TREE_VEC_ELT (expanded_arguments
, i
) =
20491 tree_cons (NULL_TREE
,
20492 TREE_VEC_ELT (expanded_exprs
, i
),
20493 TREE_VEC_ELT (expanded_arguments
, i
));
20496 in_base_initializer
= 0;
20498 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20499 since we built them backwards. */
20500 for (i
= 0; i
< len
; i
++)
20502 TREE_VEC_ELT (expanded_arguments
, i
) =
20503 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20508 for (i
= 0; i
< len
; ++i
)
20510 if (expanded_bases
)
20512 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20513 decl
= expand_member_init (decl
);
20514 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20519 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20520 tf_warning_or_error
, NULL_TREE
);
20522 decl
= expand_member_init (decl
);
20523 if (decl
&& !DECL_P (decl
))
20524 in_base_initializer
= 1;
20526 init
= TREE_VALUE (t
);
20528 if (init
!= void_type_node
)
20529 init
= tsubst_expr (init
, argvec
,
20530 tf_warning_or_error
, NULL_TREE
,
20531 /*integral_constant_expression_p=*/false);
20532 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20533 /* If we had an initializer but it instantiated to nothing,
20534 value-initialize the object. This will only occur when
20535 the initializer was a pack expansion where the parameter
20536 packs used in that expansion were of length zero. */
20537 init
= void_type_node
;
20538 in_base_initializer
= 0;
20543 init
= build_tree_list (decl
, init
);
20544 TREE_CHAIN (init
) = inits
;
20552 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20555 set_current_access_from_decl (tree decl
)
20557 if (TREE_PRIVATE (decl
))
20558 current_access_specifier
= access_private_node
;
20559 else if (TREE_PROTECTED (decl
))
20560 current_access_specifier
= access_protected_node
;
20562 current_access_specifier
= access_public_node
;
20565 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20566 is the instantiation (which should have been created with
20567 start_enum) and ARGS are the template arguments to use. */
20570 tsubst_enum (tree tag
, tree newtag
, tree args
)
20574 if (SCOPED_ENUM_P (newtag
))
20575 begin_scope (sk_scoped_enum
, newtag
);
20577 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20582 decl
= TREE_VALUE (e
);
20583 /* Note that in a template enum, the TREE_VALUE is the
20584 CONST_DECL, not the corresponding INTEGER_CST. */
20585 value
= tsubst_expr (DECL_INITIAL (decl
),
20586 args
, tf_warning_or_error
, NULL_TREE
,
20587 /*integral_constant_expression_p=*/true);
20589 /* Give this enumeration constant the correct access. */
20590 set_current_access_from_decl (decl
);
20592 /* Actually build the enumerator itself. */
20594 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
20597 if (SCOPED_ENUM_P (newtag
))
20600 finish_enum_value_list (newtag
);
20601 finish_enum (newtag
);
20603 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20604 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20607 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20608 its type -- but without substituting the innermost set of template
20609 arguments. So, innermost set of template parameters will appear in
20613 get_mostly_instantiated_function_type (tree decl
)
20621 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
20622 targs
= DECL_TI_ARGS (decl
);
20623 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
20624 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
20626 /* There should be as many levels of arguments as there are levels
20628 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
20630 fn_type
= TREE_TYPE (tmpl
);
20632 if (parm_depth
== 1)
20633 /* No substitution is necessary. */
20640 /* Replace the innermost level of the TARGS with NULL_TREEs to
20641 let tsubst know not to substitute for those parameters. */
20642 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20643 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
20644 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
20645 TMPL_ARGS_LEVEL (targs
, i
));
20646 SET_TMPL_ARGS_LEVEL (partial_args
,
20647 TMPL_ARGS_DEPTH (targs
),
20648 make_tree_vec (DECL_NTPARMS (tmpl
)));
20650 /* Make sure that we can see identifiers, and compute access
20652 push_access_scope (decl
);
20654 ++processing_template_decl
;
20655 /* Now, do the (partial) substitution to figure out the
20656 appropriate function type. */
20657 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
20658 --processing_template_decl
;
20660 /* Substitute into the template parameters to obtain the real
20661 innermost set of parameters. This step is important if the
20662 innermost set of template parameters contains value
20663 parameters whose types depend on outer template parameters. */
20664 TREE_VEC_LENGTH (partial_args
)--;
20665 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
20667 pop_access_scope (decl
);
20673 /* Return truthvalue if we're processing a template different from
20674 the last one involved in diagnostics. */
20676 problematic_instantiation_changed (void)
20678 return current_tinst_level
!= last_error_tinst_level
;
20681 /* Remember current template involved in diagnostics. */
20683 record_last_problematic_instantiation (void)
20685 last_error_tinst_level
= current_tinst_level
;
20688 struct tinst_level
*
20689 current_instantiation (void)
20691 return current_tinst_level
;
20694 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20695 type. Return zero for ok, nonzero for disallowed. Issue error and
20696 warning messages under control of COMPLAIN. */
20699 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20701 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20703 else if (POINTER_TYPE_P (type
))
20705 else if (TYPE_PTRMEM_P (type
))
20707 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20709 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20711 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20713 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20716 if (complain
& tf_error
)
20718 if (type
== error_mark_node
)
20719 inform (input_location
, "invalid template non-type parameter");
20721 error ("%q#T is not a valid type for a template non-type parameter",
20727 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20728 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20731 dependent_type_p_r (tree type
)
20737 A type is dependent if it is:
20739 -- a template parameter. Template template parameters are types
20740 for us (since TYPE_P holds true for them) so we handle
20742 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20743 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20745 /* -- a qualified-id with a nested-name-specifier which contains a
20746 class-name that names a dependent type or whose unqualified-id
20747 names a dependent type. */
20748 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20750 /* -- a cv-qualified type where the cv-unqualified type is
20752 No code is necessary for this bullet; the code below handles
20753 cv-qualified types, and we don't want to strip aliases with
20754 TYPE_MAIN_VARIANT because of DR 1558. */
20755 /* -- a compound type constructed from any dependent type. */
20756 if (TYPE_PTRMEM_P (type
))
20757 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20758 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20760 else if (TYPE_PTR_P (type
)
20761 || TREE_CODE (type
) == REFERENCE_TYPE
)
20762 return dependent_type_p (TREE_TYPE (type
));
20763 else if (TREE_CODE (type
) == FUNCTION_TYPE
20764 || TREE_CODE (type
) == METHOD_TYPE
)
20768 if (dependent_type_p (TREE_TYPE (type
)))
20770 for (arg_type
= TYPE_ARG_TYPES (type
);
20772 arg_type
= TREE_CHAIN (arg_type
))
20773 if (dependent_type_p (TREE_VALUE (arg_type
)))
20777 /* -- an array type constructed from any dependent type or whose
20778 size is specified by a constant expression that is
20781 We checked for type- and value-dependence of the bounds in
20782 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20783 if (TREE_CODE (type
) == ARRAY_TYPE
)
20785 if (TYPE_DOMAIN (type
)
20786 && dependent_type_p (TYPE_DOMAIN (type
)))
20788 return dependent_type_p (TREE_TYPE (type
));
20791 /* -- a template-id in which either the template name is a template
20793 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20795 /* ... or any of the template arguments is a dependent type or
20796 an expression that is type-dependent or value-dependent. */
20797 else if (TYPE_TEMPLATE_INFO (type
)
20798 && (any_dependent_template_arguments_p
20799 (INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (type
)))))
20802 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20803 dependent; if the argument of the `typeof' expression is not
20804 type-dependent, then it should already been have resolved. */
20805 if (TREE_CODE (type
) == TYPEOF_TYPE
20806 || TREE_CODE (type
) == DECLTYPE_TYPE
20807 || TREE_CODE (type
) == UNDERLYING_TYPE
)
20810 /* A template argument pack is dependent if any of its packed
20812 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
20814 tree args
= ARGUMENT_PACK_ARGS (type
);
20815 int i
, len
= TREE_VEC_LENGTH (args
);
20816 for (i
= 0; i
< len
; ++i
)
20817 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20821 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20822 be template parameters. */
20823 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
20826 /* The standard does not specifically mention types that are local
20827 to template functions or local classes, but they should be
20828 considered dependent too. For example:
20830 template <int I> void f() {
20835 The size of `E' cannot be known until the value of `I' has been
20836 determined. Therefore, `E' must be considered dependent. */
20837 scope
= TYPE_CONTEXT (type
);
20838 if (scope
&& TYPE_P (scope
))
20839 return dependent_type_p (scope
);
20840 /* Don't use type_dependent_expression_p here, as it can lead
20841 to infinite recursion trying to determine whether a lambda
20842 nested in a lambda is dependent (c++/47687). */
20843 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
20844 && DECL_LANG_SPECIFIC (scope
)
20845 && DECL_TEMPLATE_INFO (scope
)
20846 && (any_dependent_template_arguments_p
20847 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
20850 /* Other types are non-dependent. */
20854 /* Returns TRUE if TYPE is dependent, in the sense of
20855 [temp.dep.type]. Note that a NULL type is considered dependent. */
20858 dependent_type_p (tree type
)
20860 /* If there are no template parameters in scope, then there can't be
20861 any dependent types. */
20862 if (!processing_template_decl
)
20864 /* If we are not processing a template, then nobody should be
20865 providing us with a dependent type. */
20867 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
20871 /* If the type is NULL, we have not computed a type for the entity
20872 in question; in that case, the type is dependent. */
20876 /* Erroneous types can be considered non-dependent. */
20877 if (type
== error_mark_node
)
20880 /* If we have not already computed the appropriate value for TYPE,
20882 if (!TYPE_DEPENDENT_P_VALID (type
))
20884 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
20885 TYPE_DEPENDENT_P_VALID (type
) = 1;
20888 return TYPE_DEPENDENT_P (type
);
20891 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20892 lookup. In other words, a dependent type that is not the current
20896 dependent_scope_p (tree scope
)
20898 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
20899 && !currently_open_class (scope
));
20902 /* T is a SCOPE_REF; return whether we need to consider it
20903 instantiation-dependent so that we can check access at instantiation
20904 time even though we know which member it resolves to. */
20907 instantiation_dependent_scope_ref_p (tree t
)
20909 if (DECL_P (TREE_OPERAND (t
, 1))
20910 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
20911 && accessible_in_template_p (TREE_OPERAND (t
, 0),
20912 TREE_OPERAND (t
, 1)))
20918 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20919 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20922 /* Note that this predicate is not appropriate for general expressions;
20923 only constant expressions (that satisfy potential_constant_expression)
20924 can be tested for value dependence. */
20927 value_dependent_expression_p (tree expression
)
20929 if (!processing_template_decl
)
20932 /* A name declared with a dependent type. */
20933 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
20936 switch (TREE_CODE (expression
))
20938 case IDENTIFIER_NODE
:
20939 /* A name that has not been looked up -- must be dependent. */
20942 case TEMPLATE_PARM_INDEX
:
20943 /* A non-type template parm. */
20947 /* A non-type template parm. */
20948 if (DECL_TEMPLATE_PARM_P (expression
))
20950 return value_dependent_expression_p (DECL_INITIAL (expression
));
20953 /* A constant with literal type and is initialized
20954 with an expression that is value-dependent.
20956 Note that a non-dependent parenthesized initializer will have
20957 already been replaced with its constant value, so if we see
20958 a TREE_LIST it must be dependent. */
20959 if (DECL_INITIAL (expression
)
20960 && decl_constant_var_p (expression
)
20961 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
20962 /* cp_finish_decl doesn't fold reference initializers. */
20963 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
20964 || value_dependent_expression_p (DECL_INITIAL (expression
))))
20968 case DYNAMIC_CAST_EXPR
:
20969 case STATIC_CAST_EXPR
:
20970 case CONST_CAST_EXPR
:
20971 case REINTERPRET_CAST_EXPR
:
20973 /* These expressions are value-dependent if the type to which
20974 the cast occurs is dependent or the expression being casted
20975 is value-dependent. */
20977 tree type
= TREE_TYPE (expression
);
20979 if (dependent_type_p (type
))
20982 /* A functional cast has a list of operands. */
20983 expression
= TREE_OPERAND (expression
, 0);
20986 /* If there are no operands, it must be an expression such
20987 as "int()". This should not happen for aggregate types
20988 because it would form non-constant expressions. */
20989 gcc_assert (cxx_dialect
>= cxx11
20990 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
20995 if (TREE_CODE (expression
) == TREE_LIST
)
20996 return any_value_dependent_elements_p (expression
);
20998 return value_dependent_expression_p (expression
);
21002 if (SIZEOF_EXPR_TYPE_P (expression
))
21003 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
21007 /* A `sizeof' expression is value-dependent if the operand is
21008 type-dependent or is a pack expansion. */
21009 expression
= TREE_OPERAND (expression
, 0);
21010 if (PACK_EXPANSION_P (expression
))
21012 else if (TYPE_P (expression
))
21013 return dependent_type_p (expression
);
21014 return instantiation_dependent_expression_p (expression
);
21016 case AT_ENCODE_EXPR
:
21017 /* An 'encode' expression is value-dependent if the operand is
21019 expression
= TREE_OPERAND (expression
, 0);
21020 return dependent_type_p (expression
);
21022 case NOEXCEPT_EXPR
:
21023 expression
= TREE_OPERAND (expression
, 0);
21024 return instantiation_dependent_expression_p (expression
);
21027 /* All instantiation-dependent expressions should also be considered
21028 value-dependent. */
21029 return instantiation_dependent_scope_ref_p (expression
);
21031 case COMPONENT_REF
:
21032 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
21033 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
21035 case NONTYPE_ARGUMENT_PACK
:
21036 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
21037 is value-dependent. */
21039 tree values
= ARGUMENT_PACK_ARGS (expression
);
21040 int i
, len
= TREE_VEC_LENGTH (values
);
21042 for (i
= 0; i
< len
; ++i
)
21043 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
21051 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
21052 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
21053 || (type2
? dependent_type_p (type2
) : false));
21057 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21058 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
21061 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21062 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
21066 tree op
= TREE_OPERAND (expression
, 0);
21067 return (value_dependent_expression_p (op
)
21068 || has_value_dependent_address (op
));
21073 tree fn
= get_callee_fndecl (expression
);
21075 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
21077 nargs
= call_expr_nargs (expression
);
21078 for (i
= 0; i
< nargs
; ++i
)
21080 tree op
= CALL_EXPR_ARG (expression
, i
);
21081 /* In a call to a constexpr member function, look through the
21082 implicit ADDR_EXPR on the object argument so that it doesn't
21083 cause the call to be considered value-dependent. We also
21084 look through it in potential_constant_expression. */
21085 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
21086 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
21087 && TREE_CODE (op
) == ADDR_EXPR
)
21088 op
= TREE_OPERAND (op
, 0);
21089 if (value_dependent_expression_p (op
))
21095 case TEMPLATE_ID_EXPR
:
21096 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21098 return type_dependent_expression_p (expression
);
21104 if (dependent_type_p (TREE_TYPE (expression
)))
21106 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
21107 if (value_dependent_expression_p (val
))
21113 /* Treat a GNU statement expression as dependent to avoid crashing
21114 under instantiate_non_dependent_expr; it can't be constant. */
21118 /* A constant expression is value-dependent if any subexpression is
21119 value-dependent. */
21120 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
21122 case tcc_reference
:
21124 case tcc_comparison
:
21126 case tcc_expression
:
21129 int i
, len
= cp_tree_operand_length (expression
);
21131 for (i
= 0; i
< len
; i
++)
21133 tree t
= TREE_OPERAND (expression
, i
);
21135 /* In some cases, some of the operands may be missing.l
21136 (For example, in the case of PREDECREMENT_EXPR, the
21137 amount to increment by may be missing.) That doesn't
21138 make the expression dependent. */
21139 if (t
&& value_dependent_expression_p (t
))
21150 /* The expression is not value-dependent. */
21154 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21155 [temp.dep.expr]. Note that an expression with no type is
21156 considered dependent. Other parts of the compiler arrange for an
21157 expression with type-dependent subexpressions to have no type, so
21158 this function doesn't have to be fully recursive. */
21161 type_dependent_expression_p (tree expression
)
21163 if (!processing_template_decl
)
21166 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
21169 /* An unresolved name is always dependent. */
21170 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
21173 /* Some expression forms are never type-dependent. */
21174 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
21175 || TREE_CODE (expression
) == SIZEOF_EXPR
21176 || TREE_CODE (expression
) == ALIGNOF_EXPR
21177 || TREE_CODE (expression
) == AT_ENCODE_EXPR
21178 || TREE_CODE (expression
) == NOEXCEPT_EXPR
21179 || TREE_CODE (expression
) == TRAIT_EXPR
21180 || TREE_CODE (expression
) == TYPEID_EXPR
21181 || TREE_CODE (expression
) == DELETE_EXPR
21182 || TREE_CODE (expression
) == VEC_DELETE_EXPR
21183 || TREE_CODE (expression
) == THROW_EXPR
)
21186 /* The types of these expressions depends only on the type to which
21187 the cast occurs. */
21188 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
21189 || TREE_CODE (expression
) == STATIC_CAST_EXPR
21190 || TREE_CODE (expression
) == CONST_CAST_EXPR
21191 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
21192 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
21193 || TREE_CODE (expression
) == CAST_EXPR
)
21194 return dependent_type_p (TREE_TYPE (expression
));
21196 /* The types of these expressions depends only on the type created
21197 by the expression. */
21198 if (TREE_CODE (expression
) == NEW_EXPR
21199 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
21201 /* For NEW_EXPR tree nodes created inside a template, either
21202 the object type itself or a TREE_LIST may appear as the
21204 tree type
= TREE_OPERAND (expression
, 1);
21205 if (TREE_CODE (type
) == TREE_LIST
)
21206 /* This is an array type. We need to check array dimensions
21208 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
21209 || value_dependent_expression_p
21210 (TREE_OPERAND (TREE_VALUE (type
), 1));
21212 return dependent_type_p (type
);
21215 if (TREE_CODE (expression
) == SCOPE_REF
)
21217 tree scope
= TREE_OPERAND (expression
, 0);
21218 tree name
= TREE_OPERAND (expression
, 1);
21220 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21221 contains an identifier associated by name lookup with one or more
21222 declarations declared with a dependent type, or...a
21223 nested-name-specifier or qualified-id that names a member of an
21224 unknown specialization. */
21225 return (type_dependent_expression_p (name
)
21226 || dependent_scope_p (scope
));
21229 if (TREE_CODE (expression
) == FUNCTION_DECL
21230 && DECL_LANG_SPECIFIC (expression
)
21231 && DECL_TEMPLATE_INFO (expression
)
21232 && (any_dependent_template_arguments_p
21233 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
21236 if (TREE_CODE (expression
) == TEMPLATE_DECL
21237 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
21240 if (TREE_CODE (expression
) == STMT_EXPR
)
21241 expression
= stmt_expr_value_expr (expression
);
21243 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21248 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21250 if (type_dependent_expression_p (elt
))
21256 /* A static data member of the current instantiation with incomplete
21257 array type is type-dependent, as the definition and specializations
21258 can have different bounds. */
21259 if (VAR_P (expression
)
21260 && DECL_CLASS_SCOPE_P (expression
)
21261 && dependent_type_p (DECL_CONTEXT (expression
))
21262 && VAR_HAD_UNKNOWN_BOUND (expression
))
21265 /* An array of unknown bound depending on a variadic parameter, eg:
21267 template<typename... Args>
21268 void foo (Args... args)
21270 int arr[] = { args... };
21273 template<int... vals>
21276 int arr[] = { vals... };
21279 If the array has no length and has an initializer, it must be that
21280 we couldn't determine its length in cp_complete_array_type because
21281 it is dependent. */
21282 if (VAR_P (expression
)
21283 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21284 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21285 && DECL_INITIAL (expression
))
21288 if (TREE_TYPE (expression
) == unknown_type_node
)
21290 if (TREE_CODE (expression
) == ADDR_EXPR
)
21291 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21292 if (TREE_CODE (expression
) == COMPONENT_REF
21293 || TREE_CODE (expression
) == OFFSET_REF
)
21295 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21297 expression
= TREE_OPERAND (expression
, 1);
21298 if (identifier_p (expression
))
21301 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21302 if (TREE_CODE (expression
) == SCOPE_REF
)
21305 /* Always dependent, on the number of arguments if nothing else. */
21306 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21309 if (BASELINK_P (expression
))
21311 if (BASELINK_OPTYPE (expression
)
21312 && dependent_type_p (BASELINK_OPTYPE (expression
)))
21314 expression
= BASELINK_FUNCTIONS (expression
);
21317 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21319 if (any_dependent_template_arguments_p
21320 (TREE_OPERAND (expression
, 1)))
21322 expression
= TREE_OPERAND (expression
, 0);
21324 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21325 || TREE_CODE (expression
) == FUNCTION_DECL
);
21329 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21331 expression
= OVL_NEXT (expression
);
21336 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21338 return (dependent_type_p (TREE_TYPE (expression
)));
21341 /* walk_tree callback function for instantiation_dependent_expression_p,
21342 below. Returns non-zero if a dependent subexpression is found. */
21345 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21350 /* We don't have to worry about decltype currently because decltype
21351 of an instantiation-dependent expr is a dependent type. This
21352 might change depending on the resolution of DR 1172. */
21353 *walk_subtrees
= false;
21356 enum tree_code code
= TREE_CODE (*tp
);
21359 /* Don't treat an argument list as dependent just because it has no
21367 /* A constant with a dependent initializer is dependent. */
21368 if (value_dependent_expression_p (*tp
))
21372 case TEMPLATE_PARM_INDEX
:
21375 /* Handle expressions with type operands. */
21379 case AT_ENCODE_EXPR
:
21381 tree op
= TREE_OPERAND (*tp
, 0);
21382 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21383 op
= TREE_TYPE (op
);
21386 if (dependent_type_p (op
))
21390 *walk_subtrees
= false;
21398 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21399 || (TRAIT_EXPR_TYPE2 (*tp
)
21400 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21402 *walk_subtrees
= false;
21405 case COMPONENT_REF
:
21406 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21407 /* In a template, finish_class_member_access_expr creates a
21408 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21409 type-dependent, so that we can check access control at
21410 instantiation time (PR 42277). See also Core issue 1273. */
21415 if (instantiation_dependent_scope_ref_p (*tp
))
21420 /* Treat statement-expressions as dependent. */
21428 if (type_dependent_expression_p (*tp
))
21434 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21435 sense defined by the ABI:
21437 "An expression is instantiation-dependent if it is type-dependent
21438 or value-dependent, or it has a subexpression that is type-dependent
21439 or value-dependent." */
21442 instantiation_dependent_expression_p (tree expression
)
21446 if (!processing_template_decl
)
21449 if (expression
== error_mark_node
)
21452 result
= cp_walk_tree_without_duplicates (&expression
,
21453 instantiation_dependent_r
, NULL
);
21454 return result
!= NULL_TREE
;
21457 /* Like type_dependent_expression_p, but it also works while not processing
21458 a template definition, i.e. during substitution or mangling. */
21461 type_dependent_expression_p_push (tree expr
)
21464 ++processing_template_decl
;
21465 b
= type_dependent_expression_p (expr
);
21466 --processing_template_decl
;
21470 /* Returns TRUE if ARGS contains a type-dependent expression. */
21473 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21478 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21480 if (type_dependent_expression_p (arg
))
21486 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21487 expressions) contains any type-dependent expressions. */
21490 any_type_dependent_elements_p (const_tree list
)
21492 for (; list
; list
= TREE_CHAIN (list
))
21493 if (type_dependent_expression_p (TREE_VALUE (list
)))
21499 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21500 expressions) contains any value-dependent expressions. */
21503 any_value_dependent_elements_p (const_tree list
)
21505 for (; list
; list
= TREE_CHAIN (list
))
21506 if (value_dependent_expression_p (TREE_VALUE (list
)))
21512 /* Returns TRUE if the ARG (a template argument) is dependent. */
21515 dependent_template_arg_p (tree arg
)
21517 if (!processing_template_decl
)
21520 /* Assume a template argument that was wrongly written by the user
21521 is dependent. This is consistent with what
21522 any_dependent_template_arguments_p [that calls this function]
21524 if (!arg
|| arg
== error_mark_node
)
21527 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21528 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21530 if (TREE_CODE (arg
) == TEMPLATE_DECL
21531 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21532 return dependent_template_p (arg
);
21533 else if (ARGUMENT_PACK_P (arg
))
21535 tree args
= ARGUMENT_PACK_ARGS (arg
);
21536 int i
, len
= TREE_VEC_LENGTH (args
);
21537 for (i
= 0; i
< len
; ++i
)
21539 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21545 else if (TYPE_P (arg
))
21546 return dependent_type_p (arg
);
21548 return (type_dependent_expression_p (arg
)
21549 || value_dependent_expression_p (arg
));
21552 /* Returns true if ARGS (a collection of template arguments) contains
21553 any types that require structural equality testing. */
21556 any_template_arguments_need_structural_equality_p (tree args
)
21563 if (args
== error_mark_node
)
21566 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21568 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21569 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21571 tree arg
= TREE_VEC_ELT (level
, j
);
21572 tree packed_args
= NULL_TREE
;
21575 if (ARGUMENT_PACK_P (arg
))
21577 /* Look inside the argument pack. */
21578 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21579 len
= TREE_VEC_LENGTH (packed_args
);
21582 for (k
= 0; k
< len
; ++k
)
21585 arg
= TREE_VEC_ELT (packed_args
, k
);
21587 if (error_operand_p (arg
))
21589 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21591 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21593 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21594 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21603 /* Returns true if ARGS (a collection of template arguments) contains
21604 any dependent arguments. */
21607 any_dependent_template_arguments_p (const_tree args
)
21614 if (args
== error_mark_node
)
21617 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21619 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21620 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21621 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21628 /* Returns TRUE if the template TMPL is dependent. */
21631 dependent_template_p (tree tmpl
)
21633 if (TREE_CODE (tmpl
) == OVERLOAD
)
21637 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21639 tmpl
= OVL_NEXT (tmpl
);
21644 /* Template template parameters are dependent. */
21645 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21646 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21648 /* So are names that have not been looked up. */
21649 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21651 /* So are member templates of dependent classes. */
21652 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21653 return dependent_type_p (DECL_CONTEXT (tmpl
));
21657 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21660 dependent_template_id_p (tree tmpl
, tree args
)
21662 return (dependent_template_p (tmpl
)
21663 || any_dependent_template_arguments_p (args
));
21666 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21670 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21674 if (!processing_template_decl
)
21677 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21679 tree decl
= TREE_VEC_ELT (declv
, i
);
21680 tree init
= TREE_VEC_ELT (initv
, i
);
21681 tree cond
= TREE_VEC_ELT (condv
, i
);
21682 tree incr
= TREE_VEC_ELT (incrv
, i
);
21684 if (type_dependent_expression_p (decl
))
21687 if (init
&& type_dependent_expression_p (init
))
21690 if (type_dependent_expression_p (cond
))
21693 if (COMPARISON_CLASS_P (cond
)
21694 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21695 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21698 if (TREE_CODE (incr
) == MODOP_EXPR
)
21700 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21701 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21704 else if (type_dependent_expression_p (incr
))
21706 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21708 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21710 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21712 tree t
= TREE_OPERAND (incr
, 1);
21713 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21714 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21723 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21724 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21725 no such TYPE can be found. Note that this function peers inside
21726 uninstantiated templates and therefore should be used only in
21727 extremely limited situations. ONLY_CURRENT_P restricts this
21728 peering to the currently open classes hierarchy (which is required
21729 when comparing types). */
21732 resolve_typename_type (tree type
, bool only_current_p
)
21741 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21743 scope
= TYPE_CONTEXT (type
);
21744 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21745 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21746 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21747 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21748 identifier of the TYPENAME_TYPE anymore.
21749 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21750 TYPENAME_TYPE instead, we avoid messing up with a possible
21751 typedef variant case. */
21752 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21754 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21755 it first before we can figure out what NAME refers to. */
21756 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21758 if (TYPENAME_IS_RESOLVING_P (scope
))
21759 /* Given a class template A with a dependent base with nested type C,
21760 typedef typename A::C::C C will land us here, as trying to resolve
21761 the initial A::C leads to the local C typedef, which leads back to
21762 A::C::C. So we break the recursion now. */
21765 scope
= resolve_typename_type (scope
, only_current_p
);
21767 /* If we don't know what SCOPE refers to, then we cannot resolve the
21769 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21771 /* If the SCOPE is a template type parameter, we have no way of
21772 resolving the name. */
21773 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21775 /* If the SCOPE is not the current instantiation, there's no reason
21776 to look inside it. */
21777 if (only_current_p
&& !currently_open_class (scope
))
21779 /* If this is a typedef, we don't want to look inside (c++/11987). */
21780 if (typedef_variant_p (type
))
21782 /* If SCOPE isn't the template itself, it will not have a valid
21783 TYPE_FIELDS list. */
21784 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21785 /* scope is either the template itself or a compatible instantiation
21786 like X<T>, so look up the name in the original template. */
21787 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
21789 /* scope is a partial instantiation, so we can't do the lookup or we
21790 will lose the template arguments. */
21792 /* Enter the SCOPE so that name lookup will be resolved as if we
21793 were in the class definition. In particular, SCOPE will no
21794 longer be considered a dependent type. */
21795 pushed_scope
= push_scope (scope
);
21796 /* Look up the declaration. */
21797 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
21798 tf_warning_or_error
);
21800 result
= NULL_TREE
;
21802 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21803 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21806 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
21807 && TREE_CODE (decl
) == TYPE_DECL
)
21809 result
= TREE_TYPE (decl
);
21810 if (result
== error_mark_node
)
21811 result
= NULL_TREE
;
21813 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
21814 && DECL_CLASS_TEMPLATE_P (decl
))
21818 /* Obtain the template and the arguments. */
21819 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
21820 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
21821 /* Instantiate the template. */
21822 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
21823 /*entering_scope=*/0,
21824 tf_error
| tf_user
);
21825 if (result
== error_mark_node
)
21826 result
= NULL_TREE
;
21829 /* Leave the SCOPE. */
21831 pop_scope (pushed_scope
);
21833 /* If we failed to resolve it, return the original typename. */
21837 /* If lookup found a typename type, resolve that too. */
21838 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
21840 /* Ill-formed programs can cause infinite recursion here, so we
21841 must catch that. */
21842 TYPENAME_IS_RESOLVING_P (type
) = 1;
21843 result
= resolve_typename_type (result
, only_current_p
);
21844 TYPENAME_IS_RESOLVING_P (type
) = 0;
21847 /* Qualify the resulting type. */
21848 quals
= cp_type_quals (type
);
21850 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
21855 /* EXPR is an expression which is not type-dependent. Return a proxy
21856 for EXPR that can be used to compute the types of larger
21857 expressions containing EXPR. */
21860 build_non_dependent_expr (tree expr
)
21864 #ifdef ENABLE_CHECKING
21865 /* Try to get a constant value for all non-dependent expressions in
21866 order to expose bugs in *_dependent_expression_p and constexpr. */
21867 if (cxx_dialect
>= cxx11
)
21868 fold_non_dependent_expr (expr
);
21871 /* Preserve OVERLOADs; the functions must be available to resolve
21874 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
21875 inner_expr
= stmt_expr_value_expr (inner_expr
);
21876 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
21877 inner_expr
= TREE_OPERAND (inner_expr
, 0);
21878 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
21879 inner_expr
= TREE_OPERAND (inner_expr
, 1);
21880 if (is_overloaded_fn (inner_expr
)
21881 || TREE_CODE (inner_expr
) == OFFSET_REF
)
21883 /* There is no need to return a proxy for a variable. */
21886 /* Preserve string constants; conversions from string constants to
21887 "char *" are allowed, even though normally a "const char *"
21888 cannot be used to initialize a "char *". */
21889 if (TREE_CODE (expr
) == STRING_CST
)
21891 /* Preserve void and arithmetic constants, as an optimization -- there is no
21892 reason to create a new node. */
21893 if (TREE_CODE (expr
) == VOID_CST
21894 || TREE_CODE (expr
) == INTEGER_CST
21895 || TREE_CODE (expr
) == REAL_CST
)
21897 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21898 There is at least one place where we want to know that a
21899 particular expression is a throw-expression: when checking a ?:
21900 expression, there are special rules if the second or third
21901 argument is a throw-expression. */
21902 if (TREE_CODE (expr
) == THROW_EXPR
)
21905 /* Don't wrap an initializer list, we need to be able to look inside. */
21906 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
21909 /* Don't wrap a dummy object, we need to be able to test for it. */
21910 if (is_dummy_object (expr
))
21913 if (TREE_CODE (expr
) == COND_EXPR
)
21914 return build3 (COND_EXPR
,
21916 TREE_OPERAND (expr
, 0),
21917 (TREE_OPERAND (expr
, 1)
21918 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
21919 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
21920 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
21921 if (TREE_CODE (expr
) == COMPOUND_EXPR
21922 && !COMPOUND_EXPR_OVERLOADED (expr
))
21923 return build2 (COMPOUND_EXPR
,
21925 TREE_OPERAND (expr
, 0),
21926 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
21928 /* If the type is unknown, it can't really be non-dependent */
21929 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
21931 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21932 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
21935 /* ARGS is a vector of expressions as arguments to a function call.
21936 Replace the arguments with equivalent non-dependent expressions.
21937 This modifies ARGS in place. */
21940 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
21945 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
21947 tree newarg
= build_non_dependent_expr (arg
);
21949 (*args
)[ix
] = newarg
;
21953 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21954 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21958 make_auto_1 (tree name
)
21960 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
21961 TYPE_NAME (au
) = build_decl (input_location
,
21962 TYPE_DECL
, name
, au
);
21963 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
21964 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
21965 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
21966 TYPE_NAME (au
), NULL_TREE
);
21967 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
21968 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
21969 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
21975 make_decltype_auto (void)
21977 return make_auto_1 (get_identifier ("decltype(auto)"));
21983 return make_auto_1 (get_identifier ("auto"));
21986 /* Given type ARG, return std::initializer_list<ARG>. */
21991 tree std_init_list
= namespace_binding
21992 (get_identifier ("initializer_list"), std_node
);
21994 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
21996 error ("deducing from brace-enclosed initializer list requires "
21997 "#include <initializer_list>");
21998 return error_mark_node
;
22000 argvec
= make_tree_vec (1);
22001 TREE_VEC_ELT (argvec
, 0) = arg
;
22002 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
22003 NULL_TREE
, 0, tf_warning_or_error
);
22006 /* Replace auto in TYPE with std::initializer_list<auto>. */
22009 listify_autos (tree type
, tree auto_node
)
22011 tree init_auto
= listify (auto_node
);
22012 tree argvec
= make_tree_vec (1);
22013 TREE_VEC_ELT (argvec
, 0) = init_auto
;
22014 if (processing_template_decl
)
22015 argvec
= add_to_template_args (current_template_args (), argvec
);
22016 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22019 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
22020 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
22023 do_auto_deduction (tree type
, tree init
, tree auto_node
)
22027 if (init
== error_mark_node
)
22028 return error_mark_node
;
22030 if (type_dependent_expression_p (init
))
22031 /* Defining a subset of type-dependent expressions that we can deduce
22032 from ahead of time isn't worth the trouble. */
22035 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
22036 with either a new invented type template parameter U or, if the
22037 initializer is a braced-init-list (8.5.4), with
22038 std::initializer_list<U>. */
22039 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
22040 type
= listify_autos (type
, auto_node
);
22042 init
= resolve_nondeduced_context (init
);
22044 targs
= make_tree_vec (1);
22045 if (AUTO_IS_DECLTYPE (auto_node
))
22047 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
22048 && !REF_PARENTHESIZED_P (init
)));
22049 TREE_VEC_ELT (targs
, 0)
22050 = finish_decltype_type (init
, id
, tf_warning_or_error
);
22051 if (type
!= auto_node
)
22053 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
22054 return error_mark_node
;
22059 tree parms
= build_tree_list (NULL_TREE
, type
);
22060 tree tparms
= make_tree_vec (1);
22063 TREE_VEC_ELT (tparms
, 0)
22064 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
22065 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
22066 DEDUCE_CALL
, LOOKUP_NORMAL
,
22067 NULL
, /*explain_p=*/false);
22070 if (processing_template_decl
)
22071 /* Try again at instantiation time. */
22073 if (type
&& type
!= error_mark_node
)
22074 /* If type is error_mark_node a diagnostic must have been
22075 emitted by now. Also, having a mention to '<type error>'
22076 in the diagnostic is not really useful to the user. */
22078 if (cfun
&& auto_node
== current_function_auto_return_pattern
22079 && LAMBDA_FUNCTION_P (current_function_decl
))
22080 error ("unable to deduce lambda return type from %qE", init
);
22082 error ("unable to deduce %qT from %qE", type
, init
);
22084 return error_mark_node
;
22088 /* If the list of declarators contains more than one declarator, the type
22089 of each declared variable is determined as described above. If the
22090 type deduced for the template parameter U is not the same in each
22091 deduction, the program is ill-formed. */
22092 if (TREE_TYPE (auto_node
)
22093 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
22095 if (cfun
&& auto_node
== current_function_auto_return_pattern
22096 && LAMBDA_FUNCTION_P (current_function_decl
))
22097 error ("inconsistent types %qT and %qT deduced for "
22098 "lambda return type", TREE_TYPE (auto_node
),
22099 TREE_VEC_ELT (targs
, 0));
22101 error ("inconsistent deduction for %qT: %qT and then %qT",
22102 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
22103 return error_mark_node
;
22105 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
22107 if (processing_template_decl
)
22108 targs
= add_to_template_args (current_template_args (), targs
);
22109 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
22112 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22116 splice_late_return_type (tree type
, tree late_return_type
)
22120 if (late_return_type
== NULL_TREE
)
22122 argvec
= make_tree_vec (1);
22123 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
22124 if (processing_template_parmlist
)
22125 /* For a late-specified return type in a template type-parameter, we
22126 need to add a dummy argument level for its parmlist. */
22127 argvec
= add_to_template_args
22128 (make_tree_vec (processing_template_parmlist
), argvec
);
22129 if (current_template_parms
)
22130 argvec
= add_to_template_args (current_template_args (), argvec
);
22131 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22134 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22135 'decltype(auto)'. */
22138 is_auto (const_tree type
)
22140 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
22141 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
22142 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
22148 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22149 a use of `auto'. Returns NULL_TREE otherwise. */
22152 type_uses_auto (tree type
)
22154 return find_type_usage (type
, is_auto
);
22157 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22158 'decltype(auto)' or a concept. */
22161 is_auto_or_concept (const_tree type
)
22163 return is_auto (type
); // or concept
22166 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22167 a concept identifier) iff TYPE contains a use of a generic type. Returns
22168 NULL_TREE otherwise. */
22171 type_uses_auto_or_concept (tree type
)
22173 return find_type_usage (type
, is_auto_or_concept
);
22177 /* For a given template T, return the vector of typedefs referenced
22178 in T for which access check is needed at T instantiation time.
22179 T is either a FUNCTION_DECL or a RECORD_TYPE.
22180 Those typedefs were added to T by the function
22181 append_type_to_template_for_access_check. */
22183 vec
<qualified_typedef_usage_t
, va_gc
> *
22184 get_types_needing_access_check (tree t
)
22187 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
22189 if (!t
|| t
== error_mark_node
)
22192 if (!(ti
= get_template_info (t
)))
22195 if (CLASS_TYPE_P (t
)
22196 || TREE_CODE (t
) == FUNCTION_DECL
)
22198 if (!TI_TEMPLATE (ti
))
22201 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
22207 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22208 tied to T. That list of typedefs will be access checked at
22209 T instantiation time.
22210 T is either a FUNCTION_DECL or a RECORD_TYPE.
22211 TYPE_DECL is a TYPE_DECL node representing a typedef.
22212 SCOPE is the scope through which TYPE_DECL is accessed.
22213 LOCATION is the location of the usage point of TYPE_DECL.
22215 This function is a subroutine of
22216 append_type_to_template_for_access_check. */
22219 append_type_to_template_for_access_check_1 (tree t
,
22222 location_t location
)
22224 qualified_typedef_usage_t typedef_usage
;
22227 if (!t
|| t
== error_mark_node
)
22230 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
22231 || CLASS_TYPE_P (t
))
22233 && TREE_CODE (type_decl
) == TYPE_DECL
22236 if (!(ti
= get_template_info (t
)))
22239 gcc_assert (TI_TEMPLATE (ti
));
22241 typedef_usage
.typedef_decl
= type_decl
;
22242 typedef_usage
.context
= scope
;
22243 typedef_usage
.locus
= location
;
22245 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22248 /* Append TYPE_DECL to the template TEMPL.
22249 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22250 At TEMPL instanciation time, TYPE_DECL will be checked to see
22251 if it can be accessed through SCOPE.
22252 LOCATION is the location of the usage point of TYPE_DECL.
22254 e.g. consider the following code snippet:
22261 template<class U> struct S
22263 C::myint mi; // <-- usage point of the typedef C::myint
22268 At S<char> instantiation time, we need to check the access of C::myint
22269 In other words, we need to check the access of the myint typedef through
22270 the C scope. For that purpose, this function will add the myint typedef
22271 and the scope C through which its being accessed to a list of typedefs
22272 tied to the template S. That list will be walked at template instantiation
22273 time and access check performed on each typedefs it contains.
22274 Note that this particular code snippet should yield an error because
22275 myint is private to C. */
22278 append_type_to_template_for_access_check (tree templ
,
22281 location_t location
)
22283 qualified_typedef_usage_t
*iter
;
22286 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22288 /* Make sure we don't append the type to the template twice. */
22289 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22290 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22293 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22297 /* Convert the generic type parameters in PARM that match the types given in the
22298 range [START_IDX, END_IDX) from the current_template_parms into generic type
22302 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22304 tree current
= current_template_parms
;
22305 int depth
= TMPL_PARMS_DEPTH (current
);
22306 current
= INNERMOST_TEMPLATE_PARMS (current
);
22307 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22309 for (int i
= 0; i
< start_idx
; ++i
)
22310 TREE_VEC_ELT (replacement
, i
)
22311 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22313 for (int i
= start_idx
; i
< end_idx
; ++i
)
22315 /* Create a distinct parameter pack type from the current parm and add it
22316 to the replacement args to tsubst below into the generic function
22319 tree o
= TREE_TYPE (TREE_VALUE
22320 (TREE_VEC_ELT (current
, i
)));
22321 tree t
= copy_type (o
);
22322 TEMPLATE_TYPE_PARM_INDEX (t
)
22323 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22325 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22326 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22327 TYPE_MAIN_VARIANT (t
) = t
;
22328 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22329 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22330 TREE_VEC_ELT (replacement
, i
) = t
;
22331 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22334 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22335 TREE_VEC_ELT (replacement
, i
)
22336 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22338 /* If there are more levels then build up the replacement with the outer
22341 replacement
= add_to_template_args (template_parms_to_args
22342 (TREE_CHAIN (current_template_parms
)),
22345 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22349 /* Set up the hash tables for template instantiations. */
22352 init_template_processing (void)
22354 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22355 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
22358 /* Print stats about the template hash tables for -fstats. */
22361 print_template_statistics (void)
22363 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22364 "%f collisions\n", (long) decl_specializations
->size (),
22365 (long) decl_specializations
->elements (),
22366 decl_specializations
->collisions ());
22367 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22368 "%f collisions\n", (long) type_specializations
->size (),
22369 (long) type_specializations
->elements (),
22370 type_specializations
->collisions ());
22373 #include "gt-cp-pt.h"