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 typedef struct GTY(()) spec_entry
90 static GTY ((param_is (spec_entry
)))
91 htab_t decl_specializations
;
93 static GTY ((param_is (spec_entry
)))
94 htab_t type_specializations
;
96 /* Contains canonical template parameter types. The vector is indexed by
97 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
98 TREE_LIST, whose TREE_VALUEs contain the canonical template
99 parameters of various types and levels. */
100 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
102 #define UNIFY_ALLOW_NONE 0
103 #define UNIFY_ALLOW_MORE_CV_QUAL 1
104 #define UNIFY_ALLOW_LESS_CV_QUAL 2
105 #define UNIFY_ALLOW_DERIVED 4
106 #define UNIFY_ALLOW_INTEGER 8
107 #define UNIFY_ALLOW_OUTER_LEVEL 16
108 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
109 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
111 enum template_base_result
{
113 tbr_ambiguous_baseclass
,
117 static void push_access_scope (tree
);
118 static void pop_access_scope (tree
);
119 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
120 unification_kind_t
, int,
122 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
123 unification_kind_t
, int, bool, bool);
124 static int unify (tree
, tree
, tree
, tree
, int, bool);
125 static void add_pending_template (tree
);
126 static tree
reopen_tinst_level (struct tinst_level
*);
127 static tree
tsubst_initializer_list (tree
, tree
);
128 static tree
get_class_bindings (tree
, tree
, tree
, tree
);
129 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
131 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
133 static void tsubst_enum (tree
, tree
, tree
);
134 static tree
add_to_template_args (tree
, tree
);
135 static tree
add_outermost_template_args (tree
, tree
);
136 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
137 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
139 static int type_unification_real (tree
, tree
, tree
, const tree
*,
140 unsigned int, int, unification_kind_t
, int,
141 vec
<deferred_access_check
, va_gc
> **,
143 static void note_template_header (int);
144 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
145 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
146 static tree
convert_template_argument (tree
, tree
, tree
,
147 tsubst_flags_t
, int, tree
);
148 static int for_each_template_parm (tree
, tree_fn_t
, void*,
149 hash_set
<tree
> *, bool);
150 static tree
expand_template_argument_pack (tree
);
151 static tree
build_template_parm_index (int, int, int, tree
, tree
);
152 static bool inline_needs_template_parms (tree
, bool);
153 static void push_inline_template_parms_recursive (tree
, int);
154 static tree
retrieve_local_specialization (tree
);
155 static void register_local_specialization (tree
, tree
);
156 static hashval_t
hash_specialization (const void *p
);
157 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
158 static int mark_template_parm (tree
, void *);
159 static int template_parm_this_level_p (tree
, void *);
160 static tree
tsubst_friend_function (tree
, tree
);
161 static tree
tsubst_friend_class (tree
, tree
);
162 static int can_complete_type_without_circularity (tree
);
163 static tree
get_bindings (tree
, tree
, tree
, bool);
164 static int template_decl_level (tree
);
165 static int check_cv_quals_for_unify (int, tree
, tree
);
166 static void template_parm_level_and_index (tree
, int*, int*);
167 static int unify_pack_expansion (tree
, tree
, tree
,
168 tree
, unification_kind_t
, bool, bool);
169 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
170 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
171 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
172 static void regenerate_decl_from_template (tree
, tree
);
173 static tree
most_specialized_class (tree
, tsubst_flags_t
);
174 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
175 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
176 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
177 static bool check_specialization_scope (void);
178 static tree
process_partial_specialization (tree
);
179 static void set_current_access_from_decl (tree
);
180 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
182 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
183 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
185 static bool template_template_parm_bindings_ok_p (tree
, tree
);
186 static int template_args_equal (tree
, tree
);
187 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
188 static tree
for_each_template_parm_r (tree
*, int *, void *);
189 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
190 static void copy_default_args_to_explicit_spec (tree
);
191 static int invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
192 static bool dependent_template_arg_p (tree
);
193 static bool any_template_arguments_need_structural_equality_p (tree
);
194 static bool dependent_type_p_r (tree
);
195 static tree
tsubst_expr (tree
, tree
, tsubst_flags_t
, tree
, bool);
196 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
197 static tree
tsubst_pack_expansion (tree
, tree
, tsubst_flags_t
, tree
);
198 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
199 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
200 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
202 static tree
listify (tree
);
203 static tree
listify_autos (tree
, tree
);
204 static tree
template_parm_to_arg (tree t
);
205 static tree
current_template_args (void);
206 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
207 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
209 /* Make the current scope suitable for access checking when we are
210 processing T. T can be FUNCTION_DECL for instantiated function
211 template, VAR_DECL for static member variable, or TYPE_DECL for
212 alias template (needed by instantiate_decl). */
215 push_access_scope (tree t
)
217 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
218 || TREE_CODE (t
) == TYPE_DECL
);
220 if (DECL_FRIEND_CONTEXT (t
))
221 push_nested_class (DECL_FRIEND_CONTEXT (t
));
222 else if (DECL_CLASS_SCOPE_P (t
))
223 push_nested_class (DECL_CONTEXT (t
));
225 push_to_top_level ();
227 if (TREE_CODE (t
) == FUNCTION_DECL
)
229 saved_access_scope
= tree_cons
230 (NULL_TREE
, current_function_decl
, saved_access_scope
);
231 current_function_decl
= t
;
235 /* Restore the scope set up by push_access_scope. T is the node we
239 pop_access_scope (tree t
)
241 if (TREE_CODE (t
) == FUNCTION_DECL
)
243 current_function_decl
= TREE_VALUE (saved_access_scope
);
244 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
247 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
250 pop_from_top_level ();
253 /* Do any processing required when DECL (a member template
254 declaration) is finished. Returns the TEMPLATE_DECL corresponding
255 to DECL, unless it is a specialization, in which case the DECL
256 itself is returned. */
259 finish_member_template_decl (tree decl
)
261 if (decl
== error_mark_node
)
262 return error_mark_node
;
264 gcc_assert (DECL_P (decl
));
266 if (TREE_CODE (decl
) == TYPE_DECL
)
270 type
= TREE_TYPE (decl
);
271 if (type
== error_mark_node
)
272 return error_mark_node
;
273 if (MAYBE_CLASS_TYPE_P (type
)
274 && CLASSTYPE_TEMPLATE_INFO (type
)
275 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
277 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
278 check_member_template (tmpl
);
283 else if (TREE_CODE (decl
) == FIELD_DECL
)
284 error ("data member %qD cannot be a member template", decl
);
285 else if (DECL_TEMPLATE_INFO (decl
))
287 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
289 check_member_template (DECL_TI_TEMPLATE (decl
));
290 return DECL_TI_TEMPLATE (decl
);
296 error ("invalid member template declaration %qD", decl
);
298 return error_mark_node
;
301 /* Create a template info node. */
304 build_template_info (tree template_decl
, tree template_args
)
306 tree result
= make_node (TEMPLATE_INFO
);
307 TI_TEMPLATE (result
) = template_decl
;
308 TI_ARGS (result
) = template_args
;
312 /* Return the template info node corresponding to T, whatever T is. */
315 get_template_info (const_tree t
)
317 tree tinfo
= NULL_TREE
;
319 if (!t
|| t
== error_mark_node
)
322 if (TREE_CODE (t
) == NAMESPACE_DECL
)
325 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
326 tinfo
= DECL_TEMPLATE_INFO (t
);
328 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
331 if (OVERLOAD_TYPE_P (t
))
332 tinfo
= TYPE_TEMPLATE_INFO (t
);
333 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
334 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
339 /* Returns the template nesting level of the indicated class TYPE.
349 A<T>::B<U> has depth two, while A<T> has depth one.
350 Both A<T>::B<int> and A<int>::B<U> have depth one, if
351 they are instantiations, not specializations.
353 This function is guaranteed to return 0 if passed NULL_TREE so
354 that, for example, `template_class_depth (current_class_type)' is
358 template_class_depth (tree type
)
363 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
364 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
365 ? CP_DECL_CONTEXT (type
) : CP_TYPE_CONTEXT (type
))
367 tree tinfo
= get_template_info (type
);
369 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
370 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
377 /* Subroutine of maybe_begin_member_template_processing.
378 Returns true if processing DECL needs us to push template parms. */
381 inline_needs_template_parms (tree decl
, bool nsdmi
)
383 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
386 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
387 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
390 /* Subroutine of maybe_begin_member_template_processing.
391 Push the template parms in PARMS, starting from LEVELS steps into the
392 chain, and ending at the beginning, since template parms are listed
396 push_inline_template_parms_recursive (tree parmlist
, int levels
)
398 tree parms
= TREE_VALUE (parmlist
);
402 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
404 ++processing_template_decl
;
405 current_template_parms
406 = tree_cons (size_int (processing_template_decl
),
407 parms
, current_template_parms
);
408 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
410 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
412 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
414 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
416 if (error_operand_p (parm
))
419 gcc_assert (DECL_P (parm
));
421 switch (TREE_CODE (parm
))
430 /* Make a CONST_DECL as is done in process_template_parm.
431 It is ugly that we recreate this here; the original
432 version built in process_template_parm is no longer
434 tree decl
= build_decl (DECL_SOURCE_LOCATION (parm
),
435 CONST_DECL
, DECL_NAME (parm
),
437 DECL_ARTIFICIAL (decl
) = 1;
438 TREE_CONSTANT (decl
) = 1;
439 TREE_READONLY (decl
) = 1;
440 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
441 SET_DECL_TEMPLATE_PARM_P (decl
);
452 /* Restore the template parameter context for a member template, a
453 friend template defined in a class definition, or a non-template
454 member of template class. */
457 maybe_begin_member_template_processing (tree decl
)
461 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
465 tree ctx
= DECL_CONTEXT (decl
);
466 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
467 /* Disregard full specializations (c++/60999). */
468 && uses_template_parms (ctx
)
469 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
472 if (inline_needs_template_parms (decl
, nsdmi
))
474 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
475 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
477 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
480 parms
= TREE_CHAIN (parms
);
483 push_inline_template_parms_recursive (parms
, levels
);
486 /* Remember how many levels of template parameters we pushed so that
487 we can pop them later. */
488 inline_parm_levels
.safe_push (levels
);
491 /* Undo the effects of maybe_begin_member_template_processing. */
494 maybe_end_member_template_processing (void)
499 if (inline_parm_levels
.length () == 0)
502 last
= inline_parm_levels
.pop ();
503 for (i
= 0; i
< last
; ++i
)
505 --processing_template_decl
;
506 current_template_parms
= TREE_CHAIN (current_template_parms
);
511 /* Return a new template argument vector which contains all of ARGS,
512 but has as its innermost set of arguments the EXTRA_ARGS. */
515 add_to_template_args (tree args
, tree extra_args
)
522 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
525 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
526 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
528 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
529 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
531 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
532 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
537 /* Like add_to_template_args, but only the outermost ARGS are added to
538 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
539 (EXTRA_ARGS) levels are added. This function is used to combine
540 the template arguments from a partial instantiation with the
541 template arguments used to attain the full instantiation from the
542 partial instantiation. */
545 add_outermost_template_args (tree args
, tree extra_args
)
549 /* If there are more levels of EXTRA_ARGS than there are ARGS,
550 something very fishy is going on. */
551 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
553 /* If *all* the new arguments will be the EXTRA_ARGS, just return
555 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
558 /* For the moment, we make ARGS look like it contains fewer levels. */
559 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
561 new_args
= add_to_template_args (args
, extra_args
);
563 /* Now, we restore ARGS to its full dimensions. */
564 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
569 /* Return the N levels of innermost template arguments from the ARGS. */
572 get_innermost_template_args (tree args
, int n
)
580 /* If N is 1, just return the innermost set of template arguments. */
582 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
584 /* If we're not removing anything, just return the arguments we were
586 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
587 gcc_assert (extra_levels
>= 0);
588 if (extra_levels
== 0)
591 /* Make a new set of arguments, not containing the outer arguments. */
592 new_args
= make_tree_vec (n
);
593 for (i
= 1; i
<= n
; ++i
)
594 SET_TMPL_ARGS_LEVEL (new_args
, i
,
595 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
600 /* The inverse of get_innermost_template_args: Return all but the innermost
601 EXTRA_LEVELS levels of template arguments from the ARGS. */
604 strip_innermost_template_args (tree args
, int extra_levels
)
607 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
612 /* If N is 1, just return the outermost set of template arguments. */
614 return TMPL_ARGS_LEVEL (args
, 1);
616 /* If we're not removing anything, just return the arguments we were
618 gcc_assert (extra_levels
>= 0);
619 if (extra_levels
== 0)
622 /* Make a new set of arguments, not containing the inner arguments. */
623 new_args
= make_tree_vec (n
);
624 for (i
= 1; i
<= n
; ++i
)
625 SET_TMPL_ARGS_LEVEL (new_args
, i
,
626 TMPL_ARGS_LEVEL (args
, i
));
631 /* We've got a template header coming up; push to a new level for storing
635 begin_template_parm_list (void)
637 /* We use a non-tag-transparent scope here, which causes pushtag to
638 put tags in this scope, rather than in the enclosing class or
639 namespace scope. This is the right thing, since we want
640 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
641 global template class, push_template_decl handles putting the
642 TEMPLATE_DECL into top-level scope. For a nested template class,
645 template <class T> struct S1 {
646 template <class T> struct S2 {};
649 pushtag contains special code to call pushdecl_with_scope on the
650 TEMPLATE_DECL for S2. */
651 begin_scope (sk_template_parms
, NULL
);
652 ++processing_template_decl
;
653 ++processing_template_parmlist
;
654 note_template_header (0);
657 /* This routine is called when a specialization is declared. If it is
658 invalid to declare a specialization here, an error is reported and
659 false is returned, otherwise this routine will return true. */
662 check_specialization_scope (void)
664 tree scope
= current_scope ();
668 An explicit specialization shall be declared in the namespace of
669 which the template is a member, or, for member templates, in the
670 namespace of which the enclosing class or enclosing class
671 template is a member. An explicit specialization of a member
672 function, member class or static data member of a class template
673 shall be declared in the namespace of which the class template
675 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
677 error ("explicit specialization in non-namespace scope %qD", scope
);
683 In an explicit specialization declaration for a member of a class
684 template or a member template that appears in namespace scope,
685 the member template and some of its enclosing class templates may
686 remain unspecialized, except that the declaration shall not
687 explicitly specialize a class member template if its enclosing
688 class templates are not explicitly specialized as well. */
689 if (current_template_parms
)
691 error ("enclosing class templates are not explicitly specialized");
698 /* We've just seen template <>. */
701 begin_specialization (void)
703 begin_scope (sk_template_spec
, NULL
);
704 note_template_header (1);
705 return check_specialization_scope ();
708 /* Called at then end of processing a declaration preceded by
712 end_specialization (void)
715 reset_specialization ();
718 /* Any template <>'s that we have seen thus far are not referring to a
719 function specialization. */
722 reset_specialization (void)
724 processing_specialization
= 0;
725 template_header_count
= 0;
728 /* We've just seen a template header. If SPECIALIZATION is nonzero,
729 it was of the form template <>. */
732 note_template_header (int specialization
)
734 processing_specialization
= specialization
;
735 template_header_count
++;
738 /* We're beginning an explicit instantiation. */
741 begin_explicit_instantiation (void)
743 gcc_assert (!processing_explicit_instantiation
);
744 processing_explicit_instantiation
= true;
749 end_explicit_instantiation (void)
751 gcc_assert (processing_explicit_instantiation
);
752 processing_explicit_instantiation
= false;
755 /* An explicit specialization or partial specialization of TMPL is being
756 declared. Check that the namespace in which the specialization is
757 occurring is permissible. Returns false iff it is invalid to
758 specialize TMPL in the current namespace. */
761 check_specialization_namespace (tree tmpl
)
763 tree tpl_ns
= decl_namespace_context (tmpl
);
767 An explicit specialization shall be declared in the namespace of
768 which the template is a member, or, for member templates, in the
769 namespace of which the enclosing class or enclosing class
770 template is a member. An explicit specialization of a member
771 function, member class or static data member of a class template
772 shall be declared in the namespace of which the class template is
774 if (current_scope() != DECL_CONTEXT (tmpl
)
775 && !at_namespace_scope_p ())
777 error ("specialization of %qD must appear at namespace scope", tmpl
);
780 if (is_associated_namespace (current_namespace
, tpl_ns
))
781 /* Same or super-using namespace. */
785 permerror (input_location
, "specialization of %qD in different namespace", tmpl
);
786 permerror (input_location
, " from definition of %q+#D", tmpl
);
791 /* SPEC is an explicit instantiation. Check that it is valid to
792 perform this explicit instantiation in the current namespace. */
795 check_explicit_instantiation_namespace (tree spec
)
799 /* DR 275: An explicit instantiation shall appear in an enclosing
800 namespace of its template. */
801 ns
= decl_namespace_context (spec
);
802 if (!is_ancestor (current_namespace
, ns
))
803 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
804 "(which does not enclose namespace %qD)",
805 spec
, current_namespace
, ns
);
808 /* The TYPE is being declared. If it is a template type, that means it
809 is a partial specialization. Do appropriate error-checking. */
812 maybe_process_partial_specialization (tree type
)
816 if (type
== error_mark_node
)
817 return error_mark_node
;
819 /* A lambda that appears in specialization context is not itself a
821 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
824 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
826 error ("name of class shadows template template parameter %qD",
828 return error_mark_node
;
831 context
= TYPE_CONTEXT (type
);
833 if (TYPE_ALIAS_P (type
))
835 if (TYPE_TEMPLATE_INFO (type
)
836 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type
)))
837 error ("specialization of alias template %qD",
838 TYPE_TI_TEMPLATE (type
));
840 error ("explicit specialization of non-template %qT", type
);
841 return error_mark_node
;
843 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
845 /* This is for ordinary explicit specialization and partial
846 specialization of a template class such as:
848 template <> class C<int>;
852 template <class T> class C<T*>;
854 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
856 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
857 && !COMPLETE_TYPE_P (type
))
859 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type
))
860 && !at_namespace_scope_p ())
861 return error_mark_node
;
862 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
863 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
864 if (processing_template_decl
)
866 if (push_template_decl (TYPE_MAIN_DECL (type
))
868 return error_mark_node
;
871 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
872 error ("specialization of %qT after instantiation", type
);
873 else if (errorcount
&& !processing_specialization
874 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
875 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
876 /* Trying to define a specialization either without a template<> header
877 or in an inappropriate place. We've already given an error, so just
878 bail now so we don't actually define the specialization. */
879 return error_mark_node
;
881 else if (CLASS_TYPE_P (type
)
882 && !CLASSTYPE_USE_TEMPLATE (type
)
883 && CLASSTYPE_TEMPLATE_INFO (type
)
884 && context
&& CLASS_TYPE_P (context
)
885 && CLASSTYPE_TEMPLATE_INFO (context
))
887 /* This is for an explicit specialization of member class
888 template according to [temp.expl.spec/18]:
890 template <> template <class U> class C<int>::D;
892 The context `C<int>' must be an implicit instantiation.
893 Otherwise this is just a member class template declared
896 template <> class C<int> { template <class U> class D; };
897 template <> template <class U> class C<int>::D;
899 In the first case, `C<int>::D' is a specialization of `C<T>::D'
900 while in the second case, `C<int>::D' is a primary template
901 and `C<T>::D' may not exist. */
903 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
904 && !COMPLETE_TYPE_P (type
))
907 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
909 if (current_namespace
910 != decl_namespace_context (tmpl
))
912 permerror (input_location
, "specializing %q#T in different namespace", type
);
913 permerror (input_location
, " from definition of %q+#D", tmpl
);
916 /* Check for invalid specialization after instantiation:
918 template <> template <> class C<int>::D<int>;
919 template <> template <class U> class C<int>::D; */
921 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
922 t
; t
= TREE_CHAIN (t
))
924 tree inst
= TREE_VALUE (t
);
925 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
926 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
928 /* We already have a full specialization of this partial
929 instantiation, or a full specialization has been
930 looked up but not instantiated. Reassign it to the
931 new member specialization template. */
936 elt
.tmpl
= most_general_template (tmpl
);
937 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
940 htab_remove_elt (type_specializations
, &elt
);
943 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
945 slot
= htab_find_slot (type_specializations
, &elt
, INSERT
);
946 entry
= ggc_alloc
<spec_entry
> ();
951 /* But if we've had an implicit instantiation, that's a
952 problem ([temp.expl.spec]/6). */
953 error ("specialization %qT after instantiation %qT",
957 /* Mark TYPE as a specialization. And as a result, we only
958 have one level of template argument for the innermost
960 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
961 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
962 CLASSTYPE_TI_ARGS (type
)
963 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
966 else if (processing_specialization
)
968 /* Someday C++0x may allow for enum template specialization. */
969 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
970 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
971 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
972 "of %qD not allowed by ISO C++", type
);
975 error ("explicit specialization of non-template %qT", type
);
976 return error_mark_node
;
983 /* Returns nonzero if we can optimize the retrieval of specializations
984 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
985 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
988 optimize_specialization_lookup_p (tree tmpl
)
990 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
991 && DECL_CLASS_SCOPE_P (tmpl
)
992 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
994 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
995 /* The optimized lookup depends on the fact that the
996 template arguments for the member function template apply
997 purely to the containing class, which is not true if the
998 containing class is an explicit or partial
1000 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1001 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1002 && !DECL_CONV_FN_P (tmpl
)
1003 /* It is possible to have a template that is not a member
1004 template and is not a member of a template class:
1006 template <typename T>
1007 struct S { friend A::f(); };
1009 Here, the friend function is a template, but the context does
1010 not have template information. The optimized lookup relies
1011 on having ARGS be the template arguments for both the class
1012 and the function template. */
1013 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1016 /* Retrieve the specialization (in the sense of [temp.spec] - a
1017 specialization is either an instantiation or an explicit
1018 specialization) of TMPL for the given template ARGS. If there is
1019 no such specialization, return NULL_TREE. The ARGS are a vector of
1020 arguments, or a vector of vectors of arguments, in the case of
1021 templates with more than one level of parameters.
1023 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1024 then we search for a partial specialization matching ARGS. This
1025 parameter is ignored if TMPL is not a class template.
1027 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1028 result is a NONTYPE_ARGUMENT_PACK. */
1031 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1033 if (tmpl
== NULL_TREE
)
1036 if (args
== error_mark_node
)
1039 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1040 || TREE_CODE (tmpl
) == FIELD_DECL
);
1042 /* There should be as many levels of arguments as there are
1043 levels of parameters. */
1044 gcc_assert (TMPL_ARGS_DEPTH (args
)
1045 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1046 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1047 : template_class_depth (DECL_CONTEXT (tmpl
))));
1049 if (optimize_specialization_lookup_p (tmpl
))
1051 tree class_template
;
1052 tree class_specialization
;
1053 vec
<tree
, va_gc
> *methods
;
1057 /* The template arguments actually apply to the containing
1058 class. Find the class specialization with those
1060 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1061 class_specialization
1062 = retrieve_specialization (class_template
, args
, 0);
1063 if (!class_specialization
)
1065 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1066 for the specialization. */
1067 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
1070 /* Iterate through the methods with the indicated name, looking
1071 for the one that has an instance of TMPL. */
1072 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
1073 for (fns
= (*methods
)[idx
]; fns
; fns
= OVL_NEXT (fns
))
1075 tree fn
= OVL_CURRENT (fns
);
1076 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1077 /* using-declarations can add base methods to the method vec,
1078 and we don't want those here. */
1079 && DECL_CONTEXT (fn
) == class_specialization
)
1088 htab_t specializations
;
1092 elt
.spec
= NULL_TREE
;
1094 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1095 specializations
= type_specializations
;
1097 specializations
= decl_specializations
;
1100 hash
= hash_specialization (&elt
);
1101 found
= (spec_entry
*) htab_find_with_hash (specializations
, &elt
, hash
);
1109 /* Like retrieve_specialization, but for local declarations. */
1112 retrieve_local_specialization (tree tmpl
)
1114 if (local_specializations
== NULL
)
1117 tree
*slot
= local_specializations
->get (tmpl
);
1118 return slot
? *slot
: NULL_TREE
;
1121 /* Returns nonzero iff DECL is a specialization of TMPL. */
1124 is_specialization_of (tree decl
, tree tmpl
)
1128 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1132 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1138 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1140 for (t
= TREE_TYPE (decl
);
1142 t
= CLASSTYPE_USE_TEMPLATE (t
)
1143 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1144 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1151 /* Returns nonzero iff DECL is a specialization of friend declaration
1152 FRIEND_DECL according to [temp.friend]. */
1155 is_specialization_of_friend (tree decl
, tree friend_decl
)
1157 bool need_template
= true;
1160 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1161 || TREE_CODE (decl
) == TYPE_DECL
);
1163 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1164 of a template class, we want to check if DECL is a specialization
1166 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1167 && DECL_TEMPLATE_INFO (friend_decl
)
1168 && !DECL_USE_TEMPLATE (friend_decl
))
1170 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1171 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1172 need_template
= false;
1174 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1175 && !PRIMARY_TEMPLATE_P (friend_decl
))
1176 need_template
= false;
1178 /* There is nothing to do if this is not a template friend. */
1179 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1182 if (is_specialization_of (decl
, friend_decl
))
1186 A member of a class template may be declared to be a friend of a
1187 non-template class. In this case, the corresponding member of
1188 every specialization of the class template is a friend of the
1189 class granting friendship.
1191 For example, given a template friend declaration
1193 template <class T> friend void A<T>::f();
1195 the member function below is considered a friend
1197 template <> struct A<int> {
1201 For this type of template friend, TEMPLATE_DEPTH below will be
1202 nonzero. To determine if DECL is a friend of FRIEND, we first
1203 check if the enclosing class is a specialization of another. */
1205 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1207 && DECL_CLASS_SCOPE_P (decl
)
1208 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1209 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1211 /* Next, we check the members themselves. In order to handle
1212 a few tricky cases, such as when FRIEND_DECL's are
1214 template <class T> friend void A<T>::g(T t);
1215 template <class T> template <T t> friend void A<T>::h();
1219 void A<int>::g(int);
1220 template <int> void A<int>::h();
1222 we need to figure out ARGS, the template arguments from
1223 the context of DECL. This is required for template substitution
1224 of `T' in the function parameter of `g' and template parameter
1225 of `h' in the above examples. Here ARGS corresponds to `int'. */
1227 tree context
= DECL_CONTEXT (decl
);
1228 tree args
= NULL_TREE
;
1229 int current_depth
= 0;
1231 while (current_depth
< template_depth
)
1233 if (CLASSTYPE_TEMPLATE_INFO (context
))
1235 if (current_depth
== 0)
1236 args
= TYPE_TI_ARGS (context
);
1238 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1241 context
= TYPE_CONTEXT (context
);
1244 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1249 tree friend_args_type
;
1250 tree decl_args_type
;
1252 /* Make sure that both DECL and FRIEND_DECL are templates or
1254 is_template
= DECL_TEMPLATE_INFO (decl
)
1255 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1256 if (need_template
^ is_template
)
1258 else if (is_template
)
1260 /* If both are templates, check template parameter list. */
1262 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1264 if (!comp_template_parms
1265 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1269 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1272 decl_type
= TREE_TYPE (decl
);
1274 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1275 tf_none
, NULL_TREE
);
1276 if (friend_type
== error_mark_node
)
1279 /* Check if return types match. */
1280 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1283 /* Check if function parameter types match, ignoring the
1284 `this' parameter. */
1285 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1286 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1287 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1288 friend_args_type
= TREE_CHAIN (friend_args_type
);
1289 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1290 decl_args_type
= TREE_CHAIN (decl_args_type
);
1292 return compparms (decl_args_type
, friend_args_type
);
1296 /* DECL is a TYPE_DECL */
1298 tree decl_type
= TREE_TYPE (decl
);
1300 /* Make sure that both DECL and FRIEND_DECL are templates or
1303 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1304 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1306 if (need_template
^ is_template
)
1308 else if (is_template
)
1311 /* If both are templates, check the name of the two
1312 TEMPLATE_DECL's first because is_friend didn't. */
1313 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1314 != DECL_NAME (friend_decl
))
1317 /* Now check template parameter list. */
1319 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1321 return comp_template_parms
1322 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1326 return (DECL_NAME (decl
)
1327 == DECL_NAME (friend_decl
));
1333 /* Register the specialization SPEC as a specialization of TMPL with
1334 the indicated ARGS. IS_FRIEND indicates whether the specialization
1335 is actually just a friend declaration. Returns SPEC, or an
1336 equivalent prior declaration, if available.
1338 We also store instantiations of field packs in the hash table, even
1339 though they are not themselves templates, to make lookup easier. */
1342 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1349 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1350 || (TREE_CODE (tmpl
) == FIELD_DECL
1351 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1353 if (TREE_CODE (spec
) == FUNCTION_DECL
1354 && uses_template_parms (DECL_TI_ARGS (spec
)))
1355 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1356 register it; we want the corresponding TEMPLATE_DECL instead.
1357 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1358 the more obvious `uses_template_parms (spec)' to avoid problems
1359 with default function arguments. In particular, given
1360 something like this:
1362 template <class T> void f(T t1, T t = T())
1364 the default argument expression is not substituted for in an
1365 instantiation unless and until it is actually needed. */
1368 if (optimize_specialization_lookup_p (tmpl
))
1369 /* We don't put these specializations in the hash table, but we might
1370 want to give an error about a mismatch. */
1371 fn
= retrieve_specialization (tmpl
, args
, 0);
1379 hash
= hash_specialization (&elt
);
1382 htab_find_slot_with_hash (decl_specializations
, &elt
, hash
, INSERT
);
1384 fn
= ((spec_entry
*) *slot
)->spec
;
1389 /* We can sometimes try to re-register a specialization that we've
1390 already got. In particular, regenerate_decl_from_template calls
1391 duplicate_decls which will update the specialization list. But,
1392 we'll still get called again here anyhow. It's more convenient
1393 to simply allow this than to try to prevent it. */
1396 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1398 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1400 if (DECL_ODR_USED (fn
)
1401 || DECL_EXPLICIT_INSTANTIATION (fn
))
1403 error ("specialization of %qD after instantiation",
1405 return error_mark_node
;
1410 /* This situation should occur only if the first
1411 specialization is an implicit instantiation, the
1412 second is an explicit specialization, and the
1413 implicit instantiation has not yet been used. That
1414 situation can occur if we have implicitly
1415 instantiated a member function and then specialized
1418 We can also wind up here if a friend declaration that
1419 looked like an instantiation turns out to be a
1422 template <class T> void foo(T);
1423 class S { friend void foo<>(int) };
1424 template <> void foo(int);
1426 We transform the existing DECL in place so that any
1427 pointers to it become pointers to the updated
1430 If there was a definition for the template, but not
1431 for the specialization, we want this to look as if
1432 there were no definition, and vice versa. */
1433 DECL_INITIAL (fn
) = NULL_TREE
;
1434 duplicate_decls (spec
, fn
, is_friend
);
1435 /* The call to duplicate_decls will have applied
1438 An explicit specialization of a function template
1439 is inline only if it is explicitly declared to be,
1440 and independently of whether its function template
1443 to the primary function; now copy the inline bits to
1444 the various clones. */
1445 FOR_EACH_CLONE (clone
, fn
)
1447 DECL_DECLARED_INLINE_P (clone
)
1448 = DECL_DECLARED_INLINE_P (fn
);
1449 DECL_SOURCE_LOCATION (clone
)
1450 = DECL_SOURCE_LOCATION (fn
);
1451 DECL_DELETED_FN (clone
)
1452 = DECL_DELETED_FN (fn
);
1454 check_specialization_namespace (tmpl
);
1459 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1461 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1462 /* Dup decl failed, but this is a new definition. Set the
1463 line number so any errors match this new
1465 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1471 return duplicate_decls (spec
, fn
, is_friend
);
1473 /* A specialization must be declared in the same namespace as the
1474 template it is specializing. */
1475 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1476 && !check_specialization_namespace (tmpl
))
1477 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1479 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1481 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1482 gcc_assert (tmpl
&& args
&& spec
);
1485 if (TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1486 && PRIMARY_TEMPLATE_P (tmpl
)
1487 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1488 /* TMPL is a forward declaration of a template function; keep a list
1489 of all specializations in case we need to reassign them to a friend
1490 template later in tsubst_friend_function. */
1491 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1492 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1498 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1499 TMPL and ARGS members, ignores SPEC. */
1501 int comparing_specializations
;
1504 eq_specializations (const void *p1
, const void *p2
)
1506 const spec_entry
*e1
= (const spec_entry
*)p1
;
1507 const spec_entry
*e2
= (const spec_entry
*)p2
;
1510 ++comparing_specializations
;
1511 equal
= (e1
->tmpl
== e2
->tmpl
1512 && comp_template_args (e1
->args
, e2
->args
));
1513 --comparing_specializations
;
1518 /* Returns a hash for a template TMPL and template arguments ARGS. */
1521 hash_tmpl_and_args (tree tmpl
, tree args
)
1523 hashval_t val
= DECL_UID (tmpl
);
1524 return iterative_hash_template_arg (args
, val
);
1527 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1531 hash_specialization (const void *p
)
1533 const spec_entry
*e
= (const spec_entry
*)p
;
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
= (spec_entry
*) htab_find (decl_specializations
, &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 fold_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 fold_non_dependent_expr (tree expr
)
5253 return fold_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 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 the number of innermost template parameters in TMPL. */
5288 num_innermost_template_parms (tree tmpl
)
5290 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5291 return TREE_VEC_LENGTH (parms
);
5294 /* Return either TMPL or another template that it is equivalent to under DR
5295 1286: An alias that just changes the name of a template is equivalent to
5296 the other template. */
5299 get_underlying_template (tree tmpl
)
5301 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5302 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5304 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5305 if (TYPE_TEMPLATE_INFO (result
))
5307 tree sub
= TYPE_TI_TEMPLATE (result
);
5308 if (PRIMARY_TEMPLATE_P (sub
)
5309 && (num_innermost_template_parms (tmpl
)
5310 == num_innermost_template_parms (sub
)))
5312 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5313 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5314 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5316 /* The alias type is equivalent to the pattern of the
5317 underlying template, so strip the alias. */
5327 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5328 must be a function or a pointer-to-function type, as specified
5329 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5330 and check that the resulting function has external linkage. */
5333 convert_nontype_argument_function (tree type
, tree expr
,
5334 tsubst_flags_t complain
)
5338 linkage_kind linkage
;
5340 fn
= instantiate_type (type
, fns
, tf_none
);
5341 if (fn
== error_mark_node
)
5342 return error_mark_node
;
5345 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5346 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5347 if (BASELINK_P (fn_no_ptr
))
5348 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5350 /* [temp.arg.nontype]/1
5352 A template-argument for a non-type, non-template template-parameter
5355 -- the address of an object or function with external [C++11: or
5356 internal] linkage. */
5358 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5360 if (complain
& tf_error
)
5362 error ("%qE is not a valid template argument for type %qT",
5364 if (TYPE_PTR_P (type
))
5365 error ("it must be the address of a function with "
5366 "external linkage");
5368 error ("it must be the name of a function with "
5369 "external linkage");
5374 linkage
= decl_linkage (fn_no_ptr
);
5375 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5377 if (complain
& tf_error
)
5379 if (cxx_dialect
>= cxx11
)
5380 error ("%qE is not a valid template argument for type %qT "
5381 "because %qD has no linkage",
5382 expr
, type
, fn_no_ptr
);
5384 error ("%qE is not a valid template argument for type %qT "
5385 "because %qD does not have external linkage",
5386 expr
, type
, fn_no_ptr
);
5394 /* Subroutine of convert_nontype_argument.
5395 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5396 Emit an error otherwise. */
5399 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5400 tsubst_flags_t complain
)
5403 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5405 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5407 if (processing_template_decl
5408 && TREE_CODE (expr
) == ADDR_EXPR
5409 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
5411 if (complain
& tf_error
)
5413 error ("%qE is not a valid template argument for type %qT",
5415 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5420 /* Returns TRUE iff the address of OP is value-dependent.
5422 14.6.2.4 [temp.dep.temp]:
5423 A non-integral non-type template-argument is dependent if its type is
5424 dependent or it has either of the following forms
5427 and contains a nested-name-specifier which specifies a class-name that
5428 names a dependent type.
5430 We generalize this to just say that the address of a member of a
5431 dependent class is value-dependent; the above doesn't cover the
5432 address of a static data member named with an unqualified-id. */
5435 has_value_dependent_address (tree op
)
5437 /* We could use get_inner_reference here, but there's no need;
5438 this is only relevant for template non-type arguments, which
5439 can only be expressed as &id-expression. */
5442 tree ctx
= CP_DECL_CONTEXT (op
);
5443 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5450 /* The next set of functions are used for providing helpful explanatory
5451 diagnostics for failed overload resolution. Their messages should be
5452 indented by two spaces for consistency with the messages in
5456 unify_success (bool /*explain_p*/)
5462 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5465 inform (input_location
,
5466 " couldn't deduce template parameter %qD", parm
);
5471 unify_invalid (bool /*explain_p*/)
5477 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5480 inform (input_location
,
5481 " types %qT and %qT have incompatible cv-qualifiers",
5487 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5490 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5495 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5498 inform (input_location
,
5499 " template parameter %qD is not a parameter pack, but "
5506 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5509 inform (input_location
,
5510 " template argument %qE does not match "
5511 "pointer-to-member constant %qE",
5517 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5520 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5525 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5528 inform (input_location
,
5529 " inconsistent parameter pack deduction with %qT and %qT",
5535 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5540 inform (input_location
,
5541 " deduced conflicting types for parameter %qT (%qT and %qT)",
5542 parm
, first
, second
);
5544 inform (input_location
,
5545 " deduced conflicting values for non-type parameter "
5546 "%qE (%qE and %qE)", parm
, first
, second
);
5552 unify_vla_arg (bool explain_p
, tree arg
)
5555 inform (input_location
,
5556 " variable-sized array type %qT is not "
5557 "a valid template argument",
5563 unify_method_type_error (bool explain_p
, tree arg
)
5566 inform (input_location
,
5567 " member function type %qT is not a valid template argument",
5573 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
5578 inform_n (input_location
, wanted
,
5579 " candidate expects at least %d argument, %d provided",
5580 " candidate expects at least %d arguments, %d provided",
5583 inform_n (input_location
, wanted
,
5584 " candidate expects %d argument, %d provided",
5585 " candidate expects %d arguments, %d provided",
5592 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5594 return unify_arity (explain_p
, have
, wanted
);
5598 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
5599 bool least_p
= false)
5601 return unify_arity (explain_p
, have
, wanted
, least_p
);
5605 unify_arg_conversion (bool explain_p
, tree to_type
,
5606 tree from_type
, tree arg
)
5609 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5610 " cannot convert %qE (type %qT) to type %qT",
5611 arg
, from_type
, to_type
);
5616 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5617 tree parm
, tree arg
)
5622 case tbr_ambiguous_baseclass
:
5623 inform (input_location
, " %qT is an ambiguous base class of %qT",
5627 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5634 unify_inconsistent_template_template_parameters (bool explain_p
)
5637 inform (input_location
,
5638 " template parameters of a template template argument are "
5639 "inconsistent with other deduced template arguments");
5644 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5647 inform (input_location
,
5648 " can't deduce a template for %qT from non-template type %qT",
5654 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5657 inform (input_location
,
5658 " template argument %qE does not match %qD", arg
, parm
);
5663 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5666 inform (input_location
,
5667 " could not resolve address from overloaded function %qE",
5672 /* Attempt to convert the non-type template parameter EXPR to the
5673 indicated TYPE. If the conversion is successful, return the
5674 converted value. If the conversion is unsuccessful, return
5675 NULL_TREE if we issued an error message, or error_mark_node if we
5676 did not. We issue error messages for out-and-out bad template
5677 parameters, but not simply because the conversion failed, since we
5678 might be just trying to do argument deduction. Both TYPE and EXPR
5679 must be non-dependent.
5681 The conversion follows the special rules described in
5682 [temp.arg.nontype], and it is much more strict than an implicit
5685 This function is called twice for each template argument (see
5686 lookup_template_class for a more accurate description of this
5687 problem). This means that we need to handle expressions which
5688 are not valid in a C++ source, but can be created from the
5689 first call (for instance, casts to perform conversions). These
5690 hacks can go away after we fix the double coercion problem. */
5693 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5697 /* Detect immediately string literals as invalid non-type argument.
5698 This special-case is not needed for correctness (we would easily
5699 catch this later), but only to provide better diagnostic for this
5700 common user mistake. As suggested by DR 100, we do not mention
5701 linkage issues in the diagnostic as this is not the point. */
5702 /* FIXME we're making this OK. */
5703 if (TREE_CODE (expr
) == STRING_CST
)
5705 if (complain
& tf_error
)
5706 error ("%qE is not a valid template argument for type %qT "
5707 "because string literals can never be used in this context",
5712 /* Add the ADDR_EXPR now for the benefit of
5713 value_dependent_expression_p. */
5714 if (TYPE_PTROBV_P (type
)
5715 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5717 expr
= decay_conversion (expr
, complain
);
5718 if (expr
== error_mark_node
)
5719 return error_mark_node
;
5722 /* If we are in a template, EXPR may be non-dependent, but still
5723 have a syntactic, rather than semantic, form. For example, EXPR
5724 might be a SCOPE_REF, rather than the VAR_DECL to which the
5725 SCOPE_REF refers. Preserving the qualifying scope is necessary
5726 so that access checking can be performed when the template is
5727 instantiated -- but here we need the resolved form so that we can
5728 convert the argument. */
5729 if (TYPE_REF_OBJ_P (type
)
5730 && has_value_dependent_address (expr
))
5731 /* If we want the address and it's value-dependent, don't fold. */;
5732 else if (!type_unknown_p (expr
))
5733 expr
= fold_non_dependent_expr_sfinae (expr
, complain
);
5734 if (error_operand_p (expr
))
5735 return error_mark_node
;
5736 expr_type
= TREE_TYPE (expr
);
5737 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5738 expr
= mark_lvalue_use (expr
);
5740 expr
= mark_rvalue_use (expr
);
5742 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5743 to a non-type argument of "nullptr". */
5744 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5745 expr
= convert (type
, expr
);
5747 /* In C++11, integral or enumeration non-type template arguments can be
5748 arbitrary constant expressions. Pointer and pointer to
5749 member arguments can be general constant expressions that evaluate
5750 to a null value, but otherwise still need to be of a specific form. */
5751 if (cxx_dialect
>= cxx11
)
5753 if (TREE_CODE (expr
) == PTRMEM_CST
)
5754 /* A PTRMEM_CST is already constant, and a valid template
5755 argument for a parameter of pointer to member type, we just want
5756 to leave it in that form rather than lower it to a
5758 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5759 expr
= maybe_constant_value (expr
);
5760 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5762 tree folded
= maybe_constant_value (expr
);
5763 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5764 : null_member_pointer_value_p (folded
))
5769 /* HACK: Due to double coercion, we can get a
5770 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5771 which is the tree that we built on the first call (see
5772 below when coercing to reference to object or to reference to
5773 function). We just strip everything and get to the arg.
5774 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5776 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5778 tree probe_type
, probe
= expr
;
5779 if (REFERENCE_REF_P (probe
))
5780 probe
= TREE_OPERAND (probe
, 0);
5781 probe_type
= TREE_TYPE (probe
);
5782 if (TREE_CODE (probe
) == NOP_EXPR
)
5784 /* ??? Maybe we could use convert_from_reference here, but we
5785 would need to relax its constraints because the NOP_EXPR
5786 could actually change the type to something more cv-qualified,
5787 and this is not folded by convert_from_reference. */
5788 tree addr
= TREE_OPERAND (probe
, 0);
5789 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5790 && TREE_CODE (addr
) == ADDR_EXPR
5791 && TYPE_PTR_P (TREE_TYPE (addr
))
5792 && (same_type_ignoring_top_level_qualifiers_p
5793 (TREE_TYPE (probe_type
),
5794 TREE_TYPE (TREE_TYPE (addr
)))))
5796 expr
= TREE_OPERAND (addr
, 0);
5797 expr_type
= TREE_TYPE (probe_type
);
5802 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5803 parameter is a pointer to object, through decay and
5804 qualification conversion. Let's strip everything. */
5805 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5809 if (TREE_CODE (probe
) == ADDR_EXPR
5810 && TYPE_PTR_P (TREE_TYPE (probe
)))
5812 /* Skip the ADDR_EXPR only if it is part of the decay for
5813 an array. Otherwise, it is part of the original argument
5814 in the source code. */
5815 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5816 probe
= TREE_OPERAND (probe
, 0);
5818 expr_type
= TREE_TYPE (expr
);
5822 /* [temp.arg.nontype]/5, bullet 1
5824 For a non-type template-parameter of integral or enumeration type,
5825 integral promotions (_conv.prom_) and integral conversions
5826 (_conv.integral_) are applied. */
5827 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5829 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5830 t
= maybe_constant_value (t
);
5831 if (t
!= error_mark_node
)
5834 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5835 return error_mark_node
;
5837 /* Notice that there are constant expressions like '4 % 0' which
5838 do not fold into integer constants. */
5839 if (TREE_CODE (expr
) != INTEGER_CST
)
5841 if (complain
& tf_error
)
5843 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
5844 if (processing_template_decl
5845 && !require_potential_constant_expression (expr
))
5847 expr
= cxx_constant_value (expr
);
5848 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
5849 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
5850 "in template argument for type %qT ", type
);
5851 if (expr
== error_mark_node
)
5853 /* else cxx_constant_value complained but gave us
5854 a real constant, so go ahead. */
5855 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
5861 /* Avoid typedef problems. */
5862 if (TREE_TYPE (expr
) != type
)
5863 expr
= fold_convert (type
, expr
);
5865 /* [temp.arg.nontype]/5, bullet 2
5867 For a non-type template-parameter of type pointer to object,
5868 qualification conversions (_conv.qual_) and the array-to-pointer
5869 conversion (_conv.array_) are applied. */
5870 else if (TYPE_PTROBV_P (type
))
5872 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5874 A template-argument for a non-type, non-template template-parameter
5875 shall be one of: [...]
5877 -- the name of a non-type template-parameter;
5878 -- the address of an object or function with external linkage, [...]
5879 expressed as "& id-expression" where the & is optional if the name
5880 refers to a function or array, or if the corresponding
5881 template-parameter is a reference.
5883 Here, we do not care about functions, as they are invalid anyway
5884 for a parameter of type pointer-to-object. */
5886 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
5887 /* Non-type template parameters are OK. */
5889 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5890 /* Null pointer values are OK in C++11. */;
5891 else if (TREE_CODE (expr
) != ADDR_EXPR
5892 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
5896 if (complain
& tf_error
)
5897 error ("%qD is not a valid template argument "
5898 "because %qD is a variable, not the address of "
5899 "a variable", expr
, expr
);
5902 if (POINTER_TYPE_P (expr_type
))
5904 if (complain
& tf_error
)
5905 error ("%qE is not a valid template argument for %qT "
5906 "because it is not the address of a variable",
5910 /* Other values, like integer constants, might be valid
5911 non-type arguments of some other type. */
5912 return error_mark_node
;
5918 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
5919 ? TREE_OPERAND (expr
, 0) : expr
);
5922 if (complain
& tf_error
)
5923 error ("%qE is not a valid template argument of type %qT "
5924 "because %qE is not a variable", expr
, type
, decl
);
5927 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
5929 if (complain
& tf_error
)
5930 error ("%qE is not a valid template argument of type %qT "
5931 "because %qD does not have external linkage",
5935 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
5937 if (complain
& tf_error
)
5938 error ("%qE is not a valid template argument of type %qT "
5939 "because %qD has no linkage", expr
, type
, decl
);
5944 expr
= decay_conversion (expr
, complain
);
5945 if (expr
== error_mark_node
)
5946 return error_mark_node
;
5948 expr
= perform_qualification_conversions (type
, expr
);
5949 if (expr
== error_mark_node
)
5950 return error_mark_node
;
5952 /* [temp.arg.nontype]/5, bullet 3
5954 For a non-type template-parameter of type reference to object, no
5955 conversions apply. The type referred to by the reference may be more
5956 cv-qualified than the (otherwise identical) type of the
5957 template-argument. The template-parameter is bound directly to the
5958 template-argument, which must be an lvalue. */
5959 else if (TYPE_REF_OBJ_P (type
))
5961 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
5963 return error_mark_node
;
5965 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
5967 if (complain
& tf_error
)
5968 error ("%qE is not a valid template argument for type %qT "
5969 "because of conflicts in cv-qualification", expr
, type
);
5973 if (!real_lvalue_p (expr
))
5975 if (complain
& tf_error
)
5976 error ("%qE is not a valid template argument for type %qT "
5977 "because it is not an lvalue", expr
, type
);
5981 /* [temp.arg.nontype]/1
5983 A template-argument for a non-type, non-template template-parameter
5984 shall be one of: [...]
5986 -- the address of an object or function with external linkage. */
5987 if (INDIRECT_REF_P (expr
)
5988 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
5990 expr
= TREE_OPERAND (expr
, 0);
5993 if (complain
& tf_error
)
5994 error ("%q#D is not a valid template argument for type %qT "
5995 "because a reference variable does not have a constant "
5996 "address", expr
, type
);
6003 if (complain
& tf_error
)
6004 error ("%qE is not a valid template argument for type %qT "
6005 "because it is not an object with external linkage",
6010 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
6012 if (complain
& tf_error
)
6013 error ("%qE is not a valid template argument for type %qT "
6014 "because object %qD has not external linkage",
6019 expr
= build_nop (type
, build_address (expr
));
6021 /* [temp.arg.nontype]/5, bullet 4
6023 For a non-type template-parameter of type pointer to function, only
6024 the function-to-pointer conversion (_conv.func_) is applied. If the
6025 template-argument represents a set of overloaded functions (or a
6026 pointer to such), the matching function is selected from the set
6028 else if (TYPE_PTRFN_P (type
))
6030 /* If the argument is a template-id, we might not have enough
6031 context information to decay the pointer. */
6032 if (!type_unknown_p (expr_type
))
6034 expr
= decay_conversion (expr
, complain
);
6035 if (expr
== error_mark_node
)
6036 return error_mark_node
;
6039 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6040 /* Null pointer values are OK in C++11. */
6041 return perform_qualification_conversions (type
, expr
);
6043 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6044 if (!expr
|| expr
== error_mark_node
)
6047 /* [temp.arg.nontype]/5, bullet 5
6049 For a non-type template-parameter of type reference to function, no
6050 conversions apply. If the template-argument represents a set of
6051 overloaded functions, the matching function is selected from the set
6053 else if (TYPE_REFFN_P (type
))
6055 if (TREE_CODE (expr
) == ADDR_EXPR
)
6057 if (complain
& tf_error
)
6059 error ("%qE is not a valid template argument for type %qT "
6060 "because it is a pointer", expr
, type
);
6061 inform (input_location
, "try using %qE instead",
6062 TREE_OPERAND (expr
, 0));
6067 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6068 if (!expr
|| expr
== error_mark_node
)
6071 expr
= build_nop (type
, build_address (expr
));
6073 /* [temp.arg.nontype]/5, bullet 6
6075 For a non-type template-parameter of type pointer to member function,
6076 no conversions apply. If the template-argument represents a set of
6077 overloaded member functions, the matching member function is selected
6078 from the set (_over.over_). */
6079 else if (TYPE_PTRMEMFUNC_P (type
))
6081 expr
= instantiate_type (type
, expr
, tf_none
);
6082 if (expr
== error_mark_node
)
6083 return error_mark_node
;
6085 /* [temp.arg.nontype] bullet 1 says the pointer to member
6086 expression must be a pointer-to-member constant. */
6087 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6088 return error_mark_node
;
6090 /* There is no way to disable standard conversions in
6091 resolve_address_of_overloaded_function (called by
6092 instantiate_type). It is possible that the call succeeded by
6093 converting &B::I to &D::I (where B is a base of D), so we need
6094 to reject this conversion here.
6096 Actually, even if there was a way to disable standard conversions,
6097 it would still be better to reject them here so that we can
6098 provide a superior diagnostic. */
6099 if (!same_type_p (TREE_TYPE (expr
), type
))
6101 if (complain
& tf_error
)
6103 error ("%qE is not a valid template argument for type %qT "
6104 "because it is of type %qT", expr
, type
,
6106 /* If we are just one standard conversion off, explain. */
6107 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6108 inform (input_location
,
6109 "standard conversions are not allowed in this context");
6114 /* [temp.arg.nontype]/5, bullet 7
6116 For a non-type template-parameter of type pointer to data member,
6117 qualification conversions (_conv.qual_) are applied. */
6118 else if (TYPE_PTRDATAMEM_P (type
))
6120 /* [temp.arg.nontype] bullet 1 says the pointer to member
6121 expression must be a pointer-to-member constant. */
6122 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6123 return error_mark_node
;
6125 expr
= perform_qualification_conversions (type
, expr
);
6126 if (expr
== error_mark_node
)
6129 else if (NULLPTR_TYPE_P (type
))
6131 if (expr
!= nullptr_node
)
6133 if (complain
& tf_error
)
6134 error ("%qE is not a valid template argument for type %qT "
6135 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6140 /* A template non-type parameter must be one of the above. */
6144 /* Sanity check: did we actually convert the argument to the
6146 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6147 (type
, TREE_TYPE (expr
)));
6151 /* Subroutine of coerce_template_template_parms, which returns 1 if
6152 PARM_PARM and ARG_PARM match using the rule for the template
6153 parameters of template template parameters. Both PARM and ARG are
6154 template parameters; the rest of the arguments are the same as for
6155 coerce_template_template_parms.
6158 coerce_template_template_parm (tree parm
,
6160 tsubst_flags_t complain
,
6164 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6165 || parm
== NULL_TREE
|| error_operand_p (parm
))
6168 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6171 switch (TREE_CODE (parm
))
6174 /* We encounter instantiations of templates like
6175 template <template <template <class> class> class TT>
6178 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6179 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6181 if (!coerce_template_template_parms
6182 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6188 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6189 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6190 /* Argument is a parameter pack but parameter is not. */
6195 /* The tsubst call is used to handle cases such as
6197 template <int> class C {};
6198 template <class T, template <T> class TT> class D {};
6201 i.e. the parameter list of TT depends on earlier parameters. */
6202 if (!uses_template_parms (TREE_TYPE (arg
))
6204 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6208 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6209 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6210 /* Argument is a parameter pack but parameter is not. */
6223 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6224 template template parameters. Both PARM_PARMS and ARG_PARMS are
6225 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6228 Consider the example:
6229 template <class T> class A;
6230 template<template <class U> class TT> class B;
6232 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6233 the parameters to A, and OUTER_ARGS contains A. */
6236 coerce_template_template_parms (tree parm_parms
,
6238 tsubst_flags_t complain
,
6242 int nparms
, nargs
, i
;
6246 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6247 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6249 nparms
= TREE_VEC_LENGTH (parm_parms
);
6250 nargs
= TREE_VEC_LENGTH (arg_parms
);
6252 /* Determine whether we have a parameter pack at the end of the
6253 template template parameter's template parameter list. */
6254 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6256 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6258 if (error_operand_p (parm
))
6261 switch (TREE_CODE (parm
))
6265 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6270 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6280 && !(variadic_p
&& nargs
>= nparms
- 1))
6283 /* Check all of the template parameters except the parameter pack at
6284 the end (if any). */
6285 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6287 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6288 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6291 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6292 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6294 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6302 /* Check each of the template parameters in the template
6303 argument against the template parameter pack at the end of
6304 the template template parameter. */
6305 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6308 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6310 for (; i
< nargs
; ++i
)
6312 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6315 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6317 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6326 /* Verifies that the deduced template arguments (in TARGS) for the
6327 template template parameters (in TPARMS) represent valid bindings,
6328 by comparing the template parameter list of each template argument
6329 to the template parameter list of its corresponding template
6330 template parameter, in accordance with DR150. This
6331 routine can only be called after all template arguments have been
6332 deduced. It will return TRUE if all of the template template
6333 parameter bindings are okay, FALSE otherwise. */
6335 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6337 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6340 /* We're dealing with template parms in this process. */
6341 ++processing_template_decl
;
6343 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6345 for (i
= 0; i
< ntparms
; ++i
)
6347 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6348 tree targ
= TREE_VEC_ELT (targs
, i
);
6350 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6352 tree packed_args
= NULL_TREE
;
6355 if (ARGUMENT_PACK_P (targ
))
6357 /* Look inside the argument pack. */
6358 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6359 len
= TREE_VEC_LENGTH (packed_args
);
6362 for (idx
= 0; idx
< len
; ++idx
)
6364 tree targ_parms
= NULL_TREE
;
6367 /* Extract the next argument from the argument
6369 targ
= TREE_VEC_ELT (packed_args
, idx
);
6371 if (PACK_EXPANSION_P (targ
))
6372 /* Look at the pattern of the pack expansion. */
6373 targ
= PACK_EXPANSION_PATTERN (targ
);
6375 /* Extract the template parameters from the template
6377 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6378 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6379 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6380 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6382 /* Verify that we can coerce the template template
6383 parameters from the template argument to the template
6384 parameter. This requires an exact match. */
6386 && !coerce_template_template_parms
6387 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6402 --processing_template_decl
;
6406 /* Since type attributes aren't mangled, we need to strip them from
6407 template type arguments. */
6410 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6413 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6415 mv
= TYPE_MAIN_VARIANT (arg
);
6416 arg
= strip_typedefs (arg
);
6417 if (TYPE_ALIGN (arg
) != TYPE_ALIGN (mv
)
6418 || TYPE_ATTRIBUTES (arg
) != TYPE_ATTRIBUTES (mv
))
6420 if (complain
& tf_warning
)
6421 warning (0, "ignoring attributes on template argument %qT", arg
);
6422 arg
= build_aligned_type (arg
, TYPE_ALIGN (mv
));
6423 arg
= cp_build_type_attribute_variant (arg
, TYPE_ATTRIBUTES (mv
));
6428 /* Convert the indicated template ARG as necessary to match the
6429 indicated template PARM. Returns the converted ARG, or
6430 error_mark_node if the conversion was unsuccessful. Error and
6431 warning messages are issued under control of COMPLAIN. This
6432 conversion is for the Ith parameter in the parameter list. ARGS is
6433 the full set of template arguments deduced so far. */
6436 convert_template_argument (tree parm
,
6439 tsubst_flags_t complain
,
6445 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6447 if (TREE_CODE (arg
) == TREE_LIST
6448 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6450 /* The template argument was the name of some
6451 member function. That's usually
6452 invalid, but static members are OK. In any
6453 case, grab the underlying fields/functions
6454 and issue an error later if required. */
6455 orig_arg
= TREE_VALUE (arg
);
6456 TREE_TYPE (arg
) = unknown_type_node
;
6461 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6462 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6463 || requires_tmpl_type
);
6465 /* When determining whether an argument pack expansion is a template,
6466 look at the pattern. */
6467 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6468 arg
= PACK_EXPANSION_PATTERN (arg
);
6470 /* Deal with an injected-class-name used as a template template arg. */
6471 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6473 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6474 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6476 if (cxx_dialect
>= cxx11
)
6477 /* OK under DR 1004. */;
6478 else if (complain
& tf_warning_or_error
)
6479 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6480 " used as template template argument", TYPE_NAME (arg
));
6481 else if (flag_pedantic_errors
)
6489 ((TREE_CODE (arg
) == TEMPLATE_DECL
6490 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6491 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6492 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6493 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6496 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6497 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6498 arg
= TYPE_STUB_DECL (arg
);
6500 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6502 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6503 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6505 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6507 if (complain
& tf_error
)
6508 error ("invalid use of destructor %qE as a type", orig_arg
);
6509 return error_mark_node
;
6512 permerror (input_location
,
6513 "to refer to a type member of a template parameter, "
6514 "use %<typename %E%>", orig_arg
);
6516 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6517 TREE_OPERAND (arg
, 1),
6523 if (is_type
!= requires_type
)
6527 if (complain
& tf_error
)
6529 error ("type/value mismatch at argument %d in template "
6530 "parameter list for %qD",
6533 inform (input_location
,
6534 " expected a constant of type %qT, got %qT",
6536 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6537 else if (requires_tmpl_type
)
6538 inform (input_location
,
6539 " expected a class template, got %qE", orig_arg
);
6541 inform (input_location
,
6542 " expected a type, got %qE", orig_arg
);
6545 return error_mark_node
;
6547 if (is_tmpl_type
^ requires_tmpl_type
)
6549 if (in_decl
&& (complain
& tf_error
))
6551 error ("type/value mismatch at argument %d in template "
6552 "parameter list for %qD",
6555 inform (input_location
,
6556 " expected a type, got %qT", DECL_NAME (arg
));
6558 inform (input_location
,
6559 " expected a class template, got %qT", orig_arg
);
6561 return error_mark_node
;
6566 if (requires_tmpl_type
)
6568 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6570 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6571 /* The number of argument required is not known yet.
6572 Just accept it for now. */
6573 val
= TREE_TYPE (arg
);
6576 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6579 /* Strip alias templates that are equivalent to another
6581 arg
= get_underlying_template (arg
);
6582 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6584 if (coerce_template_template_parms (parmparm
, argparm
,
6590 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6592 if (val
!= error_mark_node
)
6594 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6595 val
= TREE_TYPE (val
);
6596 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6597 val
= make_pack_expansion (val
);
6602 if (in_decl
&& (complain
& tf_error
))
6604 error ("type/value mismatch at argument %d in "
6605 "template parameter list for %qD",
6607 inform (input_location
,
6608 " expected a template of type %qD, got %qT",
6612 val
= error_mark_node
;
6618 /* We only form one instance of each template specialization.
6619 Therefore, if we use a non-canonical variant (i.e., a
6620 typedef), any future messages referring to the type will use
6621 the typedef, which is confusing if those future uses do not
6622 themselves also use the typedef. */
6624 val
= canonicalize_type_argument (val
, complain
);
6628 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6630 if (invalid_nontype_parm_type_p (t
, complain
))
6631 return error_mark_node
;
6633 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6635 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6639 /* Not sure if this is reachable, but it doesn't hurt
6641 error ("type mismatch in nontype parameter pack");
6642 val
= error_mark_node
;
6645 else if (!dependent_template_arg_p (orig_arg
)
6646 && !uses_template_parms (t
))
6647 /* We used to call digest_init here. However, digest_init
6648 will report errors, which we don't want when complain
6649 is zero. More importantly, digest_init will try too
6650 hard to convert things: for example, `0' should not be
6651 converted to pointer type at this point according to
6652 the standard. Accepting this is not merely an
6653 extension, since deciding whether or not these
6654 conversions can occur is part of determining which
6655 function template to call, or whether a given explicit
6656 argument specification is valid. */
6657 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6659 val
= strip_typedefs_expr (orig_arg
);
6661 if (val
== NULL_TREE
)
6662 val
= error_mark_node
;
6663 else if (val
== error_mark_node
&& (complain
& tf_error
))
6664 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6666 if (TREE_CODE (val
) == SCOPE_REF
)
6668 /* Strip typedefs from the SCOPE_REF. */
6669 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6670 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6672 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6673 QUALIFIED_NAME_IS_TEMPLATE (val
));
6680 /* Coerces the remaining template arguments in INNER_ARGS (from
6681 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6682 Returns the coerced argument pack. PARM_IDX is the position of this
6683 parameter in the template parameter list. ARGS is the original
6684 template argument list. */
6686 coerce_template_parameter_pack (tree parms
,
6694 tsubst_flags_t complain
)
6696 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6697 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6700 tree packed_parms
= NULL_TREE
;
6702 if (arg_idx
> nargs
)
6705 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6707 /* When the template parameter is a non-type template parameter pack
6708 or template template parameter pack whose type or template
6709 parameters use parameter packs, we know exactly how many arguments
6710 we are looking for. Build a vector of the instantiated decls for
6711 these template parameters in PACKED_PARMS. */
6712 /* We can't use make_pack_expansion here because it would interpret a
6713 _DECL as a use rather than a declaration. */
6714 tree decl
= TREE_VALUE (parm
);
6715 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6716 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6717 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6718 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6720 TREE_VEC_LENGTH (args
)--;
6721 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6722 TREE_VEC_LENGTH (args
)++;
6724 if (packed_parms
== error_mark_node
)
6725 return error_mark_node
;
6727 /* If we're doing a partial instantiation of a member template,
6728 verify that all of the types used for the non-type
6729 template parameter pack are, in fact, valid for non-type
6730 template parameters. */
6732 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6734 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6735 for (j
= 0; j
< len
; ++j
)
6737 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6738 if (invalid_nontype_parm_type_p (t
, complain
))
6739 return error_mark_node
;
6743 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6746 packed_args
= make_tree_vec (nargs
- arg_idx
);
6748 /* Convert the remaining arguments, which will be a part of the
6749 parameter pack "parm". */
6750 for (; arg_idx
< nargs
; ++arg_idx
)
6752 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6753 tree actual_parm
= TREE_VALUE (parm
);
6754 int pack_idx
= arg_idx
- parm_idx
;
6758 /* Once we've packed as many args as we have types, stop. */
6759 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6761 else if (PACK_EXPANSION_P (arg
))
6762 /* We don't know how many args we have yet, just
6763 use the unconverted ones for now. */
6766 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6769 if (arg
== error_mark_node
)
6771 if (complain
& tf_error
)
6772 error ("template argument %d is invalid", arg_idx
+ 1);
6775 arg
= convert_template_argument (actual_parm
,
6776 arg
, new_args
, complain
, parm_idx
,
6778 if (arg
== error_mark_node
)
6780 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6783 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6784 && TREE_VEC_LENGTH (packed_args
) > 0)
6786 if (complain
& tf_error
)
6787 error ("wrong number of template arguments (%d, should be %d)",
6788 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6789 return error_mark_node
;
6792 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6793 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6794 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6797 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6798 TREE_TYPE (argument_pack
)
6799 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6800 TREE_CONSTANT (argument_pack
) = 1;
6803 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6804 #ifdef ENABLE_CHECKING
6805 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6806 TREE_VEC_LENGTH (packed_args
));
6808 return argument_pack
;
6811 /* Returns the number of pack expansions in the template argument vector
6815 pack_expansion_args_count (tree args
)
6820 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6822 tree elt
= TREE_VEC_ELT (args
, i
);
6823 if (elt
&& PACK_EXPANSION_P (elt
))
6829 /* Convert all template arguments to their appropriate types, and
6830 return a vector containing the innermost resulting template
6831 arguments. If any error occurs, return error_mark_node. Error and
6832 warning messages are issued under control of COMPLAIN.
6834 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6835 for arguments not specified in ARGS. Otherwise, if
6836 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6837 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6838 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6842 coerce_template_parms (tree parms
,
6845 tsubst_flags_t complain
,
6846 bool require_all_args
,
6847 bool use_default_args
)
6849 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6850 tree orig_inner_args
;
6853 tree new_inner_args
;
6854 int saved_unevaluated_operand
;
6855 int saved_inhibit_evaluation_warnings
;
6857 /* When used as a boolean value, indicates whether this is a
6858 variadic template parameter list. Since it's an int, we can also
6859 subtract it from nparms to get the number of non-variadic
6862 int variadic_args_p
= 0;
6863 int post_variadic_parms
= 0;
6865 /* Likewise for parameters with default arguments. */
6868 if (args
== error_mark_node
)
6869 return error_mark_node
;
6871 nparms
= TREE_VEC_LENGTH (parms
);
6873 /* Determine if there are any parameter packs or default arguments. */
6874 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
6876 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6878 ++post_variadic_parms
;
6879 if (template_parameter_pack_p (TREE_VALUE (parm
)))
6881 if (TREE_PURPOSE (parm
))
6885 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
6886 /* If there are no parameters that follow a parameter pack, we need to
6887 expand any argument packs so that we can deduce a parameter pack from
6888 some non-packed args followed by an argument pack, as in variadic85.C.
6889 If there are such parameters, we need to leave argument packs intact
6890 so the arguments are assigned properly. This can happen when dealing
6891 with a nested class inside a partial specialization of a class
6892 template, as in variadic92.C, or when deducing a template parameter pack
6893 from a sub-declarator, as in variadic114.C. */
6894 if (!post_variadic_parms
)
6895 inner_args
= expand_template_argument_pack (inner_args
);
6897 /* Count any pack expansion args. */
6898 variadic_args_p
= pack_expansion_args_count (inner_args
);
6900 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6901 if ((nargs
> nparms
&& !variadic_p
)
6902 || (nargs
< nparms
- variadic_p
6905 && (!use_default_args
6906 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
6907 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
6909 if (complain
& tf_error
)
6911 if (variadic_p
|| default_p
)
6913 nparms
-= variadic_p
+ default_p
;
6914 error ("wrong number of template arguments "
6915 "(%d, should be at least %d)", nargs
, nparms
);
6918 error ("wrong number of template arguments "
6919 "(%d, should be %d)", nargs
, nparms
);
6922 inform (input_location
, "provided for %q+D", in_decl
);
6925 return error_mark_node
;
6927 /* We can't pass a pack expansion to a non-pack parameter of an alias
6928 template (DR 1430). */
6929 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
6931 && nargs
- variadic_args_p
< nparms
- variadic_p
)
6933 if (complain
& tf_error
)
6935 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
6937 tree arg
= TREE_VEC_ELT (inner_args
, i
);
6938 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
6940 if (PACK_EXPANSION_P (arg
)
6941 && !template_parameter_pack_p (parm
))
6943 error ("pack expansion argument for non-pack parameter "
6944 "%qD of alias template %qD", parm
, in_decl
);
6945 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
6952 return error_mark_node
;
6955 /* We need to evaluate the template arguments, even though this
6956 template-id may be nested within a "sizeof". */
6957 saved_unevaluated_operand
= cp_unevaluated_operand
;
6958 cp_unevaluated_operand
= 0;
6959 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6960 c_inhibit_evaluation_warnings
= 0;
6961 new_inner_args
= make_tree_vec (nparms
);
6962 new_args
= add_outermost_template_args (args
, new_inner_args
);
6963 int pack_adjust
= 0;
6964 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
6969 /* Get the Ith template parameter. */
6970 parm
= TREE_VEC_ELT (parms
, parm_idx
);
6972 if (parm
== error_mark_node
)
6974 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
6978 /* Calculate the next argument. */
6979 if (arg_idx
< nargs
)
6980 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6984 if (template_parameter_pack_p (TREE_VALUE (parm
))
6985 && !(arg
&& ARGUMENT_PACK_P (arg
)))
6987 /* Some arguments will be placed in the
6988 template parameter pack PARM. */
6989 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
6990 inner_args
, arg_idx
,
6994 if (arg
== NULL_TREE
)
6996 /* We don't know how many args we have yet, just use the
6997 unconverted (and still packed) ones for now. */
6998 new_inner_args
= orig_inner_args
;
7003 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
7005 /* Store this argument. */
7006 if (arg
== error_mark_node
)
7009 /* We are done with all of the arguments. */
7014 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
7015 arg_idx
+= pack_adjust
;
7022 if (PACK_EXPANSION_P (arg
))
7024 /* "If every valid specialization of a variadic template
7025 requires an empty template parameter pack, the template is
7026 ill-formed, no diagnostic required." So check that the
7027 pattern works with this parameter. */
7028 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
7029 tree conv
= convert_template_argument (TREE_VALUE (parm
),
7033 if (conv
== error_mark_node
)
7035 inform (input_location
, "so any instantiation with a "
7036 "non-empty parameter pack would be ill-formed");
7039 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
7040 /* Recover from missing typename. */
7041 TREE_VEC_ELT (inner_args
, arg_idx
)
7042 = make_pack_expansion (conv
);
7044 /* We don't know how many args we have yet, just
7045 use the unconverted ones for now. */
7046 new_inner_args
= inner_args
;
7051 else if (require_all_args
)
7053 /* There must be a default arg in this case. */
7054 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
7056 /* The position of the first default template argument,
7057 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7059 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7060 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7061 arg_idx
- pack_adjust
);
7066 if (arg
== error_mark_node
)
7068 if (complain
& tf_error
)
7069 error ("template argument %d is invalid", arg_idx
+ 1);
7072 /* This only occurs if there was an error in the template
7073 parameter list itself (which we would already have
7074 reported) that we are trying to recover from, e.g., a class
7075 template with a parameter list such as
7076 template<typename..., typename>. */
7079 arg
= convert_template_argument (TREE_VALUE (parm
),
7080 arg
, new_args
, complain
,
7083 if (arg
== error_mark_node
)
7085 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7087 cp_unevaluated_operand
= saved_unevaluated_operand
;
7088 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7090 if (variadic_p
&& arg_idx
< nargs
)
7092 if (complain
& tf_error
)
7094 error ("wrong number of template arguments "
7095 "(%d, should be %d)", nargs
, arg_idx
);
7097 error ("provided for %q+D", in_decl
);
7099 return error_mark_node
;
7103 return error_mark_node
;
7105 #ifdef ENABLE_CHECKING
7106 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7107 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7108 TREE_VEC_LENGTH (new_inner_args
));
7111 return new_inner_args
;
7114 /* Like coerce_template_parms. If PARMS represents all template
7115 parameters levels, this function returns a vector of vectors
7116 representing all the resulting argument levels. Note that in this
7117 case, only the innermost arguments are coerced because the
7118 outermost ones are supposed to have been coerced already.
7120 Otherwise, if PARMS represents only (the innermost) vector of
7121 parameters, this function returns a vector containing just the
7122 innermost resulting arguments. */
7125 coerce_innermost_template_parms (tree parms
,
7128 tsubst_flags_t complain
,
7129 bool require_all_args
,
7130 bool use_default_args
)
7132 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7133 int args_depth
= TMPL_ARGS_DEPTH (args
);
7136 if (parms_depth
> 1)
7138 coerced_args
= make_tree_vec (parms_depth
);
7142 for (level
= parms
, cur_depth
= parms_depth
;
7143 parms_depth
> 0 && level
!= NULL_TREE
;
7144 level
= TREE_CHAIN (level
), --cur_depth
)
7147 if (cur_depth
== args_depth
)
7148 l
= coerce_template_parms (TREE_VALUE (level
),
7149 args
, in_decl
, complain
,
7153 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7155 if (l
== error_mark_node
)
7156 return error_mark_node
;
7158 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7162 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7163 args
, in_decl
, complain
,
7166 return coerced_args
;
7169 /* Returns 1 if template args OT and NT are equivalent. */
7172 template_args_equal (tree ot
, tree nt
)
7176 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7179 if (TREE_CODE (nt
) == TREE_VEC
)
7180 /* For member templates */
7181 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7182 else if (PACK_EXPANSION_P (ot
))
7183 return (PACK_EXPANSION_P (nt
)
7184 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7185 PACK_EXPANSION_PATTERN (nt
))
7186 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7187 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7188 else if (ARGUMENT_PACK_P (ot
))
7193 if (!ARGUMENT_PACK_P (nt
))
7196 opack
= ARGUMENT_PACK_ARGS (ot
);
7197 npack
= ARGUMENT_PACK_ARGS (nt
);
7198 len
= TREE_VEC_LENGTH (opack
);
7199 if (TREE_VEC_LENGTH (npack
) != len
)
7201 for (i
= 0; i
< len
; ++i
)
7202 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7203 TREE_VEC_ELT (npack
, i
)))
7207 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7209 /* We get here probably because we are in the middle of substituting
7210 into the pattern of a pack expansion. In that case the
7211 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7212 interested in. So we want to use the initial pack argument for
7214 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7215 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7216 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7217 return template_args_equal (ot
, nt
);
7219 else if (TYPE_P (nt
))
7220 return TYPE_P (ot
) && same_type_p (ot
, nt
);
7221 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7224 return cp_tree_equal (ot
, nt
);
7227 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7228 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7229 NEWARG_PTR with the offending arguments if they are non-NULL. */
7232 comp_template_args_with_info (tree oldargs
, tree newargs
,
7233 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7237 if (oldargs
== newargs
)
7240 if (!oldargs
|| !newargs
)
7243 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7246 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7248 tree nt
= TREE_VEC_ELT (newargs
, i
);
7249 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7251 if (! template_args_equal (ot
, nt
))
7253 if (oldarg_ptr
!= NULL
)
7255 if (newarg_ptr
!= NULL
)
7263 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7264 of template arguments. Returns 0 otherwise. */
7267 comp_template_args (tree oldargs
, tree newargs
)
7269 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7273 add_pending_template (tree d
)
7275 tree ti
= (TYPE_P (d
)
7276 ? CLASSTYPE_TEMPLATE_INFO (d
)
7277 : DECL_TEMPLATE_INFO (d
));
7278 struct pending_template
*pt
;
7281 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7284 /* We are called both from instantiate_decl, where we've already had a
7285 tinst_level pushed, and instantiate_template, where we haven't.
7287 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7290 push_tinst_level (d
);
7292 pt
= ggc_alloc
<pending_template
> ();
7294 pt
->tinst
= current_tinst_level
;
7295 if (last_pending_template
)
7296 last_pending_template
->next
= pt
;
7298 pending_templates
= pt
;
7300 last_pending_template
= pt
;
7302 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7309 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7310 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7311 documentation for TEMPLATE_ID_EXPR. */
7314 lookup_template_function (tree fns
, tree arglist
)
7318 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7319 return error_mark_node
;
7321 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7323 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7325 error ("%q#D is not a function template", fns
);
7326 return error_mark_node
;
7329 if (BASELINK_P (fns
))
7331 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7333 BASELINK_FUNCTIONS (fns
),
7338 type
= TREE_TYPE (fns
);
7339 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7340 type
= unknown_type_node
;
7342 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7345 /* Within the scope of a template class S<T>, the name S gets bound
7346 (in build_self_reference) to a TYPE_DECL for the class, not a
7347 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7348 or one of its enclosing classes, and that type is a template,
7349 return the associated TEMPLATE_DECL. Otherwise, the original
7352 Also handle the case when DECL is a TREE_LIST of ambiguous
7353 injected-class-names from different bases. */
7356 maybe_get_template_decl_from_type_decl (tree decl
)
7358 if (decl
== NULL_TREE
)
7361 /* DR 176: A lookup that finds an injected-class-name (10.2
7362 [class.member.lookup]) can result in an ambiguity in certain cases
7363 (for example, if it is found in more than one base class). If all of
7364 the injected-class-names that are found refer to specializations of
7365 the same class template, and if the name is followed by a
7366 template-argument-list, the reference refers to the class template
7367 itself and not a specialization thereof, and is not ambiguous. */
7368 if (TREE_CODE (decl
) == TREE_LIST
)
7370 tree t
, tmpl
= NULL_TREE
;
7371 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7373 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7376 else if (tmpl
!= elt
)
7379 if (tmpl
&& t
== NULL_TREE
)
7385 return (decl
!= NULL_TREE
7386 && DECL_SELF_REFERENCE_P (decl
)
7387 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7388 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7391 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7392 parameters, find the desired type.
7394 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7396 IN_DECL, if non-NULL, is the template declaration we are trying to
7399 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7400 the class we are looking up.
7402 Issue error and warning messages under control of COMPLAIN.
7404 If the template class is really a local class in a template
7405 function, then the FUNCTION_CONTEXT is the function in which it is
7408 ??? Note that this function is currently called *twice* for each
7409 template-id: the first time from the parser, while creating the
7410 incomplete type (finish_template_type), and the second type during the
7411 real instantiation (instantiate_template_class). This is surely something
7412 that we want to avoid. It also causes some problems with argument
7413 coercion (see convert_nontype_argument for more information on this). */
7416 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7417 int entering_scope
, tsubst_flags_t complain
)
7419 tree templ
= NULL_TREE
, parmlist
;
7426 if (identifier_p (d1
))
7428 tree value
= innermost_non_namespace_value (d1
);
7429 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7434 push_decl_namespace (context
);
7435 templ
= lookup_name (d1
);
7436 templ
= maybe_get_template_decl_from_type_decl (templ
);
7438 pop_decl_namespace ();
7441 context
= DECL_CONTEXT (templ
);
7443 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7445 tree type
= TREE_TYPE (d1
);
7447 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7448 an implicit typename for the second A. Deal with it. */
7449 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7450 type
= TREE_TYPE (type
);
7452 if (CLASSTYPE_TEMPLATE_INFO (type
))
7454 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7455 d1
= DECL_NAME (templ
);
7458 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7459 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7461 templ
= TYPE_TI_TEMPLATE (d1
);
7462 d1
= DECL_NAME (templ
);
7464 else if (DECL_TYPE_TEMPLATE_P (d1
))
7467 d1
= DECL_NAME (templ
);
7468 context
= DECL_CONTEXT (templ
);
7470 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7473 d1
= DECL_NAME (templ
);
7476 /* Issue an error message if we didn't find a template. */
7479 if (complain
& tf_error
)
7480 error ("%qT is not a template", d1
);
7481 return error_mark_node
;
7484 if (TREE_CODE (templ
) != TEMPLATE_DECL
7485 /* Make sure it's a user visible template, if it was named by
7487 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7488 && !PRIMARY_TEMPLATE_P (templ
)))
7490 if (complain
& tf_error
)
7492 error ("non-template type %qT used as a template", d1
);
7494 error ("for template declaration %q+D", in_decl
);
7496 return error_mark_node
;
7499 complain
&= ~tf_user
;
7501 /* An alias that just changes the name of a template is equivalent to the
7502 other template, so if any of the arguments are pack expansions, strip
7503 the alias to avoid problems with a pack expansion passed to a non-pack
7504 alias template parameter (DR 1430). */
7505 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7506 templ
= get_underlying_template (templ
);
7508 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7510 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7511 template arguments */
7517 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7519 /* Consider an example where a template template parameter declared as
7521 template <class T, class U = std::allocator<T> > class TT
7523 The template parameter level of T and U are one level larger than
7524 of TT. To proper process the default argument of U, say when an
7525 instantiation `TT<int>' is seen, we need to build the full
7526 arguments containing {int} as the innermost level. Outer levels,
7527 available when not appearing as default template argument, can be
7528 obtained from the arguments of the enclosing template.
7530 Suppose that TT is later substituted with std::vector. The above
7531 instantiation is `TT<int, std::allocator<T> >' with TT at
7532 level 1, and T at level 2, while the template arguments at level 1
7533 becomes {std::vector} and the inner level 2 is {int}. */
7535 outer
= DECL_CONTEXT (templ
);
7537 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7538 else if (current_template_parms
)
7539 /* This is an argument of the current template, so we haven't set
7540 DECL_CONTEXT yet. */
7541 outer
= current_template_args ();
7544 arglist
= add_to_template_args (outer
, arglist
);
7546 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7548 /*require_all_args=*/true,
7549 /*use_default_args=*/true);
7550 if (arglist2
== error_mark_node
7551 || (!uses_template_parms (arglist2
)
7552 && check_instantiated_args (templ
, arglist2
, complain
)))
7553 return error_mark_node
;
7555 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7560 tree template_type
= TREE_TYPE (templ
);
7563 tree found
= NULL_TREE
;
7566 int is_dependent_type
;
7567 int use_partial_inst_tmpl
= false;
7569 if (template_type
== error_mark_node
)
7570 /* An error occurred while building the template TEMPL, and a
7571 diagnostic has most certainly been emitted for that
7572 already. Let's propagate that error. */
7573 return error_mark_node
;
7575 gen_tmpl
= most_general_template (templ
);
7576 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7577 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7578 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7580 if (arg_depth
== 1 && parm_depth
> 1)
7582 /* We've been given an incomplete set of template arguments.
7585 template <class T> struct S1 {
7586 template <class U> struct S2 {};
7587 template <class U> struct S2<U*> {};
7590 we will be called with an ARGLIST of `U*', but the
7591 TEMPLATE will be `template <class T> template
7592 <class U> struct S1<T>::S2'. We must fill in the missing
7595 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7597 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7600 /* Now we should have enough arguments. */
7601 gcc_assert (parm_depth
== arg_depth
);
7603 /* From here on, we're only interested in the most general
7606 /* Calculate the BOUND_ARGS. These will be the args that are
7607 actually tsubst'd into the definition to create the
7611 /* We have multiple levels of arguments to coerce, at once. */
7613 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
7615 tree bound_args
= make_tree_vec (parm_depth
);
7617 for (i
= saved_depth
,
7618 t
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7619 i
> 0 && t
!= NULL_TREE
;
7620 --i
, t
= TREE_CHAIN (t
))
7623 if (i
== saved_depth
)
7624 a
= coerce_template_parms (TREE_VALUE (t
),
7627 /*require_all_args=*/true,
7628 /*use_default_args=*/true);
7630 /* Outer levels should have already been coerced. */
7631 a
= TMPL_ARGS_LEVEL (arglist
, i
);
7633 /* Don't process further if one of the levels fails. */
7634 if (a
== error_mark_node
)
7636 /* Restore the ARGLIST to its full size. */
7637 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7638 return error_mark_node
;
7641 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
7643 /* We temporarily reduce the length of the ARGLIST so
7644 that coerce_template_parms will see only the arguments
7645 corresponding to the template parameters it is
7647 TREE_VEC_LENGTH (arglist
)--;
7650 /* Restore the ARGLIST to its full size. */
7651 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7653 arglist
= bound_args
;
7657 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
7658 INNERMOST_TEMPLATE_ARGS (arglist
),
7661 /*require_all_args=*/true,
7662 /*use_default_args=*/true);
7664 if (arglist
== error_mark_node
)
7665 /* We were unable to bind the arguments. */
7666 return error_mark_node
;
7668 /* In the scope of a template class, explicit references to the
7669 template class refer to the type of the template, not any
7670 instantiation of it. For example, in:
7672 template <class T> class C { void f(C<T>); }
7674 the `C<T>' is just the same as `C'. Outside of the
7675 class, however, such a reference is an instantiation. */
7677 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7678 || currently_open_class (template_type
))
7679 /* comp_template_args is expensive, check it last. */
7680 && comp_template_args (TYPE_TI_ARGS (template_type
),
7682 return template_type
;
7684 /* If we already have this specialization, return it. */
7685 elt
.tmpl
= gen_tmpl
;
7687 hash
= hash_specialization (&elt
);
7688 entry
= (spec_entry
*) htab_find_with_hash (type_specializations
,
7694 is_dependent_type
= uses_template_parms (arglist
);
7696 /* If the deduced arguments are invalid, then the binding
7698 if (!is_dependent_type
7699 && check_instantiated_args (gen_tmpl
,
7700 INNERMOST_TEMPLATE_ARGS (arglist
),
7702 return error_mark_node
;
7704 if (!is_dependent_type
7705 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7706 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7707 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7709 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7710 DECL_NAME (gen_tmpl
),
7711 /*tag_scope=*/ts_global
);
7715 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7717 if (context
== error_mark_node
)
7718 return error_mark_node
;
7721 context
= global_namespace
;
7723 /* Create the type. */
7724 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7726 /* The user referred to a specialization of an alias
7727 template represented by GEN_TMPL.
7729 [temp.alias]/2 says:
7731 When a template-id refers to the specialization of an
7732 alias template, it is equivalent to the associated
7733 type obtained by substitution of its
7734 template-arguments for the template-parameters in the
7735 type-id of the alias template. */
7737 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7738 /* Note that the call above (by indirectly calling
7739 register_specialization in tsubst_decl) registers the
7740 TYPE_DECL representing the specialization of the alias
7741 template. So next time someone substitutes ARGLIST for
7742 the template parms into the alias template (GEN_TMPL),
7743 she'll get that TYPE_DECL back. */
7745 if (t
== error_mark_node
)
7748 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7750 if (!is_dependent_type
)
7752 set_current_access_from_decl (TYPE_NAME (template_type
));
7753 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7754 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7755 arglist
, complain
, in_decl
),
7756 SCOPED_ENUM_P (template_type
), NULL
);
7758 if (t
== error_mark_node
)
7763 /* We don't want to call start_enum for this type, since
7764 the values for the enumeration constants may involve
7765 template parameters. And, no one should be interested
7766 in the enumeration constants for such a type. */
7767 t
= cxx_make_type (ENUMERAL_TYPE
);
7768 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7770 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7771 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7772 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7774 else if (CLASS_TYPE_P (template_type
))
7776 t
= make_class_type (TREE_CODE (template_type
));
7777 CLASSTYPE_DECLARED_CLASS (t
)
7778 = CLASSTYPE_DECLARED_CLASS (template_type
);
7779 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7780 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7782 /* A local class. Make sure the decl gets registered properly. */
7783 if (context
== current_function_decl
)
7784 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7786 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7787 /* This instantiation is another name for the primary
7788 template type. Set the TYPE_CANONICAL field
7790 TYPE_CANONICAL (t
) = template_type
;
7791 else if (any_template_arguments_need_structural_equality_p (arglist
))
7792 /* Some of the template arguments require structural
7793 equality testing, so this template class requires
7794 structural equality testing. */
7795 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7800 /* If we called start_enum or pushtag above, this information
7801 will already be set up. */
7804 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7806 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7807 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7808 DECL_SOURCE_LOCATION (type_decl
)
7809 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7812 type_decl
= TYPE_NAME (t
);
7814 if (CLASS_TYPE_P (template_type
))
7816 TREE_PRIVATE (type_decl
)
7817 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7818 TREE_PROTECTED (type_decl
)
7819 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7820 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7822 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7823 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7827 if (OVERLOAD_TYPE_P (t
)
7828 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7831 = lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (template_type
)))
7833 if (!TREE_CHAIN (attributes
))
7834 TYPE_ATTRIBUTES (t
) = attributes
;
7837 = build_tree_list (TREE_PURPOSE (attributes
),
7838 TREE_VALUE (attributes
));
7842 /* Let's consider the explicit specialization of a member
7843 of a class template specialization that is implicitly instantiated,
7848 template<class U> struct M {}; //#0
7853 struct S<int>::M<char> //#1
7857 [temp.expl.spec]/4 says this is valid.
7859 In this case, when we write:
7862 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7865 When we encounter #1, we want to store the partial instantiation
7866 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7868 For all cases other than this "explicit specialization of member of a
7869 class template", we just want to store the most general template into
7870 the CLASSTYPE_TI_TEMPLATE of M.
7872 This case of "explicit specialization of member of a class template"
7874 1/ the enclosing class is an instantiation of, and therefore not
7875 the same as, the context of the most general template, and
7876 2/ we aren't looking at the partial instantiation itself, i.e.
7877 the innermost arguments are not the same as the innermost parms of
7878 the most general template.
7880 So it's only when 1/ and 2/ happens that we want to use the partial
7881 instantiation of the member template in lieu of its most general
7884 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
7885 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
7886 /* the enclosing class must be an instantiation... */
7887 && CLASS_TYPE_P (context
)
7888 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
7890 tree partial_inst_args
;
7891 TREE_VEC_LENGTH (arglist
)--;
7892 ++processing_template_decl
;
7894 tsubst (INNERMOST_TEMPLATE_ARGS
7895 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
7896 arglist
, complain
, NULL_TREE
);
7897 --processing_template_decl
;
7898 TREE_VEC_LENGTH (arglist
)++;
7899 use_partial_inst_tmpl
=
7900 /*...and we must not be looking at the partial instantiation
7902 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
7906 if (!use_partial_inst_tmpl
)
7907 /* This case is easy; there are no member templates involved. */
7911 /* This is a full instantiation of a member template. Find
7912 the partial instantiation of which this is an instance. */
7914 /* Temporarily reduce by one the number of levels in the ARGLIST
7915 so as to avoid comparing the last set of arguments. */
7916 TREE_VEC_LENGTH (arglist
)--;
7917 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
7918 TREE_VEC_LENGTH (arglist
)++;
7919 /* FOUND is either a proper class type, or an alias
7920 template specialization. In the later case, it's a
7921 TYPE_DECL, resulting from the substituting of arguments
7922 for parameters in the TYPE_DECL of the alias template
7923 done earlier. So be careful while getting the template
7925 found
= TREE_CODE (found
) == TYPE_DECL
7926 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
7927 : CLASSTYPE_TI_TEMPLATE (found
);
7930 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
7933 slot
= htab_find_slot_with_hash (type_specializations
,
7934 &elt
, hash
, INSERT
);
7935 entry
= ggc_alloc
<spec_entry
> ();
7939 /* Note this use of the partial instantiation so we can check it
7940 later in maybe_process_partial_specialization. */
7941 DECL_TEMPLATE_INSTANTIATIONS (found
)
7942 = tree_cons (arglist
, t
,
7943 DECL_TEMPLATE_INSTANTIATIONS (found
));
7945 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
7946 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7947 /* Now that the type has been registered on the instantiations
7948 list, we set up the enumerators. Because the enumeration
7949 constants may involve the enumeration type itself, we make
7950 sure to register the type first, and then create the
7951 constants. That way, doing tsubst_expr for the enumeration
7952 constants won't result in recursive calls here; we'll find
7953 the instantiation and exit above. */
7954 tsubst_enum (template_type
, t
, arglist
);
7956 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
7957 /* If the type makes use of template parameters, the
7958 code that generates debugging information will crash. */
7959 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
7961 /* Possibly limit visibility based on template args. */
7962 TREE_PUBLIC (type_decl
) = 1;
7963 determine_visibility (type_decl
);
7965 inherit_targ_abi_tags (t
);
7971 /* Wrapper for lookup_template_class_1. */
7974 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
7975 int entering_scope
, tsubst_flags_t complain
)
7978 timevar_push (TV_TEMPLATE_INST
);
7979 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
7980 entering_scope
, complain
);
7981 timevar_pop (TV_TEMPLATE_INST
);
7985 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST.
7986 If the ARGLIST refers to any template parameters, the type of the
7987 expression is the unknown_type_node since the template-id could
7988 refer to an explicit or partial specialization. */
7991 lookup_template_variable (tree templ
, tree arglist
)
7994 if (uses_template_parms (arglist
))
7995 type
= unknown_type_node
;
7997 type
= TREE_TYPE (templ
);
7998 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
8006 /* True when we should also visit template parameters that occur in
8007 non-deduced contexts. */
8008 bool include_nondeduced_p
;
8009 hash_set
<tree
> *visited
;
8012 /* Called from for_each_template_parm via walk_tree. */
8015 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
8018 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
8019 tree_fn_t fn
= pfd
->fn
;
8020 void *data
= pfd
->data
;
8023 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
8024 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
8025 pfd
->include_nondeduced_p
))
8026 return error_mark_node
;
8028 switch (TREE_CODE (t
))
8031 if (TYPE_PTRMEMFUNC_P (t
))
8037 if (!TYPE_TEMPLATE_INFO (t
))
8039 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
8040 fn
, data
, pfd
->visited
,
8041 pfd
->include_nondeduced_p
))
8042 return error_mark_node
;
8046 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
8047 fn
, data
, pfd
->visited
,
8048 pfd
->include_nondeduced_p
)
8049 || for_each_template_parm (TYPE_MAX_VALUE (t
),
8050 fn
, data
, pfd
->visited
,
8051 pfd
->include_nondeduced_p
))
8052 return error_mark_node
;
8056 /* Since we're not going to walk subtrees, we have to do this
8058 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
8059 pfd
->visited
, pfd
->include_nondeduced_p
))
8060 return error_mark_node
;
8064 /* Check the return type. */
8065 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8066 pfd
->include_nondeduced_p
))
8067 return error_mark_node
;
8069 /* Check the parameter types. Since default arguments are not
8070 instantiated until they are needed, the TYPE_ARG_TYPES may
8071 contain expressions that involve template parameters. But,
8072 no-one should be looking at them yet. And, once they're
8073 instantiated, they don't contain template parameters, so
8074 there's no point in looking at them then, either. */
8078 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
8079 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
8080 pfd
->visited
, pfd
->include_nondeduced_p
))
8081 return error_mark_node
;
8083 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8084 want walk_tree walking into them itself. */
8090 case UNDERLYING_TYPE
:
8091 if (pfd
->include_nondeduced_p
8092 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
8094 pfd
->include_nondeduced_p
))
8095 return error_mark_node
;
8100 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
8101 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
8102 pfd
->visited
, pfd
->include_nondeduced_p
))
8103 return error_mark_node
;
8108 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
8109 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
8110 pfd
->visited
, pfd
->include_nondeduced_p
))
8111 return error_mark_node
;
8112 if (DECL_CONTEXT (t
)
8113 && pfd
->include_nondeduced_p
8114 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
8115 pfd
->visited
, pfd
->include_nondeduced_p
))
8116 return error_mark_node
;
8119 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8120 /* Record template parameters such as `T' inside `TT<T>'. */
8121 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
8122 pfd
->include_nondeduced_p
))
8123 return error_mark_node
;
8126 case TEMPLATE_TEMPLATE_PARM
:
8127 case TEMPLATE_TYPE_PARM
:
8128 case TEMPLATE_PARM_INDEX
:
8129 if (fn
&& (*fn
)(t
, data
))
8130 return error_mark_node
;
8132 return error_mark_node
;
8136 /* A template template parameter is encountered. */
8137 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
8138 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8139 pfd
->include_nondeduced_p
))
8140 return error_mark_node
;
8142 /* Already substituted template template parameter */
8148 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8150 pfd
->include_nondeduced_p
))
8151 return error_mark_node
;
8155 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8156 && pfd
->include_nondeduced_p
8157 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8158 (TREE_TYPE (t
)), fn
, data
,
8159 pfd
->visited
, pfd
->include_nondeduced_p
))
8160 return error_mark_node
;
8165 /* If there's no type, then this thing must be some expression
8166 involving template parameters. */
8167 if (!fn
&& !TREE_TYPE (t
))
8168 return error_mark_node
;
8173 case IMPLICIT_CONV_EXPR
:
8174 case REINTERPRET_CAST_EXPR
:
8175 case CONST_CAST_EXPR
:
8176 case STATIC_CAST_EXPR
:
8177 case DYNAMIC_CAST_EXPR
:
8181 case PSEUDO_DTOR_EXPR
:
8183 return error_mark_node
;
8190 /* We didn't find any template parameters we liked. */
8194 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8195 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8196 call FN with the parameter and the DATA.
8197 If FN returns nonzero, the iteration is terminated, and
8198 for_each_template_parm returns 1. Otherwise, the iteration
8199 continues. If FN never returns a nonzero value, the value
8200 returned by for_each_template_parm is 0. If FN is NULL, it is
8201 considered to be the function which always returns 1.
8203 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8204 parameters that occur in non-deduced contexts. When false, only
8205 visits those template parameters that can be deduced. */
8208 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8209 hash_set
<tree
> *visited
,
8210 bool include_nondeduced_p
)
8212 struct pair_fn_data pfd
;
8218 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8220 /* Walk the tree. (Conceptually, we would like to walk without
8221 duplicates, but for_each_template_parm_r recursively calls
8222 for_each_template_parm, so we would need to reorganize a fair
8223 bit to use walk_tree_without_duplicates, so we keep our own
8226 pfd
.visited
= visited
;
8228 pfd
.visited
= new hash_set
<tree
>;
8229 result
= cp_walk_tree (&t
,
8230 for_each_template_parm_r
,
8232 pfd
.visited
) != NULL_TREE
;
8244 /* Returns true if T depends on any template parameter. */
8247 uses_template_parms (tree t
)
8250 int saved_processing_template_decl
;
8252 saved_processing_template_decl
= processing_template_decl
;
8253 if (!saved_processing_template_decl
)
8254 processing_template_decl
= 1;
8256 dependent_p
= dependent_type_p (t
);
8257 else if (TREE_CODE (t
) == TREE_VEC
)
8258 dependent_p
= any_dependent_template_arguments_p (t
);
8259 else if (TREE_CODE (t
) == TREE_LIST
)
8260 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8261 || uses_template_parms (TREE_CHAIN (t
)));
8262 else if (TREE_CODE (t
) == TYPE_DECL
)
8263 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8266 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8267 || TREE_CODE (t
) == OVERLOAD
8270 || TREE_CODE (t
) == TRAIT_EXPR
8271 || TREE_CODE (t
) == CONSTRUCTOR
8272 || CONSTANT_CLASS_P (t
))
8273 dependent_p
= (type_dependent_expression_p (t
)
8274 || value_dependent_expression_p (t
));
8277 gcc_assert (t
== error_mark_node
);
8278 dependent_p
= false;
8281 processing_template_decl
= saved_processing_template_decl
;
8286 /* Returns true iff current_function_decl is an incompletely instantiated
8287 template. Useful instead of processing_template_decl because the latter
8288 is set to 0 during fold_non_dependent_expr. */
8291 in_template_function (void)
8293 tree fn
= current_function_decl
;
8295 ++processing_template_decl
;
8296 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8297 && DECL_TEMPLATE_INFO (fn
)
8298 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8299 --processing_template_decl
;
8303 /* Returns true if T depends on any template parameter with level LEVEL. */
8306 uses_template_parms_level (tree t
, int level
)
8308 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8309 /*include_nondeduced_p=*/true);
8312 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8313 ill-formed translation unit, i.e. a variable or function that isn't
8314 usable in a constant expression. */
8317 neglectable_inst_p (tree d
)
8320 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8321 : decl_maybe_constant_var_p (d
)));
8324 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8325 neglectable and instantiated from within an erroneous instantiation. */
8328 limit_bad_template_recursion (tree decl
)
8330 struct tinst_level
*lev
= current_tinst_level
;
8331 int errs
= errorcount
+ sorrycount
;
8332 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8335 for (; lev
; lev
= lev
->next
)
8336 if (neglectable_inst_p (lev
->decl
))
8339 return (lev
&& errs
> lev
->errors
);
8342 static int tinst_depth
;
8343 extern int max_tinst_depth
;
8346 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8348 /* We're starting to instantiate D; record the template instantiation context
8349 for diagnostics and to restore it later. */
8352 push_tinst_level (tree d
)
8354 return push_tinst_level_loc (d
, input_location
);
8357 /* We're starting to instantiate D; record the template instantiation context
8358 at LOC for diagnostics and to restore it later. */
8361 push_tinst_level_loc (tree d
, location_t loc
)
8363 struct tinst_level
*new_level
;
8365 if (tinst_depth
>= max_tinst_depth
)
8367 fatal_error ("template instantiation depth exceeds maximum of %d"
8368 " (use -ftemplate-depth= to increase the maximum)",
8373 /* If the current instantiation caused problems, don't let it instantiate
8374 anything else. Do allow deduction substitution and decls usable in
8375 constant expressions. */
8376 if (limit_bad_template_recursion (d
))
8379 new_level
= ggc_alloc
<tinst_level
> ();
8380 new_level
->decl
= d
;
8381 new_level
->locus
= loc
;
8382 new_level
->errors
= errorcount
+sorrycount
;
8383 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8384 new_level
->next
= current_tinst_level
;
8385 current_tinst_level
= new_level
;
8388 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8389 depth_reached
= tinst_depth
;
8394 /* We're done instantiating this template; return to the instantiation
8398 pop_tinst_level (void)
8400 /* Restore the filename and line number stashed away when we started
8401 this instantiation. */
8402 input_location
= current_tinst_level
->locus
;
8403 current_tinst_level
= current_tinst_level
->next
;
8407 /* We're instantiating a deferred template; restore the template
8408 instantiation context in which the instantiation was requested, which
8409 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8412 reopen_tinst_level (struct tinst_level
*level
)
8414 struct tinst_level
*t
;
8417 for (t
= level
; t
; t
= t
->next
)
8420 current_tinst_level
= level
;
8422 if (current_tinst_level
)
8423 current_tinst_level
->errors
= errorcount
+sorrycount
;
8427 /* Returns the TINST_LEVEL which gives the original instantiation
8430 struct tinst_level
*
8431 outermost_tinst_level (void)
8433 struct tinst_level
*level
= current_tinst_level
;
8436 level
= level
->next
;
8440 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8441 vector of template arguments, as for tsubst.
8443 Returns an appropriate tsubst'd friend declaration. */
8446 tsubst_friend_function (tree decl
, tree args
)
8450 if (TREE_CODE (decl
) == FUNCTION_DECL
8451 && DECL_TEMPLATE_INSTANTIATION (decl
)
8452 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8453 /* This was a friend declared with an explicit template
8454 argument list, e.g.:
8458 to indicate that f was a template instantiation, not a new
8459 function declaration. Now, we have to figure out what
8460 instantiation of what template. */
8462 tree template_id
, arglist
, fns
;
8465 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8467 /* Friend functions are looked up in the containing namespace scope.
8468 We must enter that scope, to avoid finding member functions of the
8469 current class with same name. */
8470 push_nested_namespace (ns
);
8471 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8472 tf_warning_or_error
, NULL_TREE
,
8473 /*integral_constant_expression_p=*/false);
8474 pop_nested_namespace (ns
);
8475 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8476 tf_warning_or_error
, NULL_TREE
);
8477 template_id
= lookup_template_function (fns
, arglist
);
8479 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8480 tmpl
= determine_specialization (template_id
, new_friend
,
8482 /*need_member_template=*/0,
8483 TREE_VEC_LENGTH (args
),
8485 return instantiate_template (tmpl
, new_args
, tf_error
);
8488 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8490 /* The NEW_FRIEND will look like an instantiation, to the
8491 compiler, but is not an instantiation from the point of view of
8492 the language. For example, we might have had:
8494 template <class T> struct S {
8495 template <class U> friend void f(T, U);
8498 Then, in S<int>, template <class U> void f(int, U) is not an
8499 instantiation of anything. */
8500 if (new_friend
== error_mark_node
)
8501 return error_mark_node
;
8503 DECL_USE_TEMPLATE (new_friend
) = 0;
8504 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8506 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8507 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8508 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8511 /* The mangled name for the NEW_FRIEND is incorrect. The function
8512 is not a template instantiation and should not be mangled like
8513 one. Therefore, we forget the mangling here; we'll recompute it
8514 later if we need it. */
8515 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8517 SET_DECL_RTL (new_friend
, NULL
);
8518 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8521 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8524 tree new_friend_template_info
;
8525 tree new_friend_result_template_info
;
8527 int new_friend_is_defn
;
8529 /* We must save some information from NEW_FRIEND before calling
8530 duplicate decls since that function will free NEW_FRIEND if
8532 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8533 new_friend_is_defn
=
8534 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8535 (template_for_substitution (new_friend
)))
8537 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8539 /* This declaration is a `primary' template. */
8540 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8542 new_friend_result_template_info
8543 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8546 new_friend_result_template_info
= NULL_TREE
;
8548 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8549 if (new_friend_is_defn
)
8550 DECL_INITIAL (new_friend
) = error_mark_node
;
8552 /* Inside pushdecl_namespace_level, we will push into the
8553 current namespace. However, the friend function should go
8554 into the namespace of the template. */
8555 ns
= decl_namespace_context (new_friend
);
8556 push_nested_namespace (ns
);
8557 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8558 pop_nested_namespace (ns
);
8560 if (old_decl
== error_mark_node
)
8561 return error_mark_node
;
8563 if (old_decl
!= new_friend
)
8565 /* This new friend declaration matched an existing
8566 declaration. For example, given:
8568 template <class T> void f(T);
8569 template <class U> class C {
8570 template <class T> friend void f(T) {}
8573 the friend declaration actually provides the definition
8574 of `f', once C has been instantiated for some type. So,
8575 old_decl will be the out-of-class template declaration,
8576 while new_friend is the in-class definition.
8578 But, if `f' was called before this point, the
8579 instantiation of `f' will have DECL_TI_ARGS corresponding
8580 to `T' but not to `U', references to which might appear
8581 in the definition of `f'. Previously, the most general
8582 template for an instantiation of `f' was the out-of-class
8583 version; now it is the in-class version. Therefore, we
8584 run through all specialization of `f', adding to their
8585 DECL_TI_ARGS appropriately. In particular, they need a
8586 new set of outer arguments, corresponding to the
8587 arguments for this class instantiation.
8589 The same situation can arise with something like this:
8592 template <class T> class C {
8596 when `C<int>' is instantiated. Now, `f(int)' is defined
8599 if (!new_friend_is_defn
)
8600 /* On the other hand, if the in-class declaration does
8601 *not* provide a definition, then we don't want to alter
8602 existing definitions. We can just leave everything
8607 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8608 tree new_args
= TI_ARGS (new_friend_template_info
);
8610 /* Overwrite whatever template info was there before, if
8611 any, with the new template information pertaining to
8613 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8615 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8617 /* We should have called reregister_specialization in
8619 gcc_assert (retrieve_specialization (new_template
,
8623 /* Instantiate it if the global has already been used. */
8624 if (DECL_ODR_USED (old_decl
))
8625 instantiate_decl (old_decl
, /*defer_ok=*/true,
8626 /*expl_inst_class_mem_p=*/false);
8632 /* Indicate that the old function template is a partial
8634 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8635 = new_friend_result_template_info
;
8637 gcc_assert (new_template
8638 == most_general_template (new_template
));
8639 gcc_assert (new_template
!= old_decl
);
8641 /* Reassign any specializations already in the hash table
8642 to the new more general template, and add the
8643 additional template args. */
8644 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8648 tree spec
= TREE_VALUE (t
);
8651 elt
.tmpl
= old_decl
;
8652 elt
.args
= DECL_TI_ARGS (spec
);
8653 elt
.spec
= NULL_TREE
;
8655 htab_remove_elt (decl_specializations
, &elt
);
8658 = add_outermost_template_args (new_args
,
8659 DECL_TI_ARGS (spec
));
8661 register_specialization
8662 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8665 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8669 /* The information from NEW_FRIEND has been merged into OLD_DECL
8670 by duplicate_decls. */
8671 new_friend
= old_decl
;
8676 tree context
= DECL_CONTEXT (new_friend
);
8680 template <class T> class C {
8681 template <class U> friend void C1<U>::f (); // case 1
8682 friend void C2<T>::f (); // case 2
8684 we only need to make sure CONTEXT is a complete type for
8685 case 2. To distinguish between the two cases, we note that
8686 CONTEXT of case 1 remains dependent type after tsubst while
8687 this isn't true for case 2. */
8688 ++processing_template_decl
;
8689 dependent_p
= dependent_type_p (context
);
8690 --processing_template_decl
;
8693 && !complete_type_or_else (context
, NULL_TREE
))
8694 return error_mark_node
;
8696 if (COMPLETE_TYPE_P (context
))
8698 tree fn
= new_friend
;
8699 /* do_friend adds the TEMPLATE_DECL for any member friend
8700 template even if it isn't a member template, i.e.
8701 template <class T> friend A<T>::f();
8702 Look through it in that case. */
8703 if (TREE_CODE (fn
) == TEMPLATE_DECL
8704 && !PRIMARY_TEMPLATE_P (fn
))
8705 fn
= DECL_TEMPLATE_RESULT (fn
);
8706 /* Check to see that the declaration is really present, and,
8707 possibly obtain an improved declaration. */
8708 fn
= check_classfn (context
, fn
, NULL_TREE
);
8718 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8719 template arguments, as for tsubst.
8721 Returns an appropriate tsubst'd friend type or error_mark_node on
8725 tsubst_friend_class (tree friend_tmpl
, tree args
)
8731 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8733 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8734 return TREE_TYPE (t
);
8737 context
= CP_DECL_CONTEXT (friend_tmpl
);
8739 if (context
!= global_namespace
)
8741 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8742 push_nested_namespace (context
);
8744 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8747 /* Look for a class template declaration. We look for hidden names
8748 because two friend declarations of the same template are the
8749 same. For example, in:
8752 template <typename> friend class F;
8754 template <typename> struct B {
8755 template <typename> friend class F;
8758 both F templates are the same. */
8759 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8760 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8762 /* But, if we don't find one, it might be because we're in a
8763 situation like this:
8771 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8772 for `S<int>', not the TEMPLATE_DECL. */
8773 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8775 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8776 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8779 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8781 /* The friend template has already been declared. Just
8782 check to see that the declarations match, and install any new
8783 default parameters. We must tsubst the default parameters,
8784 of course. We only need the innermost template parameters
8785 because that is all that redeclare_class_template will look
8787 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8788 > TMPL_ARGS_DEPTH (args
))
8791 location_t saved_input_location
;
8792 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8793 args
, tf_warning_or_error
);
8795 saved_input_location
= input_location
;
8796 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8797 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8798 input_location
= saved_input_location
;
8802 friend_type
= TREE_TYPE (tmpl
);
8806 /* The friend template has not already been declared. In this
8807 case, the instantiation of the template class will cause the
8808 injection of this template into the global scope. */
8809 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8810 if (tmpl
== error_mark_node
)
8811 return error_mark_node
;
8813 /* The new TMPL is not an instantiation of anything, so we
8814 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8815 the new type because that is supposed to be the corresponding
8816 template decl, i.e., TMPL. */
8817 DECL_USE_TEMPLATE (tmpl
) = 0;
8818 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8819 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8820 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8821 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8823 /* Inject this template into the global scope. */
8824 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8827 if (context
!= global_namespace
)
8829 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8830 pop_nested_namespace (context
);
8832 pop_nested_class ();
8838 /* Returns zero if TYPE cannot be completed later due to circularity.
8839 Otherwise returns one. */
8842 can_complete_type_without_circularity (tree type
)
8844 if (type
== NULL_TREE
|| type
== error_mark_node
)
8846 else if (COMPLETE_TYPE_P (type
))
8848 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8849 return can_complete_type_without_circularity (TREE_TYPE (type
));
8850 else if (CLASS_TYPE_P (type
)
8851 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
8857 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
8859 /* Apply any attributes which had to be deferred until instantiation
8860 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8861 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8864 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
8865 tree args
, tsubst_flags_t complain
, tree in_decl
)
8867 tree last_dep
= NULL_TREE
;
8871 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
8872 if (ATTR_IS_DEPENDENT (t
))
8875 attributes
= copy_list (attributes
);
8879 if (DECL_P (*decl_p
))
8881 if (TREE_TYPE (*decl_p
) == error_mark_node
)
8883 p
= &DECL_ATTRIBUTES (*decl_p
);
8886 p
= &TYPE_ATTRIBUTES (*decl_p
);
8890 tree late_attrs
= NULL_TREE
;
8891 tree
*q
= &late_attrs
;
8893 for (*p
= attributes
; *p
; )
8896 if (ATTR_IS_DEPENDENT (t
))
8898 *p
= TREE_CHAIN (t
);
8899 TREE_CHAIN (t
) = NULL_TREE
;
8900 if ((flag_openmp
|| flag_cilkplus
)
8901 && is_attribute_p ("omp declare simd",
8902 get_attribute_name (t
))
8905 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
8906 clauses
= tsubst_omp_clauses (clauses
, true, args
,
8908 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
8909 clauses
= finish_omp_clauses (clauses
);
8910 tree parms
= DECL_ARGUMENTS (*decl_p
);
8912 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
8914 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
8916 TREE_VALUE (t
) = NULL_TREE
;
8918 /* If the first attribute argument is an identifier, don't
8919 pass it through tsubst. Attributes like mode, format,
8920 cleanup and several target specific attributes expect it
8922 else if (attribute_takes_identifier_p (get_attribute_name (t
))
8926 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
8928 /*integral_constant_expression_p=*/false);
8929 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
8931 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
8936 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
8937 /*integral_constant_expression_p=*/false);
8939 q
= &TREE_CHAIN (t
);
8942 p
= &TREE_CHAIN (t
);
8945 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
8949 /* Perform (or defer) access check for typedefs that were referenced
8950 from within the template TMPL code.
8951 This is a subroutine of instantiate_decl and instantiate_class_template.
8952 TMPL is the template to consider and TARGS is the list of arguments of
8956 perform_typedefs_access_check (tree tmpl
, tree targs
)
8958 location_t saved_location
;
8960 qualified_typedef_usage_t
*iter
;
8963 || (!CLASS_TYPE_P (tmpl
)
8964 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
8967 saved_location
= input_location
;
8968 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
8970 tree type_decl
= iter
->typedef_decl
;
8971 tree type_scope
= iter
->context
;
8973 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
8976 if (uses_template_parms (type_decl
))
8977 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
8978 if (uses_template_parms (type_scope
))
8979 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
8981 /* Make access check error messages point to the location
8982 of the use of the typedef. */
8983 input_location
= iter
->locus
;
8984 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
8985 type_decl
, type_decl
,
8986 tf_warning_or_error
);
8988 input_location
= saved_location
;
8992 instantiate_class_template_1 (tree type
)
8994 tree templ
, args
, pattern
, t
, member
;
8998 unsigned int saved_maximum_field_alignment
;
9001 if (type
== error_mark_node
)
9002 return error_mark_node
;
9004 if (COMPLETE_OR_OPEN_TYPE_P (type
)
9005 || uses_template_parms (type
))
9008 /* Figure out which template is being instantiated. */
9009 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
9010 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
9012 /* Determine what specialization of the original template to
9014 t
= most_specialized_class (type
, tf_warning_or_error
);
9015 if (t
== error_mark_node
)
9017 TYPE_BEING_DEFINED (type
) = 1;
9018 return error_mark_node
;
9022 /* This TYPE is actually an instantiation of a partial
9023 specialization. We replace the innermost set of ARGS with
9024 the arguments appropriate for substitution. For example,
9027 template <class T> struct S {};
9028 template <class T> struct S<T*> {};
9030 and supposing that we are instantiating S<int*>, ARGS will
9031 presently be {int*} -- but we need {int}. */
9032 pattern
= TREE_TYPE (t
);
9033 args
= TREE_PURPOSE (t
);
9037 pattern
= TREE_TYPE (templ
);
9038 args
= CLASSTYPE_TI_ARGS (type
);
9041 /* If the template we're instantiating is incomplete, then clearly
9042 there's nothing we can do. */
9043 if (!COMPLETE_TYPE_P (pattern
))
9046 /* If we've recursively instantiated too many templates, stop. */
9047 if (! push_tinst_level (type
))
9050 /* Now we're really doing the instantiation. Mark the type as in
9051 the process of being defined. */
9052 TYPE_BEING_DEFINED (type
) = 1;
9054 /* We may be in the middle of deferred access check. Disable
9056 push_deferring_access_checks (dk_no_deferred
);
9058 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
9059 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9060 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
9061 fn_context
= error_mark_node
;
9063 push_to_top_level ();
9064 /* Use #pragma pack from the template context. */
9065 saved_maximum_field_alignment
= maximum_field_alignment
;
9066 maximum_field_alignment
= TYPE_PRECISION (pattern
);
9068 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
9070 /* Set the input location to the most specialized template definition.
9071 This is needed if tsubsting causes an error. */
9072 typedecl
= TYPE_MAIN_DECL (pattern
);
9073 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
9074 DECL_SOURCE_LOCATION (typedecl
);
9076 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
9077 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
9078 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
9079 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
9080 if (ANON_AGGR_TYPE_P (pattern
))
9081 SET_ANON_AGGR_TYPE_P (type
);
9082 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
9084 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
9085 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
9086 /* Adjust visibility for template arguments. */
9087 determine_visibility (TYPE_MAIN_DECL (type
));
9089 if (CLASS_TYPE_P (type
))
9090 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
9092 pbinfo
= TYPE_BINFO (pattern
);
9094 /* We should never instantiate a nested class before its enclosing
9095 class; we need to look up the nested class by name before we can
9096 instantiate it, and that lookup should instantiate the enclosing
9098 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
9099 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
9101 base_list
= NULL_TREE
;
9102 if (BINFO_N_BASE_BINFOS (pbinfo
))
9108 /* We must enter the scope containing the type, as that is where
9109 the accessibility of types named in dependent bases are
9111 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9113 /* Substitute into each of the bases to determine the actual
9115 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9118 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9119 tree expanded_bases
= NULL_TREE
;
9122 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9125 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9126 args
, tf_error
, NULL_TREE
);
9127 if (expanded_bases
== error_mark_node
)
9130 len
= TREE_VEC_LENGTH (expanded_bases
);
9133 for (idx
= 0; idx
< len
; idx
++)
9136 /* Extract the already-expanded base class. */
9137 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9139 /* Substitute to figure out the base class. */
9140 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9143 if (base
== error_mark_node
)
9146 base_list
= tree_cons (access
, base
, base_list
);
9147 if (BINFO_VIRTUAL_P (pbase_binfo
))
9148 TREE_TYPE (base_list
) = integer_type_node
;
9152 /* The list is now in reverse order; correct that. */
9153 base_list
= nreverse (base_list
);
9156 pop_scope (pushed_scope
);
9158 /* Now call xref_basetypes to set up all the base-class
9160 xref_basetypes (type
, base_list
);
9162 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9163 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9164 args
, tf_error
, NULL_TREE
);
9165 fixup_attribute_variants (type
);
9167 /* Now that our base classes are set up, enter the scope of the
9168 class, so that name lookups into base classes, etc. will work
9169 correctly. This is precisely analogous to what we do in
9170 begin_class_definition when defining an ordinary non-template
9171 class, except we also need to push the enclosing classes. */
9172 push_nested_class (type
);
9174 /* Now members are processed in the order of declaration. */
9175 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9176 member
; member
= TREE_CHAIN (member
))
9178 tree t
= TREE_VALUE (member
);
9180 if (TREE_PURPOSE (member
))
9184 /* Build new CLASSTYPE_NESTED_UTDS. */
9187 bool class_template_p
;
9189 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9190 && TYPE_LANG_SPECIFIC (t
)
9191 && CLASSTYPE_IS_TEMPLATE (t
));
9192 /* If the member is a class template, then -- even after
9193 substitution -- there may be dependent types in the
9194 template argument list for the class. We increment
9195 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9196 that function will assume that no types are dependent
9197 when outside of a template. */
9198 if (class_template_p
)
9199 ++processing_template_decl
;
9200 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9201 if (class_template_p
)
9202 --processing_template_decl
;
9203 if (newtag
== error_mark_node
)
9206 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9208 tree name
= TYPE_IDENTIFIER (t
);
9210 if (class_template_p
)
9211 /* Unfortunately, lookup_template_class sets
9212 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9213 instantiation (i.e., for the type of a member
9214 template class nested within a template class.)
9215 This behavior is required for
9216 maybe_process_partial_specialization to work
9217 correctly, but is not accurate in this case;
9218 the TAG is not an instantiation of anything.
9219 (The corresponding TEMPLATE_DECL is an
9220 instantiation, but the TYPE is not.) */
9221 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9223 /* Now, we call pushtag to put this NEWTAG into the scope of
9224 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9225 pushtag calling push_template_decl. We don't have to do
9226 this for enums because it will already have been done in
9229 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9230 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9233 else if (DECL_DECLARES_FUNCTION_P (t
))
9235 /* Build new TYPE_METHODS. */
9238 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9239 ++processing_template_decl
;
9240 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9241 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9242 --processing_template_decl
;
9243 set_current_access_from_decl (r
);
9244 finish_member_declaration (r
);
9245 /* Instantiate members marked with attribute used. */
9246 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9248 if (TREE_CODE (r
) == FUNCTION_DECL
9249 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9250 cp_check_omp_declare_reduction (r
);
9252 else if (DECL_CLASS_TEMPLATE_P (t
)
9253 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
9254 /* A closure type for a lambda in a default argument for a
9255 member template. Ignore it; it will be instantiated with
9256 the default argument. */;
9259 /* Build new TYPE_FIELDS. */
9260 if (TREE_CODE (t
) == STATIC_ASSERT
)
9264 ++c_inhibit_evaluation_warnings
;
9266 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9267 tf_warning_or_error
, NULL_TREE
,
9268 /*integral_constant_expression_p=*/true);
9269 --c_inhibit_evaluation_warnings
;
9271 finish_static_assert (condition
,
9272 STATIC_ASSERT_MESSAGE (t
),
9273 STATIC_ASSERT_SOURCE_LOCATION (t
),
9276 else if (TREE_CODE (t
) != CONST_DECL
)
9279 tree vec
= NULL_TREE
;
9282 /* The file and line for this declaration, to
9283 assist in error message reporting. Since we
9284 called push_tinst_level above, we don't need to
9286 input_location
= DECL_SOURCE_LOCATION (t
);
9288 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9289 ++processing_template_decl
;
9290 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9291 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9292 --processing_template_decl
;
9294 if (TREE_CODE (r
) == TREE_VEC
)
9296 /* A capture pack became multiple fields. */
9298 len
= TREE_VEC_LENGTH (vec
);
9301 for (int i
= 0; i
< len
; ++i
)
9304 r
= TREE_VEC_ELT (vec
, i
);
9309 [t]he initialization (and any associated
9310 side-effects) of a static data member does
9311 not occur unless the static data member is
9312 itself used in a way that requires the
9313 definition of the static data member to
9316 Therefore, we do not substitute into the
9317 initialized for the static data member here. */
9318 finish_static_data_member_decl
9321 /*init_const_expr_p=*/false,
9322 /*asmspec_tree=*/NULL_TREE
,
9324 /* Instantiate members marked with attribute used. */
9325 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9328 else if (TREE_CODE (r
) == FIELD_DECL
)
9330 /* Determine whether R has a valid type and can be
9331 completed later. If R is invalid, then its type
9332 is replaced by error_mark_node. */
9333 tree rtype
= TREE_TYPE (r
);
9334 if (can_complete_type_without_circularity (rtype
))
9335 complete_type (rtype
);
9337 if (!COMPLETE_TYPE_P (rtype
))
9339 cxx_incomplete_type_error (r
, rtype
);
9340 TREE_TYPE (r
) = error_mark_node
;
9344 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9345 such a thing will already have been added to the field
9346 list by tsubst_enum in finish_member_declaration in the
9347 CLASSTYPE_NESTED_UTDS case above. */
9348 if (!(TREE_CODE (r
) == TYPE_DECL
9349 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9350 && DECL_ARTIFICIAL (r
)))
9352 set_current_access_from_decl (r
);
9353 finish_member_declaration (r
);
9361 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9362 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9364 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9366 tree friend_type
= t
;
9367 bool adjust_processing_template_decl
= false;
9369 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9371 /* template <class T> friend class C; */
9372 friend_type
= tsubst_friend_class (friend_type
, args
);
9373 adjust_processing_template_decl
= true;
9375 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9377 /* template <class T> friend class C::D; */
9378 friend_type
= tsubst (friend_type
, args
,
9379 tf_warning_or_error
, NULL_TREE
);
9380 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9381 friend_type
= TREE_TYPE (friend_type
);
9382 adjust_processing_template_decl
= true;
9384 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9385 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9387 /* This could be either
9391 when dependent_type_p is false or
9393 template <class U> friend class T::C;
9396 friend_type
= tsubst (friend_type
, args
,
9397 tf_warning_or_error
, NULL_TREE
);
9398 /* Bump processing_template_decl for correct
9399 dependent_type_p calculation. */
9400 ++processing_template_decl
;
9401 if (dependent_type_p (friend_type
))
9402 adjust_processing_template_decl
= true;
9403 --processing_template_decl
;
9405 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9406 && hidden_name_p (TYPE_NAME (friend_type
)))
9410 where C hasn't been declared yet. Let's lookup name
9411 from namespace scope directly, bypassing any name that
9412 come from dependent base class. */
9413 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9415 /* The call to xref_tag_from_type does injection for friend
9417 push_nested_namespace (ns
);
9419 xref_tag_from_type (friend_type
, NULL_TREE
,
9420 /*tag_scope=*/ts_current
);
9421 pop_nested_namespace (ns
);
9423 else if (uses_template_parms (friend_type
))
9424 /* friend class C<T>; */
9425 friend_type
= tsubst (friend_type
, args
,
9426 tf_warning_or_error
, NULL_TREE
);
9431 where C is already declared or
9433 friend class C<int>;
9435 We don't have to do anything in these cases. */
9437 if (adjust_processing_template_decl
)
9438 /* Trick make_friend_class into realizing that the friend
9439 we're adding is a template, not an ordinary class. It's
9440 important that we use make_friend_class since it will
9441 perform some error-checking and output cross-reference
9443 ++processing_template_decl
;
9445 if (friend_type
!= error_mark_node
)
9446 make_friend_class (type
, friend_type
, /*complain=*/false);
9448 if (adjust_processing_template_decl
)
9449 --processing_template_decl
;
9453 /* Build new DECL_FRIENDLIST. */
9456 /* The file and line for this declaration, to
9457 assist in error message reporting. Since we
9458 called push_tinst_level above, we don't need to
9460 input_location
= DECL_SOURCE_LOCATION (t
);
9462 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9464 ++processing_template_decl
;
9465 push_deferring_access_checks (dk_no_check
);
9468 r
= tsubst_friend_function (t
, args
);
9469 add_friend (type
, r
, /*complain=*/false);
9470 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9472 pop_deferring_access_checks ();
9473 --processing_template_decl
;
9479 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9481 tree decl
= lambda_function (type
);
9484 if (!DECL_TEMPLATE_INFO (decl
)
9485 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9486 instantiate_decl (decl
, false, false);
9488 /* We need to instantiate the capture list from the template
9489 after we've instantiated the closure members, but before we
9490 consider adding the conversion op. Also keep any captures
9491 that may have been added during instantiation of the op(). */
9492 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9494 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9495 args
, tf_warning_or_error
, NULL_TREE
,
9498 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9499 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9501 maybe_add_lambda_conv_op (type
);
9504 gcc_assert (errorcount
);
9507 /* Set the file and line number information to whatever is given for
9508 the class itself. This puts error messages involving generated
9509 implicit functions at a predictable point, and the same point
9510 that would be used for non-template classes. */
9511 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9513 unreverse_member_declarations (type
);
9514 finish_struct_1 (type
);
9515 TYPE_BEING_DEFINED (type
) = 0;
9517 /* We don't instantiate default arguments for member functions. 14.7.1:
9519 The implicit instantiation of a class template specialization causes
9520 the implicit instantiation of the declarations, but not of the
9521 definitions or default arguments, of the class member functions,
9522 member classes, static data members and member templates.... */
9524 /* Some typedefs referenced from within the template code need to be access
9525 checked at template instantiation time, i.e now. These types were
9526 added to the template at parsing time. Let's get those and perform
9527 the access checks then. */
9528 perform_typedefs_access_check (pattern
, args
);
9529 perform_deferred_access_checks (tf_warning_or_error
);
9530 pop_nested_class ();
9531 maximum_field_alignment
= saved_maximum_field_alignment
;
9533 pop_from_top_level ();
9534 pop_deferring_access_checks ();
9537 /* The vtable for a template class can be emitted in any translation
9538 unit in which the class is instantiated. When there is no key
9539 method, however, finish_struct_1 will already have added TYPE to
9540 the keyed_classes list. */
9541 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9542 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9547 /* Wrapper for instantiate_class_template_1. */
9550 instantiate_class_template (tree type
)
9553 timevar_push (TV_TEMPLATE_INST
);
9554 ret
= instantiate_class_template_1 (type
);
9555 timevar_pop (TV_TEMPLATE_INST
);
9560 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9566 else if (TYPE_P (t
))
9567 r
= tsubst (t
, args
, complain
, in_decl
);
9570 if (!(complain
& tf_warning
))
9571 ++c_inhibit_evaluation_warnings
;
9572 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9573 /*integral_constant_expression_p=*/true);
9574 if (!(complain
& tf_warning
))
9575 --c_inhibit_evaluation_warnings
;
9580 /* Given a function parameter pack TMPL_PARM and some function parameters
9581 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9582 and set *SPEC_P to point at the next point in the list. */
9585 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9587 /* Collect all of the extra "packed" parameters into an
9591 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9592 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9593 tree spec_parm
= *spec_p
;
9596 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9598 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9601 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9602 parmvec
= make_tree_vec (len
);
9603 parmtypevec
= make_tree_vec (len
);
9604 spec_parm
= *spec_p
;
9605 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9607 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9608 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9611 /* Build the argument packs. */
9612 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9613 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9614 TREE_TYPE (argpack
) = argtypepack
;
9615 *spec_p
= spec_parm
;
9620 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9621 NONTYPE_ARGUMENT_PACK. */
9624 make_fnparm_pack (tree spec_parm
)
9626 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9629 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9633 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9635 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9636 if (i
>= TREE_VEC_LENGTH (vec
))
9638 return PACK_EXPANSION_P (TREE_VEC_ELT (vec
, i
));
9642 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9645 make_argument_pack_select (tree arg_pack
, unsigned index
)
9647 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9649 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9650 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9655 /* This is a subroutine of tsubst_pack_expansion.
9657 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9658 mechanism to store the (non complete list of) arguments of the
9659 substitution and return a non substituted pack expansion, in order
9660 to wait for when we have enough arguments to really perform the
9664 use_pack_expansion_extra_args_p (tree parm_packs
,
9668 /* If one pack has an expansion and another pack has a normal
9669 argument or if one pack has an empty argument and an another
9670 one hasn't then tsubst_pack_expansion cannot perform the
9671 substitution and need to fall back on the
9672 PACK_EXPANSION_EXTRA mechanism. */
9673 if (parm_packs
== NULL_TREE
)
9675 else if (has_empty_arg
)
9678 bool has_expansion_arg
= false;
9679 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9681 bool has_non_expansion_arg
= false;
9682 for (tree parm_pack
= parm_packs
;
9684 parm_pack
= TREE_CHAIN (parm_pack
))
9686 tree arg
= TREE_VALUE (parm_pack
);
9688 if (argument_pack_element_is_expansion_p (arg
, i
))
9689 has_expansion_arg
= true;
9691 has_non_expansion_arg
= true;
9694 if (has_expansion_arg
&& has_non_expansion_arg
)
9700 /* [temp.variadic]/6 says that:
9702 The instantiation of a pack expansion [...]
9703 produces a list E1,E2, ..., En, where N is the number of elements
9704 in the pack expansion parameters.
9706 This subroutine of tsubst_pack_expansion produces one of these Ei.
9708 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9709 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9710 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9711 INDEX is the index 'i' of the element Ei to produce. ARGS,
9712 COMPLAIN, and IN_DECL are the same parameters as for the
9713 tsubst_pack_expansion function.
9715 The function returns the resulting Ei upon successful completion,
9718 Note that this function possibly modifies the ARGS parameter, so
9719 it's the responsibility of the caller to restore it. */
9722 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9725 tree args
/* This parm gets
9727 tsubst_flags_t complain
,
9731 bool ith_elem_is_expansion
= false;
9733 /* For each parameter pack, change the substitution of the parameter
9734 pack to the ith argument in its argument pack, then expand the
9736 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9738 tree parm
= TREE_PURPOSE (pack
);
9739 tree arg_pack
= TREE_VALUE (pack
);
9740 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9742 ith_elem_is_expansion
|=
9743 argument_pack_element_is_expansion_p (arg_pack
, index
);
9745 /* Select the Ith argument from the pack. */
9746 if (TREE_CODE (parm
) == PARM_DECL
9747 || TREE_CODE (parm
) == FIELD_DECL
)
9751 aps
= make_argument_pack_select (arg_pack
, index
);
9753 register_local_specialization (aps
, parm
);
9756 aps
= retrieve_local_specialization (parm
);
9761 template_parm_level_and_index (parm
, &level
, &idx
);
9765 aps
= make_argument_pack_select (arg_pack
, index
);
9766 /* Update the corresponding argument. */
9767 TMPL_ARG (args
, level
, idx
) = aps
;
9770 /* Re-use the ARGUMENT_PACK_SELECT. */
9771 aps
= TMPL_ARG (args
, level
, idx
);
9773 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9776 /* Substitute into the PATTERN with the (possibly altered)
9778 if (pattern
== in_decl
)
9779 /* Expanding a fixed parameter pack from
9780 coerce_template_parameter_pack. */
9781 t
= tsubst_decl (pattern
, args
, complain
);
9782 else if (!TYPE_P (pattern
))
9783 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9784 /*integral_constant_expression_p=*/false);
9786 t
= tsubst (pattern
, args
, complain
, in_decl
);
9788 /* If the Ith argument pack element is a pack expansion, then
9789 the Ith element resulting from the substituting is going to
9790 be a pack expansion as well. */
9791 if (ith_elem_is_expansion
)
9792 t
= make_pack_expansion (t
);
9797 /* Substitute ARGS into T, which is an pack expansion
9798 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9799 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9800 (if only a partial substitution could be performed) or
9801 ERROR_MARK_NODE if there was an error. */
9803 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9807 tree pack
, packs
= NULL_TREE
;
9808 bool unsubstituted_packs
= false;
9811 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
9812 bool need_local_specializations
= false;
9815 gcc_assert (PACK_EXPANSION_P (t
));
9816 pattern
= PACK_EXPANSION_PATTERN (t
);
9818 /* Add in any args remembered from an earlier partial instantiation. */
9819 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9821 levels
= TMPL_ARGS_DEPTH (args
);
9823 /* Determine the argument packs that will instantiate the parameter
9824 packs used in the expansion expression. While we're at it,
9825 compute the number of arguments to be expanded and make sure it
9827 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
9828 pack
= TREE_CHAIN (pack
))
9830 tree parm_pack
= TREE_VALUE (pack
);
9831 tree arg_pack
= NULL_TREE
;
9832 tree orig_arg
= NULL_TREE
;
9835 if (TREE_CODE (parm_pack
) == BASES
)
9837 if (BASES_DIRECT (parm_pack
))
9838 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9839 args
, complain
, in_decl
, false));
9841 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9842 args
, complain
, in_decl
, false));
9844 if (TREE_CODE (parm_pack
) == PARM_DECL
)
9846 if (PACK_EXPANSION_LOCAL_P (t
))
9847 arg_pack
= retrieve_local_specialization (parm_pack
);
9850 /* We can't rely on local_specializations for a parameter
9851 name used later in a function declaration (such as in a
9852 late-specified return type). Even if it exists, it might
9853 have the wrong value for a recursive call. Just make a
9854 dummy decl, since it's only used for its type. */
9855 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
9856 if (arg_pack
&& DECL_PACK_P (arg_pack
))
9857 /* Partial instantiation of the parm_pack, we can't build
9858 up an argument pack yet. */
9859 arg_pack
= NULL_TREE
;
9861 arg_pack
= make_fnparm_pack (arg_pack
);
9862 need_local_specializations
= true;
9865 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
9866 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
9870 template_parm_level_and_index (parm_pack
, &level
, &idx
);
9872 if (level
<= levels
)
9873 arg_pack
= TMPL_ARG (args
, level
, idx
);
9876 orig_arg
= arg_pack
;
9877 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
9878 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
9880 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
9881 /* This can only happen if we forget to expand an argument
9882 pack somewhere else. Just return an error, silently. */
9884 result
= make_tree_vec (1);
9885 TREE_VEC_ELT (result
, 0) = error_mark_node
;
9892 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
9894 /* Don't bother trying to do a partial substitution with
9895 incomplete packs; we'll try again after deduction. */
9896 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
9901 else if (len
!= my_len
)
9903 if (!(complain
& tf_error
))
9904 /* Fail quietly. */;
9905 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
9906 error ("mismatched argument pack lengths while expanding "
9910 error ("mismatched argument pack lengths while expanding "
9913 return error_mark_node
;
9916 /* Keep track of the parameter packs and their corresponding
9918 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
9919 TREE_TYPE (packs
) = orig_arg
;
9923 /* We can't substitute for this parameter pack. We use a flag as
9924 well as the missing_level counter because function parameter
9925 packs don't have a level. */
9926 unsubstituted_packs
= true;
9930 /* If the expansion is just T..., return the matching argument pack. */
9931 if (!unsubstituted_packs
9932 && TREE_PURPOSE (packs
) == pattern
)
9934 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
9935 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
9936 || pack_expansion_args_count (args
))
9938 /* Otherwise use the normal path so we get convert_from_reference. */
9941 /* We cannot expand this expansion expression, because we don't have
9942 all of the argument packs we need. */
9943 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
9945 /* We got some full packs, but we can't substitute them in until we
9946 have values for all the packs. So remember these until then. */
9948 t
= make_pack_expansion (pattern
);
9949 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
9952 else if (unsubstituted_packs
)
9954 /* There were no real arguments, we're just replacing a parameter
9955 pack with another version of itself. Substitute into the
9956 pattern and return a PACK_EXPANSION_*. The caller will need to
9958 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
9959 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9960 /*integral_constant_expression_p=*/false);
9962 t
= tsubst (pattern
, args
, complain
, in_decl
);
9963 t
= make_pack_expansion (t
);
9967 gcc_assert (len
>= 0);
9969 if (need_local_specializations
)
9971 /* We're in a late-specified return type, so create our own local
9972 specializations map; the current map is either NULL or (in the
9973 case of recursive unification) might have bindings that we don't
9974 want to use or alter. */
9975 saved_local_specializations
= local_specializations
;
9976 local_specializations
= new hash_map
<tree
, tree
>;
9979 /* For each argument in each argument pack, substitute into the
9981 result
= make_tree_vec (len
);
9982 for (i
= 0; i
< len
; ++i
)
9984 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
9988 TREE_VEC_ELT (result
, i
) = t
;
9989 if (t
== error_mark_node
)
9991 result
= error_mark_node
;
9996 /* Update ARGS to restore the substitution from parameter packs to
9997 their argument packs. */
9998 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
10000 tree parm
= TREE_PURPOSE (pack
);
10002 if (TREE_CODE (parm
) == PARM_DECL
10003 || TREE_CODE (parm
) == FIELD_DECL
)
10004 register_local_specialization (TREE_TYPE (pack
), parm
);
10009 if (TREE_VALUE (pack
) == NULL_TREE
)
10012 template_parm_level_and_index (parm
, &level
, &idx
);
10014 /* Update the corresponding argument. */
10015 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
10016 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
10019 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
10023 if (need_local_specializations
)
10025 delete local_specializations
;
10026 local_specializations
= saved_local_specializations
;
10032 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10033 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10034 parameter packs; all parms generated from a function parameter pack will
10035 have the same DECL_PARM_INDEX. */
10038 get_pattern_parm (tree parm
, tree tmpl
)
10040 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
10043 if (DECL_ARTIFICIAL (parm
))
10045 for (patparm
= DECL_ARGUMENTS (pattern
);
10046 patparm
; patparm
= DECL_CHAIN (patparm
))
10047 if (DECL_ARTIFICIAL (patparm
)
10048 && DECL_NAME (parm
) == DECL_NAME (patparm
))
10053 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
10054 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
10055 gcc_assert (DECL_PARM_INDEX (patparm
)
10056 == DECL_PARM_INDEX (parm
));
10062 /* Substitute ARGS into the vector or list of template arguments T. */
10065 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10068 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
10071 if (t
== error_mark_node
)
10072 return error_mark_node
;
10074 len
= TREE_VEC_LENGTH (t
);
10075 elts
= XALLOCAVEC (tree
, len
);
10077 for (i
= 0; i
< len
; i
++)
10079 tree orig_arg
= TREE_VEC_ELT (t
, i
);
10082 if (TREE_CODE (orig_arg
) == TREE_VEC
)
10083 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
10084 else if (PACK_EXPANSION_P (orig_arg
))
10086 /* Substitute into an expansion expression. */
10087 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
10089 if (TREE_CODE (new_arg
) == TREE_VEC
)
10090 /* Add to the expanded length adjustment the number of
10091 expanded arguments. We subtract one from this
10092 measurement, because the argument pack expression
10093 itself is already counted as 1 in
10094 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10095 the argument pack is empty. */
10096 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
10098 else if (ARGUMENT_PACK_P (orig_arg
))
10100 /* Substitute into each of the arguments. */
10101 new_arg
= TYPE_P (orig_arg
)
10102 ? cxx_make_type (TREE_CODE (orig_arg
))
10103 : make_node (TREE_CODE (orig_arg
));
10105 SET_ARGUMENT_PACK_ARGS (
10107 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
10108 args
, complain
, in_decl
));
10110 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
10111 new_arg
= error_mark_node
;
10113 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
10114 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
10115 complain
, in_decl
);
10116 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
10118 if (TREE_TYPE (new_arg
) == error_mark_node
)
10119 new_arg
= error_mark_node
;
10123 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
10125 if (new_arg
== error_mark_node
)
10126 return error_mark_node
;
10129 if (new_arg
!= orig_arg
)
10136 /* Make space for the expanded arguments coming from template
10138 t
= make_tree_vec (len
+ expanded_len_adjust
);
10139 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10140 arguments for a member template.
10141 In that case each TREE_VEC in ORIG_T represents a level of template
10142 arguments, and ORIG_T won't carry any non defaulted argument count.
10143 It will rather be the nested TREE_VECs that will carry one.
10144 In other words, ORIG_T carries a non defaulted argument count only
10145 if it doesn't contain any nested TREE_VEC. */
10146 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
10148 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
10149 count
+= expanded_len_adjust
;
10150 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
10152 for (i
= 0, out
= 0; i
< len
; i
++)
10154 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
10155 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
10156 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10160 /* Now expand the template argument pack "in place". */
10161 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10162 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10166 TREE_VEC_ELT (t
, out
) = elts
[i
];
10174 /* Return the result of substituting ARGS into the template parameters
10175 given by PARMS. If there are m levels of ARGS and m + n levels of
10176 PARMS, then the result will contain n levels of PARMS. For
10177 example, if PARMS is `template <class T> template <class U>
10178 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10179 result will be `template <int*, double, class V>'. */
10182 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10184 tree r
= NULL_TREE
;
10187 /* When substituting into a template, we must set
10188 PROCESSING_TEMPLATE_DECL as the template parameters may be
10189 dependent if they are based on one-another, and the dependency
10190 predicates are short-circuit outside of templates. */
10191 ++processing_template_decl
;
10193 for (new_parms
= &r
;
10194 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10195 new_parms
= &(TREE_CHAIN (*new_parms
)),
10196 parms
= TREE_CHAIN (parms
))
10199 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10202 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10206 if (parms
== error_mark_node
)
10209 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10211 if (tuple
== error_mark_node
)
10214 TREE_VEC_ELT (new_vec
, i
) =
10215 tsubst_template_parm (tuple
, args
, complain
);
10219 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10220 - TMPL_ARGS_DEPTH (args
)),
10221 new_vec
, NULL_TREE
);
10224 --processing_template_decl
;
10229 /* Return the result of substituting ARGS into one template parameter
10230 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10231 parameter and which TREE_PURPOSE is the default argument of the
10232 template parameter. */
10235 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10237 tree default_value
, parm_decl
;
10239 if (args
== NULL_TREE
10241 || t
== error_mark_node
)
10244 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10246 default_value
= TREE_PURPOSE (t
);
10247 parm_decl
= TREE_VALUE (t
);
10249 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10250 if (TREE_CODE (parm_decl
) == PARM_DECL
10251 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10252 parm_decl
= error_mark_node
;
10253 default_value
= tsubst_template_arg (default_value
, args
,
10254 complain
, NULL_TREE
);
10256 return build_tree_list (default_value
, parm_decl
);
10259 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10260 type T. If T is not an aggregate or enumeration type, it is
10261 handled as if by tsubst. IN_DECL is as for tsubst. If
10262 ENTERING_SCOPE is nonzero, T is the context for a template which
10263 we are presently tsubst'ing. Return the substituted value. */
10266 tsubst_aggr_type (tree t
,
10268 tsubst_flags_t complain
,
10270 int entering_scope
)
10272 if (t
== NULL_TREE
)
10275 switch (TREE_CODE (t
))
10278 if (TYPE_PTRMEMFUNC_P (t
))
10279 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10281 /* Else fall through. */
10282 case ENUMERAL_TYPE
:
10284 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10289 int saved_unevaluated_operand
;
10290 int saved_inhibit_evaluation_warnings
;
10292 /* In "sizeof(X<I>)" we need to evaluate "I". */
10293 saved_unevaluated_operand
= cp_unevaluated_operand
;
10294 cp_unevaluated_operand
= 0;
10295 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10296 c_inhibit_evaluation_warnings
= 0;
10298 /* First, determine the context for the type we are looking
10300 context
= TYPE_CONTEXT (t
);
10301 if (context
&& TYPE_P (context
))
10303 context
= tsubst_aggr_type (context
, args
, complain
,
10304 in_decl
, /*entering_scope=*/1);
10305 /* If context is a nested class inside a class template,
10306 it may still need to be instantiated (c++/33959). */
10307 context
= complete_type (context
);
10310 /* Then, figure out what arguments are appropriate for the
10311 type we are trying to find. For example, given:
10313 template <class T> struct S;
10314 template <class T, class U> void f(T, U) { S<U> su; }
10316 and supposing that we are instantiating f<int, double>,
10317 then our ARGS will be {int, double}, but, when looking up
10318 S we only want {double}. */
10319 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10320 complain
, in_decl
);
10321 if (argvec
== error_mark_node
)
10322 r
= error_mark_node
;
10325 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10326 entering_scope
, complain
);
10327 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10330 cp_unevaluated_operand
= saved_unevaluated_operand
;
10331 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10336 /* This is not a template type, so there's nothing to do. */
10340 return tsubst (t
, args
, complain
, in_decl
);
10344 /* Substitute into the default argument ARG (a default argument for
10345 FN), which has the indicated TYPE. */
10348 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10350 tree saved_class_ptr
= NULL_TREE
;
10351 tree saved_class_ref
= NULL_TREE
;
10352 int errs
= errorcount
+ sorrycount
;
10354 /* This can happen in invalid code. */
10355 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10358 /* This default argument came from a template. Instantiate the
10359 default argument here, not in tsubst. In the case of
10368 we must be careful to do name lookup in the scope of S<T>,
10369 rather than in the current class. */
10370 push_access_scope (fn
);
10371 /* The "this" pointer is not valid in a default argument. */
10374 saved_class_ptr
= current_class_ptr
;
10375 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10376 saved_class_ref
= current_class_ref
;
10377 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10380 push_deferring_access_checks(dk_no_deferred
);
10381 /* The default argument expression may cause implicitly defined
10382 member functions to be synthesized, which will result in garbage
10383 collection. We must treat this situation as if we were within
10384 the body of function so as to avoid collecting live data on the
10387 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10388 complain
, NULL_TREE
,
10389 /*integral_constant_expression_p=*/false);
10391 pop_deferring_access_checks();
10393 /* Restore the "this" pointer. */
10396 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10397 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10400 if (errorcount
+sorrycount
> errs
10401 && (complain
& tf_warning_or_error
))
10402 inform (input_location
,
10403 " when instantiating default argument for call to %D", fn
);
10405 /* Make sure the default argument is reasonable. */
10406 arg
= check_default_argument (type
, arg
, complain
);
10408 pop_access_scope (fn
);
10413 /* Substitute into all the default arguments for FN. */
10416 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10421 tmpl_args
= DECL_TI_ARGS (fn
);
10423 /* If this function is not yet instantiated, we certainly don't need
10424 its default arguments. */
10425 if (uses_template_parms (tmpl_args
))
10427 /* Don't do this again for clones. */
10428 if (DECL_CLONED_FUNCTION_P (fn
))
10431 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10433 arg
= TREE_CHAIN (arg
))
10434 if (TREE_PURPOSE (arg
))
10435 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10437 TREE_PURPOSE (arg
),
10441 /* Substitute the ARGS into the T, which is a _DECL. Return the
10442 result of the substitution. Issue error and warning messages under
10443 control of COMPLAIN. */
10446 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10448 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10449 location_t saved_loc
;
10450 tree r
= NULL_TREE
;
10452 hashval_t hash
= 0;
10454 /* Set the filename and linenumber to improve error-reporting. */
10455 saved_loc
= input_location
;
10456 input_location
= DECL_SOURCE_LOCATION (t
);
10458 switch (TREE_CODE (t
))
10460 case TEMPLATE_DECL
:
10462 /* We can get here when processing a member function template,
10463 member class template, or template template parameter. */
10464 tree decl
= DECL_TEMPLATE_RESULT (t
);
10469 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10471 /* Template template parameter is treated here. */
10472 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10473 if (new_type
== error_mark_node
)
10474 RETURN (error_mark_node
);
10475 /* If we get a real template back, return it. This can happen in
10476 the context of most_specialized_class. */
10477 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10481 DECL_CHAIN (r
) = NULL_TREE
;
10482 TREE_TYPE (r
) = new_type
;
10483 DECL_TEMPLATE_RESULT (r
)
10484 = build_decl (DECL_SOURCE_LOCATION (decl
),
10485 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10486 DECL_TEMPLATE_PARMS (r
)
10487 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10489 TYPE_NAME (new_type
) = r
;
10493 /* We might already have an instance of this template.
10494 The ARGS are for the surrounding class type, so the
10495 full args contain the tsubst'd args for the context,
10496 plus the innermost args from the template decl. */
10497 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10498 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10499 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10500 /* Because this is a template, the arguments will still be
10501 dependent, even after substitution. If
10502 PROCESSING_TEMPLATE_DECL is not set, the dependency
10503 predicates will short-circuit. */
10504 ++processing_template_decl
;
10505 full_args
= tsubst_template_args (tmpl_args
, args
,
10506 complain
, in_decl
);
10507 --processing_template_decl
;
10508 if (full_args
== error_mark_node
)
10509 RETURN (error_mark_node
);
10511 /* If this is a default template template argument,
10512 tsubst might not have changed anything. */
10513 if (full_args
== tmpl_args
)
10516 hash
= hash_tmpl_and_args (t
, full_args
);
10517 spec
= retrieve_specialization (t
, full_args
, hash
);
10518 if (spec
!= NULL_TREE
)
10524 /* Make a new template decl. It will be similar to the
10525 original, but will record the current template arguments.
10526 We also create a new function declaration, which is just
10527 like the old one, but points to this new template, rather
10528 than the old one. */
10530 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10531 DECL_CHAIN (r
) = NULL_TREE
;
10533 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10535 if (TREE_CODE (decl
) == TYPE_DECL
10536 && !TYPE_DECL_ALIAS_P (decl
))
10539 ++processing_template_decl
;
10540 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10541 --processing_template_decl
;
10542 if (new_type
== error_mark_node
)
10543 RETURN (error_mark_node
);
10545 TREE_TYPE (r
) = new_type
;
10546 /* For a partial specialization, we need to keep pointing to
10547 the primary template. */
10548 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10549 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10550 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10551 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10552 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10557 ++processing_template_decl
;
10558 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10559 --processing_template_decl
;
10560 if (new_decl
== error_mark_node
)
10561 RETURN (error_mark_node
);
10563 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10564 DECL_TI_TEMPLATE (new_decl
) = r
;
10565 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10566 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10567 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10570 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10571 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10572 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10574 /* The template parameters for this new template are all the
10575 template parameters for the old template, except the
10576 outermost level of parameters. */
10577 DECL_TEMPLATE_PARMS (r
)
10578 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10581 if (PRIMARY_TEMPLATE_P (t
))
10582 DECL_PRIMARY_TEMPLATE (r
) = r
;
10584 if (TREE_CODE (decl
) != TYPE_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
10585 /* Record this non-type partial instantiation. */
10586 register_specialization (r
, t
,
10587 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10592 case FUNCTION_DECL
:
10595 tree argvec
= NULL_TREE
;
10603 /* Nobody should be tsubst'ing into non-template functions. */
10604 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10606 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10611 /* If T is not dependent, just return it. We have to
10612 increment PROCESSING_TEMPLATE_DECL because
10613 value_dependent_expression_p assumes that nothing is
10614 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10615 ++processing_template_decl
;
10616 dependent_p
= value_dependent_expression_p (t
);
10617 --processing_template_decl
;
10621 /* Calculate the most general template of which R is a
10622 specialization, and the complete set of arguments used to
10624 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10625 argvec
= tsubst_template_args (DECL_TI_ARGS
10626 (DECL_TEMPLATE_RESULT
10627 (DECL_TI_TEMPLATE (t
))),
10628 args
, complain
, in_decl
);
10629 if (argvec
== error_mark_node
)
10630 RETURN (error_mark_node
);
10632 /* Check to see if we already have this specialization. */
10633 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10634 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10642 /* We can see more levels of arguments than parameters if
10643 there was a specialization of a member template, like
10646 template <class T> struct S { template <class U> void f(); }
10647 template <> template <class U> void S<int>::f(U);
10649 Here, we'll be substituting into the specialization,
10650 because that's where we can find the code we actually
10651 want to generate, but we'll have enough arguments for
10652 the most general template.
10654 We also deal with the peculiar case:
10656 template <class T> struct S {
10657 template <class U> friend void f();
10659 template <class U> void f() {}
10661 template void f<double>();
10663 Here, the ARGS for the instantiation of will be {int,
10664 double}. But, we only need as many ARGS as there are
10665 levels of template parameters in CODE_PATTERN. We are
10666 careful not to get fooled into reducing the ARGS in
10669 template <class T> struct S { template <class U> void f(U); }
10670 template <class T> template <> void S<T>::f(int) {}
10672 which we can spot because the pattern will be a
10673 specialization in this case. */
10674 args_depth
= TMPL_ARGS_DEPTH (args
);
10676 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10677 if (args_depth
> parms_depth
10678 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10679 args
= get_innermost_template_args (args
, parms_depth
);
10683 /* This special case arises when we have something like this:
10685 template <class T> struct S {
10686 friend void f<int>(int, double);
10689 Here, the DECL_TI_TEMPLATE for the friend declaration
10690 will be an IDENTIFIER_NODE. We are being called from
10691 tsubst_friend_function, and we want only to create a
10692 new decl (R) with appropriate types so that we can call
10693 determine_specialization. */
10694 gen_tmpl
= NULL_TREE
;
10697 if (DECL_CLASS_SCOPE_P (t
))
10699 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10703 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10704 complain
, t
, /*entering_scope=*/1);
10709 ctx
= DECL_CONTEXT (t
);
10711 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10712 if (type
== error_mark_node
)
10713 RETURN (error_mark_node
);
10715 /* If we hit excessive deduction depth, the type is bogus even if
10716 it isn't error_mark_node, so don't build a decl. */
10717 if (excessive_deduction_depth
)
10718 RETURN (error_mark_node
);
10720 /* We do NOT check for matching decls pushed separately at this
10721 point, as they may not represent instantiations of this
10722 template, and in any case are considered separate under the
10725 DECL_USE_TEMPLATE (r
) = 0;
10726 TREE_TYPE (r
) = type
;
10727 /* Clear out the mangled name and RTL for the instantiation. */
10728 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10729 SET_DECL_RTL (r
, NULL
);
10730 /* Leave DECL_INITIAL set on deleted instantiations. */
10731 if (!DECL_DELETED_FN (r
))
10732 DECL_INITIAL (r
) = NULL_TREE
;
10733 DECL_CONTEXT (r
) = ctx
;
10735 /* OpenMP UDRs have the only argument a reference to the declared
10736 type. We want to diagnose if the declared type is a reference,
10737 which is invalid, but as references to references are usually
10738 quietly merged, diagnose it here. */
10739 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10742 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10743 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10744 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10745 error_at (DECL_SOURCE_LOCATION (t
),
10746 "reference type %qT in "
10747 "%<#pragma omp declare reduction%>", argtype
);
10748 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10749 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10753 if (member
&& DECL_CONV_FN_P (r
))
10754 /* Type-conversion operator. Reconstruct the name, in
10755 case it's the name of one of the template's parameters. */
10756 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10758 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10760 DECL_RESULT (r
) = NULL_TREE
;
10762 TREE_STATIC (r
) = 0;
10763 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10764 DECL_EXTERNAL (r
) = 1;
10765 /* If this is an instantiation of a function with internal
10766 linkage, we already know what object file linkage will be
10767 assigned to the instantiation. */
10768 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10769 DECL_DEFER_OUTPUT (r
) = 0;
10770 DECL_CHAIN (r
) = NULL_TREE
;
10771 DECL_PENDING_INLINE_INFO (r
) = 0;
10772 DECL_PENDING_INLINE_P (r
) = 0;
10773 DECL_SAVED_TREE (r
) = NULL_TREE
;
10774 DECL_STRUCT_FUNCTION (r
) = NULL
;
10776 /* We'll re-clone as appropriate in instantiate_template. */
10777 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10779 /* If we aren't complaining now, return on error before we register
10780 the specialization so that we'll complain eventually. */
10781 if ((complain
& tf_error
) == 0
10782 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10783 && !grok_op_properties (r
, /*complain=*/false))
10784 RETURN (error_mark_node
);
10786 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10787 this in the special friend case mentioned above where
10788 GEN_TMPL is NULL. */
10791 DECL_TEMPLATE_INFO (r
)
10792 = build_template_info (gen_tmpl
, argvec
);
10793 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10796 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10798 /* We instantiated this while substituting into
10799 the type earlier (template/friend54.C). */
10802 /* We're not supposed to instantiate default arguments
10803 until they are called, for a template. But, for a
10806 template <class T> void f ()
10807 { extern void g(int i = T()); }
10809 we should do the substitution when the template is
10810 instantiated. We handle the member function case in
10811 instantiate_class_template since the default arguments
10812 might refer to other members of the class. */
10814 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10815 && !uses_template_parms (argvec
))
10816 tsubst_default_arguments (r
, complain
);
10819 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10821 /* Copy the list of befriending classes. */
10822 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10824 friends
= &TREE_CHAIN (*friends
))
10826 *friends
= copy_node (*friends
);
10827 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
10832 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
10834 maybe_retrofit_in_chrg (r
);
10835 if (DECL_CONSTRUCTOR_P (r
))
10836 grok_ctor_properties (ctx
, r
);
10837 if (DECL_INHERITED_CTOR_BASE (r
))
10838 deduce_inheriting_ctor (r
);
10839 /* If this is an instantiation of a member template, clone it.
10840 If it isn't, that'll be handled by
10841 clone_constructors_and_destructors. */
10842 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
10843 clone_function_decl (r
, /*update_method_vec_p=*/0);
10845 else if ((complain
& tf_error
) != 0
10846 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10847 && !grok_op_properties (r
, /*complain=*/true))
10848 RETURN (error_mark_node
);
10850 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
10851 SET_DECL_FRIEND_CONTEXT (r
,
10852 tsubst (DECL_FRIEND_CONTEXT (t
),
10853 args
, complain
, in_decl
));
10855 /* Possibly limit visibility based on template args. */
10856 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10857 if (DECL_VISIBILITY_SPECIFIED (t
))
10859 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10860 DECL_ATTRIBUTES (r
)
10861 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10863 determine_visibility (r
);
10864 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
10865 && !processing_template_decl
)
10866 defaulted_late_check (r
);
10868 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10869 args
, complain
, in_decl
);
10875 tree type
= NULL_TREE
;
10877 tree expanded_types
= NULL_TREE
;
10878 tree prev_r
= NULL_TREE
;
10879 tree first_r
= NULL_TREE
;
10881 if (DECL_PACK_P (t
))
10883 /* If there is a local specialization that isn't a
10884 parameter pack, it means that we're doing a "simple"
10885 substitution from inside tsubst_pack_expansion. Just
10886 return the local specialization (which will be a single
10888 tree spec
= retrieve_local_specialization (t
);
10890 && TREE_CODE (spec
) == PARM_DECL
10891 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
10894 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10895 the parameters in this function parameter pack. */
10896 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10897 complain
, in_decl
);
10898 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10900 len
= TREE_VEC_LENGTH (expanded_types
);
10902 /* Zero-length parameter packs are boring. Just substitute
10905 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
10910 /* All we did was update the type. Make a note of that. */
10911 type
= expanded_types
;
10912 expanded_types
= NULL_TREE
;
10916 /* Loop through all of the parameters we'll build. When T is
10917 a function parameter pack, LEN is the number of expanded
10918 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10920 for (i
= 0; i
< len
; ++i
)
10924 if (DECL_TEMPLATE_PARM_P (t
))
10925 SET_DECL_TEMPLATE_PARM_P (r
);
10927 if (expanded_types
)
10928 /* We're on the Ith parameter of the function parameter
10931 /* Get the Ith type. */
10932 type
= TREE_VEC_ELT (expanded_types
, i
);
10934 /* Rename the parameter to include the index. */
10936 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10939 /* We're dealing with a normal parameter. */
10940 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10942 type
= type_decays_to (type
);
10943 TREE_TYPE (r
) = type
;
10944 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10946 if (DECL_INITIAL (r
))
10948 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
10949 DECL_INITIAL (r
) = TREE_TYPE (r
);
10951 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
10952 complain
, in_decl
);
10955 DECL_CONTEXT (r
) = NULL_TREE
;
10957 if (!DECL_TEMPLATE_PARM_P (r
))
10958 DECL_ARG_TYPE (r
) = type_passed_as (type
);
10960 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10961 args
, complain
, in_decl
);
10963 /* Keep track of the first new parameter we
10964 generate. That's what will be returned to the
10969 /* Build a proper chain of parameters when substituting
10970 into a function parameter pack. */
10972 DECL_CHAIN (prev_r
) = r
;
10975 /* If cp_unevaluated_operand is set, we're just looking for a
10976 single dummy parameter, so don't keep going. */
10977 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
10978 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
10979 complain
, DECL_CHAIN (t
));
10981 /* FIRST_R contains the start of the chain we've built. */
10988 tree type
= NULL_TREE
;
10989 tree vec
= NULL_TREE
;
10990 tree expanded_types
= NULL_TREE
;
10993 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
10995 /* This field is a lambda capture pack. Return a TREE_VEC of
10996 the expanded fields to instantiate_class_template_1 and
10997 store them in the specializations hash table as a
10998 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
10999 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11000 complain
, in_decl
);
11001 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11003 len
= TREE_VEC_LENGTH (expanded_types
);
11004 vec
= make_tree_vec (len
);
11008 /* All we did was update the type. Make a note of that. */
11009 type
= expanded_types
;
11010 expanded_types
= NULL_TREE
;
11014 for (int i
= 0; i
< len
; ++i
)
11017 if (expanded_types
)
11019 type
= TREE_VEC_ELT (expanded_types
, i
);
11021 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11024 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11026 if (type
== error_mark_node
)
11027 RETURN (error_mark_node
);
11028 TREE_TYPE (r
) = type
;
11029 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11031 if (DECL_C_BIT_FIELD (r
))
11032 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11033 non-bit-fields DECL_INITIAL is a non-static data member
11034 initializer, which gets deferred instantiation. */
11036 = tsubst_expr (DECL_INITIAL (t
), args
,
11038 /*integral_constant_expression_p=*/true);
11039 else if (DECL_INITIAL (t
))
11041 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11042 NSDMI in perform_member_init. Still set DECL_INITIAL
11043 so that we know there is one. */
11044 DECL_INITIAL (r
) = void_node
;
11045 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
11046 retrofit_lang_decl (r
);
11047 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
11049 /* We don't have to set DECL_CONTEXT here; it is set by
11050 finish_member_declaration. */
11051 DECL_CHAIN (r
) = NULL_TREE
;
11053 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11054 args
, complain
, in_decl
);
11057 TREE_VEC_ELT (vec
, i
) = r
;
11063 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
11064 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
11065 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
11066 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
11067 TREE_TYPE (pack
) = tpack
;
11068 register_specialization (pack
, t
, args
, false, 0);
11074 /* We reach here only for member using decls. We also need to check
11075 uses_template_parms because DECL_DEPENDENT_P is not set for a
11076 using-declaration that designates a member of the current
11077 instantiation (c++/53549). */
11078 if (DECL_DEPENDENT_P (t
)
11079 || uses_template_parms (USING_DECL_SCOPE (t
)))
11081 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
11082 complain
, in_decl
);
11083 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
11084 r
= do_class_using_decl (inst_scope
, name
);
11086 r
= error_mark_node
;
11089 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
11090 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
11096 DECL_CHAIN (r
) = NULL_TREE
;
11103 tree argvec
= NULL_TREE
;
11104 tree gen_tmpl
= NULL_TREE
;
11106 tree tmpl
= NULL_TREE
;
11108 tree type
= NULL_TREE
;
11111 if (TREE_TYPE (t
) == error_mark_node
)
11112 RETURN (error_mark_node
);
11114 if (TREE_CODE (t
) == TYPE_DECL
11115 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
11117 /* If this is the canonical decl, we don't have to
11118 mess with instantiations, and often we can't (for
11119 typename, template type parms and such). Note that
11120 TYPE_NAME is not correct for the above test if
11121 we've copied the type for a typedef. */
11122 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11123 if (type
== error_mark_node
)
11124 RETURN (error_mark_node
);
11125 r
= TYPE_NAME (type
);
11129 /* Check to see if we already have the specialization we
11132 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
11134 /* T is a static data member or namespace-scope entity.
11135 We have to substitute into namespace-scope variables
11136 (even though such entities are never templates) because
11139 template <class T> void f() { extern T t; }
11141 where the entity referenced is not known until
11142 instantiation time. */
11144 ctx
= DECL_CONTEXT (t
);
11145 if (DECL_CLASS_SCOPE_P (t
))
11147 ctx
= tsubst_aggr_type (ctx
, args
,
11149 in_decl
, /*entering_scope=*/1);
11150 /* If CTX is unchanged, then T is in fact the
11151 specialization we want. That situation occurs when
11152 referencing a static data member within in its own
11153 class. We can use pointer equality, rather than
11154 same_type_p, because DECL_CONTEXT is always
11156 if (ctx
== DECL_CONTEXT (t
)
11157 /* ... unless T is a member template; in which
11158 case our caller can be willing to create a
11159 specialization of that template represented
11161 && !(DECL_TI_TEMPLATE (t
)
11162 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
11168 tmpl
= DECL_TI_TEMPLATE (t
);
11169 gen_tmpl
= most_general_template (tmpl
);
11170 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11171 if (argvec
== error_mark_node
)
11172 RETURN (error_mark_node
);
11173 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11174 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11179 /* A local variable. */
11181 /* Subsequent calls to pushdecl will fill this in. */
11183 spec
= retrieve_local_specialization (t
);
11185 /* If we already have the specialization we need, there is
11186 nothing more to do. */
11193 /* Create a new node for the specialization we need. */
11195 if (type
== NULL_TREE
)
11197 if (is_typedef_decl (t
))
11198 type
= DECL_ORIGINAL_TYPE (t
);
11200 type
= TREE_TYPE (t
);
11202 && VAR_HAD_UNKNOWN_BOUND (t
)
11203 && type
!= error_mark_node
)
11204 type
= strip_array_domain (type
);
11205 type
= tsubst (type
, args
, complain
, in_decl
);
11209 /* Even if the original location is out of scope, the
11210 newly substituted one is not. */
11211 DECL_DEAD_FOR_LOCAL (r
) = 0;
11212 DECL_INITIALIZED_P (r
) = 0;
11213 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11214 if (type
== error_mark_node
)
11215 RETURN (error_mark_node
);
11216 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11218 /* It may seem that this case cannot occur, since:
11223 declares a function, not a variable. However:
11226 template <typename T> void g() { T t; }
11227 template void g<f>();
11229 is an attempt to declare a variable with function
11231 error ("variable %qD has function type",
11232 /* R is not yet sufficiently initialized, so we
11233 just use its name. */
11235 RETURN (error_mark_node
);
11237 type
= complete_type (type
);
11238 /* Wait until cp_finish_decl to set this again, to handle
11239 circular dependency (template/instantiate6.C). */
11240 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11241 type
= check_var_type (DECL_NAME (r
), type
);
11243 if (DECL_HAS_VALUE_EXPR_P (t
))
11245 tree ve
= DECL_VALUE_EXPR (t
);
11246 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11247 /*constant_expression_p=*/false);
11248 if (REFERENCE_REF_P (ve
))
11250 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11251 ve
= TREE_OPERAND (ve
, 0);
11253 SET_DECL_VALUE_EXPR (r
, ve
);
11255 if (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
11256 set_decl_tls_model (r
, decl_tls_model (t
));
11258 else if (DECL_SELF_REFERENCE_P (t
))
11259 SET_DECL_SELF_REFERENCE_P (r
);
11260 TREE_TYPE (r
) = type
;
11261 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11262 DECL_CONTEXT (r
) = ctx
;
11263 /* Clear out the mangled name and RTL for the instantiation. */
11264 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11265 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11266 SET_DECL_RTL (r
, NULL
);
11267 /* The initializer must not be expanded until it is required;
11268 see [temp.inst]. */
11269 DECL_INITIAL (r
) = NULL_TREE
;
11270 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11271 SET_DECL_RTL (r
, NULL
);
11272 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11275 /* Possibly limit visibility based on template args. */
11276 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11277 if (DECL_VISIBILITY_SPECIFIED (t
))
11279 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11280 DECL_ATTRIBUTES (r
)
11281 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11283 determine_visibility (r
);
11288 /* A static data member declaration is always marked
11289 external when it is declared in-class, even if an
11290 initializer is present. We mimic the non-template
11291 processing here. */
11292 DECL_EXTERNAL (r
) = 1;
11294 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11295 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11296 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11298 else if (!cp_unevaluated_operand
)
11299 register_local_specialization (r
, t
);
11301 DECL_CHAIN (r
) = NULL_TREE
;
11303 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11305 args
, complain
, in_decl
);
11307 /* Preserve a typedef that names a type. */
11308 if (is_typedef_decl (r
))
11310 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11311 set_underlying_type (r
);
11314 layout_decl (r
, 0);
11319 gcc_unreachable ();
11324 /* Restore the file and line information. */
11325 input_location
= saved_loc
;
11330 /* Substitute into the ARG_TYPES of a function type.
11331 If END is a TREE_CHAIN, leave it and any following types
11335 tsubst_arg_types (tree arg_types
,
11338 tsubst_flags_t complain
,
11341 tree remaining_arg_types
;
11342 tree type
= NULL_TREE
;
11344 tree expanded_args
= NULL_TREE
;
11347 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11350 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11351 args
, end
, complain
, in_decl
);
11352 if (remaining_arg_types
== error_mark_node
)
11353 return error_mark_node
;
11355 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11357 /* For a pack expansion, perform substitution on the
11358 entire expression. Later on, we'll handle the arguments
11360 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11361 args
, complain
, in_decl
);
11363 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11364 /* So that we'll spin through the parameters, one by one. */
11365 i
= TREE_VEC_LENGTH (expanded_args
);
11368 /* We only partially substituted into the parameter
11369 pack. Our type is TYPE_PACK_EXPANSION. */
11370 type
= expanded_args
;
11371 expanded_args
= NULL_TREE
;
11379 type
= TREE_VEC_ELT (expanded_args
, i
);
11381 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11383 if (type
== error_mark_node
)
11384 return error_mark_node
;
11385 if (VOID_TYPE_P (type
))
11387 if (complain
& tf_error
)
11389 error ("invalid parameter type %qT", type
);
11391 error ("in declaration %q+D", in_decl
);
11393 return error_mark_node
;
11396 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11397 return error_mark_node
;
11399 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11400 top-level qualifiers as required. */
11401 type
= cv_unqualified (type_decays_to (type
));
11403 /* We do not substitute into default arguments here. The standard
11404 mandates that they be instantiated only when needed, which is
11405 done in build_over_call. */
11406 default_arg
= TREE_PURPOSE (arg_types
);
11408 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11410 /* We've instantiated a template before its default arguments
11411 have been parsed. This can happen for a nested template
11412 class, and is not an error unless we require the default
11413 argument in a call of this function. */
11414 remaining_arg_types
=
11415 tree_cons (default_arg
, type
, remaining_arg_types
);
11416 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11419 remaining_arg_types
=
11420 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11423 return remaining_arg_types
;
11426 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11427 *not* handle the exception-specification for FNTYPE, because the
11428 initial substitution of explicitly provided template parameters
11429 during argument deduction forbids substitution into the
11430 exception-specification:
11434 All references in the function type of the function template to the
11435 corresponding template parameters are replaced by the specified tem-
11436 plate argument values. If a substitution in a template parameter or
11437 in the function type of the function template results in an invalid
11438 type, type deduction fails. [Note: The equivalent substitution in
11439 exception specifications is done only when the function is instanti-
11440 ated, at which point a program is ill-formed if the substitution
11441 results in an invalid type.] */
11444 tsubst_function_type (tree t
,
11446 tsubst_flags_t complain
,
11450 tree arg_types
= NULL_TREE
;
11453 /* The TYPE_CONTEXT is not used for function/method types. */
11454 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11456 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11458 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11460 if (late_return_type_p
)
11462 /* Substitute the argument types. */
11463 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11464 complain
, in_decl
);
11465 if (arg_types
== error_mark_node
)
11466 return error_mark_node
;
11468 tree save_ccp
= current_class_ptr
;
11469 tree save_ccr
= current_class_ref
;
11470 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11471 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11472 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11475 /* DR 1207: 'this' is in scope in the trailing return type. */
11476 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11479 /* Substitute the return type. */
11480 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11484 current_class_ptr
= save_ccp
;
11485 current_class_ref
= save_ccr
;
11489 /* Substitute the return type. */
11490 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11492 if (return_type
== error_mark_node
)
11493 return error_mark_node
;
11494 /* DR 486 clarifies that creation of a function type with an
11495 invalid return type is a deduction failure. */
11496 if (TREE_CODE (return_type
) == ARRAY_TYPE
11497 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11499 if (complain
& tf_error
)
11501 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11502 error ("function returning an array");
11504 error ("function returning a function");
11506 return error_mark_node
;
11509 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11510 return error_mark_node
;
11512 if (!late_return_type_p
)
11514 /* Substitute the argument types. */
11515 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11516 complain
, in_decl
);
11517 if (arg_types
== error_mark_node
)
11518 return error_mark_node
;
11521 /* Construct a new type node and return it. */
11522 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11524 fntype
= build_function_type (return_type
, arg_types
);
11525 fntype
= apply_memfn_quals (fntype
,
11526 type_memfn_quals (t
),
11527 type_memfn_rqual (t
));
11531 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11532 /* Don't pick up extra function qualifiers from the basetype. */
11533 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11534 if (! MAYBE_CLASS_TYPE_P (r
))
11538 Type deduction may fail for any of the following
11541 -- Attempting to create "pointer to member of T" when T
11542 is not a class type. */
11543 if (complain
& tf_error
)
11544 error ("creating pointer to member function of non-class type %qT",
11546 return error_mark_node
;
11549 fntype
= build_method_type_directly (r
, return_type
,
11550 TREE_CHAIN (arg_types
));
11551 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11553 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11555 if (late_return_type_p
)
11556 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11561 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11562 ARGS into that specification, and return the substituted
11563 specification. If there is no specification, return NULL_TREE. */
11566 tsubst_exception_specification (tree fntype
,
11568 tsubst_flags_t complain
,
11575 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11576 new_specs
= NULL_TREE
;
11577 if (specs
&& TREE_PURPOSE (specs
))
11579 /* A noexcept-specifier. */
11580 tree expr
= TREE_PURPOSE (specs
);
11581 if (TREE_CODE (expr
) == INTEGER_CST
)
11585 /* Defer instantiation of noexcept-specifiers to avoid
11586 excessive instantiations (c++/49107). */
11587 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11588 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11590 /* We already partially instantiated this member template,
11591 so combine the new args with the old. */
11592 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11593 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11594 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11595 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11599 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11600 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11604 new_specs
= tsubst_copy_and_build
11605 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11606 /*integral_constant_expression_p=*/true);
11607 new_specs
= build_noexcept_spec (new_specs
, complain
);
11611 if (! TREE_VALUE (specs
))
11618 tree expanded_specs
= NULL_TREE
;
11620 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11622 /* Expand the pack expansion type. */
11623 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11627 if (expanded_specs
== error_mark_node
)
11628 return error_mark_node
;
11629 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11630 len
= TREE_VEC_LENGTH (expanded_specs
);
11633 /* We're substituting into a member template, so
11634 we got a TYPE_PACK_EXPANSION back. Add that
11635 expansion and move on. */
11636 gcc_assert (TREE_CODE (expanded_specs
)
11637 == TYPE_PACK_EXPANSION
);
11638 new_specs
= add_exception_specifier (new_specs
,
11641 specs
= TREE_CHAIN (specs
);
11646 for (i
= 0; i
< len
; ++i
)
11648 if (expanded_specs
)
11649 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11651 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11652 if (spec
== error_mark_node
)
11654 new_specs
= add_exception_specifier (new_specs
, spec
,
11658 specs
= TREE_CHAIN (specs
);
11664 /* Take the tree structure T and replace template parameters used
11665 therein with the argument vector ARGS. IN_DECL is an associated
11666 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11667 Issue error and warning messages under control of COMPLAIN. Note
11668 that we must be relatively non-tolerant of extensions here, in
11669 order to preserve conformance; if we allow substitutions that
11670 should not be allowed, we may allow argument deductions that should
11671 not succeed, and therefore report ambiguous overload situations
11672 where there are none. In theory, we could allow the substitution,
11673 but indicate that it should have failed, and allow our caller to
11674 make sure that the right thing happens, but we don't try to do this
11677 This function is used for dealing with types, decls and the like;
11678 for expressions, use tsubst_expr or tsubst_copy. */
11681 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11683 enum tree_code code
;
11684 tree type
, r
= NULL_TREE
;
11686 if (t
== NULL_TREE
|| t
== error_mark_node
11687 || t
== integer_type_node
11688 || t
== void_type_node
11689 || t
== char_type_node
11690 || t
== unknown_type_node
11691 || TREE_CODE (t
) == NAMESPACE_DECL
11692 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11696 return tsubst_decl (t
, args
, complain
);
11698 if (args
== NULL_TREE
)
11701 code
= TREE_CODE (t
);
11703 if (code
== IDENTIFIER_NODE
)
11704 type
= IDENTIFIER_TYPE_VALUE (t
);
11706 type
= TREE_TYPE (t
);
11708 gcc_assert (type
!= unknown_type_node
);
11710 /* Reuse typedefs. We need to do this to handle dependent attributes,
11711 such as attribute aligned. */
11713 && typedef_variant_p (t
))
11715 tree decl
= TYPE_NAME (t
);
11717 if (alias_template_specialization_p (t
))
11719 /* DECL represents an alias template and we want to
11721 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11722 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11723 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11725 else if (DECL_CLASS_SCOPE_P (decl
)
11726 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11727 && uses_template_parms (DECL_CONTEXT (decl
)))
11729 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11730 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11731 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11733 else if (DECL_FUNCTION_SCOPE_P (decl
)
11734 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11735 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11736 r
= retrieve_local_specialization (decl
);
11738 /* The typedef is from a non-template context. */
11744 r
= cp_build_qualified_type_real
11745 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11746 complain
| tf_ignore_bad_quals
);
11751 /* We don't have an instantiation yet, so drop the typedef. */
11752 int quals
= cp_type_quals (t
);
11753 t
= DECL_ORIGINAL_TYPE (decl
);
11754 t
= cp_build_qualified_type_real (t
, quals
,
11755 complain
| tf_ignore_bad_quals
);
11760 && code
!= TYPENAME_TYPE
11761 && code
!= TEMPLATE_TYPE_PARM
11762 && code
!= IDENTIFIER_NODE
11763 && code
!= FUNCTION_TYPE
11764 && code
!= METHOD_TYPE
)
11765 type
= tsubst (type
, args
, complain
, in_decl
);
11766 if (type
== error_mark_node
)
11767 return error_mark_node
;
11773 case ENUMERAL_TYPE
:
11774 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11775 /*entering_scope=*/0);
11778 case IDENTIFIER_NODE
:
11789 if (t
== integer_type_node
)
11792 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11793 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11797 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11799 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11800 /*integral_constant_expression_p=*/false);
11802 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11804 if (TREE_CODE (max
) == NOP_EXPR
11805 && TREE_SIDE_EFFECTS (omax
)
11806 && !TREE_TYPE (max
))
11807 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11809 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11810 with TREE_SIDE_EFFECTS that indicates this is not an integral
11811 constant expression. */
11812 if (processing_template_decl
11813 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11815 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11816 TREE_SIDE_EFFECTS (max
) = 1;
11819 return compute_array_index_type (NULL_TREE
, max
, complain
);
11822 case TEMPLATE_TYPE_PARM
:
11823 case TEMPLATE_TEMPLATE_PARM
:
11824 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11825 case TEMPLATE_PARM_INDEX
:
11830 tree arg
= NULL_TREE
;
11834 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
11835 template_parm_level_and_index (t
, &level
, &idx
);
11837 levels
= TMPL_ARGS_DEPTH (args
);
11838 if (level
<= levels
)
11840 arg
= TMPL_ARG (args
, level
, idx
);
11842 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
11844 /* See through ARGUMENT_PACK_SELECT arguments. */
11845 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
11846 /* If the selected argument is an expansion E, that most
11847 likely means we were called from
11848 gen_elem_of_pack_expansion_instantiation during the
11849 substituting of pack an argument pack (which Ith
11850 element is a pack expansion, where I is
11851 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11852 In this case, the Ith element resulting from this
11853 substituting is going to be a pack expansion, which
11854 pattern is the pattern of E. Let's return the
11856 gen_elem_of_pack_expansion_instantiation will
11857 build the resulting pack expansion from it. */
11858 if (PACK_EXPANSION_P (arg
))
11860 /* Make sure we aren't throwing away arg info. */
11861 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
11862 arg
= PACK_EXPANSION_PATTERN (arg
);
11867 if (arg
== error_mark_node
)
11868 return error_mark_node
;
11869 else if (arg
!= NULL_TREE
)
11871 if (ARGUMENT_PACK_P (arg
))
11872 /* If ARG is an argument pack, we don't actually want to
11873 perform a substitution here, because substitutions
11874 for argument packs are only done
11875 element-by-element. We can get to this point when
11876 substituting the type of a non-type template
11877 parameter pack, when that type actually contains
11878 template parameter packs from an outer template, e.g.,
11880 template<typename... Types> struct A {
11881 template<Types... Values> struct B { };
11885 if (code
== TEMPLATE_TYPE_PARM
)
11888 gcc_assert (TYPE_P (arg
));
11890 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
11892 return cp_build_qualified_type_real
11893 (arg
, quals
, complain
| tf_ignore_bad_quals
);
11895 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11897 /* We are processing a type constructed from a
11898 template template parameter. */
11899 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
11900 args
, complain
, in_decl
);
11901 if (argvec
== error_mark_node
)
11902 return error_mark_node
;
11904 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
11905 || TREE_CODE (arg
) == TEMPLATE_DECL
11906 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
11908 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
11909 /* Consider this code:
11911 template <template <class> class Template>
11913 template <class Arg> using Bind = Template<Arg>;
11916 template <template <class> class Template, class Arg>
11917 using Instantiate = Template<Arg>; //#0
11919 template <template <class> class Template,
11922 Instantiate<Internal<Template>::template Bind,
11925 When #1 is parsed, the
11926 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11927 parameter `Template' in #0 matches the
11928 UNBOUND_CLASS_TEMPLATE representing the argument
11929 `Internal<Template>::template Bind'; We then want
11930 to assemble the type `Bind<Argument>' that can't
11931 be fully created right now, because
11932 `Internal<Template>' not being complete, the Bind
11933 template cannot be looked up in that context. So
11934 we need to "store" `Bind<Argument>' for later
11935 when the context of Bind becomes complete. Let's
11936 store that in a TYPENAME_TYPE. */
11937 return make_typename_type (TYPE_CONTEXT (arg
),
11938 build_nt (TEMPLATE_ID_EXPR
,
11939 TYPE_IDENTIFIER (arg
),
11944 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11945 are resolving nested-types in the signature of a
11946 member function templates. Otherwise ARG is a
11947 TEMPLATE_DECL and is the real template to be
11949 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11950 arg
= TYPE_NAME (arg
);
11952 r
= lookup_template_class (arg
,
11954 DECL_CONTEXT (arg
),
11955 /*entering_scope=*/0,
11957 return cp_build_qualified_type_real
11958 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
11961 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11962 return convert_from_reference (unshare_expr (arg
));
11966 /* This can happen during the attempted tsubst'ing in
11967 unify. This means that we don't yet have any information
11968 about the template parameter in question. */
11971 /* Early in template argument deduction substitution, we don't
11972 want to reduce the level of 'auto', or it will be confused
11973 with a normal template parm in subsequent deduction. */
11974 if (is_auto (t
) && (complain
& tf_partial
))
11977 /* If we get here, we must have been looking at a parm for a
11978 more deeply nested template. Make a new version of this
11979 template parameter, but with a lower level. */
11982 case TEMPLATE_TYPE_PARM
:
11983 case TEMPLATE_TEMPLATE_PARM
:
11984 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11985 if (cp_type_quals (t
))
11987 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
11988 r
= cp_build_qualified_type_real
11989 (r
, cp_type_quals (t
),
11990 complain
| (code
== TEMPLATE_TYPE_PARM
11991 ? tf_ignore_bad_quals
: 0));
11996 TEMPLATE_TYPE_PARM_INDEX (r
)
11997 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
11998 r
, levels
, args
, complain
);
11999 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
12000 TYPE_MAIN_VARIANT (r
) = r
;
12001 TYPE_POINTER_TO (r
) = NULL_TREE
;
12002 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
12004 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
12005 /* We have reduced the level of the template
12006 template parameter, but not the levels of its
12007 template parameters, so canonical_type_parameter
12008 will not be able to find the canonical template
12009 template parameter for this level. Thus, we
12010 require structural equality checking to compare
12011 TEMPLATE_TEMPLATE_PARMs. */
12012 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12013 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
12014 SET_TYPE_STRUCTURAL_EQUALITY (r
);
12016 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
12018 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12020 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
12021 complain
, in_decl
);
12022 if (argvec
== error_mark_node
)
12023 return error_mark_node
;
12025 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
12026 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
12031 case TEMPLATE_PARM_INDEX
:
12032 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
12036 gcc_unreachable ();
12044 tree purpose
, value
, chain
;
12046 if (t
== void_list_node
)
12049 purpose
= TREE_PURPOSE (t
);
12052 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
12053 if (purpose
== error_mark_node
)
12054 return error_mark_node
;
12056 value
= TREE_VALUE (t
);
12059 value
= tsubst (value
, args
, complain
, in_decl
);
12060 if (value
== error_mark_node
)
12061 return error_mark_node
;
12063 chain
= TREE_CHAIN (t
);
12064 if (chain
&& chain
!= void_type_node
)
12066 chain
= tsubst (chain
, args
, complain
, in_decl
);
12067 if (chain
== error_mark_node
)
12068 return error_mark_node
;
12070 if (purpose
== TREE_PURPOSE (t
)
12071 && value
== TREE_VALUE (t
)
12072 && chain
== TREE_CHAIN (t
))
12074 return hash_tree_cons (purpose
, value
, chain
);
12078 /* We should never be tsubsting a binfo. */
12079 gcc_unreachable ();
12082 /* A vector of template arguments. */
12083 gcc_assert (!type
);
12084 return tsubst_template_args (t
, args
, complain
, in_decl
);
12087 case REFERENCE_TYPE
:
12089 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
12094 Type deduction may fail for any of the following
12097 -- Attempting to create a pointer to reference type.
12098 -- Attempting to create a reference to a reference type or
12099 a reference to void.
12101 Core issue 106 says that creating a reference to a reference
12102 during instantiation is no longer a cause for failure. We
12103 only enforce this check in strict C++98 mode. */
12104 if ((TREE_CODE (type
) == REFERENCE_TYPE
12105 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
12106 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
12108 static location_t last_loc
;
12110 /* We keep track of the last time we issued this error
12111 message to avoid spewing a ton of messages during a
12112 single bad template instantiation. */
12113 if (complain
& tf_error
12114 && last_loc
!= input_location
)
12116 if (VOID_TYPE_P (type
))
12117 error ("forming reference to void");
12118 else if (code
== POINTER_TYPE
)
12119 error ("forming pointer to reference type %qT", type
);
12121 error ("forming reference to reference type %qT", type
);
12122 last_loc
= input_location
;
12125 return error_mark_node
;
12127 else if (TREE_CODE (type
) == FUNCTION_TYPE
12128 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
12129 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12131 if (complain
& tf_error
)
12133 if (code
== POINTER_TYPE
)
12134 error ("forming pointer to qualified function type %qT",
12137 error ("forming reference to qualified function type %qT",
12140 return error_mark_node
;
12142 else if (code
== POINTER_TYPE
)
12144 r
= build_pointer_type (type
);
12145 if (TREE_CODE (type
) == METHOD_TYPE
)
12146 r
= build_ptrmemfunc_type (r
);
12148 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12149 /* In C++0x, during template argument substitution, when there is an
12150 attempt to create a reference to a reference type, reference
12151 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12153 "If a template-argument for a template-parameter T names a type
12154 that is a reference to a type A, an attempt to create the type
12155 'lvalue reference to cv T' creates the type 'lvalue reference to
12156 A,' while an attempt to create the type type rvalue reference to
12157 cv T' creates the type T"
12159 r
= cp_build_reference_type
12161 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12163 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12164 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12166 if (cxx_dialect
>= cxx14
12167 && !(TREE_CODE (t
) == REFERENCE_TYPE
&& REFERENCE_VLA_OK (t
))
12168 && array_of_runtime_bound_p (type
)
12169 && (flag_iso
|| warn_vla
> 0))
12171 if (complain
& tf_warning_or_error
)
12173 (input_location
, OPT_Wvla
,
12174 code
== REFERENCE_TYPE
12175 ? G_("cannot declare reference to array of runtime bound")
12176 : G_("cannot declare pointer to array of runtime bound"));
12178 r
= error_mark_node
;
12181 if (r
!= error_mark_node
)
12182 /* Will this ever be needed for TYPE_..._TO values? */
12189 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12190 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12194 Type deduction may fail for any of the following
12197 -- Attempting to create "pointer to member of T" when T
12198 is not a class type. */
12199 if (complain
& tf_error
)
12200 error ("creating pointer to member of non-class type %qT", r
);
12201 return error_mark_node
;
12203 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12205 if (complain
& tf_error
)
12206 error ("creating pointer to member reference type %qT", type
);
12207 return error_mark_node
;
12209 if (VOID_TYPE_P (type
))
12211 if (complain
& tf_error
)
12212 error ("creating pointer to member of type void");
12213 return error_mark_node
;
12215 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12216 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12218 /* The type of the implicit object parameter gets its
12219 cv-qualifiers from the FUNCTION_TYPE. */
12222 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12223 type_memfn_rqual (type
));
12224 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12225 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12229 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12233 case FUNCTION_TYPE
:
12238 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12239 if (fntype
== error_mark_node
)
12240 return error_mark_node
;
12242 /* Substitute the exception specification. */
12243 specs
= tsubst_exception_specification (t
, args
, complain
,
12244 in_decl
, /*defer_ok*/true);
12245 if (specs
== error_mark_node
)
12246 return error_mark_node
;
12248 fntype
= build_exception_variant (fntype
, specs
);
12253 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12254 if (domain
== error_mark_node
)
12255 return error_mark_node
;
12257 /* As an optimization, we avoid regenerating the array type if
12258 it will obviously be the same as T. */
12259 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12262 /* These checks should match the ones in create_array_type_for_decl.
12266 The deduction may fail for any of the following reasons:
12268 -- Attempting to create an array with an element type that
12269 is void, a function type, or a reference type, or [DR337]
12270 an abstract class type. */
12271 if (VOID_TYPE_P (type
)
12272 || TREE_CODE (type
) == FUNCTION_TYPE
12273 || (TREE_CODE (type
) == ARRAY_TYPE
12274 && TYPE_DOMAIN (type
) == NULL_TREE
)
12275 || TREE_CODE (type
) == REFERENCE_TYPE
)
12277 if (complain
& tf_error
)
12278 error ("creating array of %qT", type
);
12279 return error_mark_node
;
12282 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12283 return error_mark_node
;
12285 r
= build_cplus_array_type (type
, domain
);
12287 if (TYPE_USER_ALIGN (t
))
12289 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12290 TYPE_USER_ALIGN (r
) = 1;
12296 case TYPENAME_TYPE
:
12298 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12299 in_decl
, /*entering_scope=*/1);
12300 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12301 complain
, in_decl
);
12303 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12304 return error_mark_node
;
12306 if (!MAYBE_CLASS_TYPE_P (ctx
))
12308 if (complain
& tf_error
)
12309 error ("%qT is not a class, struct, or union type", ctx
);
12310 return error_mark_node
;
12312 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12314 /* Normally, make_typename_type does not require that the CTX
12315 have complete type in order to allow things like:
12317 template <class T> struct S { typename S<T>::X Y; };
12319 But, such constructs have already been resolved by this
12320 point, so here CTX really should have complete type, unless
12321 it's a partial instantiation. */
12322 ctx
= complete_type (ctx
);
12323 if (!COMPLETE_TYPE_P (ctx
))
12325 if (complain
& tf_error
)
12326 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12327 return error_mark_node
;
12331 f
= make_typename_type (ctx
, f
, typename_type
,
12332 complain
| tf_keep_type_decl
);
12333 if (f
== error_mark_node
)
12335 if (TREE_CODE (f
) == TYPE_DECL
)
12337 complain
|= tf_ignore_bad_quals
;
12341 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12343 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12345 if (complain
& tf_error
)
12346 error ("%qT resolves to %qT, which is not an enumeration type",
12349 return error_mark_node
;
12351 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12353 if (complain
& tf_error
)
12354 error ("%qT resolves to %qT, which is is not a class type",
12357 return error_mark_node
;
12361 return cp_build_qualified_type_real
12362 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12365 case UNBOUND_CLASS_TEMPLATE
:
12367 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12368 in_decl
, /*entering_scope=*/1);
12369 tree name
= TYPE_IDENTIFIER (t
);
12370 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12372 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12373 return error_mark_node
;
12376 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12377 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12384 ++cp_unevaluated_operand
;
12385 ++c_inhibit_evaluation_warnings
;
12387 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12389 /*integral_constant_expression_p=*/false);
12391 --cp_unevaluated_operand
;
12392 --c_inhibit_evaluation_warnings
;
12394 type
= finish_typeof (type
);
12395 return cp_build_qualified_type_real (type
,
12397 | cp_type_quals (type
),
12401 case DECLTYPE_TYPE
:
12405 ++cp_unevaluated_operand
;
12406 ++c_inhibit_evaluation_warnings
;
12408 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12409 complain
|tf_decltype
, in_decl
,
12410 /*function_p*/false,
12411 /*integral_constant_expression*/false);
12413 --cp_unevaluated_operand
;
12414 --c_inhibit_evaluation_warnings
;
12416 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12417 type
= lambda_capture_field_type (type
,
12418 DECLTYPE_FOR_INIT_CAPTURE (t
));
12419 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12420 type
= lambda_proxy_type (type
);
12423 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12424 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12426 /* In a template ~id could be either a complement expression
12427 or an unqualified-id naming a destructor; if instantiating
12428 it produces an expression, it's not an id-expression or
12431 type
= finish_decltype_type (type
, id
, complain
);
12433 return cp_build_qualified_type_real (type
,
12435 | cp_type_quals (type
),
12439 case UNDERLYING_TYPE
:
12441 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12442 complain
, in_decl
);
12443 return finish_underlying_type (type
);
12446 case TYPE_ARGUMENT_PACK
:
12447 case NONTYPE_ARGUMENT_PACK
:
12449 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12451 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12455 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12457 /* For template nontype argument packs, also substitute into
12459 if (code
== NONTYPE_ARGUMENT_PACK
)
12460 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12479 /* We should use one of the expression tsubsts for these codes. */
12480 gcc_unreachable ();
12483 sorry ("use of %qs in template", get_tree_code_name (code
));
12484 return error_mark_node
;
12488 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12489 type of the expression on the left-hand side of the "." or "->"
12493 tsubst_baselink (tree baselink
, tree object_type
,
12494 tree args
, tsubst_flags_t complain
, tree in_decl
)
12497 tree qualifying_scope
;
12500 tree template_args
= 0;
12501 bool template_id_p
= false;
12502 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12504 /* A baselink indicates a function from a base class. Both the
12505 BASELINK_ACCESS_BINFO and the base class referenced may
12506 indicate bases of the template class, rather than the
12507 instantiated class. In addition, lookups that were not
12508 ambiguous before may be ambiguous now. Therefore, we perform
12509 the lookup again. */
12510 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12511 qualifying_scope
= tsubst (qualifying_scope
, args
,
12512 complain
, in_decl
);
12513 fns
= BASELINK_FUNCTIONS (baselink
);
12514 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12515 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12517 template_id_p
= true;
12518 template_args
= TREE_OPERAND (fns
, 1);
12519 fns
= TREE_OPERAND (fns
, 0);
12521 template_args
= tsubst_template_args (template_args
, args
,
12522 complain
, in_decl
);
12524 name
= DECL_NAME (get_first_fn (fns
));
12525 if (IDENTIFIER_TYPENAME_P (name
))
12526 name
= mangle_conv_op_name_for_type (optype
);
12527 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12529 return error_mark_node
;
12531 /* If lookup found a single function, mark it as used at this
12532 point. (If it lookup found multiple functions the one selected
12533 later by overload resolution will be marked as used at that
12535 if (BASELINK_P (baselink
))
12536 fns
= BASELINK_FUNCTIONS (baselink
);
12537 if (!template_id_p
&& !really_overloaded_fn (fns
))
12538 mark_used (OVL_CURRENT (fns
));
12540 /* Add back the template arguments, if present. */
12541 if (BASELINK_P (baselink
) && template_id_p
)
12542 BASELINK_FUNCTIONS (baselink
)
12543 = build_nt (TEMPLATE_ID_EXPR
,
12544 BASELINK_FUNCTIONS (baselink
),
12546 /* Update the conversion operator type. */
12547 BASELINK_OPTYPE (baselink
) = optype
;
12550 object_type
= current_class_type
;
12553 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12559 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12560 true if the qualified-id will be a postfix-expression in-and-of
12561 itself; false if more of the postfix-expression follows the
12562 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12566 tsubst_qualified_id (tree qualified_id
, tree args
,
12567 tsubst_flags_t complain
, tree in_decl
,
12568 bool done
, bool address_p
)
12574 tree template_args
;
12575 location_t loc
= UNKNOWN_LOCATION
;
12577 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12579 /* Figure out what name to look up. */
12580 name
= TREE_OPERAND (qualified_id
, 1);
12581 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12583 is_template
= true;
12584 loc
= EXPR_LOCATION (name
);
12585 template_args
= TREE_OPERAND (name
, 1);
12587 template_args
= tsubst_template_args (template_args
, args
,
12588 complain
, in_decl
);
12589 name
= TREE_OPERAND (name
, 0);
12593 is_template
= false;
12594 template_args
= NULL_TREE
;
12597 /* Substitute into the qualifying scope. When there are no ARGS, we
12598 are just trying to simplify a non-dependent expression. In that
12599 case the qualifying scope may be dependent, and, in any case,
12600 substituting will not help. */
12601 scope
= TREE_OPERAND (qualified_id
, 0);
12604 scope
= tsubst (scope
, args
, complain
, in_decl
);
12605 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12610 if (dependent_scope_p (scope
))
12613 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12614 return build_qualified_name (NULL_TREE
, scope
, expr
,
12615 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12618 if (!BASELINK_P (name
) && !DECL_P (expr
))
12620 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12622 /* A BIT_NOT_EXPR is used to represent a destructor. */
12623 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12625 error ("qualifying type %qT does not match destructor name ~%qT",
12626 scope
, TREE_OPERAND (expr
, 0));
12627 expr
= error_mark_node
;
12630 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12631 /*is_type_p=*/0, false);
12634 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12635 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12636 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12638 if (complain
& tf_error
)
12640 error ("dependent-name %qE is parsed as a non-type, but "
12641 "instantiation yields a type", qualified_id
);
12642 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12644 return error_mark_node
;
12650 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12652 /* Remember that there was a reference to this entity. */
12656 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12658 if (complain
& tf_error
)
12659 qualified_name_lookup_error (scope
,
12660 TREE_OPERAND (qualified_id
, 1),
12661 expr
, input_location
);
12662 return error_mark_node
;
12666 expr
= lookup_template_function (expr
, template_args
);
12668 if (expr
== error_mark_node
&& complain
& tf_error
)
12669 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12670 expr
, input_location
);
12671 else if (TYPE_P (scope
))
12673 expr
= (adjust_result_of_qualified_name_lookup
12674 (expr
, scope
, current_nonlambda_class_type ()));
12675 expr
= (finish_qualified_id_expr
12676 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12677 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12678 /*template_arg_p=*/false, complain
));
12681 /* Expressions do not generally have reference type. */
12682 if (TREE_CODE (expr
) != SCOPE_REF
12683 /* However, if we're about to form a pointer-to-member, we just
12684 want the referenced member referenced. */
12685 && TREE_CODE (expr
) != OFFSET_REF
)
12686 expr
= convert_from_reference (expr
);
12691 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12692 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12696 tsubst_init (tree init
, tree decl
, tree args
,
12697 tsubst_flags_t complain
, tree in_decl
)
12702 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12706 /* If we had an initializer but it
12707 instantiated to nothing,
12708 value-initialize the object. This will
12709 only occur when the initializer was a
12710 pack expansion where the parameter packs
12711 used in that expansion were of length
12713 init
= build_value_init (TREE_TYPE (decl
),
12715 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12716 init
= get_target_expr_sfinae (init
, complain
);
12722 /* Like tsubst, but deals with expressions. This function just replaces
12723 template parms; to finish processing the resultant expression, use
12724 tsubst_copy_and_build or tsubst_expr. */
12727 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12729 enum tree_code code
;
12732 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12735 code
= TREE_CODE (t
);
12740 r
= retrieve_local_specialization (t
);
12742 if (r
== NULL_TREE
)
12744 /* We get here for a use of 'this' in an NSDMI. */
12745 if (DECL_NAME (t
) == this_identifier
12746 && current_function_decl
12747 && DECL_CONSTRUCTOR_P (current_function_decl
))
12748 return current_class_ptr
;
12750 /* This can happen for a parameter name used later in a function
12751 declaration (such as in a late-specified return type). Just
12752 make a dummy decl, since it's only used for its type. */
12753 gcc_assert (cp_unevaluated_operand
!= 0);
12754 r
= tsubst_decl (t
, args
, complain
);
12755 /* Give it the template pattern as its context; its true context
12756 hasn't been instantiated yet and this is good enough for
12758 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12761 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12762 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12771 if (DECL_TEMPLATE_PARM_P (t
))
12772 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12773 /* There is no need to substitute into namespace-scope
12775 if (DECL_NAMESPACE_SCOPE_P (t
))
12777 /* If ARGS is NULL, then T is known to be non-dependent. */
12778 if (args
== NULL_TREE
)
12779 return integral_constant_value (t
);
12781 /* Unfortunately, we cannot just call lookup_name here.
12784 template <int I> int f() {
12786 struct S { void g() { E e = a; } };
12789 When we instantiate f<7>::S::g(), say, lookup_name is not
12790 clever enough to find f<7>::a. */
12792 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12793 /*entering_scope=*/0);
12795 for (v
= TYPE_VALUES (enum_type
);
12797 v
= TREE_CHAIN (v
))
12798 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12799 return TREE_VALUE (v
);
12801 /* We didn't find the name. That should never happen; if
12802 name-lookup found it during preliminary parsing, we
12803 should find it again here during instantiation. */
12804 gcc_unreachable ();
12809 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12811 /* Check for a local specialization set up by
12812 tsubst_pack_expansion. */
12813 if (tree r
= retrieve_local_specialization (t
))
12815 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12816 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12820 /* When retrieving a capture pack from a generic lambda, remove the
12821 lambda call op's own template argument list from ARGS. Only the
12822 template arguments active for the closure type should be used to
12823 retrieve the pack specialization. */
12824 if (LAMBDA_FUNCTION_P (current_function_decl
)
12825 && (template_class_depth (DECL_CONTEXT (t
))
12826 != TMPL_ARGS_DEPTH (args
)))
12827 args
= strip_innermost_template_args (args
, 1);
12829 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12830 tsubst_decl put in the hash table. */
12831 return retrieve_specialization (t
, args
, 0);
12834 if (DECL_CONTEXT (t
))
12838 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12839 /*entering_scope=*/1);
12840 if (ctx
!= DECL_CONTEXT (t
))
12842 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
12845 if (complain
& tf_error
)
12846 error ("using invalid field %qD", t
);
12847 return error_mark_node
;
12856 case FUNCTION_DECL
:
12857 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
12858 r
= tsubst (t
, args
, complain
, in_decl
);
12859 else if (local_variable_p (t
))
12861 r
= retrieve_local_specialization (t
);
12862 if (r
== NULL_TREE
)
12864 /* First try name lookup to find the instantiation. */
12865 r
= lookup_name (DECL_NAME (t
));
12868 /* Make sure that the one we found is the one we want. */
12869 tree ctx
= tsubst (DECL_CONTEXT (t
), args
,
12870 complain
, in_decl
);
12871 if (ctx
!= DECL_CONTEXT (r
))
12879 /* This can happen for a variable used in a
12880 late-specified return type of a local lambda, or for a
12881 local static or constant. Building a new VAR_DECL
12882 should be OK in all those cases. */
12883 r
= tsubst_decl (t
, args
, complain
);
12884 if (decl_maybe_constant_var_p (r
))
12886 /* We can't call cp_finish_decl, so handle the
12887 initializer by hand. */
12888 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
12889 complain
, in_decl
);
12890 if (!processing_template_decl
)
12891 init
= maybe_constant_init (init
);
12892 if (processing_template_decl
12893 ? potential_constant_expression (init
)
12894 : reduced_constant_expression_p (init
))
12895 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
12896 = TREE_CONSTANT (r
) = true;
12897 DECL_INITIAL (r
) = init
;
12899 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
12900 || decl_constant_var_p (r
)
12901 || errorcount
|| sorrycount
);
12902 if (!processing_template_decl
)
12904 if (TREE_STATIC (r
))
12905 rest_of_decl_compilation (r
, toplevel_bindings_p (),
12907 else if (decl_constant_var_p (r
))
12908 /* A use of a local constant decays to its value.
12909 FIXME update for core DR 696. */
12910 r
= integral_constant_value (r
);
12913 /* Remember this for subsequent uses. */
12914 if (local_specializations
)
12915 register_local_specialization (r
, t
);
12923 case NAMESPACE_DECL
:
12927 /* An OVERLOAD will always be a non-dependent overload set; an
12928 overload set from function scope will just be represented with an
12929 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12930 gcc_assert (!uses_template_parms (t
));
12934 return tsubst_baselink (t
, current_nonlambda_class_type (),
12935 args
, complain
, in_decl
);
12937 case TEMPLATE_DECL
:
12938 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12939 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
12940 args
, complain
, in_decl
);
12941 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
12942 return tsubst (t
, args
, complain
, in_decl
);
12943 else if (DECL_CLASS_SCOPE_P (t
)
12944 && uses_template_parms (DECL_CONTEXT (t
)))
12946 /* Template template argument like the following example need
12949 template <template <class> class TT> struct C {};
12950 template <class T> struct D {
12951 template <class U> struct E {};
12956 We are processing the template argument `E' in #1 for
12957 the template instantiation #2. Originally, `E' is a
12958 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12959 have to substitute this with one having context `D<int>'. */
12961 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
12962 return lookup_field (context
, DECL_NAME(t
), 0, false);
12965 /* Ordinary template template argument. */
12969 case REINTERPRET_CAST_EXPR
:
12970 case CONST_CAST_EXPR
:
12971 case STATIC_CAST_EXPR
:
12972 case DYNAMIC_CAST_EXPR
:
12973 case IMPLICIT_CONV_EXPR
:
12977 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12978 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12979 return build1 (code
, type
, op0
);
12983 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
12986 tree expanded
, op
= TREE_OPERAND (t
, 0);
12989 if (SIZEOF_EXPR_TYPE_P (t
))
12990 op
= TREE_TYPE (op
);
12992 ++cp_unevaluated_operand
;
12993 ++c_inhibit_evaluation_warnings
;
12994 /* We only want to compute the number of arguments. */
12995 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
12996 --cp_unevaluated_operand
;
12997 --c_inhibit_evaluation_warnings
;
12999 if (TREE_CODE (expanded
) == TREE_VEC
)
13000 len
= TREE_VEC_LENGTH (expanded
);
13002 if (expanded
== error_mark_node
)
13003 return error_mark_node
;
13004 else if (PACK_EXPANSION_P (expanded
)
13005 || (TREE_CODE (expanded
) == TREE_VEC
13007 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
13009 if (TREE_CODE (expanded
) == TREE_VEC
)
13010 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
13012 if (TYPE_P (expanded
))
13013 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
13014 complain
& tf_error
);
13016 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
13017 complain
& tf_error
);
13020 return build_int_cst (size_type_node
, len
);
13022 if (SIZEOF_EXPR_TYPE_P (t
))
13024 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
13025 args
, complain
, in_decl
);
13026 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
13027 r
= build1 (SIZEOF_EXPR
,
13028 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
13029 SIZEOF_EXPR_TYPE_P (r
) = 1;
13036 case TRUTH_NOT_EXPR
:
13039 case UNARY_PLUS_EXPR
: /* Unary + */
13041 case AT_ENCODE_EXPR
:
13045 case REALPART_EXPR
:
13046 case IMAGPART_EXPR
:
13049 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13050 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13051 return build1 (code
, type
, op0
);
13054 case COMPONENT_REF
:
13059 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13060 name
= TREE_OPERAND (t
, 1);
13061 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
13063 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13064 complain
, in_decl
);
13065 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13067 else if (TREE_CODE (name
) == SCOPE_REF
13068 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
13070 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13071 complain
, in_decl
);
13072 name
= TREE_OPERAND (name
, 1);
13073 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13074 complain
, in_decl
);
13075 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13076 name
= build_qualified_name (/*type=*/NULL_TREE
,
13078 /*template_p=*/false);
13080 else if (BASELINK_P (name
))
13081 name
= tsubst_baselink (name
,
13082 non_reference (TREE_TYPE (object
)),
13086 name
= tsubst_copy (name
, args
, complain
, in_decl
);
13087 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
13093 case TRUNC_DIV_EXPR
:
13094 case CEIL_DIV_EXPR
:
13095 case FLOOR_DIV_EXPR
:
13096 case ROUND_DIV_EXPR
:
13097 case EXACT_DIV_EXPR
:
13101 case TRUNC_MOD_EXPR
:
13102 case FLOOR_MOD_EXPR
:
13103 case TRUTH_ANDIF_EXPR
:
13104 case TRUTH_ORIF_EXPR
:
13105 case TRUTH_AND_EXPR
:
13106 case TRUTH_OR_EXPR
:
13119 case COMPOUND_EXPR
:
13122 case PREDECREMENT_EXPR
:
13123 case PREINCREMENT_EXPR
:
13124 case POSTDECREMENT_EXPR
:
13125 case POSTINCREMENT_EXPR
:
13127 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13128 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13129 return build_nt (code
, op0
, op1
);
13134 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13135 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13136 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
13137 QUALIFIED_NAME_IS_TEMPLATE (t
));
13142 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13143 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13144 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13149 int n
= VL_EXP_OPERAND_LENGTH (t
);
13150 tree result
= build_vl_exp (CALL_EXPR
, n
);
13152 for (i
= 0; i
< n
; i
++)
13153 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13154 complain
, in_decl
);
13160 case PSEUDO_DTOR_EXPR
:
13161 case VEC_PERM_EXPR
:
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 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13166 r
= build_nt (code
, op0
, op1
, op2
);
13167 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13173 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13174 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13175 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13176 r
= build_nt (code
, op0
, op1
, op2
);
13177 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13183 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13184 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13185 r
= build_nt (code
, op0
, op1
);
13186 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13187 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13191 case TEMPLATE_ID_EXPR
:
13193 /* Substituted template arguments */
13194 tree fn
= TREE_OPERAND (t
, 0);
13195 tree targs
= TREE_OPERAND (t
, 1);
13197 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13199 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13201 return lookup_template_function (fn
, targs
);
13206 tree purpose
, value
, chain
;
13208 if (t
== void_list_node
)
13211 purpose
= TREE_PURPOSE (t
);
13213 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13214 value
= TREE_VALUE (t
);
13216 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13217 chain
= TREE_CHAIN (t
);
13218 if (chain
&& chain
!= void_type_node
)
13219 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13220 if (purpose
== TREE_PURPOSE (t
)
13221 && value
== TREE_VALUE (t
)
13222 && chain
== TREE_CHAIN (t
))
13224 return tree_cons (purpose
, value
, chain
);
13229 case ENUMERAL_TYPE
:
13231 case TEMPLATE_TYPE_PARM
:
13232 case TEMPLATE_TEMPLATE_PARM
:
13233 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13234 case TEMPLATE_PARM_INDEX
:
13236 case REFERENCE_TYPE
:
13238 case FUNCTION_TYPE
:
13241 case TYPENAME_TYPE
:
13242 case UNBOUND_CLASS_TEMPLATE
:
13244 case DECLTYPE_TYPE
:
13246 return tsubst (t
, args
, complain
, in_decl
);
13250 /* Fall through. */
13251 case IDENTIFIER_NODE
:
13252 if (IDENTIFIER_TYPENAME_P (t
))
13254 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13255 return mangle_conv_op_name_for_type (new_type
);
13261 /* This is handled by tsubst_copy_and_build. */
13262 gcc_unreachable ();
13266 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13267 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13268 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13271 case CLEANUP_POINT_EXPR
:
13272 /* We shouldn't have built any of these during initial template
13273 generation. Instead, they should be built during instantiation
13274 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13275 gcc_unreachable ();
13279 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13280 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13281 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13282 r
= build2 (code
, type
, op0
, op1
);
13283 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13284 mark_used (TREE_OPERAND (r
, 1));
13288 case EXPR_PACK_EXPANSION
:
13289 error ("invalid use of pack expansion expression");
13290 return error_mark_node
;
13292 case NONTYPE_ARGUMENT_PACK
:
13293 error ("use %<...%> to expand argument pack");
13294 return error_mark_node
;
13297 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13305 /* Instantiate any typedefs in the type. */
13306 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13307 r
= fold_convert (type
, t
);
13308 gcc_assert (TREE_CODE (r
) == code
);
13313 /* These can sometimes show up in a partial instantiation, but never
13314 involve template parms. */
13315 gcc_assert (!uses_template_parms (t
));
13319 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13320 gcc_checking_assert (false);
13325 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13328 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13329 tree args
, tsubst_flags_t complain
, tree in_decl
)
13331 tree new_clauses
= NULL
, nc
, oc
;
13333 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13335 nc
= copy_node (oc
);
13336 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13339 switch (OMP_CLAUSE_CODE (nc
))
13341 case OMP_CLAUSE_LASTPRIVATE
:
13342 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13344 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13345 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13346 in_decl
, /*integral_constant_expression_p=*/false);
13347 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13348 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13351 case OMP_CLAUSE_PRIVATE
:
13352 case OMP_CLAUSE_SHARED
:
13353 case OMP_CLAUSE_FIRSTPRIVATE
:
13354 case OMP_CLAUSE_COPYIN
:
13355 case OMP_CLAUSE_COPYPRIVATE
:
13356 case OMP_CLAUSE_IF
:
13357 case OMP_CLAUSE_NUM_THREADS
:
13358 case OMP_CLAUSE_SCHEDULE
:
13359 case OMP_CLAUSE_COLLAPSE
:
13360 case OMP_CLAUSE_FINAL
:
13361 case OMP_CLAUSE_DEPEND
:
13362 case OMP_CLAUSE_FROM
:
13363 case OMP_CLAUSE_TO
:
13364 case OMP_CLAUSE_UNIFORM
:
13365 case OMP_CLAUSE_MAP
:
13366 case OMP_CLAUSE_DEVICE
:
13367 case OMP_CLAUSE_DIST_SCHEDULE
:
13368 case OMP_CLAUSE_NUM_TEAMS
:
13369 case OMP_CLAUSE_THREAD_LIMIT
:
13370 case OMP_CLAUSE_SAFELEN
:
13371 case OMP_CLAUSE_SIMDLEN
:
13372 OMP_CLAUSE_OPERAND (nc
, 0)
13373 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13374 in_decl
, /*integral_constant_expression_p=*/false);
13376 case OMP_CLAUSE_REDUCTION
:
13377 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13379 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13380 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13382 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13383 complain
, in_decl
);
13384 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13385 = build_qualified_name (NULL_TREE
, scope
,
13386 TREE_OPERAND (placeholder
, 1),
13390 gcc_assert (identifier_p (placeholder
));
13392 OMP_CLAUSE_OPERAND (nc
, 0)
13393 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13394 in_decl
, /*integral_constant_expression_p=*/false);
13396 case OMP_CLAUSE_LINEAR
:
13397 case OMP_CLAUSE_ALIGNED
:
13398 OMP_CLAUSE_OPERAND (nc
, 0)
13399 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13400 in_decl
, /*integral_constant_expression_p=*/false);
13401 OMP_CLAUSE_OPERAND (nc
, 1)
13402 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13403 in_decl
, /*integral_constant_expression_p=*/false);
13406 case OMP_CLAUSE_NOWAIT
:
13407 case OMP_CLAUSE_ORDERED
:
13408 case OMP_CLAUSE_DEFAULT
:
13409 case OMP_CLAUSE_UNTIED
:
13410 case OMP_CLAUSE_MERGEABLE
:
13411 case OMP_CLAUSE_INBRANCH
:
13412 case OMP_CLAUSE_NOTINBRANCH
:
13413 case OMP_CLAUSE_PROC_BIND
:
13414 case OMP_CLAUSE_FOR
:
13415 case OMP_CLAUSE_PARALLEL
:
13416 case OMP_CLAUSE_SECTIONS
:
13417 case OMP_CLAUSE_TASKGROUP
:
13420 gcc_unreachable ();
13424 new_clauses
= nreverse (new_clauses
);
13426 new_clauses
= finish_omp_clauses (new_clauses
);
13427 return new_clauses
;
13430 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13433 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13436 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13438 tree purpose
, value
, chain
;
13443 if (TREE_CODE (t
) != TREE_LIST
)
13444 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13445 /*function_p=*/false,
13446 /*integral_constant_expression_p=*/false);
13448 if (t
== void_list_node
)
13451 purpose
= TREE_PURPOSE (t
);
13453 purpose
= RECUR (purpose
);
13454 value
= TREE_VALUE (t
);
13457 if (TREE_CODE (value
) != LABEL_DECL
)
13458 value
= RECUR (value
);
13461 value
= lookup_label (DECL_NAME (value
));
13462 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13463 TREE_USED (value
) = 1;
13466 chain
= TREE_CHAIN (t
);
13467 if (chain
&& chain
!= void_type_node
)
13468 chain
= RECUR (chain
);
13469 return tree_cons (purpose
, value
, chain
);
13473 /* Substitute one OMP_FOR iterator. */
13476 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13477 tree condv
, tree incrv
, tree
*clauses
,
13478 tree args
, tsubst_flags_t complain
, tree in_decl
,
13479 bool integral_constant_expression_p
)
13481 #define RECUR(NODE) \
13482 tsubst_expr ((NODE), args, complain, in_decl, \
13483 integral_constant_expression_p)
13484 tree decl
, init
, cond
, incr
;
13486 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13487 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13488 decl
= TREE_OPERAND (init
, 0);
13489 init
= TREE_OPERAND (init
, 1);
13490 tree decl_expr
= NULL_TREE
;
13491 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13493 /* We need to jump through some hoops to handle declarations in the
13494 for-init-statement, since we might need to handle auto deduction,
13495 but we need to keep control of initialization. */
13497 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13498 decl
= tsubst_decl (decl
, args
, complain
);
13501 decl
= RECUR (decl
);
13502 init
= RECUR (init
);
13504 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13505 if (auto_node
&& init
)
13507 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13509 gcc_assert (!type_dependent_expression_p (decl
));
13511 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13515 /* Declare the variable, but don't let that initialize it. */
13516 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13517 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13519 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13522 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13523 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13524 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13526 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13527 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13528 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13529 NOP_EXPR
, rhs
, complain
);
13532 incr
= RECUR (incr
);
13533 TREE_VEC_ELT (declv
, i
) = decl
;
13534 TREE_VEC_ELT (initv
, i
) = init
;
13535 TREE_VEC_ELT (condv
, i
) = cond
;
13536 TREE_VEC_ELT (incrv
, i
) = incr
;
13542 /* Declare and initialize the variable. */
13549 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13551 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13552 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13553 && OMP_CLAUSE_DECL (c
) == decl
)
13555 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13556 && OMP_CLAUSE_DECL (c
) == decl
)
13557 error ("iteration variable %qD should not be firstprivate", decl
);
13558 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13559 && OMP_CLAUSE_DECL (c
) == decl
)
13560 error ("iteration variable %qD should not be reduction", decl
);
13564 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13565 OMP_CLAUSE_DECL (c
) = decl
;
13566 c
= finish_omp_clauses (c
);
13569 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13574 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13575 if (COMPARISON_CLASS_P (cond
))
13577 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13578 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13579 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13582 cond
= RECUR (cond
);
13583 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13584 switch (TREE_CODE (incr
))
13586 case PREINCREMENT_EXPR
:
13587 case PREDECREMENT_EXPR
:
13588 case POSTINCREMENT_EXPR
:
13589 case POSTDECREMENT_EXPR
:
13590 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13591 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13594 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13595 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13597 tree rhs
= TREE_OPERAND (incr
, 1);
13598 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13599 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13600 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13601 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13602 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13606 incr
= RECUR (incr
);
13609 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13610 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13612 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13613 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13614 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13615 TREE_TYPE (decl
), lhs
,
13616 RECUR (TREE_OPERAND (incr
, 2))));
13618 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13619 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13620 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13622 tree rhs
= TREE_OPERAND (incr
, 2);
13623 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13624 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13625 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13626 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13627 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13631 incr
= RECUR (incr
);
13634 incr
= RECUR (incr
);
13638 TREE_VEC_ELT (declv
, i
) = decl
;
13639 TREE_VEC_ELT (initv
, i
) = init
;
13640 TREE_VEC_ELT (condv
, i
) = cond
;
13641 TREE_VEC_ELT (incrv
, i
) = incr
;
13645 /* Like tsubst_copy for expressions, etc. but also does semantic
13649 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13650 bool integral_constant_expression_p
)
13652 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13653 #define RECUR(NODE) \
13654 tsubst_expr ((NODE), args, complain, in_decl, \
13655 integral_constant_expression_p)
13661 if (t
== NULL_TREE
|| t
== error_mark_node
)
13664 loc
= input_location
;
13665 if (EXPR_HAS_LOCATION (t
))
13666 input_location
= EXPR_LOCATION (t
);
13667 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13668 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13670 switch (TREE_CODE (t
))
13672 case STATEMENT_LIST
:
13674 tree_stmt_iterator i
;
13675 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13676 RECUR (tsi_stmt (i
));
13680 case CTOR_INITIALIZER
:
13681 finish_mem_initializers (tsubst_initializer_list
13682 (TREE_OPERAND (t
, 0), args
));
13686 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13690 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13691 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13692 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13694 finish_expr_stmt (tmp
);
13698 do_using_directive (USING_STMT_NAMESPACE (t
));
13703 tree decl
, pattern_decl
;
13706 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13707 if (TREE_CODE (decl
) == LABEL_DECL
)
13708 finish_label_decl (DECL_NAME (decl
));
13709 else if (TREE_CODE (decl
) == USING_DECL
)
13711 tree scope
= USING_DECL_SCOPE (decl
);
13712 tree name
= DECL_NAME (decl
);
13715 scope
= tsubst (scope
, args
, complain
, in_decl
);
13716 decl
= lookup_qualified_name (scope
, name
,
13717 /*is_type_p=*/false,
13718 /*complain=*/false);
13719 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13720 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13722 do_local_using_decl (decl
, scope
, name
);
13724 else if (DECL_PACK_P (decl
))
13726 /* Don't build up decls for a variadic capture proxy, we'll
13727 instantiate the elements directly as needed. */
13732 init
= DECL_INITIAL (decl
);
13733 decl
= tsubst (decl
, args
, complain
, in_decl
);
13734 if (decl
!= error_mark_node
)
13736 /* By marking the declaration as instantiated, we avoid
13737 trying to instantiate it. Since instantiate_decl can't
13738 handle local variables, and since we've already done
13739 all that needs to be done, that's the right thing to
13742 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13744 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13745 /* Anonymous aggregates are a special case. */
13746 finish_anon_union (decl
);
13747 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13749 DECL_CONTEXT (decl
) = current_function_decl
;
13750 if (DECL_NAME (decl
) == this_identifier
)
13752 tree lam
= DECL_CONTEXT (current_function_decl
);
13753 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13754 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13756 insert_capture_proxy (decl
);
13758 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13759 /* We already did a pushtag. */;
13760 else if (TREE_CODE (decl
) == FUNCTION_DECL
13761 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13762 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13764 DECL_CONTEXT (decl
) = NULL_TREE
;
13766 DECL_CONTEXT (decl
) = current_function_decl
;
13767 cp_check_omp_declare_reduction (decl
);
13771 int const_init
= false;
13772 maybe_push_decl (decl
);
13774 && DECL_PRETTY_FUNCTION_P (decl
))
13776 /* For __PRETTY_FUNCTION__ we have to adjust the
13778 const char *const name
13779 = cxx_printable_name (current_function_decl
, 2);
13780 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13783 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
13786 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13788 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13797 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13798 RECUR (FOR_INIT_STMT (t
));
13799 finish_for_init_stmt (stmt
);
13800 tmp
= RECUR (FOR_COND (t
));
13801 finish_for_cond (tmp
, stmt
, false);
13802 tmp
= RECUR (FOR_EXPR (t
));
13803 finish_for_expr (tmp
, stmt
);
13804 RECUR (FOR_BODY (t
));
13805 finish_for_stmt (stmt
);
13808 case RANGE_FOR_STMT
:
13811 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13812 decl
= RANGE_FOR_DECL (t
);
13813 decl
= tsubst (decl
, args
, complain
, in_decl
);
13814 maybe_push_decl (decl
);
13815 expr
= RECUR (RANGE_FOR_EXPR (t
));
13816 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13817 RECUR (RANGE_FOR_BODY (t
));
13818 finish_for_stmt (stmt
);
13823 stmt
= begin_while_stmt ();
13824 tmp
= RECUR (WHILE_COND (t
));
13825 finish_while_stmt_cond (tmp
, stmt
, false);
13826 RECUR (WHILE_BODY (t
));
13827 finish_while_stmt (stmt
);
13831 stmt
= begin_do_stmt ();
13832 RECUR (DO_BODY (t
));
13833 finish_do_body (stmt
);
13834 tmp
= RECUR (DO_COND (t
));
13835 finish_do_stmt (tmp
, stmt
, false);
13839 stmt
= begin_if_stmt ();
13840 tmp
= RECUR (IF_COND (t
));
13841 finish_if_stmt_cond (tmp
, stmt
);
13842 RECUR (THEN_CLAUSE (t
));
13843 finish_then_clause (stmt
);
13845 if (ELSE_CLAUSE (t
))
13847 begin_else_clause (stmt
);
13848 RECUR (ELSE_CLAUSE (t
));
13849 finish_else_clause (stmt
);
13852 finish_if_stmt (stmt
);
13856 if (BIND_EXPR_BODY_BLOCK (t
))
13857 stmt
= begin_function_body ();
13859 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
13860 ? BCS_TRY_BLOCK
: 0);
13862 RECUR (BIND_EXPR_BODY (t
));
13864 if (BIND_EXPR_BODY_BLOCK (t
))
13865 finish_function_body (stmt
);
13867 finish_compound_stmt (stmt
);
13871 finish_break_stmt ();
13874 case CONTINUE_STMT
:
13875 finish_continue_stmt ();
13879 stmt
= begin_switch_stmt ();
13880 tmp
= RECUR (SWITCH_STMT_COND (t
));
13881 finish_switch_cond (tmp
, stmt
);
13882 RECUR (SWITCH_STMT_BODY (t
));
13883 finish_switch_stmt (stmt
);
13886 case CASE_LABEL_EXPR
:
13888 tree low
= RECUR (CASE_LOW (t
));
13889 tree high
= RECUR (CASE_HIGH (t
));
13890 finish_case_label (EXPR_LOCATION (t
), low
, high
);
13896 tree decl
= LABEL_EXPR_LABEL (t
);
13899 label
= finish_label_stmt (DECL_NAME (decl
));
13900 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13901 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13906 tmp
= GOTO_DESTINATION (t
);
13907 if (TREE_CODE (tmp
) != LABEL_DECL
)
13908 /* Computed goto's must be tsubst'd into. On the other hand,
13909 non-computed gotos must not be; the identifier in question
13910 will have no binding. */
13913 tmp
= DECL_NAME (tmp
);
13914 finish_goto_stmt (tmp
);
13919 tree string
= RECUR (ASM_STRING (t
));
13920 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
13921 complain
, in_decl
);
13922 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
13923 complain
, in_decl
);
13924 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
13925 complain
, in_decl
);
13926 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
13927 complain
, in_decl
);
13928 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
13930 tree asm_expr
= tmp
;
13931 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
13932 asm_expr
= TREE_OPERAND (asm_expr
, 0);
13933 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
13940 stmt
= begin_try_block ();
13941 RECUR (TRY_STMTS (t
));
13942 finish_cleanup_try_block (stmt
);
13943 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
13947 tree compound_stmt
= NULL_TREE
;
13949 if (FN_TRY_BLOCK_P (t
))
13950 stmt
= begin_function_try_block (&compound_stmt
);
13952 stmt
= begin_try_block ();
13954 RECUR (TRY_STMTS (t
));
13956 if (FN_TRY_BLOCK_P (t
))
13957 finish_function_try_block (stmt
);
13959 finish_try_block (stmt
);
13961 RECUR (TRY_HANDLERS (t
));
13962 if (FN_TRY_BLOCK_P (t
))
13963 finish_function_handler_sequence (stmt
, compound_stmt
);
13965 finish_handler_sequence (stmt
);
13971 tree decl
= HANDLER_PARMS (t
);
13975 decl
= tsubst (decl
, args
, complain
, in_decl
);
13976 /* Prevent instantiate_decl from trying to instantiate
13977 this variable. We've already done all that needs to be
13979 if (decl
!= error_mark_node
)
13980 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13982 stmt
= begin_handler ();
13983 finish_handler_parms (decl
, stmt
);
13984 RECUR (HANDLER_BODY (t
));
13985 finish_handler (stmt
);
13990 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
13991 if (CLASS_TYPE_P (tmp
))
13993 /* Local classes are not independent templates; they are
13994 instantiated along with their containing function. And this
13995 way we don't have to deal with pushing out of one local class
13996 to instantiate a member of another local class. */
13998 /* Closures are handled by the LAMBDA_EXPR. */
13999 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
14000 complete_type (tmp
);
14001 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
14002 if (!DECL_ARTIFICIAL (fn
))
14003 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
14007 case STATIC_ASSERT
:
14011 ++c_inhibit_evaluation_warnings
;
14013 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
14016 /*integral_constant_expression_p=*/true);
14017 --c_inhibit_evaluation_warnings
;
14019 finish_static_assert (condition
,
14020 STATIC_ASSERT_MESSAGE (t
),
14021 STATIC_ASSERT_SOURCE_LOCATION (t
),
14022 /*member_p=*/false);
14027 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
14028 args
, complain
, in_decl
);
14029 stmt
= begin_omp_parallel ();
14030 RECUR (OMP_PARALLEL_BODY (t
));
14031 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
14032 = OMP_PARALLEL_COMBINED (t
);
14036 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
14037 args
, complain
, in_decl
);
14038 stmt
= begin_omp_task ();
14039 RECUR (OMP_TASK_BODY (t
));
14040 finish_omp_task (tmp
, stmt
);
14047 case OMP_DISTRIBUTE
:
14049 tree clauses
, body
, pre_body
;
14050 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
14051 tree incrv
= NULL_TREE
;
14054 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
14055 args
, complain
, in_decl
);
14056 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14058 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14059 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14060 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14061 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14064 stmt
= begin_omp_structured_block ();
14066 pre_body
= push_stmt_list ();
14067 RECUR (OMP_FOR_PRE_BODY (t
));
14068 pre_body
= pop_stmt_list (pre_body
);
14070 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14071 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
14072 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
14073 &clauses
, args
, complain
, in_decl
,
14074 integral_constant_expression_p
);
14076 body
= push_stmt_list ();
14077 RECUR (OMP_FOR_BODY (t
));
14078 body
= pop_stmt_list (body
);
14080 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14081 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
14082 condv
, incrv
, body
, pre_body
, clauses
);
14085 t
= make_node (TREE_CODE (t
));
14086 TREE_TYPE (t
) = void_type_node
;
14087 OMP_FOR_BODY (t
) = body
;
14088 OMP_FOR_PRE_BODY (t
) = pre_body
;
14089 OMP_FOR_CLAUSES (t
) = clauses
;
14090 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
14094 add_stmt (finish_omp_structured_block (stmt
));
14101 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14102 args
, complain
, in_decl
);
14103 stmt
= push_stmt_list ();
14104 RECUR (OMP_BODY (t
));
14105 stmt
= pop_stmt_list (stmt
);
14108 OMP_BODY (t
) = stmt
;
14109 OMP_CLAUSES (t
) = tmp
;
14113 case OMP_TARGET_DATA
:
14115 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14116 args
, complain
, in_decl
);
14117 keep_next_level (true);
14118 stmt
= begin_omp_structured_block ();
14120 RECUR (OMP_BODY (t
));
14121 stmt
= finish_omp_structured_block (stmt
);
14124 OMP_BODY (t
) = stmt
;
14125 OMP_CLAUSES (t
) = tmp
;
14129 case OMP_TARGET_UPDATE
:
14130 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
14131 args
, complain
, in_decl
);
14133 OMP_CLAUSES (t
) = tmp
;
14140 case OMP_TASKGROUP
:
14142 stmt
= push_stmt_list ();
14143 RECUR (OMP_BODY (t
));
14144 stmt
= pop_stmt_list (stmt
);
14147 OMP_BODY (t
) = stmt
;
14152 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14153 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14155 tree op1
= TREE_OPERAND (t
, 1);
14156 tree rhs1
= NULL_TREE
;
14158 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14160 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14161 op1
= TREE_OPERAND (op1
, 1);
14163 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14164 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14165 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14166 NULL_TREE
, NULL_TREE
, rhs1
,
14167 OMP_ATOMIC_SEQ_CST (t
));
14171 tree op1
= TREE_OPERAND (t
, 1);
14172 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14173 tree rhs1
= NULL_TREE
;
14174 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14175 enum tree_code opcode
= NOP_EXPR
;
14176 if (code
== OMP_ATOMIC_READ
)
14178 v
= RECUR (TREE_OPERAND (op1
, 0));
14179 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14181 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14182 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14184 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14185 v
= RECUR (TREE_OPERAND (op1
, 0));
14186 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14187 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14189 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14190 op11
= TREE_OPERAND (op11
, 1);
14192 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14193 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14194 opcode
= TREE_CODE (op11
);
14195 if (opcode
== MODIFY_EXPR
)
14201 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14202 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14204 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14205 OMP_ATOMIC_SEQ_CST (t
));
14209 case TRANSACTION_EXPR
:
14212 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14213 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14215 if (TRANSACTION_EXPR_IS_STMT (t
))
14217 tree body
= TRANSACTION_EXPR_BODY (t
);
14218 tree noex
= NULL_TREE
;
14219 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14221 noex
= MUST_NOT_THROW_COND (body
);
14222 if (noex
== NULL_TREE
)
14223 noex
= boolean_true_node
;
14224 body
= TREE_OPERAND (body
, 0);
14226 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14228 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14232 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14233 RECUR (TRANSACTION_EXPR_BODY (t
)),
14240 case MUST_NOT_THROW_EXPR
:
14242 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14243 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14244 RETURN (build_must_not_throw_expr (op0
, cond
));
14247 case EXPR_PACK_EXPANSION
:
14248 error ("invalid use of pack expansion expression");
14249 RETURN (error_mark_node
);
14251 case NONTYPE_ARGUMENT_PACK
:
14252 error ("use %<...%> to expand argument pack");
14253 RETURN (error_mark_node
);
14255 case CILK_SPAWN_STMT
:
14256 cfun
->calls_cilk_spawn
= 1;
14257 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14259 case CILK_SYNC_STMT
:
14260 RETURN (build_cilk_sync ());
14262 case COMPOUND_EXPR
:
14263 tmp
= RECUR (TREE_OPERAND (t
, 0));
14264 if (tmp
== NULL_TREE
)
14265 /* If the first operand was a statement, we're done with it. */
14266 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14267 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14268 RECUR (TREE_OPERAND (t
, 1)),
14271 case ANNOTATE_EXPR
:
14272 tmp
= RECUR (TREE_OPERAND (t
, 0));
14273 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14274 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14277 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14279 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14280 /*function_p=*/false,
14281 integral_constant_expression_p
));
14284 RETURN (NULL_TREE
);
14286 input_location
= loc
;
14292 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14293 function. For description of the body see comment above
14294 cp_parser_omp_declare_reduction_exprs. */
14297 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14299 if (t
== NULL_TREE
|| t
== error_mark_node
)
14302 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14304 tree_stmt_iterator tsi
;
14307 memset (stmts
, 0, sizeof stmts
);
14308 for (i
= 0, tsi
= tsi_start (t
);
14309 i
< 7 && !tsi_end_p (tsi
);
14310 i
++, tsi_next (&tsi
))
14311 stmts
[i
] = tsi_stmt (tsi
);
14312 gcc_assert (tsi_end_p (tsi
));
14316 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14317 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14318 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14319 args
, complain
, in_decl
);
14320 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14321 args
, complain
, in_decl
);
14322 DECL_CONTEXT (omp_out
) = current_function_decl
;
14323 DECL_CONTEXT (omp_in
) = current_function_decl
;
14324 keep_next_level (true);
14325 tree block
= begin_omp_structured_block ();
14326 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14327 block
= finish_omp_structured_block (block
);
14328 block
= maybe_cleanup_point_expr_void (block
);
14329 add_decl_expr (omp_out
);
14330 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14331 TREE_NO_WARNING (omp_out
) = 1;
14332 add_decl_expr (omp_in
);
14333 finish_expr_stmt (block
);
14337 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14338 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14339 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14340 args
, complain
, in_decl
);
14341 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14342 args
, complain
, in_decl
);
14343 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14344 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14345 keep_next_level (true);
14346 tree block
= begin_omp_structured_block ();
14347 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14348 block
= finish_omp_structured_block (block
);
14349 block
= maybe_cleanup_point_expr_void (block
);
14350 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14351 add_decl_expr (omp_priv
);
14352 add_decl_expr (omp_orig
);
14353 finish_expr_stmt (block
);
14355 add_decl_expr (omp_orig
);
14359 /* T is a postfix-expression that is not being used in a function
14360 call. Return the substituted version of T. */
14363 tsubst_non_call_postfix_expression (tree t
, tree args
,
14364 tsubst_flags_t complain
,
14367 if (TREE_CODE (t
) == SCOPE_REF
)
14368 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14369 /*done=*/false, /*address_p=*/false);
14371 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14372 /*function_p=*/false,
14373 /*integral_constant_expression_p=*/false);
14378 /* Sentinel to disable certain warnings during template substitution. */
14380 struct warning_sentinel
{
14383 warning_sentinel(int& flag
, bool suppress
=true)
14384 : flag(flag
), val(flag
) { if (suppress
) flag
= 0; }
14385 ~warning_sentinel() { flag
= val
; }
14388 /* Like tsubst but deals with expressions and performs semantic
14389 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14392 tsubst_copy_and_build (tree t
,
14394 tsubst_flags_t complain
,
14397 bool integral_constant_expression_p
)
14399 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14400 #define RECUR(NODE) \
14401 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14402 /*function_p=*/false, \
14403 integral_constant_expression_p)
14408 if (t
== NULL_TREE
|| t
== error_mark_node
)
14411 loc
= input_location
;
14412 if (EXPR_HAS_LOCATION (t
))
14413 input_location
= EXPR_LOCATION (t
);
14415 /* N3276 decltype magic only applies to calls at the top level or on the
14416 right side of a comma. */
14417 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14418 complain
&= ~tf_decltype
;
14420 switch (TREE_CODE (t
))
14424 /* Fall through. */
14425 case IDENTIFIER_NODE
:
14429 bool non_integral_constant_expression_p
;
14430 const char *error_msg
;
14432 if (IDENTIFIER_TYPENAME_P (t
))
14434 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14435 t
= mangle_conv_op_name_for_type (new_type
);
14438 /* Look up the name. */
14439 decl
= lookup_name (t
);
14441 /* By convention, expressions use ERROR_MARK_NODE to indicate
14442 failure, not NULL_TREE. */
14443 if (decl
== NULL_TREE
)
14444 decl
= error_mark_node
;
14446 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14448 integral_constant_expression_p
,
14449 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14450 &non_integral_constant_expression_p
,
14451 /*template_p=*/false,
14453 /*address_p=*/false,
14454 /*template_arg_p=*/false,
14459 if (!function_p
&& identifier_p (decl
))
14461 if (complain
& tf_error
)
14462 unqualified_name_lookup_error (decl
);
14463 decl
= error_mark_node
;
14468 case TEMPLATE_ID_EXPR
:
14471 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14472 tree targs
= TREE_OPERAND (t
, 1);
14475 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14477 if (TREE_CODE (templ
) == COMPONENT_REF
)
14479 object
= TREE_OPERAND (templ
, 0);
14480 templ
= TREE_OPERAND (templ
, 1);
14483 object
= NULL_TREE
;
14484 templ
= lookup_template_function (templ
, targs
);
14487 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14488 object
, templ
, NULL_TREE
));
14490 RETURN (baselink_for_fns (templ
));
14495 tree r
= RECUR (TREE_OPERAND (t
, 0));
14497 if (REFERENCE_REF_P (t
))
14499 /* A type conversion to reference type will be enclosed in
14500 such an indirect ref, but the substitution of the cast
14501 will have also added such an indirect ref. */
14502 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14503 r
= convert_from_reference (r
);
14506 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14507 complain
|decltype_flag
);
14513 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14514 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14515 RETURN (build_nop (type
, op0
));
14518 case IMPLICIT_CONV_EXPR
:
14520 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14521 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14522 int flags
= LOOKUP_IMPLICIT
;
14523 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14524 flags
= LOOKUP_NORMAL
;
14525 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14531 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14532 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14533 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14537 case REINTERPRET_CAST_EXPR
:
14538 case CONST_CAST_EXPR
:
14539 case DYNAMIC_CAST_EXPR
:
14540 case STATIC_CAST_EXPR
:
14543 tree op
, r
= NULL_TREE
;
14545 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14546 if (integral_constant_expression_p
14547 && !cast_valid_in_integral_constant_expression_p (type
))
14549 if (complain
& tf_error
)
14550 error ("a cast to a type other than an integral or "
14551 "enumeration type cannot appear in a constant-expression");
14552 RETURN (error_mark_node
);
14555 op
= RECUR (TREE_OPERAND (t
, 0));
14557 warning_sentinel
s(warn_useless_cast
);
14558 switch (TREE_CODE (t
))
14561 r
= build_functional_cast (type
, op
, complain
);
14563 case REINTERPRET_CAST_EXPR
:
14564 r
= build_reinterpret_cast (type
, op
, complain
);
14566 case CONST_CAST_EXPR
:
14567 r
= build_const_cast (type
, op
, complain
);
14569 case DYNAMIC_CAST_EXPR
:
14570 r
= build_dynamic_cast (type
, op
, complain
);
14572 case STATIC_CAST_EXPR
:
14573 r
= build_static_cast (type
, op
, complain
);
14576 gcc_unreachable ();
14582 case POSTDECREMENT_EXPR
:
14583 case POSTINCREMENT_EXPR
:
14584 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14585 args
, complain
, in_decl
);
14586 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14587 complain
|decltype_flag
));
14589 case PREDECREMENT_EXPR
:
14590 case PREINCREMENT_EXPR
:
14594 case TRUTH_NOT_EXPR
:
14595 case UNARY_PLUS_EXPR
: /* Unary + */
14596 case REALPART_EXPR
:
14597 case IMAGPART_EXPR
:
14598 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14599 RECUR (TREE_OPERAND (t
, 0)),
14600 complain
|decltype_flag
));
14602 case FIX_TRUNC_EXPR
:
14603 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14607 op1
= TREE_OPERAND (t
, 0);
14608 if (TREE_CODE (op1
) == LABEL_DECL
)
14609 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14610 EXPR_LOCATION (op1
)));
14611 if (TREE_CODE (op1
) == SCOPE_REF
)
14612 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14613 /*done=*/true, /*address_p=*/true);
14615 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14617 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14618 complain
|decltype_flag
));
14623 case TRUNC_DIV_EXPR
:
14624 case CEIL_DIV_EXPR
:
14625 case FLOOR_DIV_EXPR
:
14626 case ROUND_DIV_EXPR
:
14627 case EXACT_DIV_EXPR
:
14631 case TRUNC_MOD_EXPR
:
14632 case FLOOR_MOD_EXPR
:
14633 case TRUTH_ANDIF_EXPR
:
14634 case TRUTH_ORIF_EXPR
:
14635 case TRUTH_AND_EXPR
:
14636 case TRUTH_OR_EXPR
:
14652 warning_sentinel
s1(warn_type_limits
);
14653 warning_sentinel
s2(warn_div_by_zero
);
14654 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14655 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14656 tree r
= build_x_binary_op
14657 (input_location
, TREE_CODE (t
),
14659 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14661 : TREE_CODE (TREE_OPERAND (t
, 0))),
14663 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14665 : TREE_CODE (TREE_OPERAND (t
, 1))),
14667 complain
|decltype_flag
);
14668 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14669 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14674 case POINTER_PLUS_EXPR
:
14676 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14677 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14678 return fold_build_pointer_plus (op0
, op1
);
14682 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14683 /*address_p=*/false));
14685 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14686 args
, complain
, in_decl
);
14687 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14688 RECUR (TREE_OPERAND (t
, 1)),
14689 complain
|decltype_flag
));
14691 case ARRAY_NOTATION_REF
:
14693 tree start_index
, length
, stride
;
14694 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14695 args
, complain
, in_decl
);
14696 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14697 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14698 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14699 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14700 length
, stride
, TREE_TYPE (op1
)));
14703 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14704 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14711 op1
= TREE_OPERAND (t
, 0);
14712 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14713 op1
= TREE_TYPE (op1
);
14716 /* When there are no ARGS, we are trying to evaluate a
14717 non-dependent expression from the parser. Trying to do
14718 the substitutions may not work. */
14720 op1
= TREE_TYPE (op1
);
14724 ++cp_unevaluated_operand
;
14725 ++c_inhibit_evaluation_warnings
;
14727 op1
= tsubst (op1
, args
, complain
, in_decl
);
14729 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14730 /*function_p=*/false,
14731 /*integral_constant_expression_p=*/
14733 --cp_unevaluated_operand
;
14734 --c_inhibit_evaluation_warnings
;
14737 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14738 complain
& tf_error
);
14740 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14741 complain
& tf_error
);
14742 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14744 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14746 if (!processing_template_decl
&& TYPE_P (op1
))
14748 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14749 build1 (NOP_EXPR
, op1
, error_mark_node
));
14750 SIZEOF_EXPR_TYPE_P (r
) = 1;
14753 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14754 TREE_SIDE_EFFECTS (r
) = 0;
14755 TREE_READONLY (r
) = 1;
14757 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14762 case AT_ENCODE_EXPR
:
14764 op1
= TREE_OPERAND (t
, 0);
14765 ++cp_unevaluated_operand
;
14766 ++c_inhibit_evaluation_warnings
;
14767 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14768 /*function_p=*/false,
14769 /*integral_constant_expression_p=*/false);
14770 --cp_unevaluated_operand
;
14771 --c_inhibit_evaluation_warnings
;
14772 RETURN (objc_build_encode_expr (op1
));
14775 case NOEXCEPT_EXPR
:
14776 op1
= TREE_OPERAND (t
, 0);
14777 ++cp_unevaluated_operand
;
14778 ++c_inhibit_evaluation_warnings
;
14779 ++cp_noexcept_operand
;
14780 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14781 /*function_p=*/false,
14782 /*integral_constant_expression_p=*/false);
14783 --cp_unevaluated_operand
;
14784 --c_inhibit_evaluation_warnings
;
14785 --cp_noexcept_operand
;
14786 RETURN (finish_noexcept_expr (op1
, complain
));
14790 warning_sentinel
s(warn_div_by_zero
);
14791 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
14792 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
14793 tree r
= build_x_modify_expr
14794 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
14795 complain
|decltype_flag
);
14796 /* TREE_NO_WARNING must be set if either the expression was
14797 parenthesized or it uses an operator such as >>= rather
14798 than plain assignment. In the former case, it was already
14799 set and must be copied. In the latter case,
14800 build_x_modify_expr sets it and it must not be reset
14802 if (TREE_NO_WARNING (t
))
14803 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14809 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14810 args
, complain
, in_decl
);
14811 /* Remember that there was a reference to this entity. */
14814 RETURN (build_x_arrow (input_location
, op1
, complain
));
14818 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14819 tree init
= RECUR (TREE_OPERAND (t
, 3));
14820 vec
<tree
, va_gc
> *placement_vec
;
14821 vec
<tree
, va_gc
> *init_vec
;
14824 if (placement
== NULL_TREE
)
14825 placement_vec
= NULL
;
14828 placement_vec
= make_tree_vector ();
14829 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14830 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14833 /* If there was an initializer in the original tree, but it
14834 instantiated to an empty list, then we should pass a
14835 non-NULL empty vector to tell build_new that it was an
14836 empty initializer() rather than no initializer. This can
14837 only happen when the initializer is a pack expansion whose
14838 parameter packs are of length zero. */
14839 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
14843 init_vec
= make_tree_vector ();
14844 if (init
== void_node
)
14845 gcc_assert (init_vec
!= NULL
);
14848 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
14849 vec_safe_push (init_vec
, TREE_VALUE (init
));
14853 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14854 tree op2
= RECUR (TREE_OPERAND (t
, 2));
14855 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
14856 NEW_EXPR_USE_GLOBAL (t
),
14859 if (placement_vec
!= NULL
)
14860 release_tree_vector (placement_vec
);
14861 if (init_vec
!= NULL
)
14862 release_tree_vector (init_vec
);
14869 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14870 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14871 RETURN (delete_sanity (op0
, op1
,
14872 DELETE_EXPR_USE_VEC (t
),
14873 DELETE_EXPR_USE_GLOBAL (t
),
14877 case COMPOUND_EXPR
:
14879 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
14880 complain
& ~tf_decltype
, in_decl
,
14881 /*function_p=*/false,
14882 integral_constant_expression_p
);
14883 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
14885 RECUR (TREE_OPERAND (t
, 1)),
14886 complain
|decltype_flag
));
14892 vec
<tree
, va_gc
> *call_args
;
14893 unsigned int nargs
, i
;
14898 function
= CALL_EXPR_FN (t
);
14899 /* When we parsed the expression, we determined whether or
14900 not Koenig lookup should be performed. */
14901 koenig_p
= KOENIG_LOOKUP_P (t
);
14902 if (TREE_CODE (function
) == SCOPE_REF
)
14904 qualified_p
= true;
14905 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
14907 /*address_p=*/false);
14909 else if (koenig_p
&& identifier_p (function
))
14911 /* Do nothing; calling tsubst_copy_and_build on an identifier
14912 would incorrectly perform unqualified lookup again.
14914 Note that we can also have an IDENTIFIER_NODE if the earlier
14915 unqualified lookup found a member function; in that case
14916 koenig_p will be false and we do want to do the lookup
14917 again to find the instantiated member function.
14919 FIXME but doing that causes c++/15272, so we need to stop
14920 using IDENTIFIER_NODE in that situation. */
14921 qualified_p
= false;
14925 if (TREE_CODE (function
) == COMPONENT_REF
)
14927 tree op
= TREE_OPERAND (function
, 1);
14929 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
14930 || (BASELINK_P (op
)
14931 && BASELINK_QUALIFIED_P (op
)));
14934 qualified_p
= false;
14936 if (TREE_CODE (function
) == ADDR_EXPR
14937 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
14938 /* Avoid error about taking the address of a constructor. */
14939 function
= TREE_OPERAND (function
, 0);
14941 function
= tsubst_copy_and_build (function
, args
, complain
,
14944 integral_constant_expression_p
);
14946 if (BASELINK_P (function
))
14947 qualified_p
= true;
14950 nargs
= call_expr_nargs (t
);
14951 call_args
= make_tree_vector ();
14952 for (i
= 0; i
< nargs
; ++i
)
14954 tree arg
= CALL_EXPR_ARG (t
, i
);
14956 if (!PACK_EXPANSION_P (arg
))
14957 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
14960 /* Expand the pack expansion and push each entry onto
14962 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
14963 if (TREE_CODE (arg
) == TREE_VEC
)
14965 unsigned int len
, j
;
14967 len
= TREE_VEC_LENGTH (arg
);
14968 for (j
= 0; j
< len
; ++j
)
14970 tree value
= TREE_VEC_ELT (arg
, j
);
14971 if (value
!= NULL_TREE
)
14972 value
= convert_from_reference (value
);
14973 vec_safe_push (call_args
, value
);
14978 /* A partial substitution. Add one entry. */
14979 vec_safe_push (call_args
, arg
);
14984 /* We do not perform argument-dependent lookup if normal
14985 lookup finds a non-function, in accordance with the
14986 expected resolution of DR 218. */
14988 && ((is_overloaded_fn (function
)
14989 /* If lookup found a member function, the Koenig lookup is
14990 not appropriate, even if an unqualified-name was used
14991 to denote the function. */
14992 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
14993 || identifier_p (function
))
14994 /* Only do this when substitution turns a dependent call
14995 into a non-dependent call. */
14996 && type_dependent_expression_p_push (t
)
14997 && !any_type_dependent_arguments_p (call_args
))
14998 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
15000 if (identifier_p (function
)
15001 && !any_type_dependent_arguments_p (call_args
))
15003 if (koenig_p
&& (complain
& tf_warning_or_error
))
15005 /* For backwards compatibility and good diagnostics, try
15006 the unqualified lookup again if we aren't in SFINAE
15008 tree unq
= (tsubst_copy_and_build
15009 (function
, args
, complain
, in_decl
, true,
15010 integral_constant_expression_p
));
15011 if (unq
== error_mark_node
)
15012 RETURN (error_mark_node
);
15014 if (unq
!= function
)
15017 if (INDIRECT_REF_P (fn
))
15018 fn
= TREE_OPERAND (fn
, 0);
15019 if (TREE_CODE (fn
) == COMPONENT_REF
)
15020 fn
= TREE_OPERAND (fn
, 1);
15021 if (is_overloaded_fn (fn
))
15022 fn
= get_first_fn (fn
);
15023 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
15024 "%qD was not declared in this scope, "
15025 "and no declarations were found by "
15026 "argument-dependent lookup at the point "
15027 "of instantiation", function
))
15030 /* Can't say anything more. */;
15031 else if (DECL_CLASS_SCOPE_P (fn
))
15033 location_t loc
= EXPR_LOC_OR_LOC (t
,
15036 "declarations in dependent base %qT are "
15037 "not found by unqualified lookup",
15038 DECL_CLASS_CONTEXT (fn
));
15039 if (current_class_ptr
)
15041 "use %<this->%D%> instead", function
);
15044 "use %<%T::%D%> instead",
15045 current_class_name
, function
);
15048 inform (0, "%q+D declared here, later in the "
15049 "translation unit", fn
);
15054 if (identifier_p (function
))
15056 if (complain
& tf_error
)
15057 unqualified_name_lookup_error (function
);
15058 release_tree_vector (call_args
);
15059 RETURN (error_mark_node
);
15063 /* Remember that there was a reference to this entity. */
15064 if (DECL_P (function
))
15065 mark_used (function
);
15067 /* Put back tf_decltype for the actual call. */
15068 complain
|= decltype_flag
;
15070 if (TREE_CODE (function
) == OFFSET_REF
)
15071 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
15073 else if (TREE_CODE (function
) == COMPONENT_REF
)
15075 tree instance
= TREE_OPERAND (function
, 0);
15076 tree fn
= TREE_OPERAND (function
, 1);
15078 if (processing_template_decl
15079 && (type_dependent_expression_p (instance
)
15080 || (!BASELINK_P (fn
)
15081 && TREE_CODE (fn
) != FIELD_DECL
)
15082 || type_dependent_expression_p (fn
)
15083 || any_type_dependent_arguments_p (call_args
)))
15084 ret
= build_nt_call_vec (function
, call_args
);
15085 else if (!BASELINK_P (fn
))
15086 ret
= finish_call_expr (function
, &call_args
,
15087 /*disallow_virtual=*/false,
15088 /*koenig_p=*/false,
15091 ret
= (build_new_method_call
15093 &call_args
, NULL_TREE
,
15094 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
15099 ret
= finish_call_expr (function
, &call_args
,
15100 /*disallow_virtual=*/qualified_p
,
15104 release_tree_vector (call_args
);
15111 tree cond
= RECUR (TREE_OPERAND (t
, 0));
15114 if (TREE_CODE (cond
) == INTEGER_CST
)
15116 if (integer_zerop (cond
))
15118 ++c_inhibit_evaluation_warnings
;
15119 exp1
= RECUR (TREE_OPERAND (t
, 1));
15120 --c_inhibit_evaluation_warnings
;
15121 exp2
= RECUR (TREE_OPERAND (t
, 2));
15125 exp1
= RECUR (TREE_OPERAND (t
, 1));
15126 ++c_inhibit_evaluation_warnings
;
15127 exp2
= RECUR (TREE_OPERAND (t
, 2));
15128 --c_inhibit_evaluation_warnings
;
15133 exp1
= RECUR (TREE_OPERAND (t
, 1));
15134 exp2
= RECUR (TREE_OPERAND (t
, 2));
15137 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
15138 cond
, exp1
, exp2
, complain
));
15141 case PSEUDO_DTOR_EXPR
:
15143 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15144 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15145 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15146 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
15152 tree purpose
, value
, chain
;
15154 if (t
== void_list_node
)
15157 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15158 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15160 /* We have pack expansions, so expand those and
15161 create a new list out of it. */
15162 tree purposevec
= NULL_TREE
;
15163 tree valuevec
= NULL_TREE
;
15167 /* Expand the argument expressions. */
15168 if (TREE_PURPOSE (t
))
15169 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15170 complain
, in_decl
);
15171 if (TREE_VALUE (t
))
15172 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15173 complain
, in_decl
);
15175 /* Build the rest of the list. */
15176 chain
= TREE_CHAIN (t
);
15177 if (chain
&& chain
!= void_type_node
)
15178 chain
= RECUR (chain
);
15180 /* Determine the number of arguments. */
15181 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15183 len
= TREE_VEC_LENGTH (purposevec
);
15184 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15186 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15187 len
= TREE_VEC_LENGTH (valuevec
);
15190 /* Since we only performed a partial substitution into
15191 the argument pack, we only RETURN (a single list
15193 if (purposevec
== TREE_PURPOSE (t
)
15194 && valuevec
== TREE_VALUE (t
)
15195 && chain
== TREE_CHAIN (t
))
15198 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15201 /* Convert the argument vectors into a TREE_LIST */
15205 /* Grab the Ith values. */
15207 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15210 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15213 /* Build the list (backwards). */
15214 chain
= tree_cons (purpose
, value
, chain
);
15220 purpose
= TREE_PURPOSE (t
);
15222 purpose
= RECUR (purpose
);
15223 value
= TREE_VALUE (t
);
15225 value
= RECUR (value
);
15226 chain
= TREE_CHAIN (t
);
15227 if (chain
&& chain
!= void_type_node
)
15228 chain
= RECUR (chain
);
15229 if (purpose
== TREE_PURPOSE (t
)
15230 && value
== TREE_VALUE (t
)
15231 && chain
== TREE_CHAIN (t
))
15233 RETURN (tree_cons (purpose
, value
, chain
));
15236 case COMPONENT_REF
:
15243 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15244 args
, complain
, in_decl
);
15245 /* Remember that there was a reference to this entity. */
15246 if (DECL_P (object
))
15247 mark_used (object
);
15248 object_type
= TREE_TYPE (object
);
15250 member
= TREE_OPERAND (t
, 1);
15251 if (BASELINK_P (member
))
15252 member
= tsubst_baselink (member
,
15253 non_reference (TREE_TYPE (object
)),
15254 args
, complain
, in_decl
);
15256 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15257 if (member
== error_mark_node
)
15258 RETURN (error_mark_node
);
15260 if (type_dependent_expression_p (object
))
15261 /* We can't do much here. */;
15262 else if (!CLASS_TYPE_P (object_type
))
15264 if (scalarish_type_p (object_type
))
15266 tree s
= NULL_TREE
;
15267 tree dtor
= member
;
15269 if (TREE_CODE (dtor
) == SCOPE_REF
)
15271 s
= TREE_OPERAND (dtor
, 0);
15272 dtor
= TREE_OPERAND (dtor
, 1);
15274 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15276 dtor
= TREE_OPERAND (dtor
, 0);
15278 RETURN (finish_pseudo_destructor_expr
15279 (object
, s
, dtor
, input_location
));
15283 else if (TREE_CODE (member
) == SCOPE_REF
15284 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15286 /* Lookup the template functions now that we know what the
15288 tree scope
= TREE_OPERAND (member
, 0);
15289 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15290 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15291 member
= lookup_qualified_name (scope
, tmpl
,
15292 /*is_type_p=*/false,
15293 /*complain=*/false);
15294 if (BASELINK_P (member
))
15296 BASELINK_FUNCTIONS (member
)
15297 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15299 member
= (adjust_result_of_qualified_name_lookup
15300 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15305 qualified_name_lookup_error (scope
, tmpl
, member
,
15307 RETURN (error_mark_node
);
15310 else if (TREE_CODE (member
) == SCOPE_REF
15311 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15312 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15314 if (complain
& tf_error
)
15316 if (TYPE_P (TREE_OPERAND (member
, 0)))
15317 error ("%qT is not a class or namespace",
15318 TREE_OPERAND (member
, 0));
15320 error ("%qD is not a class or namespace",
15321 TREE_OPERAND (member
, 0));
15323 RETURN (error_mark_node
);
15325 else if (TREE_CODE (member
) == FIELD_DECL
)
15327 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15328 if (TREE_CODE (r
) == COMPONENT_REF
)
15329 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15333 r
= finish_class_member_access_expr (object
, member
,
15334 /*template_p=*/false,
15336 if (TREE_CODE (r
) == COMPONENT_REF
)
15337 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15342 RETURN (build_throw
15343 (RECUR (TREE_OPERAND (t
, 0))));
15347 vec
<constructor_elt
, va_gc
> *n
;
15348 constructor_elt
*ce
;
15349 unsigned HOST_WIDE_INT idx
;
15350 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15351 bool process_index_p
;
15353 bool need_copy_p
= false;
15356 if (type
== error_mark_node
)
15357 RETURN (error_mark_node
);
15359 /* digest_init will do the wrong thing if we let it. */
15360 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15363 /* We do not want to process the index of aggregate
15364 initializers as they are identifier nodes which will be
15365 looked up by digest_init. */
15366 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15368 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15369 newlen
= vec_safe_length (n
);
15370 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15372 if (ce
->index
&& process_index_p
15373 /* An identifier index is looked up in the type
15374 being initialized, not the current scope. */
15375 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15376 ce
->index
= RECUR (ce
->index
);
15378 if (PACK_EXPANSION_P (ce
->value
))
15380 /* Substitute into the pack expansion. */
15381 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15384 if (ce
->value
== error_mark_node
15385 || PACK_EXPANSION_P (ce
->value
))
15387 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15388 /* Just move the argument into place. */
15389 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15392 /* Update the length of the final CONSTRUCTOR
15393 arguments vector, and note that we will need to
15395 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15396 need_copy_p
= true;
15400 ce
->value
= RECUR (ce
->value
);
15405 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15407 vec_alloc (n
, newlen
);
15408 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15410 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15412 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15413 for (i
= 0; i
< len
; ++i
)
15414 CONSTRUCTOR_APPEND_ELT (n
, 0,
15415 TREE_VEC_ELT (ce
->value
, i
));
15418 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15422 r
= build_constructor (init_list_type_node
, n
);
15423 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15425 if (TREE_HAS_CONSTRUCTOR (t
))
15426 RETURN (finish_compound_literal (type
, r
, complain
));
15428 TREE_TYPE (r
) = type
;
15434 tree operand_0
= TREE_OPERAND (t
, 0);
15435 if (TYPE_P (operand_0
))
15437 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15438 RETURN (get_typeid (operand_0
, complain
));
15442 operand_0
= RECUR (operand_0
);
15443 RETURN (build_typeid (operand_0
, complain
));
15450 else if (DECL_PACK_P (t
))
15452 /* We don't build decls for an instantiation of a
15453 variadic capture proxy, we instantiate the elements
15455 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15456 return RECUR (DECL_VALUE_EXPR (t
));
15462 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15464 && !processing_template_decl
15465 && !cp_unevaluated_operand
15466 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
15467 && DECL_THREAD_LOCAL_P (r
))
15469 if (tree wrap
= get_tls_wrapper_fn (r
))
15470 /* Replace an evaluated use of the thread_local variable with
15471 a call to its wrapper. */
15472 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
15475 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15476 /* If the original type was a reference, we'll be wrapped in
15477 the appropriate INDIRECT_REF. */
15478 r
= convert_from_reference (r
);
15484 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15485 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15486 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15489 case OFFSETOF_EXPR
:
15490 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0)),
15491 EXPR_LOCATION (t
)));
15495 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15496 complain
, in_decl
);
15498 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15499 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
15500 type2
= RECUR (type2
);
15502 type2
= tsubst (type2
, args
, complain
, in_decl
);
15504 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15509 tree old_stmt_expr
= cur_stmt_expr
;
15510 tree stmt_expr
= begin_stmt_expr ();
15512 cur_stmt_expr
= stmt_expr
;
15513 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15514 integral_constant_expression_p
);
15515 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15516 cur_stmt_expr
= old_stmt_expr
;
15518 /* If the resulting list of expression statement is empty,
15519 fold it further into void_node. */
15520 if (empty_expr_stmt_p (stmt_expr
))
15521 stmt_expr
= void_node
;
15523 RETURN (stmt_expr
);
15528 tree r
= build_lambda_expr ();
15530 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15531 LAMBDA_EXPR_CLOSURE (r
) = type
;
15532 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15534 LAMBDA_EXPR_LOCATION (r
)
15535 = LAMBDA_EXPR_LOCATION (t
);
15536 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15537 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15538 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15539 LAMBDA_EXPR_DISCRIMINATOR (r
)
15540 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15541 /* For a function scope, we want to use tsubst so that we don't
15542 complain about referring to an auto function before its return
15543 type has been deduced. Otherwise, we want to use tsubst_copy so
15544 that we look up the existing field/parameter/variable rather
15545 than build a new one. */
15546 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15547 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15548 scope
= tsubst (scope
, args
, complain
, in_decl
);
15549 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15551 /* Look up the parameter we want directly, as tsubst_copy
15552 doesn't do what we need. */
15553 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15554 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15555 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15556 parm
= DECL_CHAIN (parm
);
15558 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15559 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15560 DECL_CONTEXT (scope
) = fn
;
15563 scope
= RECUR (scope
);
15564 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15565 LAMBDA_EXPR_RETURN_TYPE (r
)
15566 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15568 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15569 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15571 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15572 determine_visibility (TYPE_NAME (type
));
15573 /* Now that we know visibility, instantiate the type so we have a
15574 declaration of the op() for later calls to lambda_function. */
15575 complete_type (type
);
15577 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15579 RETURN (build_lambda_object (r
));
15583 /* We can get here for a constant initializer of non-dependent type.
15584 FIXME stop folding in cp_parser_initializer_clause. */
15586 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15591 case TRANSACTION_EXPR
:
15592 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15593 integral_constant_expression_p
));
15596 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15598 case VEC_PERM_EXPR
:
15600 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15601 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15602 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15603 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15608 /* Handle Objective-C++ constructs, if appropriate. */
15611 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15612 in_decl
, /*function_p=*/false);
15616 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15622 input_location
= loc
;
15626 /* Verify that the instantiated ARGS are valid. For type arguments,
15627 make sure that the type's linkage is ok. For non-type arguments,
15628 make sure they are constants if they are integral or enumerations.
15629 Emit an error under control of COMPLAIN, and return TRUE on error. */
15632 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15634 if (dependent_template_arg_p (t
))
15636 if (ARGUMENT_PACK_P (t
))
15638 tree vec
= ARGUMENT_PACK_ARGS (t
);
15639 int len
= TREE_VEC_LENGTH (vec
);
15640 bool result
= false;
15643 for (i
= 0; i
< len
; ++i
)
15644 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15648 else if (TYPE_P (t
))
15650 /* [basic.link]: A name with no linkage (notably, the name
15651 of a class or enumeration declared in a local scope)
15652 shall not be used to declare an entity with linkage.
15653 This implies that names with no linkage cannot be used as
15656 DR 757 relaxes this restriction for C++0x. */
15657 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15658 : no_linkage_check (t
, /*relaxed_p=*/false));
15662 /* DR 488 makes use of a type with no linkage cause
15663 type deduction to fail. */
15664 if (complain
& tf_error
)
15666 if (TYPE_ANONYMOUS_P (nt
))
15667 error ("%qT is/uses anonymous type", t
);
15669 error ("template argument for %qD uses local type %qT",
15674 /* In order to avoid all sorts of complications, we do not
15675 allow variably-modified types as template arguments. */
15676 else if (variably_modified_type_p (t
, NULL_TREE
))
15678 if (complain
& tf_error
)
15679 error ("%qT is a variably modified type", t
);
15683 /* Class template and alias template arguments should be OK. */
15684 else if (DECL_TYPE_TEMPLATE_P (t
))
15686 /* A non-type argument of integral or enumerated type must be a
15688 else if (TREE_TYPE (t
)
15689 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15690 && !TREE_CONSTANT (t
))
15692 if (complain
& tf_error
)
15693 error ("integral expression %qE is not constant", t
);
15700 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15702 int ix
, len
= DECL_NTPARMS (tmpl
);
15703 bool result
= false;
15705 for (ix
= 0; ix
!= len
; ix
++)
15707 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15710 if (result
&& (complain
& tf_error
))
15711 error (" trying to instantiate %qD", tmpl
);
15715 /* We're out of SFINAE context now, so generate diagnostics for the access
15716 errors we saw earlier when instantiating D from TMPL and ARGS. */
15719 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15721 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15722 tree type
= TREE_TYPE (pattern
);
15723 location_t loc
= input_location
;
15725 push_access_scope (d
);
15726 push_deferring_access_checks (dk_no_deferred
);
15727 input_location
= DECL_SOURCE_LOCATION (pattern
);
15728 tsubst (type
, args
, tf_warning_or_error
, d
);
15729 input_location
= loc
;
15730 pop_deferring_access_checks ();
15731 pop_access_scope (d
);
15734 /* Instantiate the indicated variable, function, or alias template TMPL with
15735 the template arguments in TARG_PTR. */
15738 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15740 tree targ_ptr
= orig_args
;
15744 bool access_ok
= true;
15746 if (tmpl
== error_mark_node
)
15747 return error_mark_node
;
15749 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15751 /* If this function is a clone, handle it specially. */
15752 if (DECL_CLONED_FUNCTION_P (tmpl
))
15757 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15758 DECL_CLONED_FUNCTION. */
15759 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15760 targ_ptr
, complain
);
15761 if (spec
== error_mark_node
)
15762 return error_mark_node
;
15764 /* Look for the clone. */
15765 FOR_EACH_CLONE (clone
, spec
)
15766 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15768 /* We should always have found the clone by now. */
15769 gcc_unreachable ();
15773 if (targ_ptr
== error_mark_node
)
15774 return error_mark_node
;
15776 /* Check to see if we already have this specialization. */
15777 gen_tmpl
= most_general_template (tmpl
);
15778 if (tmpl
!= gen_tmpl
)
15779 /* The TMPL is a partial instantiation. To get a full set of
15780 arguments we must add the arguments used to perform the
15781 partial instantiation. */
15782 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15785 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15786 but it doesn't seem to be on the hot path. */
15787 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15789 gcc_assert (tmpl
== gen_tmpl
15790 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15792 || fndecl
== NULL_TREE
);
15794 if (spec
!= NULL_TREE
)
15796 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15798 if (complain
& tf_error
)
15799 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15800 return error_mark_node
;
15805 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15807 return error_mark_node
;
15809 /* We are building a FUNCTION_DECL, during which the access of its
15810 parameters and return types have to be checked. However this
15811 FUNCTION_DECL which is the desired context for access checking
15812 is not built yet. We solve this chicken-and-egg problem by
15813 deferring all checks until we have the FUNCTION_DECL. */
15814 push_deferring_access_checks (dk_deferred
);
15816 /* Instantiation of the function happens in the context of the function
15817 template, not the context of the overload resolution we're doing. */
15818 push_to_top_level ();
15819 /* If there are dependent arguments, e.g. because we're doing partial
15820 ordering, make sure processing_template_decl stays set. */
15821 if (uses_template_parms (targ_ptr
))
15822 ++processing_template_decl
;
15823 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15825 tree ctx
= tsubst (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15826 complain
, gen_tmpl
);
15827 push_nested_class (ctx
);
15829 /* Substitute template parameters to obtain the specialization. */
15830 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
15831 targ_ptr
, complain
, gen_tmpl
);
15832 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15833 pop_nested_class ();
15834 pop_from_top_level ();
15836 if (fndecl
== error_mark_node
)
15838 pop_deferring_access_checks ();
15839 return error_mark_node
;
15842 /* The DECL_TI_TEMPLATE should always be the immediate parent
15843 template, not the most general template. */
15844 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
15846 /* Now we know the specialization, compute access previously
15848 push_access_scope (fndecl
);
15849 if (!perform_deferred_access_checks (complain
))
15851 pop_access_scope (fndecl
);
15852 pop_deferring_access_checks ();
15854 /* If we've just instantiated the main entry point for a function,
15855 instantiate all the alternate entry points as well. We do this
15856 by cloning the instantiation of the main entry point, not by
15857 instantiating the template clones. */
15858 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
15859 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
15863 if (!(complain
& tf_error
))
15865 /* Remember to reinstantiate when we're out of SFINAE so the user
15866 can see the errors. */
15867 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
15869 return error_mark_node
;
15874 /* Wrapper for instantiate_template_1. */
15877 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15880 timevar_push (TV_TEMPLATE_INST
);
15881 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
15882 timevar_pop (TV_TEMPLATE_INST
);
15886 /* Instantiate the alias template TMPL with ARGS. Also push a template
15887 instantiation level, which instantiate_template doesn't do because
15888 functions and variables have sufficient context established by the
15892 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
15894 struct pending_template
*old_last_pend
= last_pending_template
;
15895 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15896 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
15897 return error_mark_node
;
15898 tree tinst
= build_tree_list (tmpl
, args
);
15899 if (!push_tinst_level (tinst
))
15902 return error_mark_node
;
15906 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
15907 args
, tmpl
, complain
,
15908 /*require_all_args=*/true,
15909 /*use_default_args=*/true);
15911 tree r
= instantiate_template (tmpl
, args
, complain
);
15912 pop_tinst_level ();
15913 /* We can't free this if a pending_template entry or last_error_tinst_level
15914 is pointing at it. */
15915 if (last_pending_template
== old_last_pend
15916 && last_error_tinst_level
== old_error_tinst
)
15922 /* PARM is a template parameter pack for FN. Returns true iff
15923 PARM is used in a deducible way in the argument list of FN. */
15926 pack_deducible_p (tree parm
, tree fn
)
15928 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
15929 for (; t
; t
= TREE_CHAIN (t
))
15931 tree type
= TREE_VALUE (t
);
15933 if (!PACK_EXPANSION_P (type
))
15935 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
15936 packs
; packs
= TREE_CHAIN (packs
))
15937 if (template_args_equal (TREE_VALUE (packs
), parm
))
15939 /* The template parameter pack is used in a function parameter
15940 pack. If this is the end of the parameter list, the
15941 template parameter pack is deducible. */
15942 if (TREE_CHAIN (t
) == void_list_node
)
15945 /* Otherwise, not. Well, it could be deduced from
15946 a non-pack parameter, but doing so would end up with
15947 a deduction mismatch, so don't bother. */
15951 /* The template parameter pack isn't used in any function parameter
15952 packs, but it might be used deeper, e.g. tuple<Args...>. */
15956 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
15957 NARGS elements of the arguments that are being used when calling
15958 it. TARGS is a vector into which the deduced template arguments
15961 Returns either a FUNCTION_DECL for the matching specialization of FN or
15962 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
15963 true, diagnostics will be printed to explain why it failed.
15965 If FN is a conversion operator, or we are trying to produce a specific
15966 specialization, RETURN_TYPE is the return type desired.
15968 The EXPLICIT_TARGS are explicit template arguments provided via a
15971 The parameter STRICT is one of:
15974 We are deducing arguments for a function call, as in
15975 [temp.deduct.call].
15978 We are deducing arguments for a conversion function, as in
15979 [temp.deduct.conv].
15982 We are deducing arguments when doing an explicit instantiation
15983 as in [temp.explicit], when determining an explicit specialization
15984 as in [temp.expl.spec], or when taking the address of a function
15985 template, as in [temp.deduct.funcaddr]. */
15988 fn_type_unification (tree fn
,
15989 tree explicit_targs
,
15992 unsigned int nargs
,
15994 unification_kind_t strict
,
16001 tree decl
= NULL_TREE
;
16002 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
16004 static int deduction_depth
;
16005 struct pending_template
*old_last_pend
= last_pending_template
;
16006 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
16007 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
16009 tree r
= error_mark_node
;
16012 complain
|= tf_decltype
;
16014 /* In C++0x, it's possible to have a function template whose type depends
16015 on itself recursively. This is most obvious with decltype, but can also
16016 occur with enumeration scope (c++/48969). So we need to catch infinite
16017 recursion and reject the substitution at deduction time; this function
16018 will return error_mark_node for any repeated substitution.
16020 This also catches excessive recursion such as when f<N> depends on
16021 f<N-1> across all integers, and returns error_mark_node for all the
16022 substitutions back up to the initial one.
16024 This is, of course, not reentrant. */
16025 if (excessive_deduction_depth
)
16026 return error_mark_node
;
16027 tinst
= build_tree_list (fn
, NULL_TREE
);
16030 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
16032 fntype
= TREE_TYPE (fn
);
16033 if (explicit_targs
)
16037 The specified template arguments must match the template
16038 parameters in kind (i.e., type, nontype, template), and there
16039 must not be more arguments than there are parameters;
16040 otherwise type deduction fails.
16042 Nontype arguments must match the types of the corresponding
16043 nontype template parameters, or must be convertible to the
16044 types of the corresponding nontype parameters as specified in
16045 _temp.arg.nontype_, otherwise type deduction fails.
16047 All references in the function type of the function template
16048 to the corresponding template parameters are replaced by the
16049 specified template argument values. If a substitution in a
16050 template parameter or in the function type of the function
16051 template results in an invalid type, type deduction fails. */
16052 int i
, len
= TREE_VEC_LENGTH (tparms
);
16053 location_t loc
= input_location
;
16054 bool incomplete
= false;
16056 /* Adjust any explicit template arguments before entering the
16057 substitution context. */
16059 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
16061 /*require_all_args=*/false,
16062 /*use_default_args=*/false));
16063 if (explicit_targs
== error_mark_node
)
16066 /* Substitute the explicit args into the function type. This is
16067 necessary so that, for instance, explicitly declared function
16068 arguments can match null pointed constants. If we were given
16069 an incomplete set of explicit args, we must not do semantic
16070 processing during substitution as we could create partial
16072 for (i
= 0; i
< len
; i
++)
16074 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16075 bool parameter_pack
= false;
16076 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
16078 /* Dig out the actual parm. */
16079 if (TREE_CODE (parm
) == TYPE_DECL
16080 || TREE_CODE (parm
) == TEMPLATE_DECL
)
16082 parm
= TREE_TYPE (parm
);
16083 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
16085 else if (TREE_CODE (parm
) == PARM_DECL
)
16087 parm
= DECL_INITIAL (parm
);
16088 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
16091 if (!parameter_pack
&& targ
== NULL_TREE
)
16092 /* No explicit argument for this template parameter. */
16095 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
16097 /* Mark the argument pack as "incomplete". We could
16098 still deduce more arguments during unification.
16099 We remove this mark in type_unification_real. */
16102 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
16103 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
16104 = ARGUMENT_PACK_ARGS (targ
);
16107 /* We have some incomplete argument packs. */
16112 TREE_VALUE (tinst
) = explicit_targs
;
16113 if (!push_tinst_level (tinst
))
16115 excessive_deduction_depth
= true;
16118 processing_template_decl
+= incomplete
;
16119 input_location
= DECL_SOURCE_LOCATION (fn
);
16120 /* Ignore any access checks; we'll see them again in
16121 instantiate_template and they might have the wrong
16122 access path at this point. */
16123 push_deferring_access_checks (dk_deferred
);
16124 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
16125 complain
| tf_partial
, NULL_TREE
);
16126 pop_deferring_access_checks ();
16127 input_location
= loc
;
16128 processing_template_decl
-= incomplete
;
16129 pop_tinst_level ();
16131 if (fntype
== error_mark_node
)
16134 /* Place the explicitly specified arguments in TARGS. */
16135 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
16136 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
16139 /* Never do unification on the 'this' parameter. */
16140 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
16146 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
16147 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
16148 new_args
[0] = return_type
;
16149 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
16154 /* We allow incomplete unification without an error message here
16155 because the standard doesn't seem to explicitly prohibit it. Our
16156 callers must be ready to deal with unification failures in any
16159 TREE_VALUE (tinst
) = targs
;
16160 /* If we aren't explaining yet, push tinst context so we can see where
16161 any errors (e.g. from class instantiations triggered by instantiation
16162 of default template arguments) come from. If we are explaining, this
16163 context is redundant. */
16164 if (!explain_p
&& !push_tinst_level (tinst
))
16166 excessive_deduction_depth
= true;
16170 /* type_unification_real will pass back any access checks from default
16171 template argument substitution. */
16172 vec
<deferred_access_check
, va_gc
> *checks
;
16175 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16176 targs
, parms
, args
, nargs
, /*subr=*/0,
16177 strict
, flags
, &checks
, explain_p
);
16179 pop_tinst_level ();
16183 /* Now that we have bindings for all of the template arguments,
16184 ensure that the arguments deduced for the template template
16185 parameters have compatible template parameter lists. We cannot
16186 check this property before we have deduced all template
16187 arguments, because the template parameter types of a template
16188 template parameter might depend on prior template parameters
16189 deduced after the template template parameter. The following
16190 ill-formed example illustrates this issue:
16192 template<typename T, template<T> class C> void f(C<5>, T);
16194 template<int N> struct X {};
16197 f(X<5>(), 5l); // error: template argument deduction fails
16200 The template parameter list of 'C' depends on the template type
16201 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16202 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16203 time that we deduce 'C'. */
16204 if (!template_template_parm_bindings_ok_p
16205 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16207 unify_inconsistent_template_template_parameters (explain_p
);
16211 /* All is well so far. Now, check:
16215 When all template arguments have been deduced, all uses of
16216 template parameters in nondeduced contexts are replaced with
16217 the corresponding deduced argument values. If the
16218 substitution results in an invalid type, as described above,
16219 type deduction fails. */
16220 TREE_VALUE (tinst
) = targs
;
16221 if (!push_tinst_level (tinst
))
16223 excessive_deduction_depth
= true;
16227 /* Also collect access checks from the instantiation. */
16228 reopen_deferring_access_checks (checks
);
16230 decl
= instantiate_template (fn
, targs
, complain
);
16232 checks
= get_deferred_access_checks ();
16233 pop_deferring_access_checks ();
16235 pop_tinst_level ();
16237 if (decl
== error_mark_node
)
16240 /* Now perform any access checks encountered during substitution. */
16241 push_access_scope (decl
);
16242 ok
= perform_access_checks (checks
, complain
);
16243 pop_access_scope (decl
);
16247 /* If we're looking for an exact match, check that what we got
16248 is indeed an exact match. It might not be if some template
16249 parameters are used in non-deduced contexts. But don't check
16250 for an exact match if we have dependent template arguments;
16251 in that case we're doing partial ordering, and we already know
16252 that we have two candidates that will provide the actual type. */
16253 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16255 tree substed
= TREE_TYPE (decl
);
16259 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16261 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16262 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16263 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16265 unify_type_mismatch (explain_p
, args
[i
],
16266 TREE_VALUE (sarg
));
16275 if (excessive_deduction_depth
)
16277 if (deduction_depth
== 0)
16278 /* Reset once we're all the way out. */
16279 excessive_deduction_depth
= false;
16282 /* We can't free this if a pending_template entry or last_error_tinst_level
16283 is pointing at it. */
16284 if (last_pending_template
== old_last_pend
16285 && last_error_tinst_level
== old_error_tinst
)
16291 /* Adjust types before performing type deduction, as described in
16292 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16293 sections are symmetric. PARM is the type of a function parameter
16294 or the return type of the conversion function. ARG is the type of
16295 the argument passed to the call, or the type of the value
16296 initialized with the result of the conversion function.
16297 ARG_EXPR is the original argument expression, which may be null. */
16300 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16314 /* Swap PARM and ARG throughout the remainder of this
16315 function; the handling is precisely symmetric since PARM
16316 will initialize ARG rather than vice versa. */
16324 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16325 too, but here handle it by stripping the reference from PARM
16326 rather than by adding it to ARG. */
16327 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16328 && TYPE_REF_IS_RVALUE (*parm
)
16329 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16330 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16331 && TREE_CODE (*arg
) == REFERENCE_TYPE
16332 && !TYPE_REF_IS_RVALUE (*arg
))
16333 *parm
= TREE_TYPE (*parm
);
16334 /* Nothing else to do in this case. */
16338 gcc_unreachable ();
16341 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16343 /* [temp.deduct.call]
16345 If P is not a reference type:
16347 --If A is an array type, the pointer type produced by the
16348 array-to-pointer standard conversion (_conv.array_) is
16349 used in place of A for type deduction; otherwise,
16351 --If A is a function type, the pointer type produced by
16352 the function-to-pointer standard conversion
16353 (_conv.func_) is used in place of A for type deduction;
16356 --If A is a cv-qualified type, the top level
16357 cv-qualifiers of A's type are ignored for type
16359 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16360 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16361 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16362 *arg
= build_pointer_type (*arg
);
16364 *arg
= TYPE_MAIN_VARIANT (*arg
);
16367 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16368 of the form T&&, where T is a template parameter, and the argument
16369 is an lvalue, T is deduced as A& */
16370 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16371 && TYPE_REF_IS_RVALUE (*parm
)
16372 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16373 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16374 && (arg_expr
? real_lvalue_p (arg_expr
)
16375 /* try_one_overload doesn't provide an arg_expr, but
16376 functions are always lvalues. */
16377 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16378 *arg
= build_reference_type (*arg
);
16380 /* [temp.deduct.call]
16382 If P is a cv-qualified type, the top level cv-qualifiers
16383 of P's type are ignored for type deduction. If P is a
16384 reference type, the type referred to by P is used for
16386 *parm
= TYPE_MAIN_VARIANT (*parm
);
16387 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16389 *parm
= TREE_TYPE (*parm
);
16390 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16393 /* DR 322. For conversion deduction, remove a reference type on parm
16394 too (which has been swapped into ARG). */
16395 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16396 *arg
= TREE_TYPE (*arg
);
16401 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16402 template which does contain any deducible template parameters; check if
16403 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16404 unify_one_argument. */
16407 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16408 int flags
, bool explain_p
)
16413 type
= TREE_TYPE (arg
);
16417 if (same_type_p (parm
, type
))
16418 return unify_success (explain_p
);
16420 if (strict
== DEDUCE_CONV
)
16422 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16423 explain_p
? tf_warning_or_error
: tf_none
))
16424 return unify_success (explain_p
);
16426 else if (strict
!= DEDUCE_EXACT
)
16428 if (can_convert_arg (parm
, type
,
16429 TYPE_P (arg
) ? NULL_TREE
: arg
,
16430 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16431 return unify_success (explain_p
);
16434 if (strict
== DEDUCE_EXACT
)
16435 return unify_type_mismatch (explain_p
, parm
, arg
);
16437 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16440 static bool uses_deducible_template_parms (tree type
);
16442 /* Returns true iff the expression EXPR is one from which a template
16443 argument can be deduced. In other words, if it's an undecorated
16444 use of a template non-type parameter. */
16447 deducible_expression (tree expr
)
16449 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16452 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16453 deducible way; that is, if it has a max value of <PARM> - 1. */
16456 deducible_array_bound (tree domain
)
16458 if (domain
== NULL_TREE
)
16461 tree max
= TYPE_MAX_VALUE (domain
);
16462 if (TREE_CODE (max
) != MINUS_EXPR
)
16465 return deducible_expression (TREE_OPERAND (max
, 0));
16468 /* Returns true iff the template arguments ARGS use a template parameter
16469 in a deducible way. */
16472 deducible_template_args (tree args
)
16474 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16477 tree elt
= TREE_VEC_ELT (args
, i
);
16478 if (ARGUMENT_PACK_P (elt
))
16479 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16482 if (PACK_EXPANSION_P (elt
))
16483 elt
= PACK_EXPANSION_PATTERN (elt
);
16484 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16486 else if (TYPE_P (elt
))
16487 deducible
= uses_deducible_template_parms (elt
);
16489 deducible
= deducible_expression (elt
);
16497 /* Returns true iff TYPE contains any deducible references to template
16498 parameters, as per 14.8.2.5. */
16501 uses_deducible_template_parms (tree type
)
16503 if (PACK_EXPANSION_P (type
))
16504 type
= PACK_EXPANSION_PATTERN (type
);
16511 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16512 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16518 if (POINTER_TYPE_P (type
))
16519 return uses_deducible_template_parms (TREE_TYPE (type
));
16521 /* T[integer-constant ]
16523 if (TREE_CODE (type
) == ARRAY_TYPE
)
16524 return (uses_deducible_template_parms (TREE_TYPE (type
))
16525 || deducible_array_bound (TYPE_DOMAIN (type
)));
16537 if (TYPE_PTRMEM_P (type
))
16538 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16539 || (uses_deducible_template_parms
16540 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16542 /* template-name <T> (where template-name refers to a class template)
16543 template-name <i> (where template-name refers to a class template) */
16544 if (CLASS_TYPE_P (type
)
16545 && CLASSTYPE_TEMPLATE_INFO (type
)
16546 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16547 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16548 (CLASSTYPE_TI_ARGS (type
)));
16553 if (TREE_CODE (type
) == FUNCTION_TYPE
16554 || TREE_CODE (type
) == METHOD_TYPE
)
16556 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16558 tree parm
= TYPE_ARG_TYPES (type
);
16559 if (TREE_CODE (type
) == METHOD_TYPE
)
16560 parm
= TREE_CHAIN (parm
);
16561 for (; parm
; parm
= TREE_CHAIN (parm
))
16562 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16569 /* Subroutine of type_unification_real and unify_pack_expansion to
16570 handle unification of a single P/A pair. Parameters are as
16571 for those functions. */
16574 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16575 int subr
, unification_kind_t strict
, int flags
,
16578 tree arg_expr
= NULL_TREE
;
16581 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16582 return unify_invalid (explain_p
);
16583 if (arg
== unknown_type_node
)
16584 /* We can't deduce anything from this, but we might get all the
16585 template args from other function args. */
16586 return unify_success (explain_p
);
16588 /* Implicit conversions (Clause 4) will be performed on a function
16589 argument to convert it to the type of the corresponding function
16590 parameter if the parameter type contains no template-parameters that
16591 participate in template argument deduction. */
16592 if (TYPE_P (parm
) && !uses_template_parms (parm
))
16593 /* For function parameters that contain no template-parameters at all,
16594 we have historically checked for convertibility in order to shortcut
16595 consideration of this candidate. */
16596 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
16598 else if (strict
== DEDUCE_CALL
16599 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16600 /* For function parameters with only non-deducible template parameters,
16602 return unify_success (explain_p
);
16607 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16608 | UNIFY_ALLOW_MORE_CV_QUAL
16609 | UNIFY_ALLOW_DERIVED
);
16613 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16617 arg_strict
= UNIFY_ALLOW_NONE
;
16621 gcc_unreachable ();
16624 /* We only do these transformations if this is the top-level
16625 parameter_type_list in a call or declaration matching; in other
16626 situations (nested function declarators, template argument lists) we
16627 won't be comparing a type to an expression, and we don't do any type
16633 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16634 if (type_unknown_p (arg
))
16636 /* [temp.deduct.type] A template-argument can be
16637 deduced from a pointer to function or pointer
16638 to member function argument if the set of
16639 overloaded functions does not contain function
16640 templates and at most one of a set of
16641 overloaded functions provides a unique
16644 if (resolve_overloaded_unification
16645 (tparms
, targs
, parm
, arg
, strict
,
16646 arg_strict
, explain_p
))
16647 return unify_success (explain_p
);
16648 return unify_overload_resolution_failure (explain_p
, arg
);
16652 arg
= unlowered_expr_type (arg
);
16653 if (arg
== error_mark_node
)
16654 return unify_invalid (explain_p
);
16658 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16661 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16662 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
16663 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16665 /* For deduction from an init-list we need the actual list. */
16666 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16668 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16671 /* Most parms like fn_type_unification.
16673 If SUBR is 1, we're being called recursively (to unify the
16674 arguments of a function or method parameter of a function
16677 CHECKS is a pointer to a vector of access checks encountered while
16678 substituting default template arguments. */
16681 type_unification_real (tree tparms
,
16685 unsigned int xnargs
,
16687 unification_kind_t strict
,
16689 vec
<deferred_access_check
, va_gc
> **checks
,
16694 int ntparms
= TREE_VEC_LENGTH (tparms
);
16695 int saw_undeduced
= 0;
16698 unsigned int nargs
;
16701 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16702 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16703 gcc_assert (ntparms
> 0);
16705 /* Reset the number of non-defaulted template arguments contained
16707 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16715 while (parms
&& parms
!= void_list_node
16718 parm
= TREE_VALUE (parms
);
16720 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16721 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16722 /* For a function parameter pack that occurs at the end of the
16723 parameter-declaration-list, the type A of each remaining
16724 argument of the call is compared with the type P of the
16725 declarator-id of the function parameter pack. */
16728 parms
= TREE_CHAIN (parms
);
16730 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16731 /* For a function parameter pack that does not occur at the
16732 end of the parameter-declaration-list, the type of the
16733 parameter pack is a non-deduced context. */
16739 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16745 && parms
!= void_list_node
16746 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16748 /* Unify the remaining arguments with the pack expansion type. */
16750 tree parmvec
= make_tree_vec (1);
16752 /* Allocate a TREE_VEC and copy in all of the arguments */
16753 argvec
= make_tree_vec (nargs
- ia
);
16754 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16755 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16757 /* Copy the parameter into parmvec. */
16758 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16759 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16760 /*subr=*/subr
, explain_p
))
16763 /* Advance to the end of the list of parameters. */
16764 parms
= TREE_CHAIN (parms
);
16767 /* Fail if we've reached the end of the parm list, and more args
16768 are present, and the parm list isn't variadic. */
16769 if (ia
< nargs
&& parms
== void_list_node
)
16770 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16771 /* Fail if parms are left and they don't have default values and
16772 they aren't all deduced as empty packs (c++/57397). This is
16773 consistent with sufficient_parms_p. */
16774 if (parms
&& parms
!= void_list_node
16775 && TREE_PURPOSE (parms
) == NULL_TREE
)
16777 unsigned int count
= nargs
;
16782 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
16785 p
= TREE_CHAIN (p
);
16787 while (p
&& p
!= void_list_node
);
16788 if (count
!= nargs
)
16789 return unify_too_few_arguments (explain_p
, ia
, count
,
16795 tsubst_flags_t complain
= (explain_p
16796 ? tf_warning_or_error
16799 for (i
= 0; i
< ntparms
; i
++)
16801 tree targ
= TREE_VEC_ELT (targs
, i
);
16802 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16804 /* Clear the "incomplete" flags on all argument packs now so that
16805 substituting them into later default arguments works. */
16806 if (targ
&& ARGUMENT_PACK_P (targ
))
16808 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16809 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16812 if (targ
|| tparm
== error_mark_node
)
16814 tparm
= TREE_VALUE (tparm
);
16816 /* If this is an undeduced nontype parameter that depends on
16817 a type parameter, try another pass; its type may have been
16818 deduced from a later argument than the one from which
16819 this parameter can be deduced. */
16820 if (TREE_CODE (tparm
) == PARM_DECL
16821 && uses_template_parms (TREE_TYPE (tparm
))
16822 && !saw_undeduced
++)
16825 /* Core issue #226 (C++0x) [temp.deduct]:
16827 If a template argument has not been deduced, its
16828 default template argument, if any, is used.
16830 When we are in C++98 mode, TREE_PURPOSE will either
16831 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16832 to explicitly check cxx_dialect here. */
16833 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
16835 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16836 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
16837 reopen_deferring_access_checks (*checks
);
16838 location_t save_loc
= input_location
;
16840 input_location
= DECL_SOURCE_LOCATION (parm
);
16841 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
16842 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
16844 input_location
= save_loc
;
16845 *checks
= get_deferred_access_checks ();
16846 pop_deferring_access_checks ();
16847 if (arg
== error_mark_node
)
16851 TREE_VEC_ELT (targs
, i
) = arg
;
16852 /* The position of the first default template argument,
16853 is also the number of non-defaulted arguments in TARGS.
16855 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16856 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
16861 /* If the type parameter is a parameter pack, then it will
16862 be deduced to an empty parameter pack. */
16863 if (template_parameter_pack_p (tparm
))
16867 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
16869 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
16870 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
16871 TREE_CONSTANT (arg
) = 1;
16874 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16876 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
16878 TREE_VEC_ELT (targs
, i
) = arg
;
16882 return unify_parameter_deduction_failure (explain_p
, tparm
);
16885 #ifdef ENABLE_CHECKING
16886 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16887 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
16890 return unify_success (explain_p
);
16893 /* Subroutine of type_unification_real. Args are like the variables
16894 at the call site. ARG is an overloaded function (or template-id);
16895 we try deducing template args from each of the overloads, and if
16896 only one succeeds, we go with that. Modifies TARGS and returns
16897 true on success. */
16900 resolve_overloaded_unification (tree tparms
,
16904 unification_kind_t strict
,
16908 tree tempargs
= copy_node (targs
);
16910 tree goodfn
= NULL_TREE
;
16913 if (TREE_CODE (arg
) == ADDR_EXPR
)
16915 arg
= TREE_OPERAND (arg
, 0);
16921 if (TREE_CODE (arg
) == COMPONENT_REF
)
16922 /* Handle `&x' where `x' is some static or non-static member
16924 arg
= TREE_OPERAND (arg
, 1);
16926 if (TREE_CODE (arg
) == OFFSET_REF
)
16927 arg
= TREE_OPERAND (arg
, 1);
16929 /* Strip baselink information. */
16930 if (BASELINK_P (arg
))
16931 arg
= BASELINK_FUNCTIONS (arg
);
16933 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
16935 /* If we got some explicit template args, we need to plug them into
16936 the affected templates before we try to unify, in case the
16937 explicit args will completely resolve the templates in question. */
16940 tree expl_subargs
= TREE_OPERAND (arg
, 1);
16941 arg
= TREE_OPERAND (arg
, 0);
16943 for (; arg
; arg
= OVL_NEXT (arg
))
16945 tree fn
= OVL_CURRENT (arg
);
16946 tree subargs
, elem
;
16948 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16951 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16952 expl_subargs
, NULL_TREE
, tf_none
,
16953 /*require_all_args=*/true,
16954 /*use_default_args=*/true);
16955 if (subargs
!= error_mark_node
16956 && !any_dependent_template_arguments_p (subargs
))
16958 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
16959 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16960 elem
, strict
, sub_strict
, addr_p
, explain_p
)
16961 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
16970 /* If no templates (or more than one) are fully resolved by the
16971 explicit arguments, this template-id is a non-deduced context; it
16972 could still be OK if we deduce all template arguments for the
16973 enclosing call through other arguments. */
16977 else if (TREE_CODE (arg
) != OVERLOAD
16978 && TREE_CODE (arg
) != FUNCTION_DECL
)
16979 /* If ARG is, for example, "(0, &f)" then its type will be unknown
16980 -- but the deduction does not succeed because the expression is
16981 not just the function on its own. */
16984 for (; arg
; arg
= OVL_NEXT (arg
))
16985 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16986 TREE_TYPE (OVL_CURRENT (arg
)),
16987 strict
, sub_strict
, addr_p
, explain_p
)
16988 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
16990 goodfn
= OVL_CURRENT (arg
);
16994 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16995 to function or pointer to member function argument if the set of
16996 overloaded functions does not contain function templates and at most
16997 one of a set of overloaded functions provides a unique match.
16999 So if we found multiple possibilities, we return success but don't
17000 deduce anything. */
17004 int i
= TREE_VEC_LENGTH (targs
);
17006 if (TREE_VEC_ELT (tempargs
, i
))
17008 tree old
= TREE_VEC_ELT (targs
, i
);
17009 tree new_
= TREE_VEC_ELT (tempargs
, i
);
17010 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
17011 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
17012 /* Don't forget explicit template arguments in a pack. */
17013 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
17014 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
17015 TREE_VEC_ELT (targs
, i
) = new_
;
17024 /* Core DR 115: In contexts where deduction is done and fails, or in
17025 contexts where deduction is not done, if a template argument list is
17026 specified and it, along with any default template arguments, identifies
17027 a single function template specialization, then the template-id is an
17028 lvalue for the function template specialization. */
17031 resolve_nondeduced_context (tree orig_expr
)
17033 tree expr
, offset
, baselink
;
17036 if (!type_unknown_p (orig_expr
))
17041 offset
= NULL_TREE
;
17042 baselink
= NULL_TREE
;
17044 if (TREE_CODE (expr
) == ADDR_EXPR
)
17046 expr
= TREE_OPERAND (expr
, 0);
17049 if (TREE_CODE (expr
) == OFFSET_REF
)
17052 expr
= TREE_OPERAND (expr
, 1);
17054 if (BASELINK_P (expr
))
17057 expr
= BASELINK_FUNCTIONS (expr
);
17060 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
17063 tree goodfn
= NULL_TREE
;
17065 /* If we got some explicit template args, we need to plug them into
17066 the affected templates before we try to unify, in case the
17067 explicit args will completely resolve the templates in question. */
17069 tree expl_subargs
= TREE_OPERAND (expr
, 1);
17070 tree arg
= TREE_OPERAND (expr
, 0);
17071 tree badfn
= NULL_TREE
;
17072 tree badargs
= NULL_TREE
;
17074 for (; arg
; arg
= OVL_NEXT (arg
))
17076 tree fn
= OVL_CURRENT (arg
);
17077 tree subargs
, elem
;
17079 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17082 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17083 expl_subargs
, NULL_TREE
, tf_none
,
17084 /*require_all_args=*/true,
17085 /*use_default_args=*/true);
17086 if (subargs
!= error_mark_node
17087 && !any_dependent_template_arguments_p (subargs
))
17089 elem
= instantiate_template (fn
, subargs
, tf_none
);
17090 if (elem
== error_mark_node
)
17095 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
17104 mark_used (goodfn
);
17107 expr
= build_baselink (BASELINK_BINFO (baselink
),
17108 BASELINK_ACCESS_BINFO (baselink
),
17109 expr
, BASELINK_OPTYPE (baselink
));
17113 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
17114 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
17117 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
17120 else if (good
== 0 && badargs
)
17121 /* There were no good options and at least one bad one, so let the
17122 user know what the problem is. */
17123 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
17128 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17129 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17130 different overloads deduce different arguments for a given parm.
17131 ADDR_P is true if the expression for which deduction is being
17132 performed was of the form "& fn" rather than simply "fn".
17134 Returns 1 on success. */
17137 try_one_overload (tree tparms
,
17142 unification_kind_t strict
,
17151 if (arg
== error_mark_node
)
17154 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17155 to function or pointer to member function argument if the set of
17156 overloaded functions does not contain function templates and at most
17157 one of a set of overloaded functions provides a unique match.
17159 So if this is a template, just return success. */
17161 if (uses_template_parms (arg
))
17164 if (TREE_CODE (arg
) == METHOD_TYPE
)
17165 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
17167 arg
= build_pointer_type (arg
);
17169 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
17171 /* We don't copy orig_targs for this because if we have already deduced
17172 some template args from previous args, unify would complain when we
17173 try to deduce a template parameter for the same argument, even though
17174 there isn't really a conflict. */
17175 nargs
= TREE_VEC_LENGTH (targs
);
17176 tempargs
= make_tree_vec (nargs
);
17178 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
17181 /* First make sure we didn't deduce anything that conflicts with
17182 explicitly specified args. */
17183 for (i
= nargs
; i
--; )
17185 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17186 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17190 else if (uses_template_parms (elt
))
17191 /* Since we're unifying against ourselves, we will fill in
17192 template args used in the function parm list with our own
17193 template parms. Discard them. */
17194 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17195 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17199 for (i
= nargs
; i
--; )
17201 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17204 TREE_VEC_ELT (targs
, i
) = elt
;
17210 /* PARM is a template class (perhaps with unbound template
17211 parameters). ARG is a fully instantiated type. If ARG can be
17212 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17213 TARGS are as for unify. */
17216 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17219 tree copy_of_targs
;
17221 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17222 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17223 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17226 /* We need to make a new template argument vector for the call to
17227 unify. If we used TARGS, we'd clutter it up with the result of
17228 the attempted unification, even if this class didn't work out.
17229 We also don't want to commit ourselves to all the unifications
17230 we've already done, since unification is supposed to be done on
17231 an argument-by-argument basis. In other words, consider the
17232 following pathological case:
17234 template <int I, int J, int K>
17237 template <int I, int J>
17238 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17240 template <int I, int J, int K>
17241 void f(S<I, J, K>, S<I, I, I>);
17250 Now, by the time we consider the unification involving `s2', we
17251 already know that we must have `f<0, 0, 0>'. But, even though
17252 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17253 because there are two ways to unify base classes of S<0, 1, 2>
17254 with S<I, I, I>. If we kept the already deduced knowledge, we
17255 would reject the possibility I=1. */
17256 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17258 /* If unification failed, we're done. */
17259 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17260 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17266 /* Given a template type PARM and a class type ARG, find the unique
17267 base type in ARG that is an instance of PARM. We do not examine
17268 ARG itself; only its base-classes. If there is not exactly one
17269 appropriate base class, return NULL_TREE. PARM may be the type of
17270 a partial specialization, as well as a plain template type. Used
17273 static enum template_base_result
17274 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17275 bool explain_p
, tree
*result
)
17277 tree rval
= NULL_TREE
;
17280 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17282 binfo
= TYPE_BINFO (complete_type (arg
));
17285 /* The type could not be completed. */
17286 *result
= NULL_TREE
;
17287 return tbr_incomplete_type
;
17290 /* Walk in inheritance graph order. The search order is not
17291 important, and this avoids multiple walks of virtual bases. */
17292 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17294 tree r
= try_class_unification (tparms
, targs
, parm
,
17295 BINFO_TYPE (binfo
), explain_p
);
17299 /* If there is more than one satisfactory baseclass, then:
17303 If they yield more than one possible deduced A, the type
17307 if (rval
&& !same_type_p (r
, rval
))
17309 *result
= NULL_TREE
;
17310 return tbr_ambiguous_baseclass
;
17318 return tbr_success
;
17321 /* Returns the level of DECL, which declares a template parameter. */
17324 template_decl_level (tree decl
)
17326 switch (TREE_CODE (decl
))
17329 case TEMPLATE_DECL
:
17330 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17333 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17336 gcc_unreachable ();
17341 /* Decide whether ARG can be unified with PARM, considering only the
17342 cv-qualifiers of each type, given STRICT as documented for unify.
17343 Returns nonzero iff the unification is OK on that basis. */
17346 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17348 int arg_quals
= cp_type_quals (arg
);
17349 int parm_quals
= cp_type_quals (parm
);
17351 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17352 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17354 /* Although a CVR qualifier is ignored when being applied to a
17355 substituted template parameter ([8.3.2]/1 for example), that
17356 does not allow us to unify "const T" with "int&" because both
17357 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17358 It is ok when we're allowing additional CV qualifiers
17359 at the outer level [14.8.2.1]/3,1st bullet. */
17360 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17361 || TREE_CODE (arg
) == FUNCTION_TYPE
17362 || TREE_CODE (arg
) == METHOD_TYPE
)
17363 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17366 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17367 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17371 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17372 && (arg_quals
& parm_quals
) != parm_quals
)
17375 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17376 && (parm_quals
& arg_quals
) != arg_quals
)
17382 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17384 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17386 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17387 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17388 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17390 *index
= TEMPLATE_TYPE_IDX (parm
);
17391 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17395 *index
= TEMPLATE_PARM_IDX (parm
);
17396 *level
= TEMPLATE_PARM_LEVEL (parm
);
17400 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17402 if (unify (TP, TA, P, A, S, EP)) \
17406 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17407 expansion at the end of PACKED_PARMS. Returns 0 if the type
17408 deduction succeeds, 1 otherwise. STRICT is the same as in
17409 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17410 call argument list. We'll need to adjust the arguments to make them
17411 types. SUBR tells us if this is from a recursive call to
17412 type_unification_real, or for comparing two template argument
17416 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17417 tree packed_args
, unification_kind_t strict
,
17418 bool subr
, bool explain_p
)
17421 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17422 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17423 tree pack
, packs
= NULL_TREE
;
17424 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17426 packed_args
= expand_template_argument_pack (packed_args
);
17428 int len
= TREE_VEC_LENGTH (packed_args
);
17430 /* Determine the parameter packs we will be deducing from the
17431 pattern, and record their current deductions. */
17432 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17433 pack
; pack
= TREE_CHAIN (pack
))
17435 tree parm_pack
= TREE_VALUE (pack
);
17438 /* Determine the index and level of this parameter pack. */
17439 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17441 /* Keep track of the parameter packs and their corresponding
17443 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17444 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17447 /* Loop through all of the arguments that have not yet been
17448 unified and unify each with the pattern. */
17449 for (i
= start
; i
< len
; i
++)
17452 bool any_explicit
= false;
17453 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17455 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17456 or the element of its argument pack at the current index if
17457 this argument was explicitly specified. */
17458 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17462 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17465 if (TREE_VALUE (pack
)
17466 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17467 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17469 any_explicit
= true;
17470 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17472 TMPL_ARG (targs
, level
, idx
) = arg
;
17475 /* If we had explicit template arguments, substitute them into the
17476 pattern before deduction. */
17479 /* Some arguments might still be unspecified or dependent. */
17481 ++processing_template_decl
;
17482 dependent
= any_dependent_template_arguments_p (targs
);
17484 --processing_template_decl
;
17485 parm
= tsubst (pattern
, targs
,
17486 explain_p
? tf_warning_or_error
: tf_none
,
17489 --processing_template_decl
;
17490 if (parm
== error_mark_node
)
17496 /* Unify the pattern with the current argument. */
17497 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17498 LOOKUP_IMPLICIT
, explain_p
))
17501 /* For each parameter pack, collect the deduced value. */
17502 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17505 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17507 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17508 TMPL_ARG (targs
, level
, idx
);
17512 /* Verify that the results of unification with the parameter packs
17513 produce results consistent with what we've seen before, and make
17514 the deduced argument packs available. */
17515 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17517 tree old_pack
= TREE_VALUE (pack
);
17518 tree new_args
= TREE_TYPE (pack
);
17519 int i
, len
= TREE_VEC_LENGTH (new_args
);
17521 bool nondeduced_p
= false;
17523 /* By default keep the original deduced argument pack.
17524 If necessary, more specific code is going to update the
17525 resulting deduced argument later down in this function. */
17526 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17527 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17529 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17530 actually deduce anything. */
17531 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17532 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17533 nondeduced_p
= true;
17537 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17539 /* If we had fewer function args than explicit template args,
17540 just use the explicits. */
17541 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17542 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17543 if (len
< explicit_len
)
17544 new_args
= explicit_args
;
17550 /* Build the deduced *_ARGUMENT_PACK. */
17551 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17553 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17554 TREE_TYPE (result
) =
17555 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17556 TREE_CONSTANT (result
) = 1;
17559 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17561 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17563 /* Note the deduced argument packs for this parameter
17565 TMPL_ARG (targs
, level
, idx
) = result
;
17567 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17568 && (ARGUMENT_PACK_ARGS (old_pack
)
17569 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17571 /* We only had the explicitly-provided arguments before, but
17572 now we have a complete set of arguments. */
17573 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17575 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17576 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17577 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17581 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17582 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17584 if (!comp_template_args_with_info (old_args
, new_args
,
17585 &bad_old_arg
, &bad_new_arg
))
17586 /* Inconsistent unification of this parameter pack. */
17587 return unify_parameter_pack_inconsistent (explain_p
,
17593 return unify_success (explain_p
);
17596 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17597 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17598 parameters and return value are as for unify. */
17601 unify_array_domain (tree tparms
, tree targs
,
17602 tree parm_dom
, tree arg_dom
,
17610 /* Our representation of array types uses "N - 1" as the
17611 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17612 not an integer constant. We cannot unify arbitrarily
17613 complex expressions, so we eliminate the MINUS_EXPRs
17615 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17616 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17619 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17620 parm_max
= TREE_OPERAND (parm_max
, 0);
17622 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17623 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17626 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17627 trying to unify the type of a variable with the type
17628 of a template parameter. For example:
17630 template <unsigned int N>
17631 void f (char (&) [N]);
17638 Here, the type of the ARG will be "int [g(i)]", and
17639 may be a SAVE_EXPR, etc. */
17640 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17641 return unify_vla_arg (explain_p
, arg_dom
);
17642 arg_max
= TREE_OPERAND (arg_max
, 0);
17645 /* If only one of the bounds used a MINUS_EXPR, compensate
17646 by adding one to the other bound. */
17647 if (parm_cst
&& !arg_cst
)
17648 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17652 else if (arg_cst
&& !parm_cst
)
17653 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17658 return unify (tparms
, targs
, parm_max
, arg_max
,
17659 UNIFY_ALLOW_INTEGER
, explain_p
);
17662 /* Deduce the value of template parameters. TPARMS is the (innermost)
17663 set of template parameters to a template. TARGS is the bindings
17664 for those template parameters, as determined thus far; TARGS may
17665 include template arguments for outer levels of template parameters
17666 as well. PARM is a parameter to a template function, or a
17667 subcomponent of that parameter; ARG is the corresponding argument.
17668 This function attempts to match PARM with ARG in a manner
17669 consistent with the existing assignments in TARGS. If more values
17670 are deduced, then TARGS is updated.
17672 Returns 0 if the type deduction succeeds, 1 otherwise. The
17673 parameter STRICT is a bitwise or of the following flags:
17676 Require an exact match between PARM and ARG.
17677 UNIFY_ALLOW_MORE_CV_QUAL:
17678 Allow the deduced ARG to be more cv-qualified (by qualification
17679 conversion) than ARG.
17680 UNIFY_ALLOW_LESS_CV_QUAL:
17681 Allow the deduced ARG to be less cv-qualified than ARG.
17682 UNIFY_ALLOW_DERIVED:
17683 Allow the deduced ARG to be a template base class of ARG,
17684 or a pointer to a template base class of the type pointed to by
17686 UNIFY_ALLOW_INTEGER:
17687 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17688 case for more information.
17689 UNIFY_ALLOW_OUTER_LEVEL:
17690 This is the outermost level of a deduction. Used to determine validity
17691 of qualification conversions. A valid qualification conversion must
17692 have const qualified pointers leading up to the inner type which
17693 requires additional CV quals, except at the outer level, where const
17694 is not required [conv.qual]. It would be normal to set this flag in
17695 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17696 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17697 This is the outermost level of a deduction, and PARM can be more CV
17698 qualified at this point.
17699 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17700 This is the outermost level of a deduction, and PARM can be less CV
17701 qualified at this point. */
17704 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17710 int strict_in
= strict
;
17712 /* I don't think this will do the right thing with respect to types.
17713 But the only case I've seen it in so far has been array bounds, where
17714 signedness is the only information lost, and I think that will be
17716 while (TREE_CODE (parm
) == NOP_EXPR
)
17717 parm
= TREE_OPERAND (parm
, 0);
17719 if (arg
== error_mark_node
)
17720 return unify_invalid (explain_p
);
17721 if (arg
== unknown_type_node
17722 || arg
== init_list_type_node
)
17723 /* We can't deduce anything from this, but we might get all the
17724 template args from other function args. */
17725 return unify_success (explain_p
);
17727 /* If PARM uses template parameters, then we can't bail out here,
17728 even if ARG == PARM, since we won't record unifications for the
17729 template parameters. We might need them if we're trying to
17730 figure out which of two things is more specialized. */
17731 if (arg
== parm
&& !uses_template_parms (parm
))
17732 return unify_success (explain_p
);
17734 /* Handle init lists early, so the rest of the function can assume
17735 we're dealing with a type. */
17736 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17740 tree orig_parm
= parm
;
17742 /* Replace T with std::initializer_list<T> for deduction. */
17743 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17744 && flag_deduce_init_list
)
17745 parm
= listify (parm
);
17747 if (!is_std_init_list (parm
)
17748 && TREE_CODE (parm
) != ARRAY_TYPE
)
17749 /* We can only deduce from an initializer list argument if the
17750 parameter is std::initializer_list or an array; otherwise this
17751 is a non-deduced context. */
17752 return unify_success (explain_p
);
17754 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17755 elttype
= TREE_TYPE (parm
);
17757 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17759 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
17761 int elt_strict
= strict
;
17763 if (elt
== error_mark_node
)
17764 return unify_invalid (explain_p
);
17766 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
17768 tree type
= TREE_TYPE (elt
);
17769 /* It should only be possible to get here for a call. */
17770 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
17771 elt_strict
|= maybe_adjust_types_for_deduction
17772 (DEDUCE_CALL
, &elttype
, &type
, elt
);
17776 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
17780 if (TREE_CODE (parm
) == ARRAY_TYPE
17781 && deducible_array_bound (TYPE_DOMAIN (parm
)))
17783 /* Also deduce from the length of the initializer list. */
17784 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
17785 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
17786 if (idx
== error_mark_node
)
17787 return unify_invalid (explain_p
);
17788 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17792 /* If the std::initializer_list<T> deduction worked, replace the
17793 deduced A with std::initializer_list<A>. */
17794 if (orig_parm
!= parm
)
17796 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
17797 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17798 targ
= listify (targ
);
17799 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
17801 return unify_success (explain_p
);
17804 /* Immediately reject some pairs that won't unify because of
17805 cv-qualification mismatches. */
17806 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17808 /* It is the elements of the array which hold the cv quals of an array
17809 type, and the elements might be template type parms. We'll check
17810 when we recurse. */
17811 && TREE_CODE (arg
) != ARRAY_TYPE
17812 /* We check the cv-qualifiers when unifying with template type
17813 parameters below. We want to allow ARG `const T' to unify with
17814 PARM `T' for example, when computing which of two templates
17815 is more specialized, for example. */
17816 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
17817 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
17818 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17820 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
17821 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
17822 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
17823 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
17824 strict
&= ~UNIFY_ALLOW_DERIVED
;
17825 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17826 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
17828 switch (TREE_CODE (parm
))
17830 case TYPENAME_TYPE
:
17832 case UNBOUND_CLASS_TEMPLATE
:
17833 /* In a type which contains a nested-name-specifier, template
17834 argument values cannot be deduced for template parameters used
17835 within the nested-name-specifier. */
17836 return unify_success (explain_p
);
17838 case TEMPLATE_TYPE_PARM
:
17839 case TEMPLATE_TEMPLATE_PARM
:
17840 case BOUND_TEMPLATE_TEMPLATE_PARM
:
17841 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17842 if (error_operand_p (tparm
))
17843 return unify_invalid (explain_p
);
17845 if (TEMPLATE_TYPE_LEVEL (parm
)
17846 != template_decl_level (tparm
))
17847 /* The PARM is not one we're trying to unify. Just check
17848 to see if it matches ARG. */
17850 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17851 && (is_auto (parm
) ? is_auto (arg
)
17852 : same_type_p (parm
, arg
)))
17853 return unify_success (explain_p
);
17855 return unify_type_mismatch (explain_p
, parm
, arg
);
17857 idx
= TEMPLATE_TYPE_IDX (parm
);
17858 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17859 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
17860 if (error_operand_p (tparm
))
17861 return unify_invalid (explain_p
);
17863 /* Check for mixed types and values. */
17864 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17865 && TREE_CODE (tparm
) != TYPE_DECL
)
17866 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17867 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
17868 gcc_unreachable ();
17870 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17872 /* ARG must be constructed from a template class or a template
17873 template parameter. */
17874 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
17875 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
17876 return unify_template_deduction_failure (explain_p
, parm
, arg
);
17878 tree parmvec
= TYPE_TI_ARGS (parm
);
17879 /* An alias template name is never deduced. */
17880 if (TYPE_ALIAS_P (arg
))
17881 arg
= strip_typedefs (arg
);
17882 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
17883 tree full_argvec
= add_to_template_args (targs
, argvec
);
17885 = DECL_INNERMOST_TEMPLATE_PARMS
17886 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
17888 int parm_variadic_p
= 0;
17890 /* The resolution to DR150 makes clear that default
17891 arguments for an N-argument may not be used to bind T
17892 to a template template parameter with fewer than N
17893 parameters. It is not safe to permit the binding of
17894 default arguments as an extension, as that may change
17895 the meaning of a conforming program. Consider:
17897 struct Dense { static const unsigned int dim = 1; };
17899 template <template <typename> class View,
17901 void operator+(float, View<Block> const&);
17903 template <typename Block,
17904 unsigned int Dim = Block::dim>
17905 struct Lvalue_proxy { operator float() const; };
17909 Lvalue_proxy<Dense> p;
17914 Here, if Lvalue_proxy is permitted to bind to View, then
17915 the global operator+ will be used; if they are not, the
17916 Lvalue_proxy will be converted to float. */
17917 if (coerce_template_parms (parm_parms
,
17919 TYPE_TI_TEMPLATE (parm
),
17921 ? tf_warning_or_error
17923 /*require_all_args=*/true,
17924 /*use_default_args=*/false)
17925 == error_mark_node
)
17928 /* Deduce arguments T, i from TT<T> or TT<i>.
17929 We check each element of PARMVEC and ARGVEC individually
17930 rather than the whole TREE_VEC since they can have
17931 different number of elements. */
17933 parmvec
= expand_template_argument_pack (parmvec
);
17934 argvec
= expand_template_argument_pack (argvec
);
17936 len
= TREE_VEC_LENGTH (parmvec
);
17938 /* Check if the parameters end in a pack, making them
17941 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
17942 parm_variadic_p
= 1;
17944 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17945 /* If the template argument list of P contains a pack
17946 expansion that is not the last template argument, the
17947 entire template argument list is a non-deduced
17949 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
17950 return unify_success (explain_p
);
17952 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
17953 return unify_too_few_arguments (explain_p
,
17954 TREE_VEC_LENGTH (argvec
), len
);
17956 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17958 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17959 TREE_VEC_ELT (parmvec
, i
),
17960 TREE_VEC_ELT (argvec
, i
),
17961 UNIFY_ALLOW_NONE
, explain_p
);
17964 if (parm_variadic_p
17965 && unify_pack_expansion (tparms
, targs
,
17968 /*subr=*/true, explain_p
))
17971 arg
= TYPE_TI_TEMPLATE (arg
);
17973 /* Fall through to deduce template name. */
17976 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17977 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17979 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
17981 /* Simple cases: Value already set, does match or doesn't. */
17982 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
17983 return unify_success (explain_p
);
17985 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17989 /* If PARM is `const T' and ARG is only `int', we don't have
17990 a match unless we are allowing additional qualification.
17991 If ARG is `const int' and PARM is just `T' that's OK;
17992 that binds `const int' to `T'. */
17993 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
17995 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17997 /* Consider the case where ARG is `const volatile int' and
17998 PARM is `const T'. Then, T should be `volatile int'. */
17999 arg
= cp_build_qualified_type_real
18000 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
18001 if (arg
== error_mark_node
)
18002 return unify_invalid (explain_p
);
18004 /* Simple cases: Value already set, does match or doesn't. */
18005 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
18006 return unify_success (explain_p
);
18008 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
18010 /* Make sure that ARG is not a variable-sized array. (Note
18011 that were talking about variable-sized arrays (like
18012 `int[n]'), rather than arrays of unknown size (like
18013 `int[]').) We'll get very confused by such a type since
18014 the bound of the array is not constant, and therefore
18015 not mangleable. Besides, such types are not allowed in
18016 ISO C++, so we can do as we please here. We do allow
18017 them for 'auto' deduction, since that isn't ABI-exposed. */
18018 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
18019 return unify_vla_arg (explain_p
, arg
);
18021 /* Strip typedefs as in convert_template_argument. */
18022 arg
= canonicalize_type_argument (arg
, tf_none
);
18025 /* If ARG is a parameter pack or an expansion, we cannot unify
18026 against it unless PARM is also a parameter pack. */
18027 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18028 && !template_parameter_pack_p (parm
))
18029 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18031 /* If the argument deduction results is a METHOD_TYPE,
18032 then there is a problem.
18033 METHOD_TYPE doesn't map to any real C++ type the result of
18034 the deduction can not be of that type. */
18035 if (TREE_CODE (arg
) == METHOD_TYPE
)
18036 return unify_method_type_error (explain_p
, arg
);
18038 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18039 return unify_success (explain_p
);
18041 case TEMPLATE_PARM_INDEX
:
18042 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
18043 if (error_operand_p (tparm
))
18044 return unify_invalid (explain_p
);
18046 if (TEMPLATE_PARM_LEVEL (parm
)
18047 != template_decl_level (tparm
))
18049 /* The PARM is not one we're trying to unify. Just check
18050 to see if it matches ARG. */
18051 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
18052 && cp_tree_equal (parm
, arg
));
18054 unify_expression_unequal (explain_p
, parm
, arg
);
18058 idx
= TEMPLATE_PARM_IDX (parm
);
18059 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18063 int x
= !cp_tree_equal (targ
, arg
);
18065 unify_inconsistency (explain_p
, parm
, targ
, arg
);
18069 /* [temp.deduct.type] If, in the declaration of a function template
18070 with a non-type template-parameter, the non-type
18071 template-parameter is used in an expression in the function
18072 parameter-list and, if the corresponding template-argument is
18073 deduced, the template-argument type shall match the type of the
18074 template-parameter exactly, except that a template-argument
18075 deduced from an array bound may be of any integral type.
18076 The non-type parameter might use already deduced type parameters. */
18077 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
18078 if (!TREE_TYPE (arg
))
18079 /* Template-parameter dependent expression. Just accept it for now.
18080 It will later be processed in convert_template_argument. */
18082 else if (same_type_p (TREE_TYPE (arg
), tparm
))
18084 else if ((strict
& UNIFY_ALLOW_INTEGER
)
18085 && CP_INTEGRAL_TYPE_P (tparm
))
18086 /* Convert the ARG to the type of PARM; the deduced non-type
18087 template argument must exactly match the types of the
18088 corresponding parameter. */
18089 arg
= fold (build_nop (tparm
, arg
));
18090 else if (uses_template_parms (tparm
))
18091 /* We haven't deduced the type of this parameter yet. Try again
18093 return unify_success (explain_p
);
18095 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
18097 /* If ARG is a parameter pack or an expansion, we cannot unify
18098 against it unless PARM is also a parameter pack. */
18099 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18100 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
18101 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18103 arg
= strip_typedefs_expr (arg
);
18104 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18105 return unify_success (explain_p
);
18109 /* A pointer-to-member constant can be unified only with
18110 another constant. */
18111 if (TREE_CODE (arg
) != PTRMEM_CST
)
18112 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
18114 /* Just unify the class member. It would be useless (and possibly
18115 wrong, depending on the strict flags) to unify also
18116 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18117 arg refer to the same variable, even if through different
18118 classes. For instance:
18120 struct A { int x; };
18123 Unification of &A::x and &B::x must succeed. */
18124 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
18125 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
18130 if (!TYPE_PTR_P (arg
))
18131 return unify_type_mismatch (explain_p
, parm
, arg
);
18133 /* [temp.deduct.call]
18135 A can be another pointer or pointer to member type that can
18136 be converted to the deduced A via a qualification
18137 conversion (_conv.qual_).
18139 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18140 This will allow for additional cv-qualification of the
18141 pointed-to types if appropriate. */
18143 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
18144 /* The derived-to-base conversion only persists through one
18145 level of pointers. */
18146 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
18148 return unify (tparms
, targs
, TREE_TYPE (parm
),
18149 TREE_TYPE (arg
), strict
, explain_p
);
18152 case REFERENCE_TYPE
:
18153 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
18154 return unify_type_mismatch (explain_p
, parm
, arg
);
18155 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18156 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18159 if (TREE_CODE (arg
) != ARRAY_TYPE
)
18160 return unify_type_mismatch (explain_p
, parm
, arg
);
18161 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
18162 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
18163 return unify_type_mismatch (explain_p
, parm
, arg
);
18164 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18165 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18166 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
18167 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18168 TYPE_DOMAIN (arg
), explain_p
);
18169 return unify_success (explain_p
);
18176 case ENUMERAL_TYPE
:
18179 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18180 return unify_type_mismatch (explain_p
, parm
, arg
);
18182 /* We have already checked cv-qualification at the top of the
18184 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
18185 return unify_type_mismatch (explain_p
, parm
, arg
);
18187 /* As far as unification is concerned, this wins. Later checks
18188 will invalidate it if necessary. */
18189 return unify_success (explain_p
);
18191 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18192 /* Type INTEGER_CST can come from ordinary constant template args. */
18194 while (TREE_CODE (arg
) == NOP_EXPR
)
18195 arg
= TREE_OPERAND (arg
, 0);
18197 if (TREE_CODE (arg
) != INTEGER_CST
)
18198 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18199 return (tree_int_cst_equal (parm
, arg
)
18200 ? unify_success (explain_p
)
18201 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18205 int i
, len
, argslen
;
18206 int parm_variadic_p
= 0;
18208 if (TREE_CODE (arg
) != TREE_VEC
)
18209 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18211 len
= TREE_VEC_LENGTH (parm
);
18212 argslen
= TREE_VEC_LENGTH (arg
);
18214 /* Check for pack expansions in the parameters. */
18215 for (i
= 0; i
< len
; ++i
)
18217 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18220 /* We can unify against something with a trailing
18222 parm_variadic_p
= 1;
18224 /* [temp.deduct.type]/9: If the template argument list of
18225 P contains a pack expansion that is not the last
18226 template argument, the entire template argument list
18227 is a non-deduced context. */
18228 return unify_success (explain_p
);
18232 /* If we don't have enough arguments to satisfy the parameters
18233 (not counting the pack expression at the end), or we have
18234 too many arguments for a parameter list that doesn't end in
18235 a pack expression, we can't unify. */
18236 if (parm_variadic_p
18237 ? argslen
< len
- parm_variadic_p
18239 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18241 /* Unify all of the parameters that precede the (optional)
18242 pack expression. */
18243 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18245 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18246 TREE_VEC_ELT (parm
, i
),
18247 TREE_VEC_ELT (arg
, i
),
18248 UNIFY_ALLOW_NONE
, explain_p
);
18250 if (parm_variadic_p
)
18251 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18253 /*subr=*/true, explain_p
);
18254 return unify_success (explain_p
);
18259 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18260 return unify_type_mismatch (explain_p
, parm
, arg
);
18262 if (TYPE_PTRMEMFUNC_P (parm
))
18264 if (!TYPE_PTRMEMFUNC_P (arg
))
18265 return unify_type_mismatch (explain_p
, parm
, arg
);
18267 return unify (tparms
, targs
,
18268 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18269 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18270 strict
, explain_p
);
18272 else if (TYPE_PTRMEMFUNC_P (arg
))
18273 return unify_type_mismatch (explain_p
, parm
, arg
);
18275 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18277 tree t
= NULL_TREE
;
18279 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18281 /* First, we try to unify the PARM and ARG directly. */
18282 t
= try_class_unification (tparms
, targs
,
18283 parm
, arg
, explain_p
);
18287 /* Fallback to the special case allowed in
18288 [temp.deduct.call]:
18290 If P is a class, and P has the form
18291 template-id, then A can be a derived class of
18292 the deduced A. Likewise, if P is a pointer to
18293 a class of the form template-id, A can be a
18294 pointer to a derived class pointed to by the
18296 enum template_base_result r
;
18297 r
= get_template_base (tparms
, targs
, parm
, arg
,
18301 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18304 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18305 && (CLASSTYPE_TI_TEMPLATE (parm
)
18306 == CLASSTYPE_TI_TEMPLATE (arg
)))
18307 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18308 Then, we should unify `int' and `U'. */
18311 /* There's no chance of unification succeeding. */
18312 return unify_type_mismatch (explain_p
, parm
, arg
);
18314 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18315 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18317 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18318 return unify_type_mismatch (explain_p
, parm
, arg
);
18319 return unify_success (explain_p
);
18322 case FUNCTION_TYPE
:
18324 unsigned int nargs
;
18329 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18330 return unify_type_mismatch (explain_p
, parm
, arg
);
18332 /* CV qualifications for methods can never be deduced, they must
18333 match exactly. We need to check them explicitly here,
18334 because type_unification_real treats them as any other
18335 cv-qualified parameter. */
18336 if (TREE_CODE (parm
) == METHOD_TYPE
18337 && (!check_cv_quals_for_unify
18339 class_of_this_parm (arg
),
18340 class_of_this_parm (parm
))))
18341 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18343 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18344 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18346 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18347 args
= XALLOCAVEC (tree
, nargs
);
18348 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18349 a
!= NULL_TREE
&& a
!= void_list_node
;
18350 a
= TREE_CHAIN (a
), ++i
)
18351 args
[i
] = TREE_VALUE (a
);
18354 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18355 args
, nargs
, 1, DEDUCE_EXACT
,
18356 LOOKUP_NORMAL
, NULL
, explain_p
);
18360 /* Unify a pointer to member with a pointer to member function, which
18361 deduces the type of the member as a function type. */
18362 if (TYPE_PTRMEMFUNC_P (arg
))
18364 /* Check top-level cv qualifiers */
18365 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18366 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18368 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18369 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18370 UNIFY_ALLOW_NONE
, explain_p
);
18372 /* Determine the type of the function we are unifying against. */
18373 tree fntype
= static_fn_type (arg
);
18375 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18378 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18379 return unify_type_mismatch (explain_p
, parm
, arg
);
18380 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18381 TYPE_OFFSET_BASETYPE (arg
),
18382 UNIFY_ALLOW_NONE
, explain_p
);
18383 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18384 strict
, explain_p
);
18387 if (DECL_TEMPLATE_PARM_P (parm
))
18388 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18389 if (arg
!= integral_constant_value (parm
))
18390 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18391 return unify_success (explain_p
);
18394 case TEMPLATE_DECL
:
18395 /* Matched cases are handled by the ARG == PARM test above. */
18396 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18399 /* A non-type template parameter that is a variable should be a
18400 an integral constant, in which case, it whould have been
18401 folded into its (constant) value. So we should not be getting
18402 a variable here. */
18403 gcc_unreachable ();
18405 case TYPE_ARGUMENT_PACK
:
18406 case NONTYPE_ARGUMENT_PACK
:
18407 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18408 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18411 case DECLTYPE_TYPE
:
18412 case UNDERLYING_TYPE
:
18413 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18414 or UNDERLYING_TYPE nodes. */
18415 return unify_success (explain_p
);
18418 /* Unification fails if we hit an error node. */
18419 return unify_invalid (explain_p
);
18422 if (REFERENCE_REF_P (parm
))
18423 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18424 strict
, explain_p
);
18428 /* An unresolved overload is a nondeduced context. */
18429 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18430 return unify_success (explain_p
);
18431 gcc_assert (EXPR_P (parm
));
18433 /* We must be looking at an expression. This can happen with
18437 void foo(S<I>, S<I + 2>);
18439 This is a "nondeduced context":
18443 The nondeduced contexts are:
18445 --A type that is a template-id in which one or more of
18446 the template-arguments is an expression that references
18447 a template-parameter.
18449 In these cases, we assume deduction succeeded, but don't
18450 actually infer any unifications. */
18452 if (!uses_template_parms (parm
)
18453 && !template_args_equal (parm
, arg
))
18454 return unify_expression_unequal (explain_p
, parm
, arg
);
18456 return unify_success (explain_p
);
18459 #undef RECUR_AND_CHECK_FAILURE
18461 /* Note that DECL can be defined in this translation unit, if
18465 mark_definable (tree decl
)
18468 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18469 FOR_EACH_CLONE (clone
, decl
)
18470 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18473 /* Called if RESULT is explicitly instantiated, or is a member of an
18474 explicitly instantiated class. */
18477 mark_decl_instantiated (tree result
, int extern_p
)
18479 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18481 /* If this entity has already been written out, it's too late to
18482 make any modifications. */
18483 if (TREE_ASM_WRITTEN (result
))
18486 /* For anonymous namespace we don't need to do anything. */
18487 if (decl_anon_ns_mem_p (result
))
18489 gcc_assert (!TREE_PUBLIC (result
));
18493 if (TREE_CODE (result
) != FUNCTION_DECL
)
18494 /* The TREE_PUBLIC flag for function declarations will have been
18495 set correctly by tsubst. */
18496 TREE_PUBLIC (result
) = 1;
18498 /* This might have been set by an earlier implicit instantiation. */
18499 DECL_COMDAT (result
) = 0;
18502 DECL_NOT_REALLY_EXTERN (result
) = 0;
18505 mark_definable (result
);
18506 mark_needed (result
);
18507 /* Always make artificials weak. */
18508 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18509 comdat_linkage (result
);
18510 /* For WIN32 we also want to put explicit instantiations in
18511 linkonce sections. */
18512 else if (TREE_PUBLIC (result
))
18513 maybe_make_one_only (result
);
18516 /* If EXTERN_P, then this function will not be emitted -- unless
18517 followed by an explicit instantiation, at which point its linkage
18518 will be adjusted. If !EXTERN_P, then this function will be
18519 emitted here. In neither circumstance do we want
18520 import_export_decl to adjust the linkage. */
18521 DECL_INTERFACE_KNOWN (result
) = 1;
18524 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18525 important template arguments. If any are missing, we check whether
18526 they're important by using error_mark_node for substituting into any
18527 args that were used for partial ordering (the ones between ARGS and END)
18528 and seeing if it bubbles up. */
18531 check_undeduced_parms (tree targs
, tree args
, tree end
)
18533 bool found
= false;
18535 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18536 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18539 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18543 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18544 if (substed
== error_mark_node
)
18550 /* Given two function templates PAT1 and PAT2, return:
18552 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18553 -1 if PAT2 is more specialized than PAT1.
18554 0 if neither is more specialized.
18556 LEN indicates the number of parameters we should consider
18557 (defaulted parameters should not be considered).
18559 The 1998 std underspecified function template partial ordering, and
18560 DR214 addresses the issue. We take pairs of arguments, one from
18561 each of the templates, and deduce them against each other. One of
18562 the templates will be more specialized if all the *other*
18563 template's arguments deduce against its arguments and at least one
18564 of its arguments *does* *not* deduce against the other template's
18565 corresponding argument. Deduction is done as for class templates.
18566 The arguments used in deduction have reference and top level cv
18567 qualifiers removed. Iff both arguments were originally reference
18568 types *and* deduction succeeds in both directions, an lvalue reference
18569 wins against an rvalue reference and otherwise the template
18570 with the more cv-qualified argument wins for that pairing (if
18571 neither is more cv-qualified, they both are equal). Unlike regular
18572 deduction, after all the arguments have been deduced in this way,
18573 we do *not* verify the deduced template argument values can be
18574 substituted into non-deduced contexts.
18576 The logic can be a bit confusing here, because we look at deduce1 and
18577 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18578 can find template arguments for pat1 to make arg1 look like arg2, that
18579 means that arg2 is at least as specialized as arg1. */
18582 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18584 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18585 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18586 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18587 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18588 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18589 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18590 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18591 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18592 tree origs1
, origs2
;
18593 bool lose1
= false;
18594 bool lose2
= false;
18596 /* Remove the this parameter from non-static member functions. If
18597 one is a non-static member function and the other is not a static
18598 member function, remove the first parameter from that function
18599 also. This situation occurs for operator functions where we
18600 locate both a member function (with this pointer) and non-member
18601 operator (with explicit first operand). */
18602 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18604 len
--; /* LEN is the number of significant arguments for DECL1 */
18605 args1
= TREE_CHAIN (args1
);
18606 if (!DECL_STATIC_FUNCTION_P (decl2
))
18607 args2
= TREE_CHAIN (args2
);
18609 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18611 args2
= TREE_CHAIN (args2
);
18612 if (!DECL_STATIC_FUNCTION_P (decl1
))
18615 args1
= TREE_CHAIN (args1
);
18619 /* If only one is a conversion operator, they are unordered. */
18620 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18623 /* Consider the return type for a conversion function */
18624 if (DECL_CONV_FN_P (decl1
))
18626 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18627 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18631 processing_template_decl
++;
18637 /* Stop when an ellipsis is seen. */
18638 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18640 tree arg1
= TREE_VALUE (args1
);
18641 tree arg2
= TREE_VALUE (args2
);
18642 int deduce1
, deduce2
;
18648 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18649 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18651 /* When both arguments are pack expansions, we need only
18652 unify the patterns themselves. */
18653 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18654 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18656 /* This is the last comparison we need to do. */
18660 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18662 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18663 arg1
= TREE_TYPE (arg1
);
18664 quals1
= cp_type_quals (arg1
);
18667 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18669 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18670 arg2
= TREE_TYPE (arg2
);
18671 quals2
= cp_type_quals (arg2
);
18674 arg1
= TYPE_MAIN_VARIANT (arg1
);
18675 arg2
= TYPE_MAIN_VARIANT (arg2
);
18677 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18679 int i
, len2
= list_length (args2
);
18680 tree parmvec
= make_tree_vec (1);
18681 tree argvec
= make_tree_vec (len2
);
18684 /* Setup the parameter vector, which contains only ARG1. */
18685 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18687 /* Setup the argument vector, which contains the remaining
18689 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18690 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18692 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18693 argvec
, DEDUCE_EXACT
,
18694 /*subr=*/true, /*explain_p=*/false)
18697 /* We cannot deduce in the other direction, because ARG1 is
18698 a pack expansion but ARG2 is not. */
18701 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18703 int i
, len1
= list_length (args1
);
18704 tree parmvec
= make_tree_vec (1);
18705 tree argvec
= make_tree_vec (len1
);
18708 /* Setup the parameter vector, which contains only ARG1. */
18709 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18711 /* Setup the argument vector, which contains the remaining
18713 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18714 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18716 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18717 argvec
, DEDUCE_EXACT
,
18718 /*subr=*/true, /*explain_p=*/false)
18721 /* We cannot deduce in the other direction, because ARG2 is
18722 a pack expansion but ARG1 is not.*/
18728 /* The normal case, where neither argument is a pack
18730 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18731 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18733 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18734 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18738 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18739 arg2, then arg2 is not as specialized as arg1. */
18745 /* "If, for a given type, deduction succeeds in both directions
18746 (i.e., the types are identical after the transformations above)
18747 and both P and A were reference types (before being replaced with
18748 the type referred to above):
18749 - if the type from the argument template was an lvalue reference and
18750 the type from the parameter template was not, the argument type is
18751 considered to be more specialized than the other; otherwise,
18752 - if the type from the argument template is more cv-qualified
18753 than the type from the parameter template (as described above),
18754 the argument type is considered to be more specialized than the other;
18756 - neither type is more specialized than the other." */
18758 if (deduce1
&& deduce2
)
18760 if (ref1
&& ref2
&& ref1
!= ref2
)
18767 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
18769 if ((quals1
& quals2
) == quals2
)
18771 if ((quals1
& quals2
) == quals1
)
18776 if (lose1
&& lose2
)
18777 /* We've failed to deduce something in either direction.
18778 These must be unordered. */
18781 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18782 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18783 /* We have already processed all of the arguments in our
18784 handing of the pack expansion type. */
18787 args1
= TREE_CHAIN (args1
);
18788 args2
= TREE_CHAIN (args2
);
18791 /* "In most cases, all template parameters must have values in order for
18792 deduction to succeed, but for partial ordering purposes a template
18793 parameter may remain without a value provided it is not used in the
18794 types being used for partial ordering."
18796 Thus, if we are missing any of the targs1 we need to substitute into
18797 origs1, then pat2 is not as specialized as pat1. This can happen when
18798 there is a nondeduced context. */
18799 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
18801 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
18804 processing_template_decl
--;
18806 /* All things being equal, if the next argument is a pack expansion
18807 for one function but not for the other, prefer the
18808 non-variadic function. FIXME this is bogus; see c++/41958. */
18810 && args1
&& TREE_VALUE (args1
)
18811 && args2
&& TREE_VALUE (args2
))
18813 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
18814 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
18817 if (lose1
== lose2
)
18825 /* Determine which of two partial specializations of TMPL is more
18828 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18829 to the first partial specialization. The TREE_VALUE is the
18830 innermost set of template parameters for the partial
18831 specialization. PAT2 is similar, but for the second template.
18833 Return 1 if the first partial specialization is more specialized;
18834 -1 if the second is more specialized; 0 if neither is more
18837 See [temp.class.order] for information about determining which of
18838 two templates is more specialized. */
18841 more_specialized_class (tree tmpl
, tree pat1
, tree pat2
)
18846 bool any_deductions
= false;
18848 tmpl1
= TREE_TYPE (pat1
);
18849 tmpl2
= TREE_TYPE (pat2
);
18851 /* Just like what happens for functions, if we are ordering between
18852 different class template specializations, we may encounter dependent
18853 types in the arguments, and we need our dependency check functions
18854 to behave correctly. */
18855 ++processing_template_decl
;
18856 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat1
),
18857 CLASSTYPE_TI_ARGS (tmpl1
),
18858 CLASSTYPE_TI_ARGS (tmpl2
));
18862 any_deductions
= true;
18865 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat2
),
18866 CLASSTYPE_TI_ARGS (tmpl2
),
18867 CLASSTYPE_TI_ARGS (tmpl1
));
18871 any_deductions
= true;
18873 --processing_template_decl
;
18875 /* In the case of a tie where at least one of the class templates
18876 has a parameter pack at the end, the template with the most
18877 non-packed parameters wins. */
18880 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
18881 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
18883 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
18884 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
18885 int len1
= TREE_VEC_LENGTH (args1
);
18886 int len2
= TREE_VEC_LENGTH (args2
);
18888 /* We don't count the pack expansion at the end. */
18889 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
18891 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
18896 else if (len1
< len2
)
18903 /* Return the template arguments that will produce the function signature
18904 DECL from the function template FN, with the explicit template
18905 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18906 also match. Return NULL_TREE if no satisfactory arguments could be
18910 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
18912 int ntparms
= DECL_NTPARMS (fn
);
18913 tree targs
= make_tree_vec (ntparms
);
18914 tree decl_type
= TREE_TYPE (decl
);
18915 tree decl_arg_types
;
18917 unsigned int nargs
, ix
;
18920 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
18922 /* Never do unification on the 'this' parameter. */
18923 decl_arg_types
= skip_artificial_parms_for (decl
,
18924 TYPE_ARG_TYPES (decl_type
));
18926 nargs
= list_length (decl_arg_types
);
18927 args
= XALLOCAVEC (tree
, nargs
);
18928 for (arg
= decl_arg_types
, ix
= 0;
18929 arg
!= NULL_TREE
&& arg
!= void_list_node
;
18930 arg
= TREE_CHAIN (arg
), ++ix
)
18931 args
[ix
] = TREE_VALUE (arg
);
18933 if (fn_type_unification (fn
, explicit_args
, targs
,
18935 (check_rettype
|| DECL_CONV_FN_P (fn
)
18936 ? TREE_TYPE (decl_type
) : NULL_TREE
),
18937 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
18939 == error_mark_node
)
18945 /* Return the innermost template arguments that, when applied to a partial
18946 specialization of TMPL whose innermost template parameters are
18947 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
18950 For example, suppose we have:
18952 template <class T, class U> struct S {};
18953 template <class T> struct S<T*, int> {};
18955 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
18956 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
18957 int}. The resulting vector will be {double}, indicating that `T'
18958 is bound to `double'. */
18961 get_class_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
18963 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
18965 tree innermost_deduced_args
;
18967 innermost_deduced_args
= make_tree_vec (ntparms
);
18968 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18970 deduced_args
= copy_node (args
);
18971 SET_TMPL_ARGS_LEVEL (deduced_args
,
18972 TMPL_ARGS_DEPTH (deduced_args
),
18973 innermost_deduced_args
);
18976 deduced_args
= innermost_deduced_args
;
18978 if (unify (tparms
, deduced_args
,
18979 INNERMOST_TEMPLATE_ARGS (spec_args
),
18980 INNERMOST_TEMPLATE_ARGS (args
),
18981 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
18984 for (i
= 0; i
< ntparms
; ++i
)
18985 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
18988 /* Verify that nondeduced template arguments agree with the type
18989 obtained from argument deduction.
18993 struct A { typedef int X; };
18994 template <class T, class U> struct C {};
18995 template <class T> struct C<T, typename T::X> {};
18997 Then with the instantiation `C<A, int>', we can deduce that
18998 `T' is `A' but unify () does not check whether `typename T::X'
19000 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
19001 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19003 tf_none
, false, false);
19004 if (spec_args
== error_mark_node
19005 /* We only need to check the innermost arguments; the other
19006 arguments will always agree. */
19007 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
19008 INNERMOST_TEMPLATE_ARGS (args
)))
19011 /* Now that we have bindings for all of the template arguments,
19012 ensure that the arguments deduced for the template template
19013 parameters have compatible template parameter lists. See the use
19014 of template_template_parm_bindings_ok_p in fn_type_unification
19015 for more information. */
19016 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
19019 return deduced_args
;
19022 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19023 Return the TREE_LIST node with the most specialized template, if
19024 any. If there is no most specialized template, the error_mark_node
19027 Note that this function does not look at, or modify, the
19028 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19029 returned is one of the elements of INSTANTIATIONS, callers may
19030 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19031 and retrieve it from the value returned. */
19034 most_specialized_instantiation (tree templates
)
19038 ++processing_template_decl
;
19041 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
19045 if (get_bindings (TREE_VALUE (champ
),
19046 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19047 NULL_TREE
, /*check_ret=*/true))
19050 if (get_bindings (TREE_VALUE (fn
),
19051 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19052 NULL_TREE
, /*check_ret=*/true))
19059 /* Equally specialized, move to next function. If there
19060 is no next function, nothing's most specialized. */
19061 fn
= TREE_CHAIN (fn
);
19069 /* Now verify that champ is better than everything earlier in the
19070 instantiation list. */
19071 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
19072 if (get_bindings (TREE_VALUE (champ
),
19073 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19074 NULL_TREE
, /*check_ret=*/true)
19075 || !get_bindings (TREE_VALUE (fn
),
19076 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19077 NULL_TREE
, /*check_ret=*/true))
19083 processing_template_decl
--;
19086 return error_mark_node
;
19091 /* If DECL is a specialization of some template, return the most
19092 general such template. Otherwise, returns NULL_TREE.
19094 For example, given:
19096 template <class T> struct S { template <class U> void f(U); };
19098 if TMPL is `template <class U> void S<int>::f(U)' this will return
19099 the full template. This function will not trace past partial
19100 specializations, however. For example, given in addition:
19102 template <class T> struct S<T*> { template <class U> void f(U); };
19104 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19105 `template <class T> template <class U> S<T*>::f(U)'. */
19108 most_general_template (tree decl
)
19110 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19112 if (tree tinfo
= get_template_info (decl
))
19113 decl
= TI_TEMPLATE (tinfo
);
19114 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19115 template friend, or a FIELD_DECL for a capture pack. */
19116 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19120 /* Look for more and more general templates. */
19121 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
19123 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19124 (See cp-tree.h for details.) */
19125 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
19128 if (CLASS_TYPE_P (TREE_TYPE (decl
))
19129 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
19132 /* Stop if we run into an explicitly specialized class template. */
19133 if (!DECL_NAMESPACE_SCOPE_P (decl
)
19134 && DECL_CONTEXT (decl
)
19135 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
19138 decl
= DECL_TI_TEMPLATE (decl
);
19144 /* Return the most specialized of the class template partial
19145 specializations which can produce TYPE, a specialization of some class
19146 template. The value returned is actually a TREE_LIST; the TREE_TYPE is
19147 a _TYPE node corresponding to the partial specialization, while the
19148 TREE_PURPOSE is the set of template arguments that must be
19149 substituted into the TREE_TYPE in order to generate TYPE.
19151 If the choice of partial specialization is ambiguous, a diagnostic
19152 is issued, and the error_mark_node is returned. If there are no
19153 partial specializations matching TYPE, then NULL_TREE is
19154 returned, indicating that the primary template should be used. */
19157 most_specialized_class (tree type
, tsubst_flags_t complain
)
19159 tree list
= NULL_TREE
;
19164 tree outer_args
= NULL_TREE
;
19166 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
19167 tree main_tmpl
= most_general_template (tmpl
);
19168 tree args
= CLASSTYPE_TI_ARGS (type
);
19170 /* For determining which partial specialization to use, only the
19171 innermost args are interesting. */
19172 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19174 outer_args
= strip_innermost_template_args (args
, 1);
19175 args
= INNERMOST_TEMPLATE_ARGS (args
);
19178 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
19180 tree partial_spec_args
;
19182 tree spec_tmpl
= TREE_VALUE (t
);
19183 tree orig_parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19185 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
19187 ++processing_template_decl
;
19191 /* Discard the outer levels of args, and then substitute in the
19192 template args from the enclosing class. */
19193 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19194 partial_spec_args
= tsubst_template_args
19195 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19197 /* And the same for the partial specialization TEMPLATE_DECL. */
19198 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19201 partial_spec_args
=
19202 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19205 /*require_all_args=*/true,
19206 /*use_default_args=*/true);
19208 --processing_template_decl
;
19210 if (partial_spec_args
== error_mark_node
)
19211 return error_mark_node
;
19212 if (spec_tmpl
== error_mark_node
)
19213 return error_mark_node
;
19215 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19216 spec_args
= get_class_bindings (tmpl
, parms
,
19222 spec_args
= add_to_template_args (outer_args
, spec_args
);
19223 list
= tree_cons (spec_args
, orig_parms
, list
);
19224 TREE_TYPE (list
) = TREE_TYPE (t
);
19231 ambiguous_p
= false;
19234 t
= TREE_CHAIN (t
);
19235 for (; t
; t
= TREE_CHAIN (t
))
19237 fate
= more_specialized_class (tmpl
, champ
, t
);
19244 t
= TREE_CHAIN (t
);
19247 ambiguous_p
= true;
19256 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19258 fate
= more_specialized_class (tmpl
, champ
, t
);
19261 ambiguous_p
= true;
19269 char *spaces
= NULL
;
19270 if (!(complain
& tf_error
))
19271 return error_mark_node
;
19272 error ("ambiguous class template instantiation for %q#T", type
);
19273 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19274 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19276 error ("%s %+#T", spaces
? spaces
: str
, TREE_TYPE (t
));
19277 spaces
= spaces
? spaces
: get_spaces (str
);
19280 return error_mark_node
;
19286 /* Explicitly instantiate DECL. */
19289 do_decl_instantiation (tree decl
, tree storage
)
19291 tree result
= NULL_TREE
;
19294 if (!decl
|| decl
== error_mark_node
)
19295 /* An error occurred, for which grokdeclarator has already issued
19296 an appropriate message. */
19298 else if (! DECL_LANG_SPECIFIC (decl
))
19300 error ("explicit instantiation of non-template %q#D", decl
);
19304 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
19305 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
19307 if (VAR_P (decl
) && !var_templ
)
19309 /* There is an asymmetry here in the way VAR_DECLs and
19310 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19311 the latter, the DECL we get back will be marked as a
19312 template instantiation, and the appropriate
19313 DECL_TEMPLATE_INFO will be set up. This does not happen for
19314 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19315 should handle VAR_DECLs as it currently handles
19317 if (!DECL_CLASS_SCOPE_P (decl
))
19319 error ("%qD is not a static data member of a class template", decl
);
19322 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19323 if (!result
|| !VAR_P (result
))
19325 error ("no matching template for %qD found", decl
);
19328 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19330 error ("type %qT for explicit instantiation %qD does not match "
19331 "declared type %qT", TREE_TYPE (result
), decl
,
19336 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
19338 error ("explicit instantiation of %q#D", decl
);
19344 /* Check for various error cases. Note that if the explicit
19345 instantiation is valid the RESULT will currently be marked as an
19346 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19347 until we get here. */
19349 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19351 /* DR 259 [temp.spec].
19353 Both an explicit instantiation and a declaration of an explicit
19354 specialization shall not appear in a program unless the explicit
19355 instantiation follows a declaration of the explicit specialization.
19357 For a given set of template parameters, if an explicit
19358 instantiation of a template appears after a declaration of an
19359 explicit specialization for that template, the explicit
19360 instantiation has no effect. */
19363 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19367 No program shall explicitly instantiate any template more
19370 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19371 the first instantiation was `extern' and the second is not,
19372 and EXTERN_P for the opposite case. */
19373 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19374 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19375 /* If an "extern" explicit instantiation follows an ordinary
19376 explicit instantiation, the template is instantiated. */
19380 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19382 error ("no matching template for %qD found", result
);
19385 else if (!DECL_TEMPLATE_INFO (result
))
19387 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19391 if (storage
== NULL_TREE
)
19393 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19395 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19396 pedwarn (input_location
, OPT_Wpedantic
,
19397 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19402 error ("storage class %qD applied to template instantiation", storage
);
19404 check_explicit_instantiation_namespace (result
);
19405 mark_decl_instantiated (result
, extern_p
);
19407 instantiate_decl (result
, /*defer_ok=*/1,
19408 /*expl_inst_class_mem_p=*/false);
19412 mark_class_instantiated (tree t
, int extern_p
)
19414 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19415 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19416 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19417 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19420 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19421 rest_of_type_compilation (t
, 1);
19425 /* Called from do_type_instantiation through binding_table_foreach to
19426 do recursive instantiation for the type bound in ENTRY. */
19428 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19430 tree storage
= *(tree
*) data
;
19432 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19433 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19434 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19437 /* Called from do_type_instantiation to instantiate a member
19438 (a member function or a static member variable) of an
19439 explicitly instantiated class template. */
19441 instantiate_class_member (tree decl
, int extern_p
)
19443 mark_decl_instantiated (decl
, extern_p
);
19445 instantiate_decl (decl
, /*defer_ok=*/1,
19446 /*expl_inst_class_mem_p=*/true);
19449 /* Perform an explicit instantiation of template class T. STORAGE, if
19450 non-null, is the RID for extern, inline or static. COMPLAIN is
19451 nonzero if this is called from the parser, zero if called recursively,
19452 since the standard is unclear (as detailed below). */
19455 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19460 int previous_instantiation_extern_p
= 0;
19462 if (TREE_CODE (t
) == TYPE_DECL
)
19465 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19468 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19470 error ("explicit instantiation of non-class template %qD", tmpl
);
19472 error ("explicit instantiation of non-template type %qT", t
);
19478 if (!COMPLETE_TYPE_P (t
))
19480 if (complain
& tf_error
)
19481 error ("explicit instantiation of %q#T before definition of template",
19486 if (storage
!= NULL_TREE
)
19488 if (!in_system_header_at (input_location
))
19490 if (storage
== ridpointers
[(int) RID_EXTERN
])
19492 if (cxx_dialect
== cxx98
)
19493 pedwarn (input_location
, OPT_Wpedantic
,
19494 "ISO C++ 1998 forbids the use of %<extern%> on "
19495 "explicit instantiations");
19498 pedwarn (input_location
, OPT_Wpedantic
,
19499 "ISO C++ forbids the use of %qE"
19500 " on explicit instantiations", storage
);
19503 if (storage
== ridpointers
[(int) RID_INLINE
])
19505 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19507 else if (storage
== ridpointers
[(int) RID_STATIC
])
19511 error ("storage class %qD applied to template instantiation",
19517 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19519 /* DR 259 [temp.spec].
19521 Both an explicit instantiation and a declaration of an explicit
19522 specialization shall not appear in a program unless the explicit
19523 instantiation follows a declaration of the explicit specialization.
19525 For a given set of template parameters, if an explicit
19526 instantiation of a template appears after a declaration of an
19527 explicit specialization for that template, the explicit
19528 instantiation has no effect. */
19531 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19535 No program shall explicitly instantiate any template more
19538 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19539 instantiation was `extern'. If EXTERN_P then the second is.
19540 These cases are OK. */
19541 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19543 if (!previous_instantiation_extern_p
&& !extern_p
19544 && (complain
& tf_error
))
19545 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19547 /* If we've already instantiated the template, just return now. */
19548 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19552 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19553 mark_class_instantiated (t
, extern_p
);
19561 /* In contrast to implicit instantiation, where only the
19562 declarations, and not the definitions, of members are
19563 instantiated, we have here:
19567 The explicit instantiation of a class template specialization
19568 implies the instantiation of all of its members not
19569 previously explicitly specialized in the translation unit
19570 containing the explicit instantiation.
19572 Of course, we can't instantiate member template classes, since
19573 we don't have any arguments for them. Note that the standard
19574 is unclear on whether the instantiation of the members are
19575 *explicit* instantiations or not. However, the most natural
19576 interpretation is that it should be an explicit instantiation. */
19579 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19580 if (TREE_CODE (tmp
) == FUNCTION_DECL
19581 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19582 instantiate_class_member (tmp
, extern_p
);
19584 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19585 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19586 instantiate_class_member (tmp
, extern_p
);
19588 if (CLASSTYPE_NESTED_UTDS (t
))
19589 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19590 bt_instantiate_type_proc
, &storage
);
19594 /* Given a function DECL, which is a specialization of TMPL, modify
19595 DECL to be a re-instantiation of TMPL with the same template
19596 arguments. TMPL should be the template into which tsubst'ing
19597 should occur for DECL, not the most general template.
19599 One reason for doing this is a scenario like this:
19602 void f(const T&, int i);
19604 void g() { f(3, 7); }
19607 void f(const T& t, const int i) { }
19609 Note that when the template is first instantiated, with
19610 instantiate_template, the resulting DECL will have no name for the
19611 first parameter, and the wrong type for the second. So, when we go
19612 to instantiate the DECL, we regenerate it. */
19615 regenerate_decl_from_template (tree decl
, tree tmpl
)
19617 /* The arguments used to instantiate DECL, from the most general
19622 args
= DECL_TI_ARGS (decl
);
19623 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19625 /* Make sure that we can see identifiers, and compute access
19627 push_access_scope (decl
);
19629 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19637 args_depth
= TMPL_ARGS_DEPTH (args
);
19638 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19639 if (args_depth
> parms_depth
)
19640 args
= get_innermost_template_args (args
, parms_depth
);
19642 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19643 args
, tf_error
, NULL_TREE
,
19644 /*defer_ok*/false);
19645 if (specs
&& specs
!= error_mark_node
)
19646 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19649 /* Merge parameter declarations. */
19650 decl_parm
= skip_artificial_parms_for (decl
,
19651 DECL_ARGUMENTS (decl
));
19653 = skip_artificial_parms_for (code_pattern
,
19654 DECL_ARGUMENTS (code_pattern
));
19655 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19660 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19661 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19662 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19664 parm_type
= type_decays_to (parm_type
);
19665 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19666 TREE_TYPE (decl_parm
) = parm_type
;
19667 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19668 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19670 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19671 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19673 decl_parm
= DECL_CHAIN (decl_parm
);
19674 pattern_parm
= DECL_CHAIN (pattern_parm
);
19676 /* Merge any parameters that match with the function parameter
19678 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19681 tree expanded_types
;
19682 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19683 the parameters in this function parameter pack. */
19684 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19685 args
, tf_error
, NULL_TREE
);
19686 len
= TREE_VEC_LENGTH (expanded_types
);
19687 for (i
= 0; i
< len
; i
++)
19692 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19693 /* Rename the parameter to include the index. */
19694 DECL_NAME (decl_parm
) =
19695 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19696 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19697 parm_type
= type_decays_to (parm_type
);
19698 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19699 TREE_TYPE (decl_parm
) = parm_type
;
19700 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19701 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19703 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19704 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19706 decl_parm
= DECL_CHAIN (decl_parm
);
19709 /* Merge additional specifiers from the CODE_PATTERN. */
19710 if (DECL_DECLARED_INLINE_P (code_pattern
)
19711 && !DECL_DECLARED_INLINE_P (decl
))
19712 DECL_DECLARED_INLINE_P (decl
) = 1;
19714 else if (VAR_P (decl
))
19716 DECL_INITIAL (decl
) =
19717 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19718 tf_error
, DECL_TI_TEMPLATE (decl
),
19719 /*integral_constant_expression_p=*/false);
19720 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19721 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19722 tf_error
, DECL_TI_TEMPLATE (decl
));
19725 gcc_unreachable ();
19727 pop_access_scope (decl
);
19730 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19731 substituted to get DECL. */
19734 template_for_substitution (tree decl
)
19736 tree tmpl
= DECL_TI_TEMPLATE (decl
);
19738 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19739 for the instantiation. This is not always the most general
19740 template. Consider, for example:
19743 struct S { template <class U> void f();
19744 template <> void f<int>(); };
19746 and an instantiation of S<double>::f<int>. We want TD to be the
19747 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19748 while (/* An instantiation cannot have a definition, so we need a
19749 more general template. */
19750 DECL_TEMPLATE_INSTANTIATION (tmpl
)
19751 /* We must also deal with friend templates. Given:
19753 template <class T> struct S {
19754 template <class U> friend void f() {};
19757 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19758 so far as the language is concerned, but that's still
19759 where we get the pattern for the instantiation from. On
19760 other hand, if the definition comes outside the class, say:
19762 template <class T> struct S {
19763 template <class U> friend void f();
19765 template <class U> friend void f() {}
19767 we don't need to look any further. That's what the check for
19768 DECL_INITIAL is for. */
19769 || (TREE_CODE (decl
) == FUNCTION_DECL
19770 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
19771 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
19773 /* The present template, TD, should not be a definition. If it
19774 were a definition, we should be using it! Note that we
19775 cannot restructure the loop to just keep going until we find
19776 a template with a definition, since that might go too far if
19777 a specialization was declared, but not defined. */
19779 /* Fetch the more general template. */
19780 tmpl
= DECL_TI_TEMPLATE (tmpl
);
19786 /* Returns true if we need to instantiate this template instance even if we
19787 know we aren't going to emit it.. */
19790 always_instantiate_p (tree decl
)
19792 /* We always instantiate inline functions so that we can inline them. An
19793 explicit instantiation declaration prohibits implicit instantiation of
19794 non-inline functions. With high levels of optimization, we would
19795 normally inline non-inline functions -- but we're not allowed to do
19796 that for "extern template" functions. Therefore, we check
19797 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19798 return ((TREE_CODE (decl
) == FUNCTION_DECL
19799 && (DECL_DECLARED_INLINE_P (decl
)
19800 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
19801 /* And we need to instantiate static data members so that
19802 their initializers are available in integral constant
19805 && decl_maybe_constant_var_p (decl
)));
19808 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19809 instantiate it now, modifying TREE_TYPE (fn). */
19812 maybe_instantiate_noexcept (tree fn
)
19814 tree fntype
, spec
, noex
, clone
;
19816 /* Don't instantiate a noexcept-specification from template context. */
19817 if (processing_template_decl
)
19820 if (DECL_CLONED_FUNCTION_P (fn
))
19821 fn
= DECL_CLONED_FUNCTION (fn
);
19822 fntype
= TREE_TYPE (fn
);
19823 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
19825 if (!spec
|| !TREE_PURPOSE (spec
))
19828 noex
= TREE_PURPOSE (spec
);
19830 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
19832 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
19833 spec
= get_defaulted_eh_spec (fn
);
19834 else if (push_tinst_level (fn
))
19836 push_access_scope (fn
);
19837 push_deferring_access_checks (dk_no_deferred
);
19838 input_location
= DECL_SOURCE_LOCATION (fn
);
19839 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
19840 DEFERRED_NOEXCEPT_ARGS (noex
),
19841 tf_warning_or_error
, fn
,
19842 /*function_p=*/false,
19843 /*integral_constant_expression_p=*/true);
19844 pop_deferring_access_checks ();
19845 pop_access_scope (fn
);
19846 pop_tinst_level ();
19847 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
19848 if (spec
== error_mark_node
)
19849 spec
= noexcept_false_spec
;
19852 spec
= noexcept_false_spec
;
19854 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
19857 FOR_EACH_CLONE (clone
, fn
)
19859 if (TREE_TYPE (clone
) == fntype
)
19860 TREE_TYPE (clone
) = TREE_TYPE (fn
);
19862 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
19866 /* Produce the definition of D, a _DECL generated from a template. If
19867 DEFER_OK is nonzero, then we don't have to actually do the
19868 instantiation now; we just have to do it sometime. Normally it is
19869 an error if this is an explicit instantiation but D is undefined.
19870 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19871 explicitly instantiated class template. */
19874 instantiate_decl (tree d
, int defer_ok
,
19875 bool expl_inst_class_mem_p
)
19877 tree tmpl
= DECL_TI_TEMPLATE (d
);
19884 bool pattern_defined
;
19885 location_t saved_loc
= input_location
;
19886 int saved_unevaluated_operand
= cp_unevaluated_operand
;
19887 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
19893 /* This function should only be used to instantiate templates for
19894 functions and static member variables. */
19895 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
19897 /* Variables are never deferred; if instantiation is required, they
19898 are instantiated right away. That allows for better code in the
19899 case that an expression refers to the value of the variable --
19900 if the variable has a constant value the referring expression can
19901 take advantage of that fact. */
19903 || DECL_DECLARED_CONSTEXPR_P (d
))
19906 /* Don't instantiate cloned functions. Instead, instantiate the
19907 functions they cloned. */
19908 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
19909 d
= DECL_CLONED_FUNCTION (d
);
19911 if (DECL_TEMPLATE_INSTANTIATED (d
)
19912 || (TREE_CODE (d
) == FUNCTION_DECL
19913 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
19914 || DECL_TEMPLATE_SPECIALIZATION (d
))
19915 /* D has already been instantiated or explicitly specialized, so
19916 there's nothing for us to do here.
19918 It might seem reasonable to check whether or not D is an explicit
19919 instantiation, and, if so, stop here. But when an explicit
19920 instantiation is deferred until the end of the compilation,
19921 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
19922 the instantiation. */
19925 /* Check to see whether we know that this template will be
19926 instantiated in some other file, as with "extern template"
19928 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
19930 /* In general, we do not instantiate such templates. */
19931 if (external_p
&& !always_instantiate_p (d
))
19934 gen_tmpl
= most_general_template (tmpl
);
19935 gen_args
= DECL_TI_ARGS (d
);
19937 if (tmpl
!= gen_tmpl
)
19938 /* We should already have the extra args. */
19939 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
19940 == TMPL_ARGS_DEPTH (gen_args
));
19941 /* And what's in the hash table should match D. */
19942 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
19943 || spec
== NULL_TREE
);
19945 /* This needs to happen before any tsubsting. */
19946 if (! push_tinst_level (d
))
19949 timevar_push (TV_TEMPLATE_INST
);
19951 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
19952 for the instantiation. */
19953 td
= template_for_substitution (d
);
19954 code_pattern
= DECL_TEMPLATE_RESULT (td
);
19956 /* We should never be trying to instantiate a member of a class
19957 template or partial specialization. */
19958 gcc_assert (d
!= code_pattern
);
19960 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
19961 || DECL_TEMPLATE_SPECIALIZATION (td
))
19962 /* In the case of a friend template whose definition is provided
19963 outside the class, we may have too many arguments. Drop the
19964 ones we don't need. The same is true for specializations. */
19965 args
= get_innermost_template_args
19966 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
19970 if (TREE_CODE (d
) == FUNCTION_DECL
)
19972 deleted_p
= DECL_DELETED_FN (code_pattern
);
19973 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
19974 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
19980 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
19983 /* We may be in the middle of deferred access check. Disable it now. */
19984 push_deferring_access_checks (dk_no_deferred
);
19986 /* Unless an explicit instantiation directive has already determined
19987 the linkage of D, remember that a definition is available for
19989 if (pattern_defined
19990 && !DECL_INTERFACE_KNOWN (d
)
19991 && !DECL_NOT_REALLY_EXTERN (d
))
19992 mark_definable (d
);
19994 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
19995 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
19996 input_location
= DECL_SOURCE_LOCATION (d
);
19998 /* If D is a member of an explicitly instantiated class template,
19999 and no definition is available, treat it like an implicit
20001 if (!pattern_defined
&& expl_inst_class_mem_p
20002 && DECL_EXPLICIT_INSTANTIATION (d
))
20004 /* Leave linkage flags alone on instantiations with anonymous
20006 if (TREE_PUBLIC (d
))
20008 DECL_NOT_REALLY_EXTERN (d
) = 0;
20009 DECL_INTERFACE_KNOWN (d
) = 0;
20011 SET_DECL_IMPLICIT_INSTANTIATION (d
);
20014 /* Defer all other templates, unless we have been explicitly
20015 forbidden from doing so. */
20016 if (/* If there is no definition, we cannot instantiate the
20019 /* If it's OK to postpone instantiation, do so. */
20021 /* If this is a static data member that will be defined
20022 elsewhere, we don't want to instantiate the entire data
20023 member, but we do want to instantiate the initializer so that
20024 we can substitute that elsewhere. */
20025 || (external_p
&& VAR_P (d
))
20026 /* Handle here a deleted function too, avoid generating
20027 its body (c++/61080). */
20030 /* The definition of the static data member is now required so
20031 we must substitute the initializer. */
20033 && !DECL_INITIAL (d
)
20034 && DECL_INITIAL (code_pattern
))
20038 bool const_init
= false;
20039 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20041 ns
= decl_namespace_context (d
);
20042 push_nested_namespace (ns
);
20044 push_nested_class (DECL_CONTEXT (d
));
20045 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
20047 tf_warning_or_error
, NULL_TREE
,
20048 /*integral_constant_expression_p=*/false);
20049 /* If instantiating the initializer involved instantiating this
20050 again, don't call cp_finish_decl twice. */
20051 if (!DECL_INITIAL (d
))
20053 /* Make sure the initializer is still constant, in case of
20054 circular dependency (template/instantiate6.C). */
20056 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20057 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
20058 /*asmspec_tree=*/NULL_TREE
,
20059 LOOKUP_ONLYCONVERTING
);
20062 pop_nested_class ();
20063 pop_nested_namespace (ns
);
20066 /* We restore the source position here because it's used by
20067 add_pending_template. */
20068 input_location
= saved_loc
;
20070 if (at_eof
&& !pattern_defined
20071 && DECL_EXPLICIT_INSTANTIATION (d
)
20072 && DECL_NOT_REALLY_EXTERN (d
))
20075 The definition of a non-exported function template, a
20076 non-exported member function template, or a non-exported
20077 member function or static data member of a class template
20078 shall be present in every translation unit in which it is
20079 explicitly instantiated. */
20080 permerror (input_location
, "explicit instantiation of %qD "
20081 "but no definition available", d
);
20083 /* If we're in unevaluated context, we just wanted to get the
20084 constant value; this isn't an odr use, so don't queue
20085 a full instantiation. */
20086 if (cp_unevaluated_operand
!= 0)
20088 /* ??? Historically, we have instantiated inline functions, even
20089 when marked as "extern template". */
20090 if (!(external_p
&& VAR_P (d
)))
20091 add_pending_template (d
);
20094 /* Tell the repository that D is available in this translation unit
20095 -- and see if it is supposed to be instantiated here. */
20096 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
20098 /* In a PCH file, despite the fact that the repository hasn't
20099 requested instantiation in the PCH it is still possible that
20100 an instantiation will be required in a file that includes the
20103 add_pending_template (d
);
20104 /* Instantiate inline functions so that the inliner can do its
20105 job, even though we'll not be emitting a copy of this
20107 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
20111 fn_context
= decl_function_context (d
);
20112 nested
= (current_function_decl
!= NULL_TREE
);
20114 push_to_top_level ();
20118 push_function_context ();
20119 cp_unevaluated_operand
= 0;
20120 c_inhibit_evaluation_warnings
= 0;
20123 /* Mark D as instantiated so that recursive calls to
20124 instantiate_decl do not try to instantiate it again. */
20125 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
20127 /* Regenerate the declaration in case the template has been modified
20128 by a subsequent redeclaration. */
20129 regenerate_decl_from_template (d
, td
);
20131 /* We already set the file and line above. Reset them now in case
20132 they changed as a result of calling regenerate_decl_from_template. */
20133 input_location
= DECL_SOURCE_LOCATION (d
);
20138 bool const_init
= false;
20140 /* Clear out DECL_RTL; whatever was there before may not be right
20141 since we've reset the type of the declaration. */
20142 SET_DECL_RTL (d
, NULL
);
20143 DECL_IN_AGGR_P (d
) = 0;
20145 /* The initializer is placed in DECL_INITIAL by
20146 regenerate_decl_from_template so we don't need to
20147 push/pop_access_scope again here. Pull it out so that
20148 cp_finish_decl can process it. */
20149 init
= DECL_INITIAL (d
);
20150 DECL_INITIAL (d
) = NULL_TREE
;
20151 DECL_INITIALIZED_P (d
) = 0;
20153 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20154 initializer. That function will defer actual emission until
20155 we have a chance to determine linkage. */
20156 DECL_EXTERNAL (d
) = 0;
20158 /* Enter the scope of D so that access-checking works correctly. */
20159 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20161 push_nested_class (DECL_CONTEXT (d
));
20163 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20164 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
20167 pop_nested_class ();
20169 if (variable_template_p (td
))
20170 note_variable_template_instantiation (d
);
20172 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
20173 synthesize_method (d
);
20174 else if (TREE_CODE (d
) == FUNCTION_DECL
)
20176 hash_map
<tree
, tree
> *saved_local_specializations
;
20180 tree block
= NULL_TREE
;
20182 /* Save away the current list, in case we are instantiating one
20183 template from within the body of another. */
20184 saved_local_specializations
= local_specializations
;
20186 /* Set up the list of local specializations. */
20187 local_specializations
= new hash_map
<tree
, tree
>;
20189 /* Set up context. */
20190 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20191 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20192 block
= push_stmt_list ();
20194 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
20196 /* Some typedefs referenced from within the template code need to be
20197 access checked at template instantiation time, i.e now. These
20198 types were added to the template at parsing time. Let's get those
20199 and perform the access checks then. */
20200 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20203 /* Create substitution entries for the parameters. */
20204 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20205 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20206 spec_parm
= DECL_ARGUMENTS (d
);
20207 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20209 register_local_specialization (spec_parm
, tmpl_parm
);
20210 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20211 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20213 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20215 if (!DECL_PACK_P (tmpl_parm
))
20217 register_local_specialization (spec_parm
, tmpl_parm
);
20218 spec_parm
= DECL_CHAIN (spec_parm
);
20222 /* Register the (value) argument pack as a specialization of
20223 TMPL_PARM, then move on. */
20224 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20225 register_local_specialization (argpack
, tmpl_parm
);
20228 gcc_assert (!spec_parm
);
20230 /* Substitute into the body of the function. */
20231 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20232 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20233 tf_warning_or_error
, tmpl
);
20236 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20237 tf_warning_or_error
, tmpl
,
20238 /*integral_constant_expression_p=*/false);
20240 /* Set the current input_location to the end of the function
20241 so that finish_function knows where we are. */
20243 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20245 /* Remember if we saw an infinite loop in the template. */
20246 current_function_infinite_loop
20247 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20250 /* We don't need the local specializations any more. */
20251 delete local_specializations
;
20252 local_specializations
= saved_local_specializations
;
20254 /* Finish the function. */
20255 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20256 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20257 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20260 d
= finish_function (0);
20261 expand_or_defer_fn (d
);
20264 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20265 cp_check_omp_declare_reduction (d
);
20268 /* We're not deferring instantiation any more. */
20269 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20272 pop_from_top_level ();
20274 pop_function_context ();
20277 input_location
= saved_loc
;
20278 cp_unevaluated_operand
= saved_unevaluated_operand
;
20279 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20280 pop_deferring_access_checks ();
20281 pop_tinst_level ();
20283 timevar_pop (TV_TEMPLATE_INST
);
20288 /* Run through the list of templates that we wish we could
20289 instantiate, and instantiate any we can. RETRIES is the
20290 number of times we retry pending template instantiation. */
20293 instantiate_pending_templates (int retries
)
20296 location_t saved_loc
= input_location
;
20298 /* Instantiating templates may trigger vtable generation. This in turn
20299 may require further template instantiations. We place a limit here
20300 to avoid infinite loop. */
20301 if (pending_templates
&& retries
>= max_tinst_depth
)
20303 tree decl
= pending_templates
->tinst
->decl
;
20305 fatal_error ("template instantiation depth exceeds maximum of %d"
20306 " instantiating %q+D, possibly from virtual table generation"
20307 " (use -ftemplate-depth= to increase the maximum)",
20308 max_tinst_depth
, decl
);
20309 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20310 /* Pretend that we defined it. */
20311 DECL_INITIAL (decl
) = error_mark_node
;
20317 struct pending_template
**t
= &pending_templates
;
20318 struct pending_template
*last
= NULL
;
20322 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20323 bool complete
= false;
20325 if (TYPE_P (instantiation
))
20329 if (!COMPLETE_TYPE_P (instantiation
))
20331 instantiate_class_template (instantiation
);
20332 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20333 for (fn
= TYPE_METHODS (instantiation
);
20335 fn
= TREE_CHAIN (fn
))
20336 if (! DECL_ARTIFICIAL (fn
))
20337 instantiate_decl (fn
,
20339 /*expl_inst_class_mem_p=*/false);
20340 if (COMPLETE_TYPE_P (instantiation
))
20344 complete
= COMPLETE_TYPE_P (instantiation
);
20348 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20349 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20352 = instantiate_decl (instantiation
,
20354 /*expl_inst_class_mem_p=*/false);
20355 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20359 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20360 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20364 /* If INSTANTIATION has been instantiated, then we don't
20365 need to consider it again in the future. */
20373 current_tinst_level
= NULL
;
20375 last_pending_template
= last
;
20377 while (reconsider
);
20379 input_location
= saved_loc
;
20382 /* Substitute ARGVEC into T, which is a list of initializers for
20383 either base class or a non-static data member. The TREE_PURPOSEs
20384 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20385 instantiate_decl. */
20388 tsubst_initializer_list (tree t
, tree argvec
)
20390 tree inits
= NULL_TREE
;
20392 for (; t
; t
= TREE_CHAIN (t
))
20396 tree expanded_bases
= NULL_TREE
;
20397 tree expanded_arguments
= NULL_TREE
;
20400 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20405 /* Expand the base class expansion type into separate base
20407 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20408 tf_warning_or_error
,
20410 if (expanded_bases
== error_mark_node
)
20413 /* We'll be building separate TREE_LISTs of arguments for
20415 len
= TREE_VEC_LENGTH (expanded_bases
);
20416 expanded_arguments
= make_tree_vec (len
);
20417 for (i
= 0; i
< len
; i
++)
20418 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20420 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20421 expand each argument in the TREE_VALUE of t. */
20422 expr
= make_node (EXPR_PACK_EXPANSION
);
20423 PACK_EXPANSION_LOCAL_P (expr
) = true;
20424 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20425 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20427 if (TREE_VALUE (t
) == void_type_node
)
20428 /* VOID_TYPE_NODE is used to indicate
20429 value-initialization. */
20431 for (i
= 0; i
< len
; i
++)
20432 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20436 /* Substitute parameter packs into each argument in the
20438 in_base_initializer
= 1;
20439 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20441 tree expanded_exprs
;
20443 /* Expand the argument. */
20444 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20446 = tsubst_pack_expansion (expr
, argvec
,
20447 tf_warning_or_error
,
20449 if (expanded_exprs
== error_mark_node
)
20452 /* Prepend each of the expanded expressions to the
20453 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20454 for (i
= 0; i
< len
; i
++)
20456 TREE_VEC_ELT (expanded_arguments
, i
) =
20457 tree_cons (NULL_TREE
,
20458 TREE_VEC_ELT (expanded_exprs
, i
),
20459 TREE_VEC_ELT (expanded_arguments
, i
));
20462 in_base_initializer
= 0;
20464 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20465 since we built them backwards. */
20466 for (i
= 0; i
< len
; i
++)
20468 TREE_VEC_ELT (expanded_arguments
, i
) =
20469 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20474 for (i
= 0; i
< len
; ++i
)
20476 if (expanded_bases
)
20478 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20479 decl
= expand_member_init (decl
);
20480 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20485 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20486 tf_warning_or_error
, NULL_TREE
);
20488 decl
= expand_member_init (decl
);
20489 if (decl
&& !DECL_P (decl
))
20490 in_base_initializer
= 1;
20492 init
= TREE_VALUE (t
);
20494 if (init
!= void_type_node
)
20495 init
= tsubst_expr (init
, argvec
,
20496 tf_warning_or_error
, NULL_TREE
,
20497 /*integral_constant_expression_p=*/false);
20498 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20499 /* If we had an initializer but it instantiated to nothing,
20500 value-initialize the object. This will only occur when
20501 the initializer was a pack expansion where the parameter
20502 packs used in that expansion were of length zero. */
20503 init
= void_type_node
;
20504 in_base_initializer
= 0;
20509 init
= build_tree_list (decl
, init
);
20510 TREE_CHAIN (init
) = inits
;
20518 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20521 set_current_access_from_decl (tree decl
)
20523 if (TREE_PRIVATE (decl
))
20524 current_access_specifier
= access_private_node
;
20525 else if (TREE_PROTECTED (decl
))
20526 current_access_specifier
= access_protected_node
;
20528 current_access_specifier
= access_public_node
;
20531 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20532 is the instantiation (which should have been created with
20533 start_enum) and ARGS are the template arguments to use. */
20536 tsubst_enum (tree tag
, tree newtag
, tree args
)
20540 if (SCOPED_ENUM_P (newtag
))
20541 begin_scope (sk_scoped_enum
, newtag
);
20543 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20548 decl
= TREE_VALUE (e
);
20549 /* Note that in a template enum, the TREE_VALUE is the
20550 CONST_DECL, not the corresponding INTEGER_CST. */
20551 value
= tsubst_expr (DECL_INITIAL (decl
),
20552 args
, tf_warning_or_error
, NULL_TREE
,
20553 /*integral_constant_expression_p=*/true);
20555 /* Give this enumeration constant the correct access. */
20556 set_current_access_from_decl (decl
);
20558 /* Actually build the enumerator itself. */
20560 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
20563 if (SCOPED_ENUM_P (newtag
))
20566 finish_enum_value_list (newtag
);
20567 finish_enum (newtag
);
20569 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20570 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20573 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20574 its type -- but without substituting the innermost set of template
20575 arguments. So, innermost set of template parameters will appear in
20579 get_mostly_instantiated_function_type (tree decl
)
20587 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
20588 targs
= DECL_TI_ARGS (decl
);
20589 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
20590 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
20592 /* There should be as many levels of arguments as there are levels
20594 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
20596 fn_type
= TREE_TYPE (tmpl
);
20598 if (parm_depth
== 1)
20599 /* No substitution is necessary. */
20606 /* Replace the innermost level of the TARGS with NULL_TREEs to
20607 let tsubst know not to substitute for those parameters. */
20608 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20609 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
20610 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
20611 TMPL_ARGS_LEVEL (targs
, i
));
20612 SET_TMPL_ARGS_LEVEL (partial_args
,
20613 TMPL_ARGS_DEPTH (targs
),
20614 make_tree_vec (DECL_NTPARMS (tmpl
)));
20616 /* Make sure that we can see identifiers, and compute access
20618 push_access_scope (decl
);
20620 ++processing_template_decl
;
20621 /* Now, do the (partial) substitution to figure out the
20622 appropriate function type. */
20623 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
20624 --processing_template_decl
;
20626 /* Substitute into the template parameters to obtain the real
20627 innermost set of parameters. This step is important if the
20628 innermost set of template parameters contains value
20629 parameters whose types depend on outer template parameters. */
20630 TREE_VEC_LENGTH (partial_args
)--;
20631 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
20633 pop_access_scope (decl
);
20639 /* Return truthvalue if we're processing a template different from
20640 the last one involved in diagnostics. */
20642 problematic_instantiation_changed (void)
20644 return current_tinst_level
!= last_error_tinst_level
;
20647 /* Remember current template involved in diagnostics. */
20649 record_last_problematic_instantiation (void)
20651 last_error_tinst_level
= current_tinst_level
;
20654 struct tinst_level
*
20655 current_instantiation (void)
20657 return current_tinst_level
;
20660 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20661 type. Return zero for ok, nonzero for disallowed. Issue error and
20662 warning messages under control of COMPLAIN. */
20665 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20667 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20669 else if (POINTER_TYPE_P (type
))
20671 else if (TYPE_PTRMEM_P (type
))
20673 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20675 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20677 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20679 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20682 if (complain
& tf_error
)
20684 if (type
== error_mark_node
)
20685 inform (input_location
, "invalid template non-type parameter");
20687 error ("%q#T is not a valid type for a template non-type parameter",
20693 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20694 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20697 dependent_type_p_r (tree type
)
20703 A type is dependent if it is:
20705 -- a template parameter. Template template parameters are types
20706 for us (since TYPE_P holds true for them) so we handle
20708 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20709 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20711 /* -- a qualified-id with a nested-name-specifier which contains a
20712 class-name that names a dependent type or whose unqualified-id
20713 names a dependent type. */
20714 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20716 /* -- a cv-qualified type where the cv-unqualified type is
20718 type
= TYPE_MAIN_VARIANT (type
);
20719 /* -- a compound type constructed from any dependent type. */
20720 if (TYPE_PTRMEM_P (type
))
20721 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20722 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20724 else if (TYPE_PTR_P (type
)
20725 || TREE_CODE (type
) == REFERENCE_TYPE
)
20726 return dependent_type_p (TREE_TYPE (type
));
20727 else if (TREE_CODE (type
) == FUNCTION_TYPE
20728 || TREE_CODE (type
) == METHOD_TYPE
)
20732 if (dependent_type_p (TREE_TYPE (type
)))
20734 for (arg_type
= TYPE_ARG_TYPES (type
);
20736 arg_type
= TREE_CHAIN (arg_type
))
20737 if (dependent_type_p (TREE_VALUE (arg_type
)))
20741 /* -- an array type constructed from any dependent type or whose
20742 size is specified by a constant expression that is
20745 We checked for type- and value-dependence of the bounds in
20746 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20747 if (TREE_CODE (type
) == ARRAY_TYPE
)
20749 if (TYPE_DOMAIN (type
)
20750 && dependent_type_p (TYPE_DOMAIN (type
)))
20752 return dependent_type_p (TREE_TYPE (type
));
20755 /* -- a template-id in which either the template name is a template
20757 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20759 /* ... or any of the template arguments is a dependent type or
20760 an expression that is type-dependent or value-dependent. */
20761 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
20762 && (any_dependent_template_arguments_p
20763 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
20766 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20767 dependent; if the argument of the `typeof' expression is not
20768 type-dependent, then it should already been have resolved. */
20769 if (TREE_CODE (type
) == TYPEOF_TYPE
20770 || TREE_CODE (type
) == DECLTYPE_TYPE
20771 || TREE_CODE (type
) == UNDERLYING_TYPE
)
20774 /* A template argument pack is dependent if any of its packed
20776 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
20778 tree args
= ARGUMENT_PACK_ARGS (type
);
20779 int i
, len
= TREE_VEC_LENGTH (args
);
20780 for (i
= 0; i
< len
; ++i
)
20781 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20785 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20786 be template parameters. */
20787 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
20790 /* The standard does not specifically mention types that are local
20791 to template functions or local classes, but they should be
20792 considered dependent too. For example:
20794 template <int I> void f() {
20799 The size of `E' cannot be known until the value of `I' has been
20800 determined. Therefore, `E' must be considered dependent. */
20801 scope
= TYPE_CONTEXT (type
);
20802 if (scope
&& TYPE_P (scope
))
20803 return dependent_type_p (scope
);
20804 /* Don't use type_dependent_expression_p here, as it can lead
20805 to infinite recursion trying to determine whether a lambda
20806 nested in a lambda is dependent (c++/47687). */
20807 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
20808 && DECL_LANG_SPECIFIC (scope
)
20809 && DECL_TEMPLATE_INFO (scope
)
20810 && (any_dependent_template_arguments_p
20811 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
20814 /* Other types are non-dependent. */
20818 /* Returns TRUE if TYPE is dependent, in the sense of
20819 [temp.dep.type]. Note that a NULL type is considered dependent. */
20822 dependent_type_p (tree type
)
20824 /* If there are no template parameters in scope, then there can't be
20825 any dependent types. */
20826 if (!processing_template_decl
)
20828 /* If we are not processing a template, then nobody should be
20829 providing us with a dependent type. */
20831 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
20835 /* If the type is NULL, we have not computed a type for the entity
20836 in question; in that case, the type is dependent. */
20840 /* Erroneous types can be considered non-dependent. */
20841 if (type
== error_mark_node
)
20844 /* If we have not already computed the appropriate value for TYPE,
20846 if (!TYPE_DEPENDENT_P_VALID (type
))
20848 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
20849 TYPE_DEPENDENT_P_VALID (type
) = 1;
20852 return TYPE_DEPENDENT_P (type
);
20855 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20856 lookup. In other words, a dependent type that is not the current
20860 dependent_scope_p (tree scope
)
20862 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
20863 && !currently_open_class (scope
));
20866 /* T is a SCOPE_REF; return whether we need to consider it
20867 instantiation-dependent so that we can check access at instantiation
20868 time even though we know which member it resolves to. */
20871 instantiation_dependent_scope_ref_p (tree t
)
20873 if (DECL_P (TREE_OPERAND (t
, 1))
20874 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
20875 && accessible_in_template_p (TREE_OPERAND (t
, 0),
20876 TREE_OPERAND (t
, 1)))
20882 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20883 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20886 /* Note that this predicate is not appropriate for general expressions;
20887 only constant expressions (that satisfy potential_constant_expression)
20888 can be tested for value dependence. */
20891 value_dependent_expression_p (tree expression
)
20893 if (!processing_template_decl
)
20896 /* A name declared with a dependent type. */
20897 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
20900 switch (TREE_CODE (expression
))
20902 case IDENTIFIER_NODE
:
20903 /* A name that has not been looked up -- must be dependent. */
20906 case TEMPLATE_PARM_INDEX
:
20907 /* A non-type template parm. */
20911 /* A non-type template parm. */
20912 if (DECL_TEMPLATE_PARM_P (expression
))
20914 return value_dependent_expression_p (DECL_INITIAL (expression
));
20917 /* A constant with literal type and is initialized
20918 with an expression that is value-dependent.
20920 Note that a non-dependent parenthesized initializer will have
20921 already been replaced with its constant value, so if we see
20922 a TREE_LIST it must be dependent. */
20923 if (DECL_INITIAL (expression
)
20924 && decl_constant_var_p (expression
)
20925 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
20926 || value_dependent_expression_p (DECL_INITIAL (expression
))))
20930 case DYNAMIC_CAST_EXPR
:
20931 case STATIC_CAST_EXPR
:
20932 case CONST_CAST_EXPR
:
20933 case REINTERPRET_CAST_EXPR
:
20935 /* These expressions are value-dependent if the type to which
20936 the cast occurs is dependent or the expression being casted
20937 is value-dependent. */
20939 tree type
= TREE_TYPE (expression
);
20941 if (dependent_type_p (type
))
20944 /* A functional cast has a list of operands. */
20945 expression
= TREE_OPERAND (expression
, 0);
20948 /* If there are no operands, it must be an expression such
20949 as "int()". This should not happen for aggregate types
20950 because it would form non-constant expressions. */
20951 gcc_assert (cxx_dialect
>= cxx11
20952 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
20957 if (TREE_CODE (expression
) == TREE_LIST
)
20958 return any_value_dependent_elements_p (expression
);
20960 return value_dependent_expression_p (expression
);
20964 if (SIZEOF_EXPR_TYPE_P (expression
))
20965 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
20969 /* A `sizeof' expression is value-dependent if the operand is
20970 type-dependent or is a pack expansion. */
20971 expression
= TREE_OPERAND (expression
, 0);
20972 if (PACK_EXPANSION_P (expression
))
20974 else if (TYPE_P (expression
))
20975 return dependent_type_p (expression
);
20976 return instantiation_dependent_expression_p (expression
);
20978 case AT_ENCODE_EXPR
:
20979 /* An 'encode' expression is value-dependent if the operand is
20981 expression
= TREE_OPERAND (expression
, 0);
20982 return dependent_type_p (expression
);
20984 case NOEXCEPT_EXPR
:
20985 expression
= TREE_OPERAND (expression
, 0);
20986 return instantiation_dependent_expression_p (expression
);
20989 /* All instantiation-dependent expressions should also be considered
20990 value-dependent. */
20991 return instantiation_dependent_scope_ref_p (expression
);
20993 case COMPONENT_REF
:
20994 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
20995 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
20997 case NONTYPE_ARGUMENT_PACK
:
20998 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
20999 is value-dependent. */
21001 tree values
= ARGUMENT_PACK_ARGS (expression
);
21002 int i
, len
= TREE_VEC_LENGTH (values
);
21004 for (i
= 0; i
< len
; ++i
)
21005 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
21013 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
21014 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
21015 || (type2
? dependent_type_p (type2
) : false));
21019 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21020 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
21023 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21024 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
21028 tree op
= TREE_OPERAND (expression
, 0);
21029 return (value_dependent_expression_p (op
)
21030 || has_value_dependent_address (op
));
21035 tree fn
= get_callee_fndecl (expression
);
21037 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
21039 nargs
= call_expr_nargs (expression
);
21040 for (i
= 0; i
< nargs
; ++i
)
21042 tree op
= CALL_EXPR_ARG (expression
, i
);
21043 /* In a call to a constexpr member function, look through the
21044 implicit ADDR_EXPR on the object argument so that it doesn't
21045 cause the call to be considered value-dependent. We also
21046 look through it in potential_constant_expression. */
21047 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
21048 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
21049 && TREE_CODE (op
) == ADDR_EXPR
)
21050 op
= TREE_OPERAND (op
, 0);
21051 if (value_dependent_expression_p (op
))
21057 case TEMPLATE_ID_EXPR
:
21058 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21060 return type_dependent_expression_p (expression
);
21066 if (dependent_type_p (TREE_TYPE (expression
)))
21068 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
21069 if (value_dependent_expression_p (val
))
21075 /* Treat a GNU statement expression as dependent to avoid crashing
21076 under fold_non_dependent_expr; it can't be constant. */
21080 /* A constant expression is value-dependent if any subexpression is
21081 value-dependent. */
21082 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
21084 case tcc_reference
:
21086 case tcc_comparison
:
21088 case tcc_expression
:
21091 int i
, len
= cp_tree_operand_length (expression
);
21093 for (i
= 0; i
< len
; i
++)
21095 tree t
= TREE_OPERAND (expression
, i
);
21097 /* In some cases, some of the operands may be missing.l
21098 (For example, in the case of PREDECREMENT_EXPR, the
21099 amount to increment by may be missing.) That doesn't
21100 make the expression dependent. */
21101 if (t
&& value_dependent_expression_p (t
))
21112 /* The expression is not value-dependent. */
21116 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21117 [temp.dep.expr]. Note that an expression with no type is
21118 considered dependent. Other parts of the compiler arrange for an
21119 expression with type-dependent subexpressions to have no type, so
21120 this function doesn't have to be fully recursive. */
21123 type_dependent_expression_p (tree expression
)
21125 if (!processing_template_decl
)
21128 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
21131 /* An unresolved name is always dependent. */
21132 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
21135 /* Some expression forms are never type-dependent. */
21136 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
21137 || TREE_CODE (expression
) == SIZEOF_EXPR
21138 || TREE_CODE (expression
) == ALIGNOF_EXPR
21139 || TREE_CODE (expression
) == AT_ENCODE_EXPR
21140 || TREE_CODE (expression
) == NOEXCEPT_EXPR
21141 || TREE_CODE (expression
) == TRAIT_EXPR
21142 || TREE_CODE (expression
) == TYPEID_EXPR
21143 || TREE_CODE (expression
) == DELETE_EXPR
21144 || TREE_CODE (expression
) == VEC_DELETE_EXPR
21145 || TREE_CODE (expression
) == THROW_EXPR
)
21148 /* The types of these expressions depends only on the type to which
21149 the cast occurs. */
21150 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
21151 || TREE_CODE (expression
) == STATIC_CAST_EXPR
21152 || TREE_CODE (expression
) == CONST_CAST_EXPR
21153 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
21154 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
21155 || TREE_CODE (expression
) == CAST_EXPR
)
21156 return dependent_type_p (TREE_TYPE (expression
));
21158 /* The types of these expressions depends only on the type created
21159 by the expression. */
21160 if (TREE_CODE (expression
) == NEW_EXPR
21161 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
21163 /* For NEW_EXPR tree nodes created inside a template, either
21164 the object type itself or a TREE_LIST may appear as the
21166 tree type
= TREE_OPERAND (expression
, 1);
21167 if (TREE_CODE (type
) == TREE_LIST
)
21168 /* This is an array type. We need to check array dimensions
21170 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
21171 || value_dependent_expression_p
21172 (TREE_OPERAND (TREE_VALUE (type
), 1));
21174 return dependent_type_p (type
);
21177 if (TREE_CODE (expression
) == SCOPE_REF
)
21179 tree scope
= TREE_OPERAND (expression
, 0);
21180 tree name
= TREE_OPERAND (expression
, 1);
21182 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21183 contains an identifier associated by name lookup with one or more
21184 declarations declared with a dependent type, or...a
21185 nested-name-specifier or qualified-id that names a member of an
21186 unknown specialization. */
21187 return (type_dependent_expression_p (name
)
21188 || dependent_scope_p (scope
));
21191 if (TREE_CODE (expression
) == FUNCTION_DECL
21192 && DECL_LANG_SPECIFIC (expression
)
21193 && DECL_TEMPLATE_INFO (expression
)
21194 && (any_dependent_template_arguments_p
21195 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
21198 if (TREE_CODE (expression
) == TEMPLATE_DECL
21199 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
21202 if (TREE_CODE (expression
) == STMT_EXPR
)
21203 expression
= stmt_expr_value_expr (expression
);
21205 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21210 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21212 if (type_dependent_expression_p (elt
))
21218 /* A static data member of the current instantiation with incomplete
21219 array type is type-dependent, as the definition and specializations
21220 can have different bounds. */
21221 if (VAR_P (expression
)
21222 && DECL_CLASS_SCOPE_P (expression
)
21223 && dependent_type_p (DECL_CONTEXT (expression
))
21224 && VAR_HAD_UNKNOWN_BOUND (expression
))
21227 /* An array of unknown bound depending on a variadic parameter, eg:
21229 template<typename... Args>
21230 void foo (Args... args)
21232 int arr[] = { args... };
21235 template<int... vals>
21238 int arr[] = { vals... };
21241 If the array has no length and has an initializer, it must be that
21242 we couldn't determine its length in cp_complete_array_type because
21243 it is dependent. */
21244 if (VAR_P (expression
)
21245 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21246 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21247 && DECL_INITIAL (expression
))
21250 if (TREE_TYPE (expression
) == unknown_type_node
)
21252 if (TREE_CODE (expression
) == ADDR_EXPR
)
21253 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21254 if (TREE_CODE (expression
) == COMPONENT_REF
21255 || TREE_CODE (expression
) == OFFSET_REF
)
21257 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21259 expression
= TREE_OPERAND (expression
, 1);
21260 if (identifier_p (expression
))
21263 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21264 if (TREE_CODE (expression
) == SCOPE_REF
)
21267 /* Always dependent, on the number of arguments if nothing else. */
21268 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21271 if (BASELINK_P (expression
))
21273 if (BASELINK_OPTYPE (expression
)
21274 && dependent_type_p (BASELINK_OPTYPE (expression
)))
21276 expression
= BASELINK_FUNCTIONS (expression
);
21279 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21281 if (any_dependent_template_arguments_p
21282 (TREE_OPERAND (expression
, 1)))
21284 expression
= TREE_OPERAND (expression
, 0);
21286 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21287 || TREE_CODE (expression
) == FUNCTION_DECL
);
21291 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21293 expression
= OVL_NEXT (expression
);
21298 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21300 return (dependent_type_p (TREE_TYPE (expression
)));
21303 /* walk_tree callback function for instantiation_dependent_expression_p,
21304 below. Returns non-zero if a dependent subexpression is found. */
21307 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21312 /* We don't have to worry about decltype currently because decltype
21313 of an instantiation-dependent expr is a dependent type. This
21314 might change depending on the resolution of DR 1172. */
21315 *walk_subtrees
= false;
21318 enum tree_code code
= TREE_CODE (*tp
);
21321 /* Don't treat an argument list as dependent just because it has no
21329 /* A constant with a dependent initializer is dependent. */
21330 if (value_dependent_expression_p (*tp
))
21334 case TEMPLATE_PARM_INDEX
:
21337 /* Handle expressions with type operands. */
21341 case AT_ENCODE_EXPR
:
21343 tree op
= TREE_OPERAND (*tp
, 0);
21344 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21345 op
= TREE_TYPE (op
);
21348 if (dependent_type_p (op
))
21352 *walk_subtrees
= false;
21360 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21361 || (TRAIT_EXPR_TYPE2 (*tp
)
21362 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21364 *walk_subtrees
= false;
21367 case COMPONENT_REF
:
21368 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21369 /* In a template, finish_class_member_access_expr creates a
21370 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21371 type-dependent, so that we can check access control at
21372 instantiation time (PR 42277). See also Core issue 1273. */
21377 if (instantiation_dependent_scope_ref_p (*tp
))
21382 /* Treat statement-expressions as dependent. */
21390 if (type_dependent_expression_p (*tp
))
21396 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21397 sense defined by the ABI:
21399 "An expression is instantiation-dependent if it is type-dependent
21400 or value-dependent, or it has a subexpression that is type-dependent
21401 or value-dependent." */
21404 instantiation_dependent_expression_p (tree expression
)
21408 if (!processing_template_decl
)
21411 if (expression
== error_mark_node
)
21414 result
= cp_walk_tree_without_duplicates (&expression
,
21415 instantiation_dependent_r
, NULL
);
21416 return result
!= NULL_TREE
;
21419 /* Like type_dependent_expression_p, but it also works while not processing
21420 a template definition, i.e. during substitution or mangling. */
21423 type_dependent_expression_p_push (tree expr
)
21426 ++processing_template_decl
;
21427 b
= type_dependent_expression_p (expr
);
21428 --processing_template_decl
;
21432 /* Returns TRUE if ARGS contains a type-dependent expression. */
21435 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21440 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21442 if (type_dependent_expression_p (arg
))
21448 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21449 expressions) contains any type-dependent expressions. */
21452 any_type_dependent_elements_p (const_tree list
)
21454 for (; list
; list
= TREE_CHAIN (list
))
21455 if (type_dependent_expression_p (TREE_VALUE (list
)))
21461 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21462 expressions) contains any value-dependent expressions. */
21465 any_value_dependent_elements_p (const_tree list
)
21467 for (; list
; list
= TREE_CHAIN (list
))
21468 if (value_dependent_expression_p (TREE_VALUE (list
)))
21474 /* Returns TRUE if the ARG (a template argument) is dependent. */
21477 dependent_template_arg_p (tree arg
)
21479 if (!processing_template_decl
)
21482 /* Assume a template argument that was wrongly written by the user
21483 is dependent. This is consistent with what
21484 any_dependent_template_arguments_p [that calls this function]
21486 if (!arg
|| arg
== error_mark_node
)
21489 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21490 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21492 if (TREE_CODE (arg
) == TEMPLATE_DECL
21493 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21494 return dependent_template_p (arg
);
21495 else if (ARGUMENT_PACK_P (arg
))
21497 tree args
= ARGUMENT_PACK_ARGS (arg
);
21498 int i
, len
= TREE_VEC_LENGTH (args
);
21499 for (i
= 0; i
< len
; ++i
)
21501 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21507 else if (TYPE_P (arg
))
21508 return dependent_type_p (arg
);
21510 return (type_dependent_expression_p (arg
)
21511 || value_dependent_expression_p (arg
));
21514 /* Returns true if ARGS (a collection of template arguments) contains
21515 any types that require structural equality testing. */
21518 any_template_arguments_need_structural_equality_p (tree args
)
21525 if (args
== error_mark_node
)
21528 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21530 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21531 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21533 tree arg
= TREE_VEC_ELT (level
, j
);
21534 tree packed_args
= NULL_TREE
;
21537 if (ARGUMENT_PACK_P (arg
))
21539 /* Look inside the argument pack. */
21540 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21541 len
= TREE_VEC_LENGTH (packed_args
);
21544 for (k
= 0; k
< len
; ++k
)
21547 arg
= TREE_VEC_ELT (packed_args
, k
);
21549 if (error_operand_p (arg
))
21551 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21553 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21555 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21556 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21565 /* Returns true if ARGS (a collection of template arguments) contains
21566 any dependent arguments. */
21569 any_dependent_template_arguments_p (const_tree args
)
21576 if (args
== error_mark_node
)
21579 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21581 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21582 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21583 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21590 /* Returns TRUE if the template TMPL is dependent. */
21593 dependent_template_p (tree tmpl
)
21595 if (TREE_CODE (tmpl
) == OVERLOAD
)
21599 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21601 tmpl
= OVL_NEXT (tmpl
);
21606 /* Template template parameters are dependent. */
21607 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21608 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21610 /* So are names that have not been looked up. */
21611 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21613 /* So are member templates of dependent classes. */
21614 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21615 return dependent_type_p (DECL_CONTEXT (tmpl
));
21619 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21622 dependent_template_id_p (tree tmpl
, tree args
)
21624 return (dependent_template_p (tmpl
)
21625 || any_dependent_template_arguments_p (args
));
21628 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21632 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21636 if (!processing_template_decl
)
21639 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21641 tree decl
= TREE_VEC_ELT (declv
, i
);
21642 tree init
= TREE_VEC_ELT (initv
, i
);
21643 tree cond
= TREE_VEC_ELT (condv
, i
);
21644 tree incr
= TREE_VEC_ELT (incrv
, i
);
21646 if (type_dependent_expression_p (decl
))
21649 if (init
&& type_dependent_expression_p (init
))
21652 if (type_dependent_expression_p (cond
))
21655 if (COMPARISON_CLASS_P (cond
)
21656 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21657 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21660 if (TREE_CODE (incr
) == MODOP_EXPR
)
21662 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21663 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21666 else if (type_dependent_expression_p (incr
))
21668 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21670 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21672 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21674 tree t
= TREE_OPERAND (incr
, 1);
21675 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21676 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21685 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21686 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21687 no such TYPE can be found. Note that this function peers inside
21688 uninstantiated templates and therefore should be used only in
21689 extremely limited situations. ONLY_CURRENT_P restricts this
21690 peering to the currently open classes hierarchy (which is required
21691 when comparing types). */
21694 resolve_typename_type (tree type
, bool only_current_p
)
21703 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21705 scope
= TYPE_CONTEXT (type
);
21706 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21707 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21708 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21709 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21710 identifier of the TYPENAME_TYPE anymore.
21711 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21712 TYPENAME_TYPE instead, we avoid messing up with a possible
21713 typedef variant case. */
21714 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21716 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21717 it first before we can figure out what NAME refers to. */
21718 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21720 if (TYPENAME_IS_RESOLVING_P (scope
))
21721 /* Given a class template A with a dependent base with nested type C,
21722 typedef typename A::C::C C will land us here, as trying to resolve
21723 the initial A::C leads to the local C typedef, which leads back to
21724 A::C::C. So we break the recursion now. */
21727 scope
= resolve_typename_type (scope
, only_current_p
);
21729 /* If we don't know what SCOPE refers to, then we cannot resolve the
21731 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21733 /* If the SCOPE is a template type parameter, we have no way of
21734 resolving the name. */
21735 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21737 /* If the SCOPE is not the current instantiation, there's no reason
21738 to look inside it. */
21739 if (only_current_p
&& !currently_open_class (scope
))
21741 /* If this is a typedef, we don't want to look inside (c++/11987). */
21742 if (typedef_variant_p (type
))
21744 /* If SCOPE isn't the template itself, it will not have a valid
21745 TYPE_FIELDS list. */
21746 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21747 /* scope is either the template itself or a compatible instantiation
21748 like X<T>, so look up the name in the original template. */
21749 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
21751 /* scope is a partial instantiation, so we can't do the lookup or we
21752 will lose the template arguments. */
21754 /* Enter the SCOPE so that name lookup will be resolved as if we
21755 were in the class definition. In particular, SCOPE will no
21756 longer be considered a dependent type. */
21757 pushed_scope
= push_scope (scope
);
21758 /* Look up the declaration. */
21759 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
21760 tf_warning_or_error
);
21762 result
= NULL_TREE
;
21764 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21765 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21768 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
21769 && TREE_CODE (decl
) == TYPE_DECL
)
21771 result
= TREE_TYPE (decl
);
21772 if (result
== error_mark_node
)
21773 result
= NULL_TREE
;
21775 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
21776 && DECL_CLASS_TEMPLATE_P (decl
))
21780 /* Obtain the template and the arguments. */
21781 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
21782 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
21783 /* Instantiate the template. */
21784 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
21785 /*entering_scope=*/0,
21786 tf_error
| tf_user
);
21787 if (result
== error_mark_node
)
21788 result
= NULL_TREE
;
21791 /* Leave the SCOPE. */
21793 pop_scope (pushed_scope
);
21795 /* If we failed to resolve it, return the original typename. */
21799 /* If lookup found a typename type, resolve that too. */
21800 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
21802 /* Ill-formed programs can cause infinite recursion here, so we
21803 must catch that. */
21804 TYPENAME_IS_RESOLVING_P (type
) = 1;
21805 result
= resolve_typename_type (result
, only_current_p
);
21806 TYPENAME_IS_RESOLVING_P (type
) = 0;
21809 /* Qualify the resulting type. */
21810 quals
= cp_type_quals (type
);
21812 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
21817 /* EXPR is an expression which is not type-dependent. Return a proxy
21818 for EXPR that can be used to compute the types of larger
21819 expressions containing EXPR. */
21822 build_non_dependent_expr (tree expr
)
21826 #ifdef ENABLE_CHECKING
21827 /* Try to get a constant value for all non-dependent expressions in
21828 order to expose bugs in *_dependent_expression_p and constexpr. */
21829 if (cxx_dialect
>= cxx11
)
21830 maybe_constant_value (fold_non_dependent_expr_sfinae (expr
, tf_none
));
21833 /* Preserve OVERLOADs; the functions must be available to resolve
21836 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
21837 inner_expr
= stmt_expr_value_expr (inner_expr
);
21838 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
21839 inner_expr
= TREE_OPERAND (inner_expr
, 0);
21840 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
21841 inner_expr
= TREE_OPERAND (inner_expr
, 1);
21842 if (is_overloaded_fn (inner_expr
)
21843 || TREE_CODE (inner_expr
) == OFFSET_REF
)
21845 /* There is no need to return a proxy for a variable. */
21848 /* Preserve string constants; conversions from string constants to
21849 "char *" are allowed, even though normally a "const char *"
21850 cannot be used to initialize a "char *". */
21851 if (TREE_CODE (expr
) == STRING_CST
)
21853 /* Preserve void and arithmetic constants, as an optimization -- there is no
21854 reason to create a new node. */
21855 if (TREE_CODE (expr
) == VOID_CST
21856 || TREE_CODE (expr
) == INTEGER_CST
21857 || TREE_CODE (expr
) == REAL_CST
)
21859 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21860 There is at least one place where we want to know that a
21861 particular expression is a throw-expression: when checking a ?:
21862 expression, there are special rules if the second or third
21863 argument is a throw-expression. */
21864 if (TREE_CODE (expr
) == THROW_EXPR
)
21867 /* Don't wrap an initializer list, we need to be able to look inside. */
21868 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
21871 /* Don't wrap a dummy object, we need to be able to test for it. */
21872 if (is_dummy_object (expr
))
21875 if (TREE_CODE (expr
) == COND_EXPR
)
21876 return build3 (COND_EXPR
,
21878 TREE_OPERAND (expr
, 0),
21879 (TREE_OPERAND (expr
, 1)
21880 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
21881 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
21882 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
21883 if (TREE_CODE (expr
) == COMPOUND_EXPR
21884 && !COMPOUND_EXPR_OVERLOADED (expr
))
21885 return build2 (COMPOUND_EXPR
,
21887 TREE_OPERAND (expr
, 0),
21888 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
21890 /* If the type is unknown, it can't really be non-dependent */
21891 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
21893 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21894 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
21897 /* ARGS is a vector of expressions as arguments to a function call.
21898 Replace the arguments with equivalent non-dependent expressions.
21899 This modifies ARGS in place. */
21902 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
21907 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
21909 tree newarg
= build_non_dependent_expr (arg
);
21911 (*args
)[ix
] = newarg
;
21915 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21916 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21920 make_auto_1 (tree name
)
21922 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
21923 TYPE_NAME (au
) = build_decl (input_location
,
21924 TYPE_DECL
, name
, au
);
21925 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
21926 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
21927 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
21928 TYPE_NAME (au
), NULL_TREE
);
21929 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
21930 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
21931 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
21937 make_decltype_auto (void)
21939 return make_auto_1 (get_identifier ("decltype(auto)"));
21945 return make_auto_1 (get_identifier ("auto"));
21948 /* Given type ARG, return std::initializer_list<ARG>. */
21953 tree std_init_list
= namespace_binding
21954 (get_identifier ("initializer_list"), std_node
);
21956 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
21958 error ("deducing from brace-enclosed initializer list requires "
21959 "#include <initializer_list>");
21960 return error_mark_node
;
21962 argvec
= make_tree_vec (1);
21963 TREE_VEC_ELT (argvec
, 0) = arg
;
21964 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
21965 NULL_TREE
, 0, tf_warning_or_error
);
21968 /* Replace auto in TYPE with std::initializer_list<auto>. */
21971 listify_autos (tree type
, tree auto_node
)
21973 tree init_auto
= listify (auto_node
);
21974 tree argvec
= make_tree_vec (1);
21975 TREE_VEC_ELT (argvec
, 0) = init_auto
;
21976 if (processing_template_decl
)
21977 argvec
= add_to_template_args (current_template_args (), argvec
);
21978 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21981 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
21982 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
21985 do_auto_deduction (tree type
, tree init
, tree auto_node
)
21989 if (init
== error_mark_node
)
21990 return error_mark_node
;
21992 if (type_dependent_expression_p (init
))
21993 /* Defining a subset of type-dependent expressions that we can deduce
21994 from ahead of time isn't worth the trouble. */
21997 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
21998 with either a new invented type template parameter U or, if the
21999 initializer is a braced-init-list (8.5.4), with
22000 std::initializer_list<U>. */
22001 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
22002 type
= listify_autos (type
, auto_node
);
22004 init
= resolve_nondeduced_context (init
);
22006 targs
= make_tree_vec (1);
22007 if (AUTO_IS_DECLTYPE (auto_node
))
22009 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
22010 && !REF_PARENTHESIZED_P (init
)));
22011 TREE_VEC_ELT (targs
, 0)
22012 = finish_decltype_type (init
, id
, tf_warning_or_error
);
22013 if (type
!= auto_node
)
22015 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
22016 return error_mark_node
;
22021 tree parms
= build_tree_list (NULL_TREE
, type
);
22022 tree tparms
= make_tree_vec (1);
22025 TREE_VEC_ELT (tparms
, 0)
22026 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
22027 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
22028 DEDUCE_CALL
, LOOKUP_NORMAL
,
22029 NULL
, /*explain_p=*/false);
22032 if (processing_template_decl
)
22033 /* Try again at instantiation time. */
22035 if (type
&& type
!= error_mark_node
)
22036 /* If type is error_mark_node a diagnostic must have been
22037 emitted by now. Also, having a mention to '<type error>'
22038 in the diagnostic is not really useful to the user. */
22040 if (cfun
&& auto_node
== current_function_auto_return_pattern
22041 && LAMBDA_FUNCTION_P (current_function_decl
))
22042 error ("unable to deduce lambda return type from %qE", init
);
22044 error ("unable to deduce %qT from %qE", type
, init
);
22046 return error_mark_node
;
22050 /* If the list of declarators contains more than one declarator, the type
22051 of each declared variable is determined as described above. If the
22052 type deduced for the template parameter U is not the same in each
22053 deduction, the program is ill-formed. */
22054 if (TREE_TYPE (auto_node
)
22055 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
22057 if (cfun
&& auto_node
== current_function_auto_return_pattern
22058 && LAMBDA_FUNCTION_P (current_function_decl
))
22059 error ("inconsistent types %qT and %qT deduced for "
22060 "lambda return type", TREE_TYPE (auto_node
),
22061 TREE_VEC_ELT (targs
, 0));
22063 error ("inconsistent deduction for %qT: %qT and then %qT",
22064 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
22065 return error_mark_node
;
22067 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
22069 if (processing_template_decl
)
22070 targs
= add_to_template_args (current_template_args (), targs
);
22071 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
22074 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22078 splice_late_return_type (tree type
, tree late_return_type
)
22082 if (late_return_type
== NULL_TREE
)
22084 argvec
= make_tree_vec (1);
22085 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
22086 if (processing_template_parmlist
)
22087 /* For a late-specified return type in a template type-parameter, we
22088 need to add a dummy argument level for its parmlist. */
22089 argvec
= add_to_template_args
22090 (make_tree_vec (processing_template_parmlist
), argvec
);
22091 if (current_template_parms
)
22092 argvec
= add_to_template_args (current_template_args (), argvec
);
22093 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22096 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22097 'decltype(auto)'. */
22100 is_auto (const_tree type
)
22102 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
22103 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
22104 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
22110 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22111 a use of `auto'. Returns NULL_TREE otherwise. */
22114 type_uses_auto (tree type
)
22116 return find_type_usage (type
, is_auto
);
22119 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22120 'decltype(auto)' or a concept. */
22123 is_auto_or_concept (const_tree type
)
22125 return is_auto (type
); // or concept
22128 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22129 a concept identifier) iff TYPE contains a use of a generic type. Returns
22130 NULL_TREE otherwise. */
22133 type_uses_auto_or_concept (tree type
)
22135 return find_type_usage (type
, is_auto_or_concept
);
22139 /* For a given template T, return the vector of typedefs referenced
22140 in T for which access check is needed at T instantiation time.
22141 T is either a FUNCTION_DECL or a RECORD_TYPE.
22142 Those typedefs were added to T by the function
22143 append_type_to_template_for_access_check. */
22145 vec
<qualified_typedef_usage_t
, va_gc
> *
22146 get_types_needing_access_check (tree t
)
22149 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
22151 if (!t
|| t
== error_mark_node
)
22154 if (!(ti
= get_template_info (t
)))
22157 if (CLASS_TYPE_P (t
)
22158 || TREE_CODE (t
) == FUNCTION_DECL
)
22160 if (!TI_TEMPLATE (ti
))
22163 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
22169 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22170 tied to T. That list of typedefs will be access checked at
22171 T instantiation time.
22172 T is either a FUNCTION_DECL or a RECORD_TYPE.
22173 TYPE_DECL is a TYPE_DECL node representing a typedef.
22174 SCOPE is the scope through which TYPE_DECL is accessed.
22175 LOCATION is the location of the usage point of TYPE_DECL.
22177 This function is a subroutine of
22178 append_type_to_template_for_access_check. */
22181 append_type_to_template_for_access_check_1 (tree t
,
22184 location_t location
)
22186 qualified_typedef_usage_t typedef_usage
;
22189 if (!t
|| t
== error_mark_node
)
22192 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
22193 || CLASS_TYPE_P (t
))
22195 && TREE_CODE (type_decl
) == TYPE_DECL
22198 if (!(ti
= get_template_info (t
)))
22201 gcc_assert (TI_TEMPLATE (ti
));
22203 typedef_usage
.typedef_decl
= type_decl
;
22204 typedef_usage
.context
= scope
;
22205 typedef_usage
.locus
= location
;
22207 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22210 /* Append TYPE_DECL to the template TEMPL.
22211 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22212 At TEMPL instanciation time, TYPE_DECL will be checked to see
22213 if it can be accessed through SCOPE.
22214 LOCATION is the location of the usage point of TYPE_DECL.
22216 e.g. consider the following code snippet:
22223 template<class U> struct S
22225 C::myint mi; // <-- usage point of the typedef C::myint
22230 At S<char> instantiation time, we need to check the access of C::myint
22231 In other words, we need to check the access of the myint typedef through
22232 the C scope. For that purpose, this function will add the myint typedef
22233 and the scope C through which its being accessed to a list of typedefs
22234 tied to the template S. That list will be walked at template instantiation
22235 time and access check performed on each typedefs it contains.
22236 Note that this particular code snippet should yield an error because
22237 myint is private to C. */
22240 append_type_to_template_for_access_check (tree templ
,
22243 location_t location
)
22245 qualified_typedef_usage_t
*iter
;
22248 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22250 /* Make sure we don't append the type to the template twice. */
22251 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22252 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22255 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22259 /* Convert the generic type parameters in PARM that match the types given in the
22260 range [START_IDX, END_IDX) from the current_template_parms into generic type
22264 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22266 tree current
= current_template_parms
;
22267 int depth
= TMPL_PARMS_DEPTH (current
);
22268 current
= INNERMOST_TEMPLATE_PARMS (current
);
22269 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22271 for (int i
= 0; i
< start_idx
; ++i
)
22272 TREE_VEC_ELT (replacement
, i
)
22273 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22275 for (int i
= start_idx
; i
< end_idx
; ++i
)
22277 /* Create a distinct parameter pack type from the current parm and add it
22278 to the replacement args to tsubst below into the generic function
22281 tree o
= TREE_TYPE (TREE_VALUE
22282 (TREE_VEC_ELT (current
, i
)));
22283 tree t
= copy_type (o
);
22284 TEMPLATE_TYPE_PARM_INDEX (t
)
22285 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22287 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22288 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22289 TYPE_MAIN_VARIANT (t
) = t
;
22290 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22291 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22292 TREE_VEC_ELT (replacement
, i
) = t
;
22293 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22296 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22297 TREE_VEC_ELT (replacement
, i
)
22298 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22300 /* If there are more levels then build up the replacement with the outer
22303 replacement
= add_to_template_args (template_parms_to_args
22304 (TREE_CHAIN (current_template_parms
)),
22307 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22311 /* Set up the hash tables for template instantiations. */
22314 init_template_processing (void)
22316 decl_specializations
= htab_create_ggc (37,
22317 hash_specialization
,
22318 eq_specializations
,
22320 type_specializations
= htab_create_ggc (37,
22321 hash_specialization
,
22322 eq_specializations
,
22326 /* Print stats about the template hash tables for -fstats. */
22329 print_template_statistics (void)
22331 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22332 "%f collisions\n", (long) htab_size (decl_specializations
),
22333 (long) htab_elements (decl_specializations
),
22334 htab_collisions (decl_specializations
));
22335 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22336 "%f collisions\n", (long) htab_size (type_specializations
),
22337 (long) htab_elements (type_specializations
),
22338 htab_collisions (type_specializations
));
22341 #include "gt-cp-pt.h"